Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <svx/svdmodel.hxx>
21 : #include <sfx2/app.hxx>
22 : #include <sfx2/sfx.hrc>
23 : #include <tools/helpers.hxx>
24 : #include <unotools/syslocale.hxx>
25 :
26 : #include "sdmod.hxx"
27 : #include "optsitem.hxx"
28 : #include "cfgids.hxx"
29 : #include "FrameView.hxx"
30 :
31 : using namespace ::utl;
32 : using namespace ::com::sun::star::uno;
33 :
34 : #define B2U(_def_aStr) (OUString::createFromAscii(_def_aStr))
35 :
36 44 : template< class T > T getSafeValue( const Any& rAny )
37 : {
38 44 : T value = T();
39 44 : bool bOk = (rAny >>= value);
40 :
41 : DBG_ASSERT( bOk, "SdOptionsItem, wrong type from configuration!" );
42 : (void)bOk;
43 :
44 44 : return value;
45 : }
46 :
47 : // - SdOptionsItem -
48 :
49 180 : SdOptionsItem::SdOptionsItem( const SdOptionsGeneric& rParent, const OUString& rSubTree ) :
50 : ConfigItem ( rSubTree ),
51 180 : mrParent ( rParent )
52 : {
53 180 : }
54 :
55 272 : SdOptionsItem::~SdOptionsItem()
56 : {
57 272 : }
58 :
59 0 : void SdOptionsItem::Commit()
60 : {
61 0 : if( IsModified() )
62 0 : mrParent.Commit( *this );
63 0 : };
64 :
65 0 : void SdOptionsItem::Notify( const com::sun::star::uno::Sequence<OUString>& )
66 0 : {}
67 :
68 180 : Sequence< Any > SdOptionsItem::GetProperties( const Sequence< OUString >& rNames )
69 : {
70 180 : return ConfigItem::GetProperties( rNames );
71 : }
72 :
73 0 : bool SdOptionsItem::PutProperties( const Sequence< OUString >& rNames, const Sequence< Any>& rValues )
74 : {
75 0 : return ConfigItem::PutProperties( rNames, rValues );
76 : }
77 :
78 0 : void SdOptionsItem::SetModified()
79 : {
80 0 : ConfigItem::SetModified();
81 0 : }
82 :
83 : // - SdOptionsGeneric -
84 2156 : SdOptionsGeneric::SdOptionsGeneric(sal_uInt16 nConfigId, const OUString& rSubTree)
85 : : maSubTree(rSubTree)
86 : , mpCfgItem( NULL)
87 : , mnConfigId(nConfigId)
88 2156 : , mbInit(rSubTree.isEmpty())
89 4312 : , mbEnableModify(false)
90 : {
91 2156 : }
92 :
93 58546 : void SdOptionsGeneric::Init() const
94 : {
95 58546 : if( !mbInit )
96 : {
97 180 : SdOptionsGeneric* pThis = const_cast<SdOptionsGeneric*>(this);
98 :
99 180 : if( !mpCfgItem )
100 180 : pThis->mpCfgItem = new SdOptionsItem( *this, maSubTree );
101 :
102 180 : const Sequence< OUString > aNames( GetPropertyNames() );
103 360 : const Sequence< Any > aValues = mpCfgItem->GetProperties( aNames );
104 :
105 180 : if( aNames.getLength() && ( aValues.getLength() == aNames.getLength() ) )
106 : {
107 180 : const Any* pValues = aValues.getConstArray();
108 :
109 180 : pThis->EnableModify( false );
110 180 : pThis->mbInit = pThis->ReadData( pValues );
111 180 : pThis->EnableModify( true );
112 : }
113 : else
114 180 : pThis->mbInit = true;
115 : }
116 58546 : }
117 :
118 4144 : SdOptionsGeneric::~SdOptionsGeneric()
119 : {
120 2072 : delete mpCfgItem;
121 2072 : mpCfgItem = NULL;
122 2072 : }
123 :
124 0 : void SdOptionsGeneric::Commit( SdOptionsItem& rCfgItem ) const
125 : {
126 0 : const Sequence< OUString > aNames( GetPropertyNames() );
127 0 : Sequence< Any > aValues( aNames.getLength() );
128 :
129 0 : if( aNames.getLength() && ( aValues.getLength() == aNames.getLength() ) )
130 : {
131 0 : if( (const_cast<SdOptionsGeneric*>(this))->WriteData( aValues.getArray() ) )
132 0 : rCfgItem.PutProperties( aNames, aValues );
133 : else
134 : {
135 : OSL_FAIL( "PutProperties failed" );
136 : }
137 0 : }
138 0 : }
139 :
140 180 : Sequence< OUString > SdOptionsGeneric::GetPropertyNames() const
141 : {
142 : sal_uLong nCount;
143 : const char** ppPropNames;
144 :
145 180 : GetPropNameArray( ppPropNames, nCount );
146 :
147 180 : Sequence< OUString > aNames( nCount );
148 180 : OUString* pNames = aNames.getArray();
149 :
150 2126 : for( sal_uLong i = 0; i < nCount; i++ )
151 1946 : pNames[ i ] = OUString::createFromAscii( ppPropNames[ i ] );
152 :
153 180 : return aNames;
154 : }
155 :
156 0 : void SdOptionsGeneric::Store()
157 : {
158 0 : if( mpCfgItem )
159 0 : mpCfgItem->Commit();
160 0 : }
161 :
162 122 : bool SdOptionsGeneric::isMetricSystem()
163 : {
164 122 : SvtSysLocale aSysLocale;
165 122 : MeasurementSystem eSys = aSysLocale.GetLocaleDataPtr()->getMeasurementSystemEnum();
166 :
167 122 : return ( eSys == MEASURE_METRIC );
168 : }
169 :
170 : /*************************************************************************
171 : |*
172 : |* SdOptionsLayout
173 : |*
174 : \************************************************************************/
175 :
176 42 : SdOptionsLayout::SdOptionsLayout( sal_uInt16 nConfigId, bool bUseConfig ) :
177 : SdOptionsGeneric( nConfigId, bUseConfig ?
178 : ( ( SDCFG_DRAW == nConfigId ) ?
179 : B2U( "Office.Draw/Layout" ) :
180 : B2U( "Office.Impress/Layout" ) ) :
181 : OUString() ),
182 : bRuler( true ),
183 : bMoveOutline( true ),
184 : bDragStripes( false ),
185 : bHandlesBezier( false ),
186 : bHelplines( true ),
187 42 : nMetric((sal_uInt16)(isMetricSystem() ? FUNIT_CM : FUNIT_INCH)),
188 84 : nDefTab( 1250 )
189 : {
190 42 : EnableModify( true );
191 42 : }
192 :
193 0 : bool SdOptionsLayout::operator==( const SdOptionsLayout& rOpt ) const
194 : {
195 0 : return( IsRulerVisible() == rOpt.IsRulerVisible() &&
196 0 : IsMoveOutline() == rOpt.IsMoveOutline() &&
197 0 : IsDragStripes() == rOpt.IsDragStripes() &&
198 0 : IsHandlesBezier() == rOpt.IsHandlesBezier() &&
199 0 : IsHelplines() == rOpt.IsHelplines() &&
200 0 : GetMetric() == rOpt.GetMetric() &&
201 0 : GetDefTab() == rOpt.GetDefTab() );
202 : }
203 :
204 42 : void SdOptionsLayout::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const
205 : {
206 42 : if( isMetricSystem() )
207 : {
208 : static const char* aPropNamesMetric[] =
209 : {
210 : "Display/Ruler",
211 : "Display/Bezier",
212 : "Display/Contour",
213 : "Display/Guide",
214 : "Display/Helpline",
215 : "Other/MeasureUnit/Metric",
216 : "Other/TabStop/Metric"
217 : };
218 0 : ppNames = aPropNamesMetric;
219 0 : rCount = SAL_N_ELEMENTS(aPropNamesMetric);
220 : }
221 : else
222 : {
223 : static const char* aPropNamesNonMetric[] =
224 : {
225 : "Display/Ruler",
226 : "Display/Bezier",
227 : "Display/Contour",
228 : "Display/Guide",
229 : "Display/Helpline",
230 : "Other/MeasureUnit/NonMetric",
231 : "Other/TabStop/NonMetric"
232 : };
233 42 : ppNames = aPropNamesNonMetric;
234 42 : rCount = SAL_N_ELEMENTS(aPropNamesNonMetric);
235 : }
236 42 : }
237 :
238 42 : bool SdOptionsLayout::ReadData( const Any* pValues )
239 : {
240 42 : if( pValues[0].hasValue() ) SetRulerVisible( *(sal_Bool*) pValues[ 0 ].getValue() );
241 42 : if( pValues[1].hasValue() ) SetHandlesBezier( *(sal_Bool*) pValues[ 1 ].getValue() );
242 42 : if( pValues[2].hasValue() ) SetMoveOutline( *(sal_Bool*) pValues[ 2 ].getValue() );
243 42 : if( pValues[3].hasValue() ) SetDragStripes( *(sal_Bool*) pValues[ 3 ].getValue() );
244 42 : if( pValues[4].hasValue() ) SetHelplines( *(sal_Bool*) pValues[ 4 ].getValue() );
245 42 : if( pValues[5].hasValue() ) SetMetric( (sal_uInt16) *(sal_Int32*) pValues[ 5 ].getValue() );
246 42 : if( pValues[6].hasValue() ) SetDefTab( (sal_uInt16) *(sal_Int32*) pValues[ 6 ].getValue() );
247 :
248 42 : return true;
249 : }
250 :
251 0 : bool SdOptionsLayout::WriteData( Any* pValues ) const
252 : {
253 0 : pValues[ 0 ] <<= IsRulerVisible();
254 0 : pValues[ 1 ] <<= IsHandlesBezier();
255 0 : pValues[ 2 ] <<= IsMoveOutline();
256 0 : pValues[ 3 ] <<= IsDragStripes();
257 0 : pValues[ 4 ] <<= IsHelplines();
258 0 : pValues[ 5 ] <<= (sal_Int32) GetMetric();
259 0 : pValues[ 6 ] <<= (sal_Int32) GetDefTab();
260 :
261 0 : return true;
262 : }
263 :
264 : /*************************************************************************
265 : |*
266 : |* SdOptionsLayoutItem
267 : |*
268 : \************************************************************************/
269 :
270 0 : SdOptionsLayoutItem::SdOptionsLayoutItem( sal_uInt16 _nWhich )
271 : : SfxPoolItem ( _nWhich )
272 0 : , maOptionsLayout ( 0, false )
273 : {
274 0 : }
275 :
276 0 : SdOptionsLayoutItem::SdOptionsLayoutItem( sal_uInt16 _nWhich, SdOptions* pOpts, ::sd::FrameView* pView )
277 : : SfxPoolItem ( _nWhich )
278 0 : , maOptionsLayout ( 0, false )
279 : {
280 0 : if( pOpts )
281 : {
282 0 : maOptionsLayout.SetMetric( pOpts->GetMetric() );
283 0 : maOptionsLayout.SetDefTab( pOpts->GetDefTab() );
284 : }
285 :
286 0 : if( pView )
287 : {
288 0 : maOptionsLayout.SetRulerVisible( pView->HasRuler() );
289 0 : maOptionsLayout.SetMoveOutline( !pView->IsNoDragXorPolys() );
290 0 : maOptionsLayout.SetDragStripes( pView->IsDragStripes() );
291 0 : maOptionsLayout.SetHandlesBezier( pView->IsPlusHandlesAlwaysVisible() );
292 0 : maOptionsLayout.SetHelplines( pView->IsHlplVisible() );
293 : }
294 0 : else if( pOpts )
295 : {
296 0 : maOptionsLayout.SetRulerVisible( pOpts->IsRulerVisible() );
297 0 : maOptionsLayout.SetMoveOutline( pOpts->IsMoveOutline() );
298 0 : maOptionsLayout.SetDragStripes( pOpts->IsDragStripes() );
299 0 : maOptionsLayout.SetHandlesBezier( pOpts->IsHandlesBezier() );
300 0 : maOptionsLayout.SetHelplines( pOpts->IsHelplines() );
301 : }
302 0 : }
303 :
304 0 : SfxPoolItem* SdOptionsLayoutItem::Clone( SfxItemPool* ) const
305 : {
306 0 : return new SdOptionsLayoutItem( *this );
307 : }
308 :
309 0 : bool SdOptionsLayoutItem::operator==( const SfxPoolItem& rAttr ) const
310 : {
311 0 : const bool bSameType = SfxPoolItem::operator==( rAttr );
312 : DBG_ASSERT( bSameType, "SdOptionsLayoutItem::operator==(), different pool item type!" );
313 0 : return bSameType && ( maOptionsLayout == static_cast< const SdOptionsLayoutItem& >( rAttr ).maOptionsLayout );
314 : }
315 :
316 0 : void SdOptionsLayoutItem::SetOptions( SdOptions* pOpts ) const
317 : {
318 0 : if( pOpts )
319 : {
320 0 : pOpts->SetRulerVisible( maOptionsLayout.IsRulerVisible() );
321 0 : pOpts->SetMoveOutline( maOptionsLayout.IsMoveOutline() );
322 0 : pOpts->SetDragStripes( maOptionsLayout.IsDragStripes() );
323 0 : pOpts->SetHandlesBezier( maOptionsLayout.IsHandlesBezier() );
324 0 : pOpts->SetHelplines( maOptionsLayout.IsHelplines() );
325 0 : pOpts->SetMetric( maOptionsLayout.GetMetric() );
326 0 : pOpts->SetDefTab( maOptionsLayout.GetDefTab() );
327 : }
328 0 : }
329 :
330 : /*************************************************************************
331 : |*
332 : |* SdOptionsContents
333 : |*
334 : \************************************************************************/
335 :
336 42 : SdOptionsContents::SdOptionsContents( sal_uInt16 nConfigId, bool bUseConfig ) :
337 : SdOptionsGeneric( nConfigId, bUseConfig ?
338 : ( ( SDCFG_DRAW == nConfigId ) ?
339 : B2U( "Office.Draw/Content" ) :
340 : B2U( "Office.Impress/Content" ) ) :
341 42 : OUString() )
342 : {
343 42 : EnableModify( true );
344 42 : }
345 :
346 0 : bool SdOptionsContents::operator==(const SdOptionsContents&) const
347 : {
348 0 : return true;
349 : }
350 :
351 0 : void SdOptionsContents::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const
352 : {
353 : static const char* aPropNames[] =
354 : {
355 : "Display/PicturePlaceholder",
356 : "Display/ContourMode",
357 : "Display/LineContour",
358 : "Display/TextPlaceholder"
359 : };
360 :
361 0 : rCount = SAL_N_ELEMENTS(aPropNames);
362 0 : ppNames = aPropNames;
363 0 : }
364 :
365 0 : bool SdOptionsContents::ReadData(const Any*)
366 : {
367 0 : return true;
368 : }
369 :
370 0 : bool SdOptionsContents::WriteData( Any* pValues ) const
371 : {
372 : //#i80528# no draft anymore
373 0 : pValues[ 0 ] <<= false;
374 0 : pValues[ 1 ] <<= false;
375 0 : pValues[ 2 ] <<= false;
376 0 : pValues[ 3 ] <<= false;
377 :
378 0 : return true;
379 : }
380 :
381 : /*************************************************************************
382 : |*
383 : |* SdOptionsContentsItem
384 : |*
385 : \************************************************************************/
386 :
387 0 : SdOptionsContentsItem::SdOptionsContentsItem(sal_uInt16 _nWhich, SdOptions*, ::sd::FrameView*)
388 : : SfxPoolItem ( _nWhich )
389 0 : , maOptionsContents ( 0, false )
390 : {
391 0 : }
392 :
393 0 : SfxPoolItem* SdOptionsContentsItem::Clone( SfxItemPool* ) const
394 : {
395 0 : return new SdOptionsContentsItem( *this );
396 : }
397 :
398 0 : bool SdOptionsContentsItem::operator==( const SfxPoolItem& rAttr ) const
399 : {
400 0 : const bool bSameType = SfxPoolItem::operator==(rAttr);
401 : DBG_ASSERT( bSameType, "SdOptionsContentsItem::operator==(), different pool item type!" );
402 0 : return bSameType && ( maOptionsContents == static_cast<const SdOptionsContentsItem&>( rAttr ).maOptionsContents );
403 : }
404 :
405 0 : void SdOptionsContentsItem::SetOptions(SdOptions*) const
406 : {
407 0 : }
408 :
409 : /*************************************************************************
410 : |*
411 : |* SdOptionsMisc
412 : |*
413 : \************************************************************************/
414 :
415 42 : SdOptionsMisc::SdOptionsMisc( sal_uInt16 nConfigId, bool bUseConfig ) :
416 : SdOptionsGeneric( nConfigId, bUseConfig ?
417 : ( ( SDCFG_DRAW == nConfigId ) ?
418 : B2U( "Office.Draw/Misc" ) :
419 : B2U( "Office.Impress/Misc" ) ) :
420 : OUString() ),
421 : nDefaultObjectSizeWidth(8000),
422 : nDefaultObjectSizeHeight(5000),
423 : bStartWithTemplate( false ),
424 : bMarkedHitMovesAlways( true ),
425 : bMoveOnlyDragging( false ),
426 : bCrookNoContortion( false ),
427 42 : bQuickEdit( GetConfigId() != SDCFG_DRAW ),
428 : bMasterPageCache( true ),
429 : bDragWithCopy( false ),
430 : bPickThrough( true ),
431 : bDoubleClickTextEdit( true ),
432 : bClickChangeRotation( false ),
433 : bEnableSdremote( false ),
434 : bEnablePresenterScreen( true),
435 : bSolidDragging( true ),
436 : bSummationOfParagraphs( false ),
437 : bShowUndoDeleteWarning( true ),
438 : bSlideshowRespectZOrder( true ),
439 : bShowComments( true ),
440 : bPreviewNewEffects( true ),
441 : bPreviewChangedEffects( false ),
442 : bPreviewTransitions( true ),
443 : mnDisplay( 0 ),
444 : mnPenColor( 0xff0000 ),
445 : mnPenWidth( 150.0 ),
446 :
447 : // The default for 6.1-and-above documents is to use printer-independent
448 : // formatting.
449 84 : mnPrinterIndependentLayout (1)
450 : {
451 42 : EnableModify( true );
452 42 : }
453 :
454 0 : bool SdOptionsMisc::operator==( const SdOptionsMisc& rOpt ) const
455 : {
456 0 : return( IsStartWithTemplate() == rOpt.IsStartWithTemplate() &&
457 0 : IsMarkedHitMovesAlways() == rOpt.IsMarkedHitMovesAlways() &&
458 0 : IsMoveOnlyDragging() == rOpt.IsMoveOnlyDragging() &&
459 0 : IsCrookNoContortion() == rOpt.IsCrookNoContortion() &&
460 0 : IsQuickEdit() == rOpt.IsQuickEdit() &&
461 0 : IsMasterPagePaintCaching() == rOpt.IsMasterPagePaintCaching() &&
462 0 : IsDragWithCopy() == rOpt.IsDragWithCopy() &&
463 0 : IsPickThrough() == rOpt.IsPickThrough() &&
464 0 : IsDoubleClickTextEdit() == rOpt.IsDoubleClickTextEdit() &&
465 0 : IsClickChangeRotation() == rOpt.IsClickChangeRotation() &&
466 0 : IsEnableSdremote() == rOpt.IsEnableSdremote() &&
467 0 : IsEnablePresenterScreen() == rOpt.IsEnablePresenterScreen()&&
468 0 : IsSummationOfParagraphs() == rOpt.IsSummationOfParagraphs() &&
469 0 : IsSolidDragging() == rOpt.IsSolidDragging() &&
470 0 : IsShowUndoDeleteWarning() == rOpt.IsShowUndoDeleteWarning() &&
471 0 : IsSlideshowRespectZOrder() == rOpt.IsSlideshowRespectZOrder() &&
472 0 : GetPrinterIndependentLayout() == rOpt.GetPrinterIndependentLayout() &&
473 0 : GetDefaultObjectSizeWidth() == rOpt.GetDefaultObjectSizeWidth() &&
474 0 : GetDefaultObjectSizeHeight() == rOpt.GetDefaultObjectSizeHeight() &&
475 :
476 0 : IsPreviewNewEffects() == rOpt.IsPreviewNewEffects() &&
477 0 : IsPreviewChangedEffects() == rOpt.IsPreviewChangedEffects() &&
478 0 : IsPreviewTransitions() == rOpt.IsPreviewTransitions() &&
479 0 : GetDisplay() == rOpt.GetDisplay() &&
480 0 : IsShowComments() == rOpt.IsShowComments() &&
481 0 : GetPresentationPenColor() == rOpt.GetPresentationPenColor() &&
482 0 : GetPresentationPenWidth() == rOpt.GetPresentationPenWidth()
483 0 : );
484 : }
485 :
486 42 : void SdOptionsMisc::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const
487 : {
488 : static const char* aPropNames[] =
489 : {
490 : "ObjectMoveable",
491 : "NoDistort",
492 : "TextObject/QuickEditing",
493 : "BackgroundCache",
494 : "CopyWhileMoving",
495 : "TextObject/Selectable",
496 : "DclickTextedit",
497 : "RotateClick",
498 : "Preview",
499 : "ModifyWithAttributes",
500 : "DefaultObjectSize/Width",
501 : "DefaultObjectSize/Height",
502 :
503 : "Compatibility/PrinterIndependentLayout",
504 :
505 : "ShowComments",
506 :
507 : // just for impress
508 : "NewDoc/AutoPilot",
509 : "Compatibility/AddBetween",
510 : "ShowUndoDeleteWarning",
511 : "SlideshowRespectZOrder",
512 :
513 : "PreviewNewEffects",
514 : "PreviewChangedEffects",
515 : "PreviewTransitions",
516 :
517 : "Display",
518 :
519 : "PenColor",
520 : "PenWidth",
521 : "Start/EnableSdremote",
522 : "Start/EnablePresenterScreen"
523 : };
524 :
525 42 : rCount = ( ( GetConfigId() == SDCFG_IMPRESS ) ? SAL_N_ELEMENTS(aPropNames) : 14 );
526 42 : ppNames = aPropNames;
527 42 : }
528 :
529 42 : bool SdOptionsMisc::ReadData( const Any* pValues )
530 : {
531 42 : if( pValues[0].hasValue() ) SetMarkedHitMovesAlways( *(sal_Bool*) pValues[ 0 ].getValue() );
532 42 : if( pValues[1].hasValue() ) SetCrookNoContortion( *(sal_Bool*) pValues[ 1 ].getValue() );
533 42 : if( pValues[2].hasValue() ) SetQuickEdit( *(sal_Bool*)pValues[ 2 ].getValue() );
534 42 : if( pValues[3].hasValue() ) SetMasterPagePaintCaching( *(sal_Bool*) pValues[ 3 ].getValue() );
535 42 : if( pValues[4].hasValue() ) SetDragWithCopy( *(sal_Bool*) pValues[ 4 ].getValue() );
536 42 : if( pValues[5].hasValue() ) SetPickThrough( *(sal_Bool*) pValues[ 5 ].getValue() );
537 42 : if( pValues[6].hasValue() ) SetDoubleClickTextEdit( *(sal_Bool*) pValues[ 6 ].getValue() );
538 42 : if( pValues[7].hasValue() ) SetClickChangeRotation( *(sal_Bool*) pValues[ 7 ].getValue() );
539 42 : if( pValues[9].hasValue() ) SetSolidDragging( *(sal_Bool*) pValues[ 9 ].getValue() );
540 42 : if( pValues[10].hasValue() ) SetDefaultObjectSizeWidth( *(sal_uInt32*) pValues[ 10 ].getValue() );
541 42 : if( pValues[11].hasValue() ) SetDefaultObjectSizeHeight( *(sal_uInt32*) pValues[ 11 ].getValue() );
542 42 : if( pValues[12].hasValue() ) SetPrinterIndependentLayout( *(sal_uInt16*) pValues[ 12 ].getValue() );
543 :
544 42 : if( pValues[13].hasValue() )
545 42 : SetShowComments( *(sal_Bool*) pValues[ 13 ].getValue() );
546 :
547 : // just for Impress
548 42 : if( GetConfigId() == SDCFG_IMPRESS )
549 : {
550 22 : if( pValues[14].hasValue() )
551 22 : SetStartWithTemplate( *(sal_Bool*) pValues[ 14 ].getValue() );
552 22 : if( pValues[15].hasValue() )
553 22 : SetSummationOfParagraphs( *(sal_Bool*) pValues[ 15 ].getValue() );
554 22 : if( pValues[16].hasValue() )
555 22 : SetShowUndoDeleteWarning( *(sal_Bool*) pValues[ 16 ].getValue() );
556 :
557 22 : if( pValues[17].hasValue() )
558 22 : SetSlideshowRespectZOrder(*(sal_Bool*) pValues[ 17 ].getValue());
559 :
560 22 : if( pValues[18].hasValue() )
561 22 : SetPreviewNewEffects(*(sal_Bool*) pValues[ 18 ].getValue());
562 :
563 22 : if( pValues[19].hasValue() )
564 22 : SetPreviewChangedEffects(*(sal_Bool*) pValues[ 19 ].getValue());
565 :
566 22 : if( pValues[20].hasValue() )
567 22 : SetPreviewTransitions(*(sal_Bool*) pValues[ 20 ].getValue());
568 :
569 22 : if( pValues[21].hasValue() )
570 22 : SetDisplay(*(sal_Int32*) pValues[ 21 ].getValue());
571 :
572 22 : if( pValues[22].hasValue() )
573 22 : SetPresentationPenColor( getSafeValue< sal_Int32 >( pValues[ 22 ] ) );
574 :
575 22 : if( pValues[23].hasValue() )
576 22 : SetPresentationPenWidth( getSafeValue< double >( pValues[ 23 ] ) );
577 :
578 22 : if( pValues[24].hasValue() )
579 22 : SetEnableSdremote( *(sal_Bool*) pValues[ 24 ].getValue() );
580 :
581 22 : if( pValues[25].hasValue() )
582 22 : SetEnablePresenterScreen( *(sal_Bool*) pValues[ 25 ].getValue() );
583 : }
584 :
585 42 : return true;
586 : }
587 :
588 0 : bool SdOptionsMisc::WriteData( Any* pValues ) const
589 : {
590 0 : pValues[ 0 ] <<= IsMarkedHitMovesAlways();
591 0 : pValues[ 1 ] <<= IsCrookNoContortion();
592 0 : pValues[ 2 ] <<= IsQuickEdit();
593 0 : pValues[ 3 ] <<= IsMasterPagePaintCaching();
594 0 : pValues[ 4 ] <<= IsDragWithCopy();
595 0 : pValues[ 5 ] <<= IsPickThrough();
596 0 : pValues[ 6 ] <<= IsDoubleClickTextEdit();
597 0 : pValues[ 7 ] <<= IsClickChangeRotation();
598 : // The preview is not supported anymore. Use a dummy value.
599 0 : pValues[ 8 ] <<= (double)0;// GetPreviewQuality();
600 0 : pValues[ 9 ] <<= IsSolidDragging();
601 0 : pValues[ 10 ] <<= GetDefaultObjectSizeWidth();
602 0 : pValues[ 11 ] <<= GetDefaultObjectSizeHeight();
603 0 : pValues[ 12 ] <<= GetPrinterIndependentLayout();
604 0 : pValues[ 13 ] <<= IsShowComments();
605 :
606 : // just for Impress
607 0 : if( GetConfigId() == SDCFG_IMPRESS )
608 : {
609 0 : pValues[ 14 ] <<= IsStartWithTemplate();
610 0 : pValues[ 15 ] <<= IsSummationOfParagraphs();
611 0 : pValues[ 16 ] <<= IsShowUndoDeleteWarning();
612 0 : pValues[ 17 ] <<= IsSlideshowRespectZOrder();
613 :
614 0 : pValues[ 18 ] <<= IsPreviewNewEffects();
615 0 : pValues[ 19 ] <<= IsPreviewChangedEffects();
616 0 : pValues[ 20 ] <<= IsPreviewTransitions();
617 :
618 0 : pValues[ 21 ] <<= GetDisplay();
619 :
620 0 : pValues[ 22 ] <<= GetPresentationPenColor();
621 0 : pValues[ 23 ] <<= GetPresentationPenWidth();
622 0 : pValues[ 24 ] <<= IsEnableSdremote();
623 0 : pValues[ 25 ] <<= IsEnablePresenterScreen();
624 : }
625 :
626 0 : return true;
627 : }
628 :
629 : /*************************************************************************
630 : |*
631 : |* SdOptionsMiscItem
632 : |*
633 : \************************************************************************/
634 :
635 0 : SdOptionsMiscItem::SdOptionsMiscItem( sal_uInt16 _nWhich )
636 : : SfxPoolItem ( _nWhich )
637 0 : , maOptionsMisc ( 0, false )
638 : {
639 0 : }
640 :
641 0 : SdOptionsMiscItem::SdOptionsMiscItem( sal_uInt16 _nWhich, SdOptions* pOpts, ::sd::FrameView* pView )
642 : : SfxPoolItem ( _nWhich )
643 0 : , maOptionsMisc ( 0, false )
644 : {
645 0 : if( pOpts )
646 : {
647 0 : maOptionsMisc.SetStartWithTemplate( pOpts->IsStartWithTemplate() );
648 0 : maOptionsMisc.SetEnableSdremote( pOpts->IsEnableSdremote() );
649 0 : maOptionsMisc.SetEnablePresenterScreen( pOpts->IsEnablePresenterScreen() );
650 0 : maOptionsMisc.SetSummationOfParagraphs( pOpts->IsSummationOfParagraphs() );
651 0 : maOptionsMisc.SetShowUndoDeleteWarning( pOpts->IsShowUndoDeleteWarning() );
652 0 : maOptionsMisc.SetPrinterIndependentLayout( pOpts->GetPrinterIndependentLayout() );
653 0 : maOptionsMisc.SetDefaultObjectSizeWidth( pOpts->GetDefaultObjectSizeWidth() );
654 0 : maOptionsMisc.SetDefaultObjectSizeHeight( pOpts->GetDefaultObjectSizeHeight() );
655 :
656 0 : maOptionsMisc.SetPreviewNewEffects(pOpts->IsPreviewNewEffects());
657 0 : maOptionsMisc.SetPreviewChangedEffects(pOpts->IsPreviewChangedEffects());
658 0 : maOptionsMisc.SetPreviewTransitions(pOpts->IsPreviewTransitions());
659 :
660 0 : maOptionsMisc.SetDisplay(pOpts->GetDisplay());
661 0 : maOptionsMisc.SetShowComments( pOpts->IsShowComments() );
662 :
663 0 : maOptionsMisc.SetPresentationPenColor(pOpts->GetPresentationPenColor() );
664 0 : maOptionsMisc.SetPresentationPenWidth(pOpts->GetPresentationPenWidth() );
665 : }
666 :
667 0 : if( pView )
668 : {
669 0 : maOptionsMisc.SetMarkedHitMovesAlways( pView->IsMarkedHitMovesAlways() );
670 0 : maOptionsMisc.SetMoveOnlyDragging( pView->IsMoveOnlyDragging() );
671 0 : maOptionsMisc.SetCrookNoContortion( pView->IsCrookNoContortion() );
672 0 : maOptionsMisc.SetQuickEdit( pView->IsQuickEdit() );
673 :
674 : // #i26631#
675 0 : maOptionsMisc.SetMasterPagePaintCaching( pView->IsMasterPagePaintCaching() );
676 :
677 0 : maOptionsMisc.SetDragWithCopy( pView->IsDragWithCopy() );
678 0 : maOptionsMisc.SetPickThrough( pView->GetModel()->IsPickThroughTransparentTextFrames() );
679 0 : maOptionsMisc.SetDoubleClickTextEdit( pView->IsDoubleClickTextEdit() );
680 0 : maOptionsMisc.SetClickChangeRotation( pView->IsClickChangeRotation() );
681 0 : maOptionsMisc.SetSolidDragging( pView->IsSolidDragging() );
682 : }
683 0 : else if( pOpts )
684 : {
685 0 : maOptionsMisc.SetMarkedHitMovesAlways( pOpts->IsMarkedHitMovesAlways() );
686 0 : maOptionsMisc.SetMoveOnlyDragging( pOpts->IsMoveOnlyDragging() );
687 0 : maOptionsMisc.SetCrookNoContortion( pOpts->IsCrookNoContortion() );
688 0 : maOptionsMisc.SetQuickEdit( pOpts->IsQuickEdit() );
689 0 : maOptionsMisc.SetMasterPagePaintCaching( pOpts->IsMasterPagePaintCaching() );
690 0 : maOptionsMisc.SetDragWithCopy( pOpts->IsDragWithCopy() );
691 0 : maOptionsMisc.SetPickThrough( pOpts->IsPickThrough() );
692 0 : maOptionsMisc.SetDoubleClickTextEdit( pOpts->IsDoubleClickTextEdit() );
693 0 : maOptionsMisc.SetClickChangeRotation( pOpts->IsClickChangeRotation() );
694 0 : maOptionsMisc.SetSolidDragging( pOpts->IsSolidDragging() );
695 : }
696 0 : }
697 :
698 0 : SfxPoolItem* SdOptionsMiscItem::Clone( SfxItemPool* ) const
699 : {
700 0 : return new SdOptionsMiscItem( *this );
701 : }
702 :
703 0 : bool SdOptionsMiscItem::operator==( const SfxPoolItem& rAttr ) const
704 : {
705 0 : const bool bSameType = SfxPoolItem::operator==(rAttr);
706 : DBG_ASSERT( bSameType, "SdOptionsMiscItem::operator==(), different pool item type!" );
707 0 : return bSameType && ( maOptionsMisc == static_cast< const SdOptionsMiscItem& >(rAttr).maOptionsMisc );
708 : }
709 :
710 0 : void SdOptionsMiscItem::SetOptions( SdOptions* pOpts ) const
711 : {
712 0 : if( pOpts )
713 : {
714 0 : pOpts->SetStartWithTemplate( maOptionsMisc.IsStartWithTemplate() );
715 0 : pOpts->SetMarkedHitMovesAlways( maOptionsMisc.IsMarkedHitMovesAlways() );
716 0 : pOpts->SetMoveOnlyDragging( maOptionsMisc.IsMoveOnlyDragging() );
717 0 : pOpts->SetCrookNoContortion( maOptionsMisc.IsCrookNoContortion() );
718 0 : pOpts->SetQuickEdit( maOptionsMisc.IsQuickEdit() );
719 0 : pOpts->SetMasterPagePaintCaching( maOptionsMisc.IsMasterPagePaintCaching() );
720 0 : pOpts->SetDragWithCopy( maOptionsMisc.IsDragWithCopy() );
721 0 : pOpts->SetPickThrough( maOptionsMisc.IsPickThrough() );
722 0 : pOpts->SetDoubleClickTextEdit( maOptionsMisc.IsDoubleClickTextEdit() );
723 0 : pOpts->SetClickChangeRotation( maOptionsMisc.IsClickChangeRotation() );
724 0 : pOpts->SetEnableSdremote( maOptionsMisc.IsEnableSdremote() );
725 0 : pOpts->SetEnablePresenterScreen( maOptionsMisc.IsEnablePresenterScreen() );
726 0 : pOpts->SetSummationOfParagraphs( maOptionsMisc.IsSummationOfParagraphs() );
727 0 : pOpts->SetSolidDragging( maOptionsMisc.IsSolidDragging() );
728 0 : pOpts->SetShowUndoDeleteWarning( maOptionsMisc.IsShowUndoDeleteWarning() );
729 0 : pOpts->SetPrinterIndependentLayout( maOptionsMisc.GetPrinterIndependentLayout() );
730 0 : pOpts->SetShowComments( maOptionsMisc.IsShowComments() );
731 0 : pOpts->SetDefaultObjectSizeWidth( maOptionsMisc.GetDefaultObjectSizeWidth() );
732 0 : pOpts->SetDefaultObjectSizeHeight( maOptionsMisc.GetDefaultObjectSizeHeight() );
733 :
734 0 : pOpts->SetPreviewNewEffects( maOptionsMisc.IsPreviewNewEffects() );
735 0 : pOpts->SetPreviewChangedEffects( maOptionsMisc.IsPreviewChangedEffects() );
736 0 : pOpts->SetPreviewTransitions( maOptionsMisc.IsPreviewTransitions() );
737 :
738 0 : pOpts->SetDisplay( maOptionsMisc.GetDisplay() );
739 :
740 0 : pOpts->SetPresentationPenColor( maOptionsMisc.GetPresentationPenColor() );
741 0 : pOpts->SetPresentationPenWidth( maOptionsMisc.GetPresentationPenWidth() );
742 : }
743 0 : }
744 :
745 : /*************************************************************************
746 : |*
747 : |* SdOptionsSnap
748 : |*
749 : \************************************************************************/
750 :
751 42 : SdOptionsSnap::SdOptionsSnap( sal_uInt16 nConfigId, bool bUseConfig ) :
752 : SdOptionsGeneric( nConfigId, bUseConfig ?
753 : ( ( SDCFG_DRAW == nConfigId ) ?
754 : B2U( "Office.Draw/Snap" ) :
755 : B2U( "Office.Impress/Snap" ) ) :
756 : OUString() ),
757 : bSnapHelplines( true ),
758 : bSnapBorder( true ),
759 : bSnapFrame( false ),
760 : bSnapPoints( false ),
761 : bOrtho( false ),
762 : bBigOrtho( true ),
763 : bRotate( false ),
764 : nSnapArea( 5 ),
765 : nAngle( 1500 ),
766 42 : nBezAngle( 1500 )
767 :
768 : {
769 42 : EnableModify( true );
770 42 : }
771 :
772 0 : bool SdOptionsSnap::operator==( const SdOptionsSnap& rOpt ) const
773 : {
774 0 : return( IsSnapHelplines() == rOpt.IsSnapHelplines() &&
775 0 : IsSnapBorder() == rOpt.IsSnapBorder() &&
776 0 : IsSnapFrame() == rOpt.IsSnapFrame() &&
777 0 : IsSnapPoints() == rOpt.IsSnapPoints() &&
778 0 : IsOrtho() == rOpt.IsOrtho() &&
779 0 : IsBigOrtho() == rOpt.IsBigOrtho() &&
780 0 : IsRotate() == rOpt.IsRotate() &&
781 0 : GetSnapArea() == rOpt.GetSnapArea() &&
782 0 : GetAngle() == rOpt.GetAngle() &&
783 0 : GetEliminatePolyPointLimitAngle() == rOpt.GetEliminatePolyPointLimitAngle() );
784 : }
785 :
786 38 : void SdOptionsSnap::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const
787 : {
788 : static const char* aPropNames[] =
789 : {
790 : "Object/SnapLine",
791 : "Object/PageMargin",
792 : "Object/ObjectFrame",
793 : "Object/ObjectPoint",
794 : "Position/CreatingMoving",
795 : "Position/ExtendEdges",
796 : "Position/Rotating",
797 : "Object/Range",
798 : "Position/RotatingValue",
799 : "Position/PointReduction"
800 : };
801 :
802 38 : rCount = SAL_N_ELEMENTS(aPropNames);
803 38 : ppNames = aPropNames;
804 38 : }
805 :
806 38 : bool SdOptionsSnap::ReadData( const Any* pValues )
807 : {
808 38 : if( pValues[0].hasValue() ) SetSnapHelplines( *(sal_Bool*) pValues[ 0 ].getValue() );
809 38 : if( pValues[1].hasValue() ) SetSnapBorder( *(sal_Bool*)pValues[ 1 ].getValue() );
810 38 : if( pValues[2].hasValue() ) SetSnapFrame( *(sal_Bool*) pValues[ 2 ].getValue() );
811 38 : if( pValues[3].hasValue() ) SetSnapPoints( *(sal_Bool*) pValues[ 3 ].getValue() );
812 38 : if( pValues[4].hasValue() ) SetOrtho( *(sal_Bool*) pValues[ 4 ].getValue() );
813 38 : if( pValues[5].hasValue() ) SetBigOrtho( *(sal_Bool*) pValues[ 5 ].getValue() );
814 38 : if( pValues[6].hasValue() ) SetRotate( *(sal_Bool*) pValues[ 6 ].getValue() );
815 38 : if( pValues[7].hasValue() ) SetSnapArea( (sal_Int16) *(sal_Int32*) pValues[ 7 ].getValue() );
816 38 : if( pValues[8].hasValue() ) SetAngle( (sal_Int16) *(sal_Int32*) pValues[ 8 ].getValue() );
817 38 : if( pValues[9].hasValue() ) SetEliminatePolyPointLimitAngle( (sal_Int16) *(sal_Int32*) pValues[ 9 ].getValue() );
818 :
819 38 : return true;
820 : }
821 :
822 0 : bool SdOptionsSnap::WriteData( Any* pValues ) const
823 : {
824 0 : pValues[ 0 ] <<= IsSnapHelplines();
825 0 : pValues[ 1 ] <<= IsSnapBorder();
826 0 : pValues[ 2 ] <<= IsSnapFrame();
827 0 : pValues[ 3 ] <<= IsSnapPoints();
828 0 : pValues[ 4 ] <<= IsOrtho();
829 0 : pValues[ 5 ] <<= IsBigOrtho();
830 0 : pValues[ 6 ] <<= IsRotate();
831 0 : pValues[ 7 ] <<= (sal_Int32) GetSnapArea();
832 0 : pValues[ 8 ] <<= (sal_Int32) GetAngle();
833 0 : pValues[ 9 ] <<= (sal_Int32) GetEliminatePolyPointLimitAngle();
834 :
835 0 : return true;
836 : }
837 :
838 : /*************************************************************************
839 : |*
840 : |* SdOptionsSnapItem
841 : |*
842 : \************************************************************************/
843 :
844 0 : SdOptionsSnapItem::SdOptionsSnapItem( sal_uInt16 _nWhich )
845 : : SfxPoolItem ( _nWhich )
846 0 : , maOptionsSnap ( 0, false )
847 : {
848 0 : }
849 :
850 0 : SdOptionsSnapItem::SdOptionsSnapItem( sal_uInt16 _nWhich, SdOptions* pOpts, ::sd::FrameView* pView )
851 : : SfxPoolItem ( _nWhich )
852 0 : , maOptionsSnap ( 0, false )
853 : {
854 0 : if( pView )
855 : {
856 0 : maOptionsSnap.SetSnapHelplines( pView->IsHlplSnap() );
857 0 : maOptionsSnap.SetSnapBorder( pView->IsBordSnap() );
858 0 : maOptionsSnap.SetSnapFrame( pView->IsOFrmSnap() );
859 0 : maOptionsSnap.SetSnapPoints( pView->IsOPntSnap() );
860 0 : maOptionsSnap.SetOrtho( pView->IsOrtho() );
861 0 : maOptionsSnap.SetBigOrtho( pView->IsBigOrtho() );
862 0 : maOptionsSnap.SetRotate( pView->IsAngleSnapEnabled() );
863 0 : maOptionsSnap.SetSnapArea( pView->GetSnapMagneticPixel() );
864 0 : maOptionsSnap.SetAngle( (sal_Int16) pView->GetSnapAngle() );
865 0 : maOptionsSnap.SetEliminatePolyPointLimitAngle( (sal_Int16) pView->GetEliminatePolyPointLimitAngle() );
866 : }
867 0 : else if( pOpts )
868 : {
869 0 : maOptionsSnap.SetSnapHelplines( pOpts->IsSnapHelplines() );
870 0 : maOptionsSnap.SetSnapBorder( pOpts->IsSnapBorder() );
871 0 : maOptionsSnap.SetSnapFrame( pOpts->IsSnapFrame() );
872 0 : maOptionsSnap.SetSnapPoints( pOpts->IsSnapPoints() );
873 0 : maOptionsSnap.SetOrtho( pOpts->IsOrtho() );
874 0 : maOptionsSnap.SetBigOrtho( pOpts->IsBigOrtho() );
875 0 : maOptionsSnap.SetRotate( pOpts->IsRotate() );
876 0 : maOptionsSnap.SetSnapArea( pOpts->GetSnapArea() );
877 0 : maOptionsSnap.SetAngle( pOpts->GetAngle() );
878 0 : maOptionsSnap.SetEliminatePolyPointLimitAngle( pOpts->GetEliminatePolyPointLimitAngle() );
879 : }
880 0 : }
881 :
882 0 : SfxPoolItem* SdOptionsSnapItem::Clone( SfxItemPool* ) const
883 : {
884 0 : return new SdOptionsSnapItem( *this );
885 : }
886 :
887 0 : bool SdOptionsSnapItem::operator==( const SfxPoolItem& rAttr ) const
888 : {
889 0 : const bool bSameType = SfxPoolItem::operator==(rAttr);
890 : DBG_ASSERT( bSameType, "SdOptionsSnapItem::operator==(), different pool item type!" );
891 0 : return bSameType && ( maOptionsSnap == static_cast< const SdOptionsSnapItem& >(rAttr).maOptionsSnap );
892 : }
893 :
894 0 : void SdOptionsSnapItem::SetOptions( SdOptions* pOpts ) const
895 : {
896 0 : if( pOpts )
897 : {
898 0 : pOpts->SetSnapHelplines( maOptionsSnap.IsSnapHelplines() );
899 0 : pOpts->SetSnapBorder( maOptionsSnap.IsSnapBorder() );
900 0 : pOpts->SetSnapFrame( maOptionsSnap.IsSnapFrame() );
901 0 : pOpts->SetSnapPoints( maOptionsSnap.IsSnapPoints() );
902 0 : pOpts->SetOrtho( maOptionsSnap.IsOrtho() );
903 0 : pOpts->SetBigOrtho( maOptionsSnap.IsBigOrtho() );
904 0 : pOpts->SetRotate( maOptionsSnap.IsRotate() );
905 0 : pOpts->SetSnapArea( maOptionsSnap.GetSnapArea() );
906 0 : pOpts->SetAngle( maOptionsSnap.GetAngle() );
907 0 : pOpts->SetEliminatePolyPointLimitAngle( maOptionsSnap.GetEliminatePolyPointLimitAngle() );
908 : }
909 0 : }
910 :
911 : /*************************************************************************
912 : |*
913 : |* SdOptionsZoom
914 : |*
915 : \************************************************************************/
916 :
917 42 : SdOptionsZoom::SdOptionsZoom( sal_uInt16 nConfigId, bool bUseConfig ) :
918 42 : SdOptionsGeneric( nConfigId, ( bUseConfig && ( SDCFG_DRAW == nConfigId ) ) ?
919 : B2U( "Office.Draw/Zoom" ) :
920 : OUString() ),
921 : nX( 1 ),
922 62 : nY( 1 )
923 :
924 : {
925 42 : EnableModify( true );
926 42 : }
927 :
928 0 : bool SdOptionsZoom::operator==( const SdOptionsZoom& rOpt ) const
929 : {
930 : sal_Int32 nX1, nX2, nY1, nY2;
931 :
932 0 : GetScale( nX1, nY1 );
933 0 : rOpt.GetScale( nX2, nY2 );
934 :
935 0 : return( ( nX1 == nX2 ) &&
936 0 : ( nY1 == nY2 ) );
937 : }
938 :
939 20 : void SdOptionsZoom::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const
940 : {
941 : static const char* aPropNames[] =
942 : {
943 : "ScaleX",
944 : "ScaleY"
945 : };
946 :
947 20 : rCount = ( GetConfigId() == SDCFG_DRAW ) ? SAL_N_ELEMENTS(aPropNames) : 0;
948 20 : ppNames = aPropNames;
949 20 : }
950 :
951 20 : bool SdOptionsZoom::ReadData( const Any* pValues )
952 : {
953 20 : sal_Int32 x = 1, y = 1;
954 :
955 20 : if( pValues[0].hasValue() ) x = ( *(sal_Int32*) pValues[ 0 ].getValue() );
956 20 : if( pValues[1].hasValue() ) y = ( *(sal_Int32*) pValues[ 1 ].getValue() );
957 :
958 20 : SetScale( x, y );
959 :
960 20 : return true;
961 : }
962 :
963 0 : bool SdOptionsZoom::WriteData( Any* pValues ) const
964 : {
965 : sal_Int32 x, y;
966 :
967 0 : GetScale( x, y );
968 :
969 0 : pValues[ 0 ] <<= (sal_Int32) x;
970 0 : pValues[ 1 ] <<= (sal_Int32) y;
971 :
972 0 : return true;
973 : }
974 :
975 : /*************************************************************************
976 : |*
977 : |* SdOptionsGrid
978 : |*
979 : \************************************************************************/
980 :
981 42 : SdOptionsGrid::SdOptionsGrid( sal_uInt16 nConfigId, bool bUseConfig ) :
982 : SdOptionsGeneric( nConfigId, bUseConfig ?
983 : ( ( SDCFG_DRAW == nConfigId ) ?
984 : B2U( "Office.Draw/Grid" ) :
985 : B2U( "Office.Impress/Grid" ) ) :
986 42 : OUString() )
987 : {
988 42 : EnableModify( false );
989 42 : SetDefaults();
990 42 : EnableModify( true );
991 42 : }
992 :
993 30 : SdOptionsGrid::~SdOptionsGrid()
994 : {
995 30 : }
996 :
997 42 : void SdOptionsGrid::SetDefaults()
998 : {
999 42 : const sal_uInt32 nVal = 1000;
1000 :
1001 42 : SetFldDivisionX( nVal );
1002 42 : SetFldDivisionY( nVal );
1003 42 : SetFldDrawX( nVal );
1004 42 : SetFldDrawY( nVal );
1005 42 : SetFldSnapX( nVal );
1006 42 : SetFldSnapY( nVal );
1007 42 : SetUseGridSnap( false );
1008 42 : SetSynchronize( true );
1009 42 : SetGridVisible( false );
1010 42 : SetEqualGrid( true );
1011 42 : }
1012 :
1013 0 : bool SdOptionsGrid::operator==( const SdOptionsGrid& rOpt ) const
1014 : {
1015 0 : return( GetFldDrawX() == rOpt.GetFldDrawX() &&
1016 0 : GetFldDivisionX() == rOpt.GetFldDivisionX() &&
1017 0 : GetFldDrawY() == rOpt.GetFldDrawY() &&
1018 0 : GetFldDivisionY() == rOpt.GetFldDivisionY() &&
1019 0 : GetFldSnapX() == rOpt.GetFldSnapX() &&
1020 0 : GetFldSnapY() == rOpt.GetFldSnapY() &&
1021 0 : IsUseGridSnap() == rOpt.IsUseGridSnap() &&
1022 0 : IsSynchronize() == rOpt.IsSynchronize() &&
1023 0 : IsGridVisible() == rOpt.IsGridVisible() &&
1024 0 : IsEqualGrid() == rOpt.IsEqualGrid() );
1025 : }
1026 :
1027 38 : void SdOptionsGrid::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const
1028 : {
1029 38 : if( isMetricSystem() )
1030 : {
1031 : static const char* aPropNamesMetric[] =
1032 : {
1033 : "Resolution/XAxis/Metric",
1034 : "Resolution/YAxis/Metric",
1035 : "Subdivision/XAxis",
1036 : "Subdivision/YAxis",
1037 : "SnapGrid/XAxis/Metric",
1038 : "SnapGrid/YAxis/Metric",
1039 : "Option/SnapToGrid",
1040 : "Option/Synchronize",
1041 : "Option/VisibleGrid",
1042 : "SnapGrid/Size"
1043 : };
1044 0 : ppNames = aPropNamesMetric;
1045 0 : rCount = SAL_N_ELEMENTS(aPropNamesMetric);
1046 : }
1047 : else
1048 : {
1049 : static const char* aPropNamesNonMetric[] =
1050 : {
1051 : "Resolution/XAxis/NonMetric",
1052 : "Resolution/YAxis/NonMetric",
1053 : "Subdivision/XAxis",
1054 : "Subdivision/YAxis",
1055 : "SnapGrid/XAxis/NonMetric",
1056 : "SnapGrid/YAxis/NonMetric",
1057 : "Option/SnapToGrid",
1058 : "Option/Synchronize",
1059 : "Option/VisibleGrid",
1060 : "SnapGrid/Size"
1061 : };
1062 38 : ppNames = aPropNamesNonMetric;
1063 38 : rCount = SAL_N_ELEMENTS(aPropNamesNonMetric);
1064 : }
1065 38 : }
1066 :
1067 38 : bool SdOptionsGrid::ReadData( const Any* pValues )
1068 : {
1069 38 : if( pValues[0].hasValue() ) SetFldDrawX( *(sal_Int32*) pValues[ 0 ].getValue() );
1070 38 : if( pValues[1].hasValue() ) SetFldDrawY( *(sal_Int32*) pValues[ 1 ].getValue() );
1071 :
1072 38 : if( pValues[2].hasValue() )
1073 : {
1074 38 : const sal_uInt32 nDivX = FRound( *(double*) pValues[ 2 ].getValue() );
1075 38 : SetFldDivisionX( SvxOptionsGrid::GetFldDrawX() / ( nDivX + 1 ) );
1076 : }
1077 :
1078 38 : if( pValues[3].hasValue() )
1079 : {
1080 38 : const sal_uInt32 nDivY = FRound( *(double*) pValues[ 3 ].getValue() );
1081 38 : SetFldDivisionY( SvxOptionsGrid::GetFldDrawY() / ( nDivY + 1 ) );
1082 : }
1083 :
1084 38 : if( pValues[4].hasValue() ) SetFldSnapX( *(sal_Int32*) pValues[ 4 ].getValue() );
1085 38 : if( pValues[5].hasValue() ) SetFldSnapY( *(sal_Int32*) pValues[ 5 ].getValue() );
1086 38 : if( pValues[6].hasValue() ) SetUseGridSnap( *(sal_Bool*) pValues[ 6 ].getValue() );
1087 38 : if( pValues[7].hasValue() ) SetSynchronize( *(sal_Bool*) pValues[ 7 ].getValue() );
1088 38 : if( pValues[8].hasValue() ) SetGridVisible( *(sal_Bool*) pValues[ 8 ].getValue() );
1089 38 : if( pValues[9].hasValue() ) SetEqualGrid( *(sal_Bool*) pValues[ 9 ].getValue() );
1090 :
1091 38 : return true;
1092 : }
1093 :
1094 0 : bool SdOptionsGrid::WriteData( Any* pValues ) const
1095 : {
1096 0 : pValues[ 0 ] <<= (sal_Int32) GetFldDrawX();
1097 0 : pValues[ 1 ] <<= (sal_Int32) GetFldDrawY();
1098 0 : pValues[ 2 ] <<= ( GetFldDivisionX() ? ( (double) GetFldDrawX() / GetFldDivisionX() - 1.0 ) : (double) 0 );
1099 0 : pValues[ 3 ] <<= ( GetFldDivisionY() ? ( (double) GetFldDrawY() / GetFldDivisionY() - 1.0 ) : (double) 0 );
1100 0 : pValues[ 4 ] <<= (sal_Int32) GetFldSnapX();
1101 0 : pValues[ 5 ] <<= (sal_Int32) GetFldSnapY();
1102 0 : pValues[ 6 ] <<= IsUseGridSnap();
1103 0 : pValues[ 7 ] <<= IsSynchronize();
1104 0 : pValues[ 8 ] <<= IsGridVisible();
1105 0 : pValues[ 9 ] <<= IsEqualGrid();
1106 :
1107 0 : return true;
1108 : }
1109 :
1110 : /*************************************************************************
1111 : |*
1112 : |* SdOptionsGridItem
1113 : |*
1114 : \************************************************************************/
1115 :
1116 0 : SdOptionsGridItem::SdOptionsGridItem( sal_uInt16 _nWhich, SdOptions* pOpts, ::sd::FrameView* pView ) :
1117 0 : SvxGridItem( _nWhich )
1118 : {
1119 0 : SetSynchronize( pOpts->IsSynchronize() );
1120 0 : SetEqualGrid( pOpts->IsEqualGrid() );
1121 :
1122 0 : if( pView )
1123 : {
1124 0 : SetFldDrawX( pView->GetGridCoarse().Width() );
1125 0 : SetFldDrawY( pView->GetGridCoarse().Height() );
1126 0 : SetFldDivisionX( pView->GetGridFine().Width() ? ( GetFldDrawX() / pView->GetGridFine().Width() - 1 ) : 0 );
1127 0 : SetFldDivisionY( pView->GetGridFine().Height() ? ( GetFldDrawY() / pView->GetGridFine().Height() - 1 ) : 0 );
1128 0 : SetFldSnapX( long(pView->GetSnapGridWidthX()) );
1129 0 : SetFldSnapY( long(pView->GetSnapGridWidthY()) );
1130 0 : SetUseGridSnap( pView->IsGridSnap() );
1131 0 : SetGridVisible( pView->IsGridVisible() );
1132 : }
1133 : else
1134 : {
1135 0 : SetFldDrawX( pOpts->GetFldDrawX() );
1136 0 : SetFldDrawY( pOpts->GetFldDrawY() );
1137 0 : SetFldDivisionX( pOpts->GetFldDivisionX() ? ( pOpts->GetFldDrawX() / pOpts->GetFldDivisionX() - 1 ) : 0 );
1138 0 : SetFldDivisionY( pOpts->GetFldDivisionY() ? ( pOpts->GetFldDrawY() / pOpts->GetFldDivisionY() - 1 ) : 0 );
1139 0 : SetFldSnapX( pOpts->GetFldSnapX() );
1140 0 : SetFldSnapY( pOpts->GetFldSnapY() );
1141 0 : SetUseGridSnap( pOpts->IsUseGridSnap() );
1142 0 : SetGridVisible( pOpts->IsGridVisible() );
1143 : }
1144 0 : }
1145 :
1146 0 : void SdOptionsGridItem::SetOptions( SdOptions* pOpts ) const
1147 : {
1148 0 : pOpts->SetFldDrawX( GetFldDrawX() );
1149 0 : pOpts->SetFldDivisionX( GetFldDrawX() / ( GetFldDivisionX() + 1 ) );
1150 0 : pOpts->SetFldDrawY( GetFldDrawY() );
1151 0 : pOpts->SetFldDivisionY( GetFldDrawY() / ( GetFldDivisionY() + 1 ) );
1152 0 : pOpts->SetFldSnapX( GetFldSnapX() );
1153 0 : pOpts->SetFldSnapY( GetFldSnapY() );
1154 0 : pOpts->SetUseGridSnap( GetUseGridSnap() );
1155 0 : pOpts->SetSynchronize( GetSynchronize() );
1156 0 : pOpts->SetGridVisible( GetGridVisible() );
1157 0 : pOpts->SetEqualGrid( GetEqualGrid() );
1158 0 : }
1159 :
1160 : /*************************************************************************
1161 : |*
1162 : |* SdOptionsPrint
1163 : |*
1164 : \************************************************************************/
1165 :
1166 1904 : SdOptionsPrint::SdOptionsPrint( sal_uInt16 nConfigId, bool bUseConfig ) :
1167 : SdOptionsGeneric( nConfigId, bUseConfig ?
1168 : ( ( SDCFG_DRAW == nConfigId ) ?
1169 : B2U( "Office.Draw/Print" ) :
1170 : B2U( "Office.Impress/Print" ) ) :
1171 : OUString() ),
1172 : bDraw( true ),
1173 : bNotes( false ),
1174 : bHandout( false ),
1175 : bOutline( false ),
1176 : bDate( false ),
1177 : bTime( false ),
1178 : bPagename( false ),
1179 : bHiddenPages( true ),
1180 : bPagesize( false ),
1181 : bPagetile( false ),
1182 : bWarningPrinter( true ),
1183 : bWarningSize( false ),
1184 : bWarningOrientation( false ),
1185 : bBooklet( false ),
1186 : bFront( true ),
1187 : bBack( true ),
1188 : bCutPage( false ),
1189 : bPaperbin( false ),
1190 : mbHandoutHorizontal( true ),
1191 : mnHandoutPages( 6 ),
1192 1904 : nQuality( 0 )
1193 : {
1194 1904 : EnableModify( true );
1195 1904 : }
1196 :
1197 0 : bool SdOptionsPrint::operator==( const SdOptionsPrint& rOpt ) const
1198 : {
1199 0 : return( IsDraw() == rOpt.IsDraw() &&
1200 0 : IsNotes() == rOpt.IsNotes() &&
1201 0 : IsHandout() == rOpt.IsHandout() &&
1202 0 : IsOutline() == rOpt.IsOutline() &&
1203 0 : IsDate() == rOpt.IsDate() &&
1204 0 : IsTime() == rOpt.IsTime() &&
1205 0 : IsPagename() == rOpt.IsPagename() &&
1206 0 : IsHiddenPages() == rOpt.IsHiddenPages() &&
1207 0 : IsPagesize() == rOpt.IsPagesize() &&
1208 0 : IsPagetile() == rOpt.IsPagetile() &&
1209 0 : IsWarningPrinter() == rOpt.IsWarningPrinter() &&
1210 0 : IsWarningSize() == rOpt.IsWarningSize() &&
1211 0 : IsWarningOrientation() == rOpt.IsWarningOrientation() &&
1212 0 : IsBooklet() == rOpt.IsBooklet() &&
1213 0 : IsFrontPage() == rOpt.IsFrontPage() &&
1214 0 : IsBackPage() == rOpt.IsBackPage() &&
1215 0 : IsCutPage() == rOpt.IsCutPage() &&
1216 0 : IsPaperbin() == rOpt.IsPaperbin() &&
1217 0 : GetOutputQuality() == rOpt.GetOutputQuality() &&
1218 0 : IsHandoutHorizontal() == rOpt.IsHandoutHorizontal() &&
1219 0 : GetHandoutPages() == rOpt.GetHandoutPages() );
1220 : }
1221 :
1222 0 : void SdOptionsPrint::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const
1223 : {
1224 0 : if( GetConfigId() == SDCFG_IMPRESS )
1225 : {
1226 : static const char* aImpressPropNames[] =
1227 : {
1228 : "Other/Date",
1229 : "Other/Time",
1230 : "Other/PageName",
1231 : "Other/HiddenPage",
1232 : "Page/PageSize",
1233 : "Page/PageTile",
1234 : // bWarningPrinter
1235 : // bWarningSize
1236 : // bWarningOrientation
1237 : "Page/Booklet",
1238 : "Page/BookletFront",
1239 : "Page/BookletBack",
1240 : // bCutPage
1241 : "Other/FromPrinterSetup",
1242 : "Other/Quality",
1243 : "Content/Presentation",
1244 : "Content/Note",
1245 : "Content/Handout",
1246 : "Content/Outline",
1247 : "Other/HandoutHorizontal",
1248 : "Other/PagesPerHandout"
1249 : };
1250 0 : rCount = SAL_N_ELEMENTS(aImpressPropNames);
1251 0 : ppNames = aImpressPropNames;
1252 : }
1253 : else
1254 : {
1255 : static const char* aDrawPropNames[] =
1256 : {
1257 : "Other/Date",
1258 : "Other/Time",
1259 : "Other/PageName",
1260 : "Other/HiddenPage",
1261 : "Page/PageSize",
1262 : "Page/PageTile",
1263 : // bWarningPrinter
1264 : // bWarningSize
1265 : // bWarningOrientation
1266 : "Page/Booklet",
1267 : "Page/BookletFront",
1268 : "Page/BookletBack",
1269 : // bCutPage
1270 : "Other/FromPrinterSetup",
1271 : "Other/Quality",
1272 : "Content/Drawing",
1273 : };
1274 0 : rCount = SAL_N_ELEMENTS(aDrawPropNames);
1275 0 : ppNames = aDrawPropNames;
1276 : }
1277 0 : }
1278 :
1279 0 : bool SdOptionsPrint::ReadData( const Any* pValues )
1280 : {
1281 0 : if( pValues[0].hasValue() ) SetDate( *(sal_Bool*) pValues[ 0 ].getValue() );
1282 0 : if( pValues[1].hasValue() ) SetTime( *(sal_Bool*) pValues[ 1 ].getValue() );
1283 0 : if( pValues[2].hasValue() ) SetPagename( *(sal_Bool*) pValues[ 2 ].getValue() );
1284 0 : if( pValues[3].hasValue() ) SetHiddenPages( *(sal_Bool*) pValues[ 3 ].getValue() );
1285 0 : if( pValues[4].hasValue() ) SetPagesize( *(sal_Bool*) pValues[ 4 ].getValue() );
1286 0 : if( pValues[5].hasValue() ) SetPagetile( *(sal_Bool*) pValues[ 5 ].getValue() );
1287 0 : if( pValues[6].hasValue() ) SetBooklet( *(sal_Bool*) pValues[ 6 ].getValue() );
1288 0 : if( pValues[7].hasValue() ) SetFrontPage( *(sal_Bool*) pValues[ 7 ].getValue() );
1289 0 : if( pValues[8].hasValue() ) SetBackPage( *(sal_Bool*) pValues[ 8 ].getValue() );
1290 0 : if( pValues[9].hasValue() ) SetPaperbin( *(sal_Bool*) pValues[ 9 ].getValue() );
1291 0 : if( pValues[10].hasValue() ) SetOutputQuality( (sal_uInt16) *(sal_Int32*) pValues[ 10 ].getValue() );
1292 0 : if( pValues[11].hasValue() ) SetDraw( *(sal_Bool*) pValues[ 11 ].getValue() );
1293 :
1294 : // just for impress
1295 0 : if( GetConfigId() == SDCFG_IMPRESS )
1296 : {
1297 0 : if( pValues[12].hasValue() ) SetNotes( *(sal_Bool*) pValues[ 12 ].getValue() );
1298 0 : if( pValues[13].hasValue() ) SetHandout( *(sal_Bool*) pValues[ 13 ].getValue() );
1299 0 : if( pValues[14].hasValue() ) SetOutline( *(sal_Bool*) pValues[ 14 ].getValue() );
1300 0 : if( pValues[15].hasValue() ) SetHandoutHorizontal( *(sal_Bool*) pValues[15].getValue() );
1301 0 : if( pValues[16].hasValue() ) SetHandoutPages( (sal_uInt16)*(sal_Int32*) pValues[16].getValue() );
1302 : }
1303 :
1304 0 : return true;
1305 : }
1306 :
1307 0 : bool SdOptionsPrint::WriteData( Any* pValues ) const
1308 : {
1309 0 : pValues[ 0 ] <<= IsDate();
1310 0 : pValues[ 1 ] <<= IsTime();
1311 0 : pValues[ 2 ] <<= IsPagename();
1312 0 : pValues[ 3 ] <<= IsHiddenPages();
1313 0 : pValues[ 4 ] <<= IsPagesize();
1314 0 : pValues[ 5 ] <<= IsPagetile();
1315 0 : pValues[ 6 ] <<= IsBooklet();
1316 0 : pValues[ 7 ] <<= IsFrontPage();
1317 0 : pValues[ 8 ] <<= IsBackPage();
1318 0 : pValues[ 9 ] <<= IsPaperbin();
1319 0 : pValues[ 10 ] <<= (sal_Int32) GetOutputQuality();
1320 0 : pValues[ 11 ] <<= IsDraw();
1321 :
1322 : // just for impress
1323 0 : if( GetConfigId() == SDCFG_IMPRESS )
1324 : {
1325 0 : pValues[ 12 ] <<= IsNotes();
1326 0 : pValues[ 13 ] <<= IsHandout();
1327 0 : pValues[ 14 ] <<= IsOutline();
1328 0 : pValues[ 15 ] <<= IsHandoutHorizontal();
1329 0 : pValues[ 16 ] <<= GetHandoutPages();
1330 : }
1331 :
1332 0 : return true;
1333 : }
1334 :
1335 : /*************************************************************************
1336 : |*
1337 : |* SdOptionsPrintItem
1338 : |*
1339 : \************************************************************************/
1340 :
1341 1862 : SdOptionsPrintItem::SdOptionsPrintItem( sal_uInt16 _nWhich )
1342 : : SfxPoolItem ( _nWhich )
1343 1862 : , maOptionsPrint ( 0, false )
1344 : {
1345 1862 : }
1346 :
1347 0 : SdOptionsPrintItem::SdOptionsPrintItem( sal_uInt16 _nWhich, SdOptions* pOpts, ::sd::FrameView* )
1348 : : SfxPoolItem ( _nWhich )
1349 0 : , maOptionsPrint ( 0, false )
1350 : {
1351 0 : if( pOpts )
1352 : {
1353 0 : maOptionsPrint.SetDraw( pOpts->IsDraw() );
1354 0 : maOptionsPrint.SetNotes( pOpts->IsNotes() );
1355 0 : maOptionsPrint.SetHandout( pOpts->IsHandout() );
1356 0 : maOptionsPrint.SetOutline( pOpts->IsOutline() );
1357 0 : maOptionsPrint.SetDate( pOpts->IsDate() );
1358 0 : maOptionsPrint.SetTime( pOpts->IsTime() );
1359 0 : maOptionsPrint.SetPagename( pOpts->IsPagename() );
1360 0 : maOptionsPrint.SetHiddenPages( pOpts->IsHiddenPages() );
1361 0 : maOptionsPrint.SetPagesize( pOpts->IsPagesize() );
1362 0 : maOptionsPrint.SetPagetile( pOpts->IsPagetile() );
1363 0 : maOptionsPrint.SetWarningPrinter( pOpts->IsWarningPrinter() );
1364 0 : maOptionsPrint.SetWarningSize( pOpts->IsWarningSize() );
1365 0 : maOptionsPrint.SetWarningOrientation( pOpts->IsWarningOrientation() );
1366 0 : maOptionsPrint.SetBooklet( pOpts->IsBooklet() );
1367 0 : maOptionsPrint.SetFrontPage( pOpts->IsFrontPage() );
1368 0 : maOptionsPrint.SetBackPage( pOpts->IsBackPage() );
1369 0 : maOptionsPrint.SetCutPage( pOpts->IsCutPage() );
1370 0 : maOptionsPrint.SetPaperbin( pOpts->IsPaperbin() );
1371 0 : maOptionsPrint.SetOutputQuality( pOpts->GetOutputQuality() );
1372 : }
1373 0 : }
1374 :
1375 0 : SfxPoolItem* SdOptionsPrintItem::Clone( SfxItemPool* ) const
1376 : {
1377 0 : return new SdOptionsPrintItem( *this );
1378 : }
1379 :
1380 0 : bool SdOptionsPrintItem::operator==( const SfxPoolItem& rAttr ) const
1381 : {
1382 0 : const bool bSameType = SfxPoolItem::operator==(rAttr);
1383 : DBG_ASSERT( bSameType, "SdOptionsPrintItem::operator==(), different pool item type!" );
1384 0 : return bSameType && ( maOptionsPrint == static_cast< const SdOptionsPrintItem& >( rAttr ).maOptionsPrint );
1385 : }
1386 :
1387 1840 : void SdOptionsPrintItem::SetOptions( SdOptions* pOpts ) const
1388 : {
1389 1840 : if( pOpts )
1390 : {
1391 1840 : pOpts->SetDraw( maOptionsPrint.IsDraw() );
1392 1840 : pOpts->SetNotes( maOptionsPrint.IsNotes() );
1393 1840 : pOpts->SetHandout( maOptionsPrint.IsHandout() );
1394 1840 : pOpts->SetOutline( maOptionsPrint.IsOutline() );
1395 1840 : pOpts->SetDate( maOptionsPrint.IsDate() );
1396 1840 : pOpts->SetTime( maOptionsPrint.IsTime() );
1397 1840 : pOpts->SetPagename( maOptionsPrint.IsPagename() );
1398 1840 : pOpts->SetHiddenPages( maOptionsPrint.IsHiddenPages() );
1399 1840 : pOpts->SetPagesize( maOptionsPrint.IsPagesize() );
1400 1840 : pOpts->SetPagetile( maOptionsPrint.IsPagetile() );
1401 1840 : pOpts->SetWarningPrinter( maOptionsPrint.IsWarningPrinter() );
1402 1840 : pOpts->SetWarningSize( maOptionsPrint.IsWarningSize() );
1403 1840 : pOpts->SetWarningOrientation( maOptionsPrint.IsWarningOrientation() );
1404 1840 : pOpts->SetBooklet( maOptionsPrint.IsBooklet() );
1405 1840 : pOpts->SetFrontPage( maOptionsPrint.IsFrontPage() );
1406 1840 : pOpts->SetBackPage( maOptionsPrint.IsBackPage() );
1407 1840 : pOpts->SetCutPage( maOptionsPrint.IsCutPage() );
1408 1840 : pOpts->SetPaperbin( maOptionsPrint.IsPaperbin() );
1409 1840 : pOpts->SetOutputQuality( maOptionsPrint.GetOutputQuality() );
1410 : }
1411 1840 : }
1412 :
1413 : /*************************************************************************
1414 : |*
1415 : |* SdOptions
1416 : |*
1417 : \************************************************************************/
1418 :
1419 42 : SdOptions::SdOptions( sal_uInt16 nConfigId ) :
1420 : SdOptionsLayout( nConfigId, true ),
1421 : SdOptionsContents( nConfigId, true ),
1422 : SdOptionsMisc( nConfigId, true ),
1423 : SdOptionsSnap( nConfigId, true ),
1424 : SdOptionsZoom( nConfigId, true ),
1425 : SdOptionsGrid( nConfigId, true ),
1426 42 : SdOptionsPrint( nConfigId, true )
1427 : {
1428 42 : }
1429 :
1430 60 : SdOptions::~SdOptions()
1431 : {
1432 60 : }
1433 :
1434 0 : void SdOptions::StoreConfig( sal_uLong nOptionsRange )
1435 : {
1436 0 : if( nOptionsRange & SD_OPTIONS_LAYOUT )
1437 0 : SdOptionsLayout::Store();
1438 :
1439 0 : if( nOptionsRange & SD_OPTIONS_CONTENTS )
1440 0 : SdOptionsContents::Store();
1441 :
1442 0 : if( nOptionsRange & SD_OPTIONS_MISC )
1443 0 : SdOptionsMisc::Store();
1444 :
1445 0 : if( nOptionsRange & SD_OPTIONS_SNAP )
1446 0 : SdOptionsSnap::Store();
1447 :
1448 0 : if( nOptionsRange & SD_OPTIONS_ZOOM )
1449 0 : SdOptionsZoom::Store();
1450 :
1451 0 : if( nOptionsRange & SD_OPTIONS_GRID )
1452 0 : SdOptionsGrid::Store();
1453 :
1454 0 : if( nOptionsRange & SD_OPTIONS_PRINT )
1455 0 : SdOptionsPrint::Store();
1456 0 : }
1457 :
1458 0 : sal_Int32 SdOptionsMisc::GetDisplay() const
1459 : {
1460 0 : Init();
1461 0 : return mnDisplay;
1462 : }
1463 :
1464 22 : void SdOptionsMisc::SetDisplay( sal_Int32 nDisplay )
1465 : {
1466 22 : if( mnDisplay != nDisplay )
1467 : {
1468 0 : OptionsChanged();
1469 0 : mnDisplay = nDisplay;
1470 : }
1471 136 : }
1472 :
1473 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
