| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sd.hxx" |
| #include <svx/svdmodel.hxx> |
| #include <sfx2/app.hxx> |
| #include <sfx2/sfx.hrc> |
| #ifndef _SV_SALBTYPE_HRC //autogen |
| #include <vcl/salbtype.hxx> |
| #endif |
| #include <unotools/syslocale.hxx> |
| |
| #include "app.hxx" |
| #include "optsitem.hxx" |
| #include "cfgids.hxx" |
| #include "FrameView.hxx" |
| |
| using namespace ::rtl; |
| using namespace ::utl; |
| using namespace ::com::sun::star::uno; |
| |
| #define B2U(_def_aStr) (OUString::createFromAscii(_def_aStr)) |
| |
| template< class T > T getSafeValue( const Any& rAny ) |
| { |
| T value = T(); |
| bool bOk = (rAny >>= value); |
| |
| DBG_ASSERT( bOk, "SdOptionsItem, wrong type from configuration!" ); |
| (void)bOk; |
| |
| return value; |
| } |
| |
| // ----------------- |
| // - SdOptionsItem - |
| // ----------------- |
| |
| SdOptionsItem::SdOptionsItem( const SdOptionsGeneric& rParent, const OUString rSubTree ) : |
| ConfigItem ( rSubTree ), |
| mrParent ( rParent ) |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| SdOptionsItem::~SdOptionsItem() |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SdOptionsItem::Commit() |
| { |
| if( IsModified() ) |
| mrParent.Commit( *this ); |
| }; |
| |
| void SdOptionsItem::Notify( const com::sun::star::uno::Sequence<rtl::OUString>& ) |
| {} |
| |
| |
| // ----------------------------------------------------------------------------- |
| |
| Sequence< Any > SdOptionsItem::GetProperties( const Sequence< OUString >& rNames ) |
| { |
| return ConfigItem::GetProperties( rNames ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsItem::PutProperties( const Sequence< OUString >& rNames, const Sequence< Any>& rValues ) |
| { |
| return ConfigItem::PutProperties( rNames, rValues ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SdOptionsItem::SetModified() |
| { |
| ConfigItem::SetModified(); |
| } |
| |
| // -------------------- |
| // - SdOptionsGeneric - |
| // -------------------- |
| |
| SdOptionsGeneric::SdOptionsGeneric( sal_uInt16 nConfigId, const OUString& rSubTree ) : |
| maSubTree ( rSubTree ), |
| mpCfgItem ( NULL ), |
| mnConfigId ( nConfigId ), |
| mbInit ( rSubTree.getLength() == 0 ) |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SdOptionsGeneric::Init() const |
| { |
| if( !mbInit ) |
| { |
| SdOptionsGeneric* pThis = const_cast<SdOptionsGeneric*>(this); |
| |
| if( !mpCfgItem ) |
| pThis->mpCfgItem = new SdOptionsItem( *this, maSubTree ); |
| |
| const Sequence< OUString > aNames( GetPropertyNames() ); |
| const Sequence< Any > aValues = mpCfgItem->GetProperties( aNames ); |
| |
| if( aNames.getLength() && ( aValues.getLength() == aNames.getLength() ) ) |
| { |
| const Any* pValues = aValues.getConstArray(); |
| |
| pThis->EnableModify( sal_False ); |
| pThis->mbInit = pThis->ReadData( pValues ); |
| pThis->EnableModify( sal_True ); |
| } |
| else |
| pThis->mbInit = sal_True; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| SdOptionsGeneric::~SdOptionsGeneric() |
| { |
| delete mpCfgItem; |
| mpCfgItem = NULL; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SdOptionsGeneric::Commit( SdOptionsItem& rCfgItem ) const |
| { |
| const Sequence< OUString > aNames( GetPropertyNames() ); |
| Sequence< Any > aValues( aNames.getLength() ); |
| |
| if( aNames.getLength() && ( aValues.getLength() == aNames.getLength() ) ) |
| { |
| if( (const_cast<SdOptionsGeneric*>(this))->WriteData( aValues.getArray() ) ) |
| rCfgItem.PutProperties( aNames, aValues ); |
| else |
| { |
| DBG_ERROR( "PutProperties failed" ); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| Sequence< OUString > SdOptionsGeneric::GetPropertyNames() const |
| { |
| sal_uLong nCount; |
| const char** ppPropNames; |
| |
| GetPropNameArray( ppPropNames, nCount ); |
| |
| Sequence< OUString > aNames( nCount ); |
| OUString* pNames = aNames.getArray(); |
| |
| for( sal_uLong i = 0; i < nCount; i++ ) |
| pNames[ i ] = OUString::createFromAscii( ppPropNames[ i ] ); |
| |
| return aNames; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SdOptionsGeneric::Store() |
| { |
| if( mpCfgItem ) |
| mpCfgItem->Commit(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| bool SdOptionsGeneric::isMetricSystem() |
| { |
| SvtSysLocale aSysLocale; |
| MeasurementSystem eSys = aSysLocale.GetLocaleDataPtr()->getMeasurementSystemEnum(); |
| |
| return ( eSys == MEASURE_METRIC ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* SdOptionsLayout |
| |* |
| \************************************************************************/ |
| |
| SdOptionsLayout::SdOptionsLayout( sal_uInt16 nConfigId, sal_Bool bUseConfig ) : |
| SdOptionsGeneric( nConfigId, bUseConfig ? |
| ( ( SDCFG_DRAW == nConfigId ) ? |
| B2U( "Office.Draw/Layout" ) : |
| B2U( "Office.Impress/Layout" ) ) : |
| OUString() ), |
| bRuler( sal_True ), |
| bMoveOutline( sal_True ), |
| bDragStripes( sal_False ), |
| bHandlesBezier( sal_False ), |
| bHelplines( sal_True ), |
| nMetric((sal_uInt16)(isMetricSystem() ? FUNIT_CM : FUNIT_INCH)), |
| nDefTab( 1250 ) |
| { |
| EnableModify( sal_True ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsLayout::operator==( const SdOptionsLayout& rOpt ) const |
| { |
| return( IsRulerVisible() == rOpt.IsRulerVisible() && |
| IsMoveOutline() == rOpt.IsMoveOutline() && |
| IsDragStripes() == rOpt.IsDragStripes() && |
| IsHandlesBezier() == rOpt.IsHandlesBezier() && |
| IsHelplines() == rOpt.IsHelplines() && |
| GetMetric() == rOpt.GetMetric() && |
| GetDefTab() == rOpt.GetDefTab() ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SdOptionsLayout::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const |
| { |
| static const char* aPropNamesMetric[] = |
| { |
| "Display/Ruler", |
| "Display/Bezier", |
| "Display/Contour", |
| "Display/Guide", |
| "Display/Helpline", |
| "Other/MeasureUnit/Metric", |
| "Other/TabStop/Metric" |
| }; |
| |
| static const char* aPropNamesNonMetric[] = |
| { |
| "Display/Ruler", |
| "Display/Bezier", |
| "Display/Contour", |
| "Display/Guide", |
| "Display/Helpline", |
| "Other/MeasureUnit/NonMetric", |
| "Other/TabStop/NonMetric" |
| }; |
| |
| rCount = 7; |
| |
| if( isMetricSystem() ) |
| ppNames = aPropNamesMetric; |
| else |
| ppNames = aPropNamesNonMetric; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsLayout::ReadData( const Any* pValues ) |
| { |
| if( pValues[0].hasValue() ) SetRulerVisible( *(sal_Bool*) pValues[ 0 ].getValue() ); |
| if( pValues[1].hasValue() ) SetHandlesBezier( *(sal_Bool*) pValues[ 1 ].getValue() ); |
| if( pValues[2].hasValue() ) SetMoveOutline( *(sal_Bool*) pValues[ 2 ].getValue() ); |
| if( pValues[3].hasValue() ) SetDragStripes( *(sal_Bool*) pValues[ 3 ].getValue() ); |
| if( pValues[4].hasValue() ) SetHelplines( *(sal_Bool*) pValues[ 4 ].getValue() ); |
| if( pValues[5].hasValue() ) SetMetric( (sal_uInt16) *(sal_Int32*) pValues[ 5 ].getValue() ); |
| if( pValues[6].hasValue() ) SetDefTab( (sal_uInt16) *(sal_Int32*) pValues[ 6 ].getValue() ); |
| |
| return sal_True; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsLayout::WriteData( Any* pValues ) const |
| { |
| pValues[ 0 ] <<= IsRulerVisible(); |
| pValues[ 1 ] <<= IsHandlesBezier(); |
| pValues[ 2 ] <<= IsMoveOutline(); |
| pValues[ 3 ] <<= IsDragStripes(); |
| pValues[ 4 ] <<= IsHelplines(); |
| pValues[ 5 ] <<= (sal_Int32) GetMetric(); |
| pValues[ 6 ] <<= (sal_Int32) GetDefTab(); |
| |
| return sal_True; |
| } |
| |
| /************************************************************************* |
| |* |
| |* SdOptionsLayoutItem |
| |* |
| \************************************************************************/ |
| |
| SdOptionsLayoutItem::SdOptionsLayoutItem( sal_uInt16 _nWhich ) |
| : SfxPoolItem ( _nWhich ) |
| , maOptionsLayout ( 0, sal_False ) |
| { |
| } |
| |
| // ---------------------------------------------------------------------- |
| |
| SdOptionsLayoutItem::SdOptionsLayoutItem( sal_uInt16 _nWhich, SdOptions* pOpts, ::sd::FrameView* pView ) |
| : SfxPoolItem ( _nWhich ) |
| , maOptionsLayout ( 0, sal_False ) |
| { |
| if( pOpts ) |
| { |
| maOptionsLayout.SetMetric( pOpts->GetMetric() ); |
| maOptionsLayout.SetDefTab( pOpts->GetDefTab() ); |
| } |
| |
| if( pView ) |
| { |
| maOptionsLayout.SetRulerVisible( pView->HasRuler() ); |
| maOptionsLayout.SetMoveOutline( !pView->IsNoDragXorPolys() ); |
| maOptionsLayout.SetDragStripes( pView->IsDragStripes() ); |
| maOptionsLayout.SetHandlesBezier( pView->IsPlusHandlesAlwaysVisible() ); |
| maOptionsLayout.SetHelplines( pView->IsHlplVisible() ); |
| } |
| else if( pOpts ) |
| { |
| maOptionsLayout.SetRulerVisible( pOpts->IsRulerVisible() ); |
| maOptionsLayout.SetMoveOutline( pOpts->IsMoveOutline() ); |
| maOptionsLayout.SetDragStripes( pOpts->IsDragStripes() ); |
| maOptionsLayout.SetHandlesBezier( pOpts->IsHandlesBezier() ); |
| maOptionsLayout.SetHelplines( pOpts->IsHelplines() ); |
| } |
| } |
| |
| // ---------------------------------------------------------------------- |
| |
| SfxPoolItem* SdOptionsLayoutItem::Clone( SfxItemPool* ) const |
| { |
| return new SdOptionsLayoutItem( *this ); |
| } |
| |
| |
| // ---------------------------------------------------------------------- |
| |
| int SdOptionsLayoutItem::operator==( const SfxPoolItem& rAttr ) const |
| { |
| const bool bSameType = SfxPoolItem::operator==( rAttr ); |
| DBG_ASSERT( bSameType, "SdOptionsLayoutItem::operator==(), differen pool item type!" ); |
| return bSameType && ( maOptionsLayout == static_cast< const SdOptionsLayoutItem& >( rAttr ).maOptionsLayout ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SdOptionsLayoutItem::SetOptions( SdOptions* pOpts ) const |
| { |
| if( pOpts ) |
| { |
| pOpts->SetRulerVisible( maOptionsLayout.IsRulerVisible() ); |
| pOpts->SetMoveOutline( maOptionsLayout.IsMoveOutline() ); |
| pOpts->SetDragStripes( maOptionsLayout.IsDragStripes() ); |
| pOpts->SetHandlesBezier( maOptionsLayout.IsHandlesBezier() ); |
| pOpts->SetHelplines( maOptionsLayout.IsHelplines() ); |
| pOpts->SetMetric( maOptionsLayout.GetMetric() ); |
| pOpts->SetDefTab( maOptionsLayout.GetDefTab() ); |
| } |
| } |
| |
| /************************************************************************* |
| |* |
| |* SdOptionsContents |
| |* |
| \************************************************************************/ |
| |
| SdOptionsContents::SdOptionsContents( sal_uInt16 nConfigId, sal_Bool bUseConfig ) : |
| SdOptionsGeneric( nConfigId, bUseConfig ? |
| ( ( SDCFG_DRAW == nConfigId ) ? |
| B2U( "Office.Draw/Content" ) : |
| B2U( "Office.Impress/Content" ) ) : |
| OUString() ) |
| { |
| EnableModify( sal_True ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsContents::operator==(const SdOptionsContents&) const |
| { |
| return true; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SdOptionsContents::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const |
| { |
| static const char* aPropNames[] = |
| { |
| "Display/PicturePlaceholder", |
| "Display/ContourMode", |
| "Display/LineContour", |
| "Display/TextPlaceholder" |
| }; |
| |
| rCount = 4; |
| ppNames = aPropNames; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsContents::ReadData(const Any*) |
| { |
| return sal_True; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsContents::WriteData( Any* pValues ) const |
| { |
| //#i80528# no draft anymore |
| pValues[ 0 ] <<= (sal_Bool)false; |
| pValues[ 1 ] <<= (sal_Bool)false; |
| pValues[ 2 ] <<= (sal_Bool)false; |
| pValues[ 3 ] <<= (sal_Bool)false; |
| |
| return sal_True; |
| } |
| |
| /************************************************************************* |
| |* |
| |* SdOptionsContentsItem |
| |* |
| \************************************************************************/ |
| |
| SdOptionsContentsItem::SdOptionsContentsItem(sal_uInt16 _nWhich, SdOptions*, ::sd::FrameView*) |
| : SfxPoolItem ( _nWhich ) |
| , maOptionsContents ( 0, sal_False ) |
| { |
| } |
| |
| // ---------------------------------------------------------------------- |
| |
| SfxPoolItem* SdOptionsContentsItem::Clone( SfxItemPool* ) const |
| { |
| return new SdOptionsContentsItem( *this ); |
| } |
| |
| // ---------------------------------------------------------------------- |
| |
| int SdOptionsContentsItem::operator==( const SfxPoolItem& rAttr ) const |
| { |
| const bool bSameType = SfxPoolItem::operator==(rAttr); |
| DBG_ASSERT( bSameType, "SdOptionsContentsItem::operator==(), differen pool item type!" ); |
| return bSameType && ( maOptionsContents == static_cast<const SdOptionsContentsItem&>( rAttr ).maOptionsContents ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SdOptionsContentsItem::SetOptions(SdOptions*) const |
| { |
| } |
| |
| /************************************************************************* |
| |* |
| |* SdOptionsMisc |
| |* |
| \************************************************************************/ |
| |
| SdOptionsMisc::SdOptionsMisc( sal_uInt16 nConfigId, sal_Bool bUseConfig ) : |
| SdOptionsGeneric( nConfigId, bUseConfig ? |
| ( ( SDCFG_DRAW == nConfigId ) ? |
| B2U( "Office.Draw/Misc" ) : |
| B2U( "Office.Impress/Misc" ) ) : |
| OUString() ), |
| // #97016# |
| nDefaultObjectSizeWidth(8000), |
| nDefaultObjectSizeHeight(5000), |
| bStartWithTemplate( sal_True ), |
| bMarkedHitMovesAlways( sal_True ), |
| bMoveOnlyDragging( sal_False ), |
| bCrookNoContortion( sal_False ), |
| bQuickEdit( GetConfigId() != SDCFG_DRAW ), |
| bMasterPageCache( sal_True ), |
| bDragWithCopy( sal_False ), |
| bPickThrough( sal_True ), |
| bBigHandles( sal_True ), // new default: Use big handles |
| bDoubleClickTextEdit( sal_True ), |
| bClickChangeRotation( sal_False ), |
| bStartWithActualPage( sal_False ), |
| bStartWithPresenterScreen( sal_True ), // default: Enable the Presenter Screen |
| bSolidDragging( sal_True ), |
| bSolidMarkHdl( sal_True ), // default: Use nice handles |
| bSummationOfParagraphs( sal_False ), |
| // #90356# |
| bShowUndoDeleteWarning( sal_True ), |
| bSlideshowRespectZOrder( sal_True ), |
| bShowComments( sal_True ), |
| bPreviewNewEffects( sal_True ), |
| bPreviewChangedEffects( sal_False ), |
| bPreviewTransitions( sal_True ), |
| mnDisplay( 0 ), |
| mnPenColor( 0xff0000 ), |
| mnPenWidth( 150.0 ), |
| |
| // The default for 6.1-and-above documents is to use printer-independent |
| // formatting. |
| mnPrinterIndependentLayout (1) |
| { |
| EnableModify( sal_True ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsMisc::operator==( const SdOptionsMisc& rOpt ) const |
| { |
| return( IsStartWithTemplate() == rOpt.IsStartWithTemplate() && |
| IsMarkedHitMovesAlways() == rOpt.IsMarkedHitMovesAlways() && |
| IsMoveOnlyDragging() == rOpt.IsMoveOnlyDragging() && |
| IsCrookNoContortion() == rOpt.IsCrookNoContortion() && |
| IsQuickEdit() == rOpt.IsQuickEdit() && |
| IsMasterPagePaintCaching() == rOpt.IsMasterPagePaintCaching() && |
| IsDragWithCopy() == rOpt.IsDragWithCopy() && |
| IsPickThrough() == rOpt.IsPickThrough() && |
| IsBigHandles() == rOpt.IsBigHandles() && |
| IsDoubleClickTextEdit() == rOpt.IsDoubleClickTextEdit() && |
| IsClickChangeRotation() == rOpt.IsClickChangeRotation() && |
| IsStartWithActualPage() == rOpt.IsStartWithActualPage() && |
| IsStartWithPresenterScreen() == rOpt.IsStartWithPresenterScreen() && |
| IsSummationOfParagraphs() == rOpt.IsSummationOfParagraphs() && |
| IsSolidDragging() == rOpt.IsSolidDragging() && |
| IsSolidMarkHdl() == rOpt.IsSolidMarkHdl() && |
| // #90356# |
| IsShowUndoDeleteWarning() == rOpt.IsShowUndoDeleteWarning() && |
| IsSlideshowRespectZOrder() == rOpt.IsSlideshowRespectZOrder() && |
| GetPrinterIndependentLayout() == rOpt.GetPrinterIndependentLayout() && |
| // #97016# |
| GetDefaultObjectSizeWidth() == rOpt.GetDefaultObjectSizeWidth() && |
| GetDefaultObjectSizeHeight() == rOpt.GetDefaultObjectSizeHeight() && |
| |
| IsPreviewNewEffects() == rOpt.IsPreviewNewEffects() && |
| IsPreviewChangedEffects() == rOpt.IsPreviewChangedEffects() && |
| IsPreviewTransitions() == rOpt.IsPreviewTransitions() && |
| GetDisplay() == rOpt.GetDisplay() && |
| IsShowComments() == rOpt.IsShowComments() && |
| GetPresentationPenColor() == rOpt.GetPresentationPenColor() && |
| GetPresentationPenWidth() == rOpt.GetPresentationPenWidth() |
| ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SdOptionsMisc::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const |
| { |
| static const char* aPropNames[] = |
| { |
| "ObjectMoveable", |
| "NoDistort", |
| "TextObject/QuickEditing", |
| "BackgroundCache", |
| "CopyWhileMoving", |
| "TextObject/Selectable", |
| "BigHandles", |
| "DclickTextedit", |
| "RotateClick", |
| "Preview", |
| "ModifyWithAttributes", |
| "SimpleHandles", |
| // #97016# |
| "DefaultObjectSize/Width", |
| "DefaultObjectSize/Height", |
| |
| "Compatibility/PrinterIndependentLayout", |
| |
| "ShowComments", |
| |
| // just for impress |
| "NewDoc/AutoPilot", |
| "Start/CurrentPage", |
| "Compatibility/AddBetween", |
| // #90356# |
| "ShowUndoDeleteWarning", |
| "SlideshowRespectZOrder", |
| |
| "PreviewNewEffects", |
| "PreviewChangedEffects", |
| "PreviewTransitions", |
| |
| "Display", |
| |
| "PenColor", |
| "PenWidth", |
| |
| "Start/PresenterScreen" |
| }; |
| |
| rCount = ( ( GetConfigId() == SDCFG_IMPRESS ) ? 28 : 16 ); |
| ppNames = aPropNames; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsMisc::ReadData( const Any* pValues ) |
| { |
| if( pValues[0].hasValue() ) SetMarkedHitMovesAlways( *(sal_Bool*) pValues[ 0 ].getValue() ); |
| if( pValues[1].hasValue() ) SetCrookNoContortion( *(sal_Bool*) pValues[ 1 ].getValue() ); |
| if( pValues[2].hasValue() ) SetQuickEdit( *(sal_Bool*)pValues[ 2 ].getValue() ); |
| if( pValues[3].hasValue() ) SetMasterPagePaintCaching( *(sal_Bool*) pValues[ 3 ].getValue() ); |
| if( pValues[4].hasValue() ) SetDragWithCopy( *(sal_Bool*) pValues[ 4 ].getValue() ); |
| if( pValues[5].hasValue() ) SetPickThrough( *(sal_Bool*) pValues[ 5 ].getValue() ); |
| if( pValues[6].hasValue() ) SetBigHandles( *(sal_Bool*) pValues[ 6 ].getValue() ); |
| if( pValues[7].hasValue() ) SetDoubleClickTextEdit( *(sal_Bool*) pValues[ 7 ].getValue() ); |
| if( pValues[8].hasValue() ) SetClickChangeRotation( *(sal_Bool*) pValues[ 8 ].getValue() ); |
| // if( pValues[9].hasValue() ) SetPreviewQuality( FRound( *(double*) pValues[ 9 ].getValue() ) ); |
| if( pValues[10].hasValue() ) SetSolidDragging( *(sal_Bool*) pValues[ 10 ].getValue() ); |
| if( pValues[11].hasValue() ) SetSolidMarkHdl( *(sal_Bool*) pValues[ 11 ].getValue() ); |
| // #97016# |
| if( pValues[12].hasValue() ) SetDefaultObjectSizeWidth( *(sal_uInt32*) pValues[ 12 ].getValue() ); |
| if( pValues[13].hasValue() ) SetDefaultObjectSizeHeight( *(sal_uInt32*) pValues[ 13 ].getValue() ); |
| if( pValues[14].hasValue() ) SetPrinterIndependentLayout( *(sal_uInt16*) pValues[ 14 ].getValue() ); |
| |
| if( pValues[15].hasValue() ) |
| SetShowComments( *(sal_Bool*) pValues[ 15 ].getValue() ); |
| |
| // just for Impress |
| if( GetConfigId() == SDCFG_IMPRESS ) |
| { |
| if( pValues[16].hasValue() ) |
| SetStartWithTemplate( *(sal_Bool*) pValues[ 16 ].getValue() ); |
| if( pValues[17].hasValue() ) |
| SetStartWithActualPage( *(sal_Bool*) pValues[ 17 ].getValue() ); |
| if( pValues[18].hasValue() ) |
| SetSummationOfParagraphs( *(sal_Bool*) pValues[ 18 ].getValue() ); |
| // #90356# |
| if( pValues[19].hasValue() ) |
| SetShowUndoDeleteWarning( *(sal_Bool*) pValues[ 19 ].getValue() ); |
| |
| if( pValues[20].hasValue() ) |
| SetSlideshowRespectZOrder(*(sal_Bool*) pValues[ 20 ].getValue()); |
| |
| if( pValues[21].hasValue() ) |
| SetPreviewNewEffects(*(sal_Bool*) pValues[ 21 ].getValue()); |
| |
| if( pValues[22].hasValue() ) |
| SetPreviewChangedEffects(*(sal_Bool*) pValues[ 22 ].getValue()); |
| |
| if( pValues[23].hasValue() ) |
| SetPreviewTransitions(*(sal_Bool*) pValues[ 23 ].getValue()); |
| |
| if( pValues[24].hasValue() ) |
| SetDisplay(*(sal_Int32*) pValues[ 24 ].getValue()); |
| |
| if( pValues[25].hasValue() ) |
| SetPresentationPenColor( getSafeValue< sal_Int32 >( pValues[ 25 ] ) ); |
| |
| if( pValues[26].hasValue() ) |
| SetPresentationPenWidth( getSafeValue< double >( pValues[ 26 ] ) ); |
| |
| if( pValues[27].hasValue() ) |
| SetStartWithPresenterScreen( *(sal_Bool*) pValues[ 27 ].getValue() ); |
| } |
| |
| return sal_True; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsMisc::WriteData( Any* pValues ) const |
| { |
| pValues[ 0 ] <<= IsMarkedHitMovesAlways(); |
| pValues[ 1 ] <<= IsCrookNoContortion(); |
| pValues[ 2 ] <<= IsQuickEdit(); |
| pValues[ 3 ] <<= IsMasterPagePaintCaching(); |
| pValues[ 4 ] <<= IsDragWithCopy(); |
| pValues[ 5 ] <<= IsPickThrough(); |
| pValues[ 6 ] <<= IsBigHandles(); |
| pValues[ 7 ] <<= IsDoubleClickTextEdit(); |
| pValues[ 8 ] <<= IsClickChangeRotation(); |
| // The preview is not supported anymore. Use a dummy value. |
| pValues[ 9 ] <<= (double)0;// GetPreviewQuality(); |
| pValues[ 10 ] <<= IsSolidDragging(); |
| pValues[ 11 ] <<= IsSolidMarkHdl(); |
| // #97016# |
| pValues[ 12 ] <<= GetDefaultObjectSizeWidth(); |
| pValues[ 13 ] <<= GetDefaultObjectSizeHeight(); |
| pValues[ 14 ] <<= GetPrinterIndependentLayout(); |
| pValues[ 15 ] <<= (sal_Bool)IsShowComments(); |
| |
| // just for Impress |
| if( GetConfigId() == SDCFG_IMPRESS ) |
| { |
| pValues[ 16 ] <<= IsStartWithTemplate(); |
| pValues[ 17 ] <<= IsStartWithActualPage(); |
| pValues[ 18 ] <<= IsSummationOfParagraphs(); |
| // #90356# |
| pValues[ 19 ] <<= IsShowUndoDeleteWarning(); |
| pValues[ 20 ] <<= IsSlideshowRespectZOrder(); |
| |
| pValues[ 21 ] <<= IsPreviewNewEffects(); |
| pValues[ 22 ] <<= IsPreviewChangedEffects(); |
| pValues[ 23 ] <<= IsPreviewTransitions(); |
| |
| pValues[ 24 ] <<= GetDisplay(); |
| |
| pValues[ 25 ] <<= GetPresentationPenColor(); |
| pValues[ 26 ] <<= GetPresentationPenWidth(); |
| |
| pValues[ 27 ] <<= IsStartWithPresenterScreen(); |
| } |
| |
| return sal_True; |
| } |
| |
| /************************************************************************* |
| |* |
| |* SdOptionsMiscItem |
| |* |
| \************************************************************************/ |
| |
| SdOptionsMiscItem::SdOptionsMiscItem( sal_uInt16 _nWhich ) |
| : SfxPoolItem ( _nWhich ) |
| , maOptionsMisc ( 0, sal_False ) |
| { |
| } |
| |
| // ---------------------------------------------------------------------- |
| |
| SdOptionsMiscItem::SdOptionsMiscItem( sal_uInt16 _nWhich, SdOptions* pOpts, ::sd::FrameView* pView ) |
| : SfxPoolItem ( _nWhich ) |
| , maOptionsMisc ( 0, sal_False ) |
| { |
| if( pOpts ) |
| { |
| maOptionsMisc.SetStartWithTemplate( pOpts->IsStartWithTemplate() ); |
| maOptionsMisc.SetStartWithActualPage( pOpts->IsStartWithActualPage() ); |
| maOptionsMisc.SetStartWithPresenterScreen( pOpts->IsStartWithPresenterScreen() ); |
| maOptionsMisc.SetSummationOfParagraphs( pOpts->IsSummationOfParagraphs() ); |
| // #90356# |
| maOptionsMisc.SetShowUndoDeleteWarning( pOpts->IsShowUndoDeleteWarning() ); |
| maOptionsMisc.SetPrinterIndependentLayout( pOpts->GetPrinterIndependentLayout() ); |
| // #97016# |
| maOptionsMisc.SetDefaultObjectSizeWidth( pOpts->GetDefaultObjectSizeWidth() ); |
| maOptionsMisc.SetDefaultObjectSizeHeight( pOpts->GetDefaultObjectSizeHeight() ); |
| |
| maOptionsMisc.SetPreviewNewEffects(pOpts->IsPreviewNewEffects()); |
| maOptionsMisc.SetPreviewChangedEffects(pOpts->IsPreviewChangedEffects()); |
| maOptionsMisc.SetPreviewTransitions(pOpts->IsPreviewTransitions()); |
| |
| maOptionsMisc.SetDisplay(pOpts->GetDisplay()); |
| maOptionsMisc.SetShowComments( pOpts->IsShowComments() ); |
| |
| maOptionsMisc.SetPresentationPenColor(pOpts->GetPresentationPenColor() ); |
| maOptionsMisc.SetPresentationPenWidth(pOpts->GetPresentationPenWidth() ); |
| } |
| |
| if( pView ) |
| { |
| maOptionsMisc.SetMarkedHitMovesAlways( pView->IsMarkedHitMovesAlways() ); |
| maOptionsMisc.SetMoveOnlyDragging( pView->IsMoveOnlyDragging() ); |
| maOptionsMisc.SetCrookNoContortion( pView->IsCrookNoContortion() ); |
| maOptionsMisc.SetQuickEdit( pView->IsQuickEdit() ); |
| |
| // #i26631# |
| maOptionsMisc.SetMasterPagePaintCaching( pView->IsMasterPagePaintCaching() ); |
| |
| maOptionsMisc.SetDragWithCopy( pView->IsDragWithCopy() ); |
| maOptionsMisc.SetPickThrough( (sal_Bool)pView->GetModel()->IsPickThroughTransparentTextFrames() ); |
| maOptionsMisc.SetBigHandles( (sal_Bool)pView->IsBigHandles() ); |
| maOptionsMisc.SetDoubleClickTextEdit( pView->IsDoubleClickTextEdit() ); |
| maOptionsMisc.SetClickChangeRotation( pView->IsClickChangeRotation() ); |
| maOptionsMisc.SetSolidDragging( pView->IsSolidDragging() ); |
| maOptionsMisc.SetSolidMarkHdl( pView->IsSolidMarkHdl() ); |
| } |
| else if( pOpts ) |
| { |
| maOptionsMisc.SetMarkedHitMovesAlways( pOpts->IsMarkedHitMovesAlways() ); |
| maOptionsMisc.SetMoveOnlyDragging( pOpts->IsMoveOnlyDragging() ); |
| maOptionsMisc.SetCrookNoContortion( pOpts->IsCrookNoContortion() ); |
| maOptionsMisc.SetQuickEdit( pOpts->IsQuickEdit() ); |
| maOptionsMisc.SetMasterPagePaintCaching( pOpts->IsMasterPagePaintCaching() ); |
| maOptionsMisc.SetDragWithCopy( pOpts->IsDragWithCopy() ); |
| maOptionsMisc.SetPickThrough( pOpts->IsPickThrough() ); |
| maOptionsMisc.SetBigHandles( pOpts->IsBigHandles() ); |
| maOptionsMisc.SetDoubleClickTextEdit( pOpts->IsDoubleClickTextEdit() ); |
| maOptionsMisc.SetClickChangeRotation( pOpts->IsClickChangeRotation() ); |
| maOptionsMisc.SetSolidDragging( pOpts->IsSolidDragging() ); |
| maOptionsMisc.SetSolidMarkHdl( pOpts->IsSolidMarkHdl() ); |
| } |
| } |
| |
| // ---------------------------------------------------------------------- |
| |
| SfxPoolItem* SdOptionsMiscItem::Clone( SfxItemPool* ) const |
| { |
| return new SdOptionsMiscItem( *this ); |
| } |
| |
| |
| // ---------------------------------------------------------------------- |
| |
| int SdOptionsMiscItem::operator==( const SfxPoolItem& rAttr ) const |
| { |
| const bool bSameType = SfxPoolItem::operator==(rAttr); |
| DBG_ASSERT( bSameType, "SdOptionsMiscItem::operator==(), differen pool item type!" ); |
| return bSameType && ( maOptionsMisc == static_cast< const SdOptionsMiscItem& >(rAttr).maOptionsMisc ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SdOptionsMiscItem::SetOptions( SdOptions* pOpts ) const |
| { |
| if( pOpts ) |
| { |
| pOpts->SetStartWithTemplate( maOptionsMisc.IsStartWithTemplate() ); |
| pOpts->SetMarkedHitMovesAlways( maOptionsMisc.IsMarkedHitMovesAlways() ); |
| pOpts->SetMoveOnlyDragging( maOptionsMisc.IsMoveOnlyDragging() ); |
| pOpts->SetCrookNoContortion( maOptionsMisc.IsCrookNoContortion() ); |
| pOpts->SetQuickEdit( maOptionsMisc.IsQuickEdit() ); |
| pOpts->SetMasterPagePaintCaching( maOptionsMisc.IsMasterPagePaintCaching() ); |
| pOpts->SetDragWithCopy( maOptionsMisc.IsDragWithCopy() ); |
| pOpts->SetPickThrough( maOptionsMisc.IsPickThrough() ); |
| pOpts->SetBigHandles( maOptionsMisc.IsBigHandles() ); |
| pOpts->SetDoubleClickTextEdit( maOptionsMisc.IsDoubleClickTextEdit() ); |
| pOpts->SetClickChangeRotation( maOptionsMisc.IsClickChangeRotation() ); |
| pOpts->SetStartWithActualPage( maOptionsMisc.IsStartWithActualPage() ); |
| pOpts->SetStartWithPresenterScreen( maOptionsMisc.IsStartWithPresenterScreen() ); |
| pOpts->SetSummationOfParagraphs( maOptionsMisc.IsSummationOfParagraphs() ); |
| pOpts->SetSolidDragging( maOptionsMisc.IsSolidDragging() ); |
| pOpts->SetSolidMarkHdl( maOptionsMisc.IsSolidMarkHdl() ); |
| // #90356# |
| pOpts->SetShowUndoDeleteWarning( maOptionsMisc.IsShowUndoDeleteWarning() ); |
| pOpts->SetPrinterIndependentLayout( maOptionsMisc.GetPrinterIndependentLayout() ); |
| pOpts->SetShowComments( maOptionsMisc.IsShowComments() ); |
| // #97016# |
| pOpts->SetDefaultObjectSizeWidth( maOptionsMisc.GetDefaultObjectSizeWidth() ); |
| pOpts->SetDefaultObjectSizeHeight( maOptionsMisc.GetDefaultObjectSizeHeight() ); |
| |
| pOpts->SetPreviewNewEffects( maOptionsMisc.IsPreviewNewEffects() ); |
| pOpts->SetPreviewChangedEffects( maOptionsMisc.IsPreviewChangedEffects() ); |
| pOpts->SetPreviewTransitions( maOptionsMisc.IsPreviewTransitions() ); |
| |
| pOpts->SetDisplay( maOptionsMisc.GetDisplay() ); |
| |
| pOpts->SetPresentationPenColor( maOptionsMisc.GetPresentationPenColor() ); |
| pOpts->SetPresentationPenWidth( maOptionsMisc.GetPresentationPenWidth() ); |
| } |
| } |
| |
| /************************************************************************* |
| |* |
| |* SdOptionsSnap |
| |* |
| \************************************************************************/ |
| |
| SdOptionsSnap::SdOptionsSnap( sal_uInt16 nConfigId, sal_Bool bUseConfig ) : |
| SdOptionsGeneric( nConfigId, bUseConfig ? |
| ( ( SDCFG_DRAW == nConfigId ) ? |
| B2U( "Office.Draw/Snap" ) : |
| B2U( "Office.Impress/Snap" ) ) : |
| OUString() ), |
| bSnapHelplines( sal_True ), |
| bSnapBorder( sal_True ), |
| bSnapFrame( sal_False ), |
| bSnapPoints( sal_False ), |
| bOrtho( sal_False ), |
| bBigOrtho( sal_True ), |
| bRotate( sal_False ), |
| nSnapArea( 5 ), |
| nAngle( 1500 ), |
| nBezAngle( 1500 ) |
| |
| { |
| EnableModify( sal_True ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsSnap::operator==( const SdOptionsSnap& rOpt ) const |
| { |
| return( IsSnapHelplines() == rOpt.IsSnapHelplines() && |
| IsSnapBorder() == rOpt.IsSnapBorder() && |
| IsSnapFrame() == rOpt.IsSnapFrame() && |
| IsSnapPoints() == rOpt.IsSnapPoints() && |
| IsOrtho() == rOpt.IsOrtho() && |
| IsBigOrtho() == rOpt.IsBigOrtho() && |
| IsRotate() == rOpt.IsRotate() && |
| GetSnapArea() == rOpt.GetSnapArea() && |
| GetAngle() == rOpt.GetAngle() && |
| GetEliminatePolyPointLimitAngle() == rOpt.GetEliminatePolyPointLimitAngle() ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SdOptionsSnap::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const |
| { |
| static const char* aPropNames[] = |
| { |
| "Object/SnapLine", |
| "Object/PageMargin", |
| "Object/ObjectFrame", |
| "Object/ObjectPoint", |
| "Position/CreatingMoving", |
| "Position/ExtendEdges", |
| "Position/Rotating", |
| "Object/Range", |
| "Position/RotatingValue", |
| "Position/PointReduction" |
| }; |
| |
| rCount = 10; |
| ppNames = aPropNames; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsSnap::ReadData( const Any* pValues ) |
| { |
| if( pValues[0].hasValue() ) SetSnapHelplines( *(sal_Bool*) pValues[ 0 ].getValue() ); |
| if( pValues[1].hasValue() ) SetSnapBorder( *(sal_Bool*)pValues[ 1 ].getValue() ); |
| if( pValues[2].hasValue() ) SetSnapFrame( *(sal_Bool*) pValues[ 2 ].getValue() ); |
| if( pValues[3].hasValue() ) SetSnapPoints( *(sal_Bool*) pValues[ 3 ].getValue() ); |
| if( pValues[4].hasValue() ) SetOrtho( *(sal_Bool*) pValues[ 4 ].getValue() ); |
| if( pValues[5].hasValue() ) SetBigOrtho( *(sal_Bool*) pValues[ 5 ].getValue() ); |
| if( pValues[6].hasValue() ) SetRotate( *(sal_Bool*) pValues[ 6 ].getValue() ); |
| if( pValues[7].hasValue() ) SetSnapArea( (sal_Int16) *(sal_Int32*) pValues[ 7 ].getValue() ); |
| if( pValues[8].hasValue() ) SetAngle( (sal_Int16) *(sal_Int32*) pValues[ 8 ].getValue() ); |
| if( pValues[9].hasValue() ) SetEliminatePolyPointLimitAngle( (sal_Int16) *(sal_Int32*) pValues[ 9 ].getValue() ); |
| |
| return sal_True; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsSnap::WriteData( Any* pValues ) const |
| { |
| pValues[ 0 ] <<= IsSnapHelplines(); |
| pValues[ 1 ] <<= IsSnapBorder(); |
| pValues[ 2 ] <<= IsSnapFrame(); |
| pValues[ 3 ] <<= IsSnapPoints(); |
| pValues[ 4 ] <<= IsOrtho(); |
| pValues[ 5 ] <<= IsBigOrtho(); |
| pValues[ 6 ] <<= IsRotate(); |
| pValues[ 7 ] <<= (sal_Int32) GetSnapArea(); |
| pValues[ 8 ] <<= (sal_Int32) GetAngle(); |
| pValues[ 9 ] <<= (sal_Int32) GetEliminatePolyPointLimitAngle(); |
| |
| return sal_True; |
| } |
| |
| /************************************************************************* |
| |* |
| |* SdOptionsSnapItem |
| |* |
| \************************************************************************/ |
| |
| SdOptionsSnapItem::SdOptionsSnapItem( sal_uInt16 _nWhich ) |
| : SfxPoolItem ( _nWhich ) |
| , maOptionsSnap ( 0, sal_False ) |
| { |
| } |
| |
| // ---------------------------------------------------------------------- |
| |
| SdOptionsSnapItem::SdOptionsSnapItem( sal_uInt16 _nWhich, SdOptions* pOpts, ::sd::FrameView* pView ) |
| : SfxPoolItem ( _nWhich ) |
| , maOptionsSnap ( 0, sal_False ) |
| { |
| if( pView ) |
| { |
| maOptionsSnap.SetSnapHelplines( pView->IsHlplSnap() ); |
| maOptionsSnap.SetSnapBorder( pView->IsBordSnap() ); |
| maOptionsSnap.SetSnapFrame( pView->IsOFrmSnap() ); |
| maOptionsSnap.SetSnapPoints( pView->IsOPntSnap() ); |
| maOptionsSnap.SetOrtho( pView->IsOrtho() ); |
| maOptionsSnap.SetBigOrtho( pView->IsBigOrtho() ); |
| maOptionsSnap.SetRotate( pView->IsAngleSnapEnabled() ); |
| maOptionsSnap.SetSnapArea( pView->GetSnapMagneticPixel() ); |
| maOptionsSnap.SetAngle( (sal_Int16) pView->GetSnapAngle() ); |
| maOptionsSnap.SetEliminatePolyPointLimitAngle( (sal_Int16) pView->GetEliminatePolyPointLimitAngle() ); |
| } |
| else if( pOpts ) |
| { |
| maOptionsSnap.SetSnapHelplines( pOpts->IsSnapHelplines() ); |
| maOptionsSnap.SetSnapBorder( pOpts->IsSnapBorder() ); |
| maOptionsSnap.SetSnapFrame( pOpts->IsSnapFrame() ); |
| maOptionsSnap.SetSnapPoints( pOpts->IsSnapPoints() ); |
| maOptionsSnap.SetOrtho( pOpts->IsOrtho() ); |
| maOptionsSnap.SetBigOrtho( pOpts->IsBigOrtho() ); |
| maOptionsSnap.SetRotate( pOpts->IsRotate() ); |
| maOptionsSnap.SetSnapArea( pOpts->GetSnapArea() ); |
| maOptionsSnap.SetAngle( pOpts->GetAngle() ); |
| maOptionsSnap.SetEliminatePolyPointLimitAngle( pOpts->GetEliminatePolyPointLimitAngle() ); |
| } |
| } |
| |
| // ---------------------------------------------------------------------- |
| |
| SfxPoolItem* SdOptionsSnapItem::Clone( SfxItemPool* ) const |
| { |
| return new SdOptionsSnapItem( *this ); |
| } |
| |
| |
| // ---------------------------------------------------------------------- |
| |
| int SdOptionsSnapItem::operator==( const SfxPoolItem& rAttr ) const |
| { |
| const bool bSameType = SfxPoolItem::operator==(rAttr); |
| DBG_ASSERT( bSameType, "SdOptionsSnapItem::operator==(), differen pool item type!" ); |
| return bSameType && ( maOptionsSnap == static_cast< const SdOptionsSnapItem& >(rAttr).maOptionsSnap ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SdOptionsSnapItem::SetOptions( SdOptions* pOpts ) const |
| { |
| if( pOpts ) |
| { |
| pOpts->SetSnapHelplines( maOptionsSnap.IsSnapHelplines() ); |
| pOpts->SetSnapBorder( maOptionsSnap.IsSnapBorder() ); |
| pOpts->SetSnapFrame( maOptionsSnap.IsSnapFrame() ); |
| pOpts->SetSnapPoints( maOptionsSnap.IsSnapPoints() ); |
| pOpts->SetOrtho( maOptionsSnap.IsOrtho() ); |
| pOpts->SetBigOrtho( maOptionsSnap.IsBigOrtho() ); |
| pOpts->SetRotate( maOptionsSnap.IsRotate() ); |
| pOpts->SetSnapArea( maOptionsSnap.GetSnapArea() ); |
| pOpts->SetAngle( maOptionsSnap.GetAngle() ); |
| pOpts->SetEliminatePolyPointLimitAngle( maOptionsSnap.GetEliminatePolyPointLimitAngle() ); |
| } |
| } |
| |
| /************************************************************************* |
| |* |
| |* SdOptionsZoom |
| |* |
| \************************************************************************/ |
| |
| SdOptionsZoom::SdOptionsZoom( sal_uInt16 nConfigId, sal_Bool bUseConfig ) : |
| SdOptionsGeneric( nConfigId, ( bUseConfig && ( SDCFG_DRAW == nConfigId ) ) ? |
| B2U( "Office.Draw/Zoom" ) : |
| OUString() ), |
| nX( 1 ), |
| nY( 1 ) |
| |
| { |
| EnableModify( sal_True ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsZoom::operator==( const SdOptionsZoom& rOpt ) const |
| { |
| sal_Int32 nX1, nX2, nY1, nY2; |
| |
| GetScale( nX1, nY1 ); |
| rOpt.GetScale( nX2, nY2 ); |
| |
| return( ( nX1 == nX2 ) && |
| ( nY1 == nY2 ) ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SdOptionsZoom::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const |
| { |
| static const char* aPropNames[] = |
| { |
| "ScaleX", |
| "ScaleY" |
| }; |
| |
| rCount = ( GetConfigId() == SDCFG_DRAW ) ? 2 : 0; |
| ppNames = aPropNames; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsZoom::ReadData( const Any* pValues ) |
| { |
| sal_Int32 x = 1, y = 1; |
| |
| if( pValues[0].hasValue() ) x = ( *(sal_Int32*) pValues[ 0 ].getValue() ); |
| if( pValues[1].hasValue() ) y = ( *(sal_Int32*) pValues[ 1 ].getValue() ); |
| |
| SetScale( x, y ); |
| |
| return sal_True; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsZoom::WriteData( Any* pValues ) const |
| { |
| sal_Int32 x, y; |
| |
| GetScale( x, y ); |
| |
| pValues[ 0 ] <<= (sal_Int32) x; |
| pValues[ 1 ] <<= (sal_Int32) y; |
| |
| return sal_True; |
| } |
| |
| /************************************************************************* |
| |* |
| |* SdOptionsGrid |
| |* |
| \************************************************************************/ |
| |
| SdOptionsGrid::SdOptionsGrid( sal_uInt16 nConfigId, sal_Bool bUseConfig ) : |
| SdOptionsGeneric( nConfigId, bUseConfig ? |
| ( ( SDCFG_DRAW == nConfigId ) ? |
| B2U( "Office.Draw/Grid" ) : |
| B2U( "Office.Impress/Grid" ) ) : |
| OUString() ) |
| { |
| EnableModify( sal_False ); |
| SetDefaults(); |
| EnableModify( sal_True ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| SdOptionsGrid::~SdOptionsGrid() |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SdOptionsGrid::SetDefaults() |
| { |
| const sal_uInt32 nVal = 1000; |
| |
| SetFldDivisionX( nVal ); |
| SetFldDivisionY( nVal ); |
| SetFldDrawX( nVal ); |
| SetFldDrawY( nVal ); |
| SetFldSnapX( nVal ); |
| SetFldSnapY( nVal ); |
| SetUseGridSnap( sal_False ); |
| SetSynchronize( sal_True ); |
| SetGridVisible( sal_False ); |
| SetEqualGrid( sal_True ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsGrid::operator==( const SdOptionsGrid& rOpt ) const |
| { |
| return( GetFldDrawX() == rOpt.GetFldDrawX() && |
| GetFldDivisionX() == rOpt.GetFldDivisionX() && |
| GetFldDrawY() == rOpt.GetFldDrawY() && |
| GetFldDivisionY() == rOpt.GetFldDivisionY() && |
| GetFldSnapX() == rOpt.GetFldSnapX() && |
| GetFldSnapY() == rOpt.GetFldSnapY() && |
| IsUseGridSnap() == rOpt.IsUseGridSnap() && |
| IsSynchronize() == rOpt.IsSynchronize() && |
| IsGridVisible() == rOpt.IsGridVisible() && |
| IsEqualGrid() == rOpt.IsEqualGrid() ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SdOptionsGrid::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const |
| { |
| static const char* aPropNamesMetric[] = |
| { |
| "Resolution/XAxis/Metric", |
| "Resolution/YAxis/Metric", |
| "Subdivision/XAxis", |
| "Subdivision/YAxis", |
| "SnapGrid/XAxis/Metric", |
| "SnapGrid/YAxis/Metric", |
| "Option/SnapToGrid", |
| "Option/Synchronize", |
| "Option/VisibleGrid", |
| "SnapGrid/Size" |
| }; |
| |
| static const char* aPropNamesNonMetric[] = |
| { |
| "Resolution/XAxis/NonMetric", |
| "Resolution/YAxis/NonMetric", |
| "Subdivision/XAxis", |
| "Subdivision/YAxis", |
| "SnapGrid/XAxis/NonMetric", |
| "SnapGrid/YAxis/NonMetric", |
| "Option/SnapToGrid", |
| "Option/Synchronize", |
| "Option/VisibleGrid", |
| "SnapGrid/Size" |
| }; |
| |
| rCount = 10; |
| |
| if( isMetricSystem() ) |
| ppNames = aPropNamesMetric; |
| else |
| ppNames = aPropNamesNonMetric; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsGrid::ReadData( const Any* pValues ) |
| { |
| if( pValues[0].hasValue() ) SetFldDrawX( *(sal_Int32*) pValues[ 0 ].getValue() ); |
| if( pValues[1].hasValue() ) SetFldDrawY( *(sal_Int32*) pValues[ 1 ].getValue() ); |
| |
| if( pValues[2].hasValue() ) |
| { |
| const sal_uInt32 nDivX = FRound( *(double*) pValues[ 2 ].getValue() ); |
| SetFldDivisionX( SvxOptionsGrid::GetFldDrawX() / ( nDivX + 1 ) ); |
| } |
| |
| if( pValues[3].hasValue() ) |
| { |
| const sal_uInt32 nDivY = FRound( *(double*) pValues[ 3 ].getValue() ); |
| SetFldDivisionY( SvxOptionsGrid::GetFldDrawY() / ( nDivY + 1 ) ); |
| } |
| |
| if( pValues[4].hasValue() ) SetFldSnapX( *(sal_Int32*) pValues[ 4 ].getValue() ); |
| if( pValues[5].hasValue() ) SetFldSnapY( *(sal_Int32*) pValues[ 5 ].getValue() ); |
| if( pValues[6].hasValue() ) SetUseGridSnap( *(sal_Bool*) pValues[ 6 ].getValue() ); |
| if( pValues[7].hasValue() ) SetSynchronize( *(sal_Bool*) pValues[ 7 ].getValue() ); |
| if( pValues[8].hasValue() ) SetGridVisible( *(sal_Bool*) pValues[ 8 ].getValue() ); |
| if( pValues[9].hasValue() ) SetEqualGrid( *(sal_Bool*) pValues[ 9 ].getValue() ); |
| |
| return sal_True; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsGrid::WriteData( Any* pValues ) const |
| { |
| pValues[ 0 ] <<= (sal_Int32) GetFldDrawX(); |
| pValues[ 1 ] <<= (sal_Int32) GetFldDrawY(); |
| pValues[ 2 ] <<= ( GetFldDivisionX() ? ( (double) GetFldDrawX() / GetFldDivisionX() - 1.0 ) : (double) 0 ); |
| pValues[ 3 ] <<= ( GetFldDivisionY() ? ( (double) GetFldDrawY() / GetFldDivisionY() - 1.0 ) : (double) 0 ); |
| pValues[ 4 ] <<= (sal_Int32) GetFldSnapX(); |
| pValues[ 5 ] <<= (sal_Int32) GetFldSnapY(); |
| pValues[ 6 ] <<= IsUseGridSnap(); |
| pValues[ 7 ] <<= IsSynchronize(); |
| pValues[ 8 ] <<= IsGridVisible(); |
| pValues[ 9 ] <<= IsEqualGrid(); |
| |
| return sal_True; |
| } |
| |
| /************************************************************************* |
| |* |
| |* SdOptionsGridItem |
| |* |
| \************************************************************************/ |
| |
| SdOptionsGridItem::SdOptionsGridItem( sal_uInt16 _nWhich, SdOptions* pOpts, ::sd::FrameView* pView ) : |
| SvxGridItem( _nWhich ) |
| { |
| SetSynchronize( pOpts->IsSynchronize() ); |
| SetEqualGrid( pOpts->IsEqualGrid() ); |
| |
| if( pView ) |
| { |
| SetFldDrawX( pView->GetGridCoarse().Width() ); |
| SetFldDrawY( pView->GetGridCoarse().Height() ); |
| SetFldDivisionX( pView->GetGridFine().Width() ? ( GetFldDrawX() / pView->GetGridFine().Width() - 1 ) : 0 ); |
| SetFldDivisionY( pView->GetGridFine().Height() ? ( GetFldDrawY() / pView->GetGridFine().Height() - 1 ) : 0 ); |
| SetFldSnapX( long(pView->GetSnapGridWidthX()) ); |
| SetFldSnapY( long(pView->GetSnapGridWidthY()) ); |
| SetUseGridSnap( pView->IsGridSnap() ); |
| SetGridVisible( pView->IsGridVisible() ); |
| } |
| else |
| { |
| SetFldDrawX( pOpts->GetFldDrawX() ); |
| SetFldDrawY( pOpts->GetFldDrawY() ); |
| SetFldDivisionX( pOpts->GetFldDivisionX() ? ( pOpts->GetFldDrawX() / pOpts->GetFldDivisionX() - 1 ) : 0 ); |
| SetFldDivisionY( pOpts->GetFldDivisionY() ? ( pOpts->GetFldDrawY() / pOpts->GetFldDivisionY() - 1 ) : 0 ); |
| SetFldSnapX( pOpts->GetFldSnapX() ); |
| SetFldSnapY( pOpts->GetFldSnapY() ); |
| SetUseGridSnap( pOpts->IsUseGridSnap() ); |
| SetGridVisible( pOpts->IsGridVisible() ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SdOptionsGridItem::SetOptions( SdOptions* pOpts ) const |
| { |
| pOpts->SetFldDrawX( GetFldDrawX() ); |
| pOpts->SetFldDivisionX( GetFldDrawX() / ( GetFldDivisionX() + 1 ) ); |
| pOpts->SetFldDrawY( GetFldDrawY() ); |
| pOpts->SetFldDivisionY( GetFldDrawY() / ( GetFldDivisionY() + 1 ) ); |
| pOpts->SetFldSnapX( GetFldSnapX() ); |
| pOpts->SetFldSnapY( GetFldSnapY() ); |
| pOpts->SetUseGridSnap( GetUseGridSnap() ); |
| pOpts->SetSynchronize( GetSynchronize() ); |
| pOpts->SetGridVisible( GetGridVisible() ); |
| pOpts->SetEqualGrid( GetEqualGrid() ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* SdOptionsPrint |
| |* |
| \************************************************************************/ |
| |
| SdOptionsPrint::SdOptionsPrint( sal_uInt16 nConfigId, sal_Bool bUseConfig ) : |
| SdOptionsGeneric( nConfigId, bUseConfig ? |
| ( ( SDCFG_DRAW == nConfigId ) ? |
| B2U( "Office.Draw/Print" ) : |
| B2U( "Office.Impress/Print" ) ) : |
| OUString() ), |
| bDraw( sal_True ), |
| bNotes( sal_False ), |
| bHandout( sal_False ), |
| bOutline( sal_False ), |
| bDate( sal_False ), |
| bTime( sal_False ), |
| bPagename( sal_False ), |
| bHiddenPages( sal_True ), |
| bPagesize( sal_False ), |
| bPagetile( sal_False ), |
| bWarningPrinter( sal_True ), |
| bWarningSize( sal_False ), |
| bWarningOrientation( sal_False ), |
| bBooklet( sal_False ), |
| bFront( sal_True ), |
| bBack( sal_True ), |
| bCutPage( sal_False ), |
| bPaperbin( sal_False ), |
| mbHandoutHorizontal( sal_True ), |
| mnHandoutPages( 6 ), |
| nQuality( 0 ) |
| { |
| EnableModify( sal_True ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsPrint::operator==( const SdOptionsPrint& rOpt ) const |
| { |
| return( IsDraw() == rOpt.IsDraw() && |
| IsNotes() == rOpt.IsNotes() && |
| IsHandout() == rOpt.IsHandout() && |
| IsOutline() == rOpt.IsOutline() && |
| IsDate() == rOpt.IsDate() && |
| IsTime() == rOpt.IsTime() && |
| IsPagename() == rOpt.IsPagename() && |
| IsHiddenPages() == rOpt.IsHiddenPages() && |
| IsPagesize() == rOpt.IsPagesize() && |
| IsPagetile() == rOpt.IsPagetile() && |
| IsWarningPrinter() == rOpt.IsWarningPrinter() && |
| IsWarningSize() == rOpt.IsWarningSize() && |
| IsWarningOrientation() == rOpt.IsWarningOrientation() && |
| IsBooklet() == rOpt.IsBooklet() && |
| IsFrontPage() == rOpt.IsFrontPage() && |
| IsBackPage() == rOpt.IsBackPage() && |
| IsCutPage() == rOpt.IsCutPage() && |
| IsPaperbin() == rOpt.IsPaperbin() && |
| GetOutputQuality() == rOpt.GetOutputQuality() && |
| IsHandoutHorizontal() == rOpt.IsHandoutHorizontal() && |
| GetHandoutPages() == rOpt.GetHandoutPages() ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SdOptionsPrint::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const |
| { |
| static const char* aDrawPropNames[] = |
| { |
| "Other/Date", |
| "Other/Time", |
| "Other/PageName", |
| "Other/HiddenPage", |
| "Page/PageSize", |
| "Page/PageTile", |
| // bWarningPrinter |
| // bWarningSize |
| // bWarningOrientation |
| "Page/Booklet", |
| "Page/BookletFront", |
| "Page/BookletBack", |
| // bCutPage |
| "Other/FromPrinterSetup", |
| "Other/Quality", |
| "Content/Drawing", |
| }; |
| static const char* aImpressPropNames[] = |
| { |
| "Other/Date", |
| "Other/Time", |
| "Other/PageName", |
| "Other/HiddenPage", |
| "Page/PageSize", |
| "Page/PageTile", |
| // bWarningPrinter |
| // bWarningSize |
| // bWarningOrientation |
| "Page/Booklet", |
| "Page/BookletFront", |
| "Page/BookletBack", |
| // bCutPage |
| "Other/FromPrinterSetup", |
| "Other/Quality", |
| "Content/Presentation", |
| "Content/Note", |
| "Content/Handout", |
| "Content/Outline", |
| "Other/HandoutHorizontal", |
| "Other/PagesPerHandout" |
| }; |
| |
| if( GetConfigId() == SDCFG_IMPRESS ) |
| { |
| rCount = 17; |
| ppNames = aImpressPropNames; |
| } |
| else |
| { |
| rCount = 12; |
| ppNames = aDrawPropNames; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsPrint::ReadData( const Any* pValues ) |
| { |
| if( pValues[0].hasValue() ) SetDate( *(sal_Bool*) pValues[ 0 ].getValue() ); |
| if( pValues[1].hasValue() ) SetTime( *(sal_Bool*) pValues[ 1 ].getValue() ); |
| if( pValues[2].hasValue() ) SetPagename( *(sal_Bool*) pValues[ 2 ].getValue() ); |
| if( pValues[3].hasValue() ) SetHiddenPages( *(sal_Bool*) pValues[ 3 ].getValue() ); |
| if( pValues[4].hasValue() ) SetPagesize( *(sal_Bool*) pValues[ 4 ].getValue() ); |
| if( pValues[5].hasValue() ) SetPagetile( *(sal_Bool*) pValues[ 5 ].getValue() ); |
| if( pValues[6].hasValue() ) SetBooklet( *(sal_Bool*) pValues[ 6 ].getValue() ); |
| if( pValues[7].hasValue() ) SetFrontPage( *(sal_Bool*) pValues[ 7 ].getValue() ); |
| if( pValues[8].hasValue() ) SetBackPage( *(sal_Bool*) pValues[ 8 ].getValue() ); |
| if( pValues[9].hasValue() ) SetPaperbin( *(sal_Bool*) pValues[ 9 ].getValue() ); |
| if( pValues[10].hasValue() ) SetOutputQuality( (sal_uInt16) *(sal_Int32*) pValues[ 10 ].getValue() ); |
| if( pValues[11].hasValue() ) SetDraw( *(sal_Bool*) pValues[ 11 ].getValue() ); |
| |
| // just for impress |
| if( GetConfigId() == SDCFG_IMPRESS ) |
| { |
| if( pValues[12].hasValue() ) SetNotes( *(sal_Bool*) pValues[ 12 ].getValue() ); |
| if( pValues[13].hasValue() ) SetHandout( *(sal_Bool*) pValues[ 13 ].getValue() ); |
| if( pValues[14].hasValue() ) SetOutline( *(sal_Bool*) pValues[ 14 ].getValue() ); |
| if( pValues[15].hasValue() ) SetHandoutHorizontal( *(sal_Bool*) pValues[15].getValue() ); |
| if( pValues[16].hasValue() ) SetHandoutPages( (sal_uInt16)*(sal_Int32*) pValues[16].getValue() ); |
| } |
| |
| return sal_True; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool SdOptionsPrint::WriteData( Any* pValues ) const |
| { |
| pValues[ 0 ] <<= IsDate(); |
| pValues[ 1 ] <<= IsTime(); |
| pValues[ 2 ] <<= IsPagename(); |
| pValues[ 3 ] <<= IsHiddenPages(); |
| pValues[ 4 ] <<= IsPagesize(); |
| pValues[ 5 ] <<= IsPagetile(); |
| pValues[ 6 ] <<= IsBooklet(); |
| pValues[ 7 ] <<= IsFrontPage(); |
| pValues[ 8 ] <<= IsBackPage(); |
| pValues[ 9 ] <<= IsPaperbin(); |
| pValues[ 10 ] <<= (sal_Int32) GetOutputQuality(); |
| pValues[ 11 ] <<= IsDraw(); |
| |
| // just for impress |
| if( GetConfigId() == SDCFG_IMPRESS ) |
| { |
| pValues[ 12 ] <<= IsNotes(); |
| pValues[ 13 ] <<= IsHandout(); |
| pValues[ 14 ] <<= IsOutline(); |
| pValues[ 15 ] <<= IsHandoutHorizontal(); |
| pValues[ 16 ] <<= GetHandoutPages(); |
| } |
| |
| return sal_True; |
| } |
| |
| /************************************************************************* |
| |* |
| |* SdOptionsPrintItem |
| |* |
| \************************************************************************/ |
| |
| SdOptionsPrintItem::SdOptionsPrintItem( sal_uInt16 _nWhich ) |
| : SfxPoolItem ( _nWhich ) |
| , maOptionsPrint ( 0, sal_False ) |
| { |
| } |
| |
| // ---------------------------------------------------------------------- |
| |
| SdOptionsPrintItem::SdOptionsPrintItem( sal_uInt16 _nWhich, SdOptions* pOpts, ::sd::FrameView* ) |
| : SfxPoolItem ( _nWhich ) |
| , maOptionsPrint ( 0, sal_False ) |
| { |
| if( pOpts ) |
| { |
| maOptionsPrint.SetDraw( pOpts->IsDraw() ); |
| maOptionsPrint.SetNotes( pOpts->IsNotes() ); |
| maOptionsPrint.SetHandout( pOpts->IsHandout() ); |
| maOptionsPrint.SetOutline( pOpts->IsOutline() ); |
| maOptionsPrint.SetDate( pOpts->IsDate() ); |
| maOptionsPrint.SetTime( pOpts->IsTime() ); |
| maOptionsPrint.SetPagename( pOpts->IsPagename() ); |
| maOptionsPrint.SetHiddenPages( pOpts->IsHiddenPages() ); |
| maOptionsPrint.SetPagesize( pOpts->IsPagesize() ); |
| maOptionsPrint.SetPagetile( pOpts->IsPagetile() ); |
| maOptionsPrint.SetWarningPrinter( pOpts->IsWarningPrinter() ); |
| maOptionsPrint.SetWarningSize( pOpts->IsWarningSize() ); |
| maOptionsPrint.SetWarningOrientation( pOpts->IsWarningOrientation() ); |
| maOptionsPrint.SetBooklet( pOpts->IsBooklet() ); |
| maOptionsPrint.SetFrontPage( pOpts->IsFrontPage() ); |
| maOptionsPrint.SetBackPage( pOpts->IsBackPage() ); |
| maOptionsPrint.SetCutPage( pOpts->IsCutPage() ); |
| maOptionsPrint.SetPaperbin( pOpts->IsPaperbin() ); |
| maOptionsPrint.SetOutputQuality( pOpts->GetOutputQuality() ); |
| } |
| } |
| |
| // ---------------------------------------------------------------------- |
| |
| SfxPoolItem* SdOptionsPrintItem::Clone( SfxItemPool* ) const |
| { |
| return new SdOptionsPrintItem( *this ); |
| } |
| |
| // ---------------------------------------------------------------------- |
| |
| int SdOptionsPrintItem::operator==( const SfxPoolItem& rAttr ) const |
| { |
| const bool bSameType = SfxPoolItem::operator==(rAttr); |
| DBG_ASSERT( bSameType, "SdOptionsPrintItem::operator==(), differen pool item type!" ); |
| return bSameType && ( maOptionsPrint == static_cast< const SdOptionsPrintItem& >( rAttr ).maOptionsPrint ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void SdOptionsPrintItem::SetOptions( SdOptions* pOpts ) const |
| { |
| if( pOpts ) |
| { |
| pOpts->SetDraw( maOptionsPrint.IsDraw() ); |
| pOpts->SetNotes( maOptionsPrint.IsNotes() ); |
| pOpts->SetHandout( maOptionsPrint.IsHandout() ); |
| pOpts->SetOutline( maOptionsPrint.IsOutline() ); |
| pOpts->SetDate( maOptionsPrint.IsDate() ); |
| pOpts->SetTime( maOptionsPrint.IsTime() ); |
| pOpts->SetPagename( maOptionsPrint.IsPagename() ); |
| pOpts->SetHiddenPages( maOptionsPrint.IsHiddenPages() ); |
| pOpts->SetPagesize( maOptionsPrint.IsPagesize() ); |
| pOpts->SetPagetile( maOptionsPrint.IsPagetile() ); |
| pOpts->SetWarningPrinter( maOptionsPrint.IsWarningPrinter() ); |
| pOpts->SetWarningSize( maOptionsPrint.IsWarningSize() ); |
| pOpts->SetWarningOrientation( maOptionsPrint.IsWarningOrientation() ); |
| pOpts->SetBooklet( maOptionsPrint.IsBooklet() ); |
| pOpts->SetFrontPage( maOptionsPrint.IsFrontPage() ); |
| pOpts->SetBackPage( maOptionsPrint.IsBackPage() ); |
| pOpts->SetCutPage( maOptionsPrint.IsCutPage() ); |
| pOpts->SetPaperbin( maOptionsPrint.IsPaperbin() ); |
| pOpts->SetOutputQuality( maOptionsPrint.GetOutputQuality() ); |
| } |
| } |
| |
| /************************************************************************* |
| |* |
| |* SdOptions |
| |* |
| \************************************************************************/ |
| |
| SdOptions::SdOptions( sal_uInt16 nConfigId ) : |
| SdOptionsLayout( nConfigId, sal_True ), |
| SdOptionsContents( nConfigId, sal_True ), |
| SdOptionsMisc( nConfigId, sal_True ), |
| SdOptionsSnap( nConfigId, sal_True ), |
| SdOptionsZoom( nConfigId, sal_True ), |
| SdOptionsGrid( nConfigId, sal_True ), |
| SdOptionsPrint( nConfigId, sal_True ) |
| { |
| } |
| |
| // ---------------------------------------------------------------------- |
| |
| SdOptions::~SdOptions() |
| { |
| } |
| |
| // ---------------------------------------------------------------------- |
| |
| void SdOptions::StoreConfig( sal_uLong nOptionsRange ) |
| { |
| if( nOptionsRange & SD_OPTIONS_LAYOUT ) |
| SdOptionsLayout::Store(); |
| |
| if( nOptionsRange & SD_OPTIONS_CONTENTS ) |
| SdOptionsContents::Store(); |
| |
| if( nOptionsRange & SD_OPTIONS_MISC ) |
| SdOptionsMisc::Store(); |
| |
| if( nOptionsRange & SD_OPTIONS_SNAP ) |
| SdOptionsSnap::Store(); |
| |
| if( nOptionsRange & SD_OPTIONS_ZOOM ) |
| SdOptionsZoom::Store(); |
| |
| if( nOptionsRange & SD_OPTIONS_GRID ) |
| SdOptionsGrid::Store(); |
| |
| if( nOptionsRange & SD_OPTIONS_PRINT ) |
| SdOptionsPrint::Store(); |
| } |