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