LCOV - code coverage report
Current view: top level - sd/source/ui/app - optsitem.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 721 0.0 %
Date: 2014-04-14 Functions: 0 90 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10