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