/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

 *   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 .

 */

#include <sal/config.h>

#include <o3tl/any.hxx>

#include <svx/svdmodel.hxx>

#include <svx/svxids.hrc>

#include <tools/debug.hxx>

#include <tools/helpers.hxx>

#include <unotools/localedatawrapper.hxx>

#include <unotools/syslocale.hxx>

#include <osl/diagnose.h>

#include <optsitem.hxx>

#include <FrameView.hxx>

#include <sdattr.hrc>

using namespace ::utl;

using namespace ::com::sun::star::uno;

template< class T > static T getSafeValue( const Any& rAny )

{

    T value = T();

    bool bOk = (rAny >>= value);

    DBG_ASSERT( bOk, "SdOptionsItem, wrong type from configuration!" );

    return value;

}

Unexecuted instantiation: optsitem.cxx:int getSafeValue<int>(com::sun::star::uno::Any const&)

Unexecuted instantiation: optsitem.cxx:double getSafeValue<double>(com::sun::star::uno::Any const&)

SdOptionsItem::SdOptionsItem( const SdOptionsGeneric& rParent, const OUString& rSubTree ) :

    ConfigItem  ( rSubTree ),

    mrParent    ( rParent )

{

}

SdOptionsItem::~SdOptionsItem()

{

}

void SdOptionsItem::ImplCommit()

{

    if( IsModified() )

        mrParent.Commit( *this );

};

void SdOptionsItem::Notify( const css::uno::Sequence<OUString>& )

{}

Sequence< Any > SdOptionsItem::GetProperties( const Sequence< OUString >& rNames )

{

    return ConfigItem::GetProperties( rNames );

}

bool SdOptionsItem::PutProperties( const Sequence< OUString >& rNames, const Sequence< Any>& rValues )

{

    return ConfigItem::PutProperties( rNames, rValues );

}

SdOptionsGeneric::SdOptionsGeneric(bool bImpress, const OUString& rSubTree)

    : maSubTree(rSubTree)

    , mbImpress(bImpress)

    , mbInit(rSubTree.isEmpty())

    , mbEnableModify(false)

{

}

SdOptionsGeneric::SdOptionsGeneric(SdOptionsGeneric const & rSource)

{

    operator=(rSource);

}

SdOptionsGeneric& SdOptionsGeneric::operator=(SdOptionsGeneric const & rSource)

{

    if (this != &rSource)

    {

        maSubTree = rSource.maSubTree;

        mpCfgItem.reset(rSource.mpCfgItem ? new SdOptionsItem(*rSource.mpCfgItem) : nullptr );

        mbImpress = rSource.mbImpress;

        mbInit = rSource.mbInit;

        mbEnableModify = rSource.mbEnableModify;

    }

    return *this;

}

void SdOptionsGeneric::Init() const

{

    if( mbInit )

        return;

    SdOptionsGeneric* pThis = const_cast<SdOptionsGeneric*>(this);

    if( !mpCfgItem )

        pThis->mpCfgItem.reset( new SdOptionsItem( *this, maSubTree ) );

    assert(mpCfgItem && "mpCfgItem is set by now");

    const Sequence< OUString >  aNames( GetPropertyNames() );

    const Sequence< Any >       aValues = mpCfgItem->GetProperties( aNames );

    if( aNames.hasElements() && ( aValues.getLength() == aNames.getLength() ) )

    {

        const Any* pValues = aValues.getConstArray();

        pThis->EnableModify( false );

        pThis->mbInit = pThis->ReadData( pValues );

        pThis->EnableModify( true );

    }

    else

        pThis->mbInit = true;

}

SdOptionsGeneric::~SdOptionsGeneric()

{

}

void SdOptionsGeneric::Commit( SdOptionsItem& rCfgItem ) const

{

    const Sequence< OUString >  aNames( GetPropertyNames() );

    Sequence< Any >             aValues( aNames.getLength() );

    if( aNames.hasElements() )

    {

        if( WriteData( aValues.getArray() ) )

            rCfgItem.PutProperties( aNames, aValues );

        else

        {

            OSL_FAIL( "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.GetLocaleData().getMeasurementSystemEnum();

    return ( eSys == MeasurementSystem::Metric );

}

/*************************************************************************

|*

|* SdOptionsMisc

|*

\************************************************************************/

SdOptionsMisc::SdOptionsMisc( bool bImpress, bool bUseConfig ) :

    SdOptionsGeneric( bImpress, bUseConfig ?

                      ( bImpress ?

                        u"Office.Impress/Misc"_ustr :

                        u"Office.Draw/Misc"_ustr ) :

                      OUString() ),

    nDefaultObjectSizeWidth(8000),

    nDefaultObjectSizeHeight(5000),

    bStartWithTemplate( false ),

    bMarkedHitMovesAlways( true ),

    bMoveOnlyDragging( false ),

    bCrookNoContortion( false ),

    bQuickEdit( IsImpress() ),

    bMasterPageCache( true ),

    bDragWithCopy( false ),

    bPickThrough( true ),

    bDoubleClickTextEdit( true ),

    bClickChangeRotation( false ),

    bSolidDragging( true ),

    bSummationOfParagraphs( false ),

    bTabBarVisible( true ),

    bShowUndoDeleteWarning( true ),

    bSlideshowRespectZOrder( true ),

    bShowComments( true ),

    bPreviewNewEffects( true ),

    bPreviewChangedEffects( false ),

    bPreviewTransitions( true ),

    mnDisplay( 0 ),

    mnPenColor( 0xff0000 ),

    mnPenWidth( 150.0 ),

    // The default for 6.1-and-above documents is to use printer-independent

    // formatting.

    mnPrinterIndependentLayout (1),

    mnDragThresholdPixels(6)

{

    EnableModify( true );

}

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() &&

            IsDoubleClickTextEdit() == rOpt.IsDoubleClickTextEdit() &&

            IsClickChangeRotation() == rOpt.IsClickChangeRotation() &&

            IsSummationOfParagraphs() == rOpt.IsSummationOfParagraphs() &&

            IsTabBarVisible() == rOpt.IsTabBarVisible() &&

            IsSolidDragging() == rOpt.IsSolidDragging() &&

            IsShowUndoDeleteWarning() == rOpt.IsShowUndoDeleteWarning() &&

            IsSlideshowRespectZOrder() == rOpt.IsSlideshowRespectZOrder() &&

            GetPrinterIndependentLayout() == rOpt.GetPrinterIndependentLayout() &&

            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() &&

            GetDragThresholdPixels() == rOpt.GetDragThresholdPixels()

        );

}

void SdOptionsMisc::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const

{

    static const char* aPropNames[] =

    {

        "ObjectMoveable",

        "NoDistort",

        "TextObject/QuickEditing",

        "BackgroundCache",

        "CopyWhileMoving",

        "TextObject/Selectable",

        "DclickTextedit",

        "RotateClick",

        "Preview",

        "ModifyWithAttributes",

        "DefaultObjectSize/Width",

        "DefaultObjectSize/Height",

        "Compatibility/PrinterIndependentLayout",

        "ShowComments",

        "DragThresholdPixels",

        // just for impress

        "NewDoc/AutoPilot",

        "Compatibility/AddBetween",

        "ShowUndoDeleteWarning",

        "SlideshowRespectZOrder",

        "PreviewNewEffects",

        "PreviewChangedEffects",

        "PreviewTransitions",

        "Display",

        "PenColor",

        "PenWidth",

        "TabBarVisible"

    };

    rCount = ( IsImpress() ? SAL_N_ELEMENTS(aPropNames) : 15 );

    ppNames = aPropNames;

}

bool SdOptionsMisc::ReadData( const Any* pValues )

{

    if( pValues[0].hasValue() ) SetMarkedHitMovesAlways( *o3tl::doAccess<bool>(pValues[ 0 ]) );

    if( pValues[1].hasValue() ) SetCrookNoContortion( *o3tl::doAccess<bool>(pValues[ 1 ]) );

    if( pValues[2].hasValue() ) SetQuickEdit( *o3tl::doAccess<bool>(pValues[ 2 ]) );

    if( pValues[3].hasValue() ) SetMasterPagePaintCaching( *o3tl::doAccess<bool>(pValues[ 3 ]) );

    if( pValues[4].hasValue() ) SetDragWithCopy( *o3tl::doAccess<bool>(pValues[ 4 ]) );

    if( pValues[5].hasValue() ) SetPickThrough( *o3tl::doAccess<bool>(pValues[ 5 ]) );

    if( pValues[6].hasValue() ) SetDoubleClickTextEdit( *o3tl::doAccess<bool>(pValues[ 6 ]) );

    if( pValues[7].hasValue() ) SetClickChangeRotation( *o3tl::doAccess<bool>(pValues[ 7 ]) );

    if( pValues[9].hasValue() ) SetSolidDragging( *o3tl::doAccess<bool>(pValues[ 9 ]) );

    if( pValues[10].hasValue() ) SetDefaultObjectSizeWidth( *o3tl::doAccess<sal_Int32>(pValues[ 10 ]) );

    if( pValues[11].hasValue() ) SetDefaultObjectSizeHeight( *o3tl::doAccess<sal_Int32>(pValues[ 11 ]) );

    if( pValues[12].hasValue() ) SetPrinterIndependentLayout( *o3tl::doAccess<sal_uInt16>(pValues[ 12 ]) );

    if( pValues[13].hasValue() )

        SetShowComments(  *o3tl::doAccess<bool>(pValues[ 13 ]) );

    if (pValues[14].hasValue())

        SetDragThreshold(*o3tl::doAccess<sal_Int32>(pValues[ 14 ]));

    // just for Impress

    if (IsImpress())

    {

        if( pValues[15].hasValue() )

            SetStartWithTemplate( *o3tl::doAccess<bool>(pValues[ 15 ]) );

        if( pValues[16].hasValue() )

            SetSummationOfParagraphs( *o3tl::doAccess<bool>(pValues[ 16 ]) );

        if( pValues[17].hasValue() )

            SetShowUndoDeleteWarning( *o3tl::doAccess<bool>(pValues[ 17 ]) );

        if( pValues[18].hasValue() )

            SetSlideshowRespectZOrder(*o3tl::doAccess<bool>(pValues[ 18 ]));

        if( pValues[19].hasValue() )

            SetPreviewNewEffects(*o3tl::doAccess<bool>(pValues[ 19 ]));

        if( pValues[20].hasValue() )

            SetPreviewChangedEffects(*o3tl::doAccess<bool>(pValues[ 20 ]));

        if( pValues[21].hasValue() )

            SetPreviewTransitions(*o3tl::doAccess<bool>(pValues[ 21 ]));

        if( pValues[22].hasValue() )

            SetDisplay(*o3tl::doAccess<sal_Int32>(pValues[ 22 ]));

        if( pValues[23].hasValue() )

            SetPresentationPenColor( getSafeValue< sal_Int32 >( pValues[ 23 ] ) );

        if( pValues[24].hasValue() )

            SetPresentationPenWidth( getSafeValue< double >( pValues[ 24 ] ) );

        if( pValues[25].hasValue() ) {

            SetTabBarVisible( *o3tl::doAccess<bool>(pValues[ 25 ]) );

        }

    }

    return true;

}

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 ] <<= IsDoubleClickTextEdit();

    pValues[ 7 ] <<= IsClickChangeRotation();

    // The preview is not supported anymore.  Use a dummy value.

    pValues[ 8 ] <<= double(0);// GetPreviewQuality();

    pValues[ 9 ] <<= IsSolidDragging();

    pValues[ 10 ] <<= GetDefaultObjectSizeWidth();

    pValues[ 11 ] <<= GetDefaultObjectSizeHeight();

    pValues[ 12 ] <<= GetPrinterIndependentLayout();

    pValues[ 13 ] <<= IsShowComments();

    pValues[ 14 ] <<= GetDragThresholdPixels();

    // just for Impress

    if (IsImpress())

    {

        pValues[ 15 ] <<= IsStartWithTemplate();

        pValues[ 16 ] <<= IsSummationOfParagraphs();

        pValues[ 17 ] <<= IsShowUndoDeleteWarning();

        pValues[ 18 ] <<= IsSlideshowRespectZOrder();

        pValues[ 19 ] <<= IsPreviewNewEffects();

        pValues[ 20 ] <<= IsPreviewChangedEffects();

        pValues[ 21 ] <<= IsPreviewTransitions();

        pValues[ 22 ] <<= GetDisplay();

        pValues[ 23 ] <<= GetPresentationPenColor();

        pValues[ 24 ] <<= GetPresentationPenWidth();

        pValues[ 25 ] <<= IsTabBarVisible();

    }

    return true;

}

/*************************************************************************

|*

|* SdOptionsMiscItem

|*

\************************************************************************/

SdOptionsMiscItem::SdOptionsMiscItem()

:   SfxPoolItem     ( ATTR_OPTIONS_MISC )

,   maOptionsMisc   ( false, false )

{

}

SdOptionsMiscItem::SdOptionsMiscItem( SdOptions const * pOpts, ::sd::FrameView const * pView )

:   SfxPoolItem     ( ATTR_OPTIONS_MISC )

,   maOptionsMisc   ( false, false )

{

    if( pOpts )

    {

        maOptionsMisc.SetStartWithTemplate( pOpts->IsStartWithTemplate() );

        maOptionsMisc.SetSummationOfParagraphs( pOpts->IsSummationOfParagraphs() );

        maOptionsMisc.SetTabBarVisible( pOpts->IsTabBarVisible() );

        maOptionsMisc.SetShowUndoDeleteWarning( pOpts->IsShowUndoDeleteWarning() );

        maOptionsMisc.SetPrinterIndependentLayout( pOpts->GetPrinterIndependentLayout() );

        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(pView->GetModel().IsPickThroughTransparentTextFrames());

        maOptionsMisc.SetDoubleClickTextEdit( pView->IsDoubleClickTextEdit() );

        maOptionsMisc.SetClickChangeRotation( pView->IsClickChangeRotation() );

        maOptionsMisc.SetSolidDragging( pView->IsSolidDragging() );

        maOptionsMisc.SetDragThreshold(pView->GetDragThresholdPixels());

    }

    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.SetDoubleClickTextEdit( pOpts->IsDoubleClickTextEdit() );

        maOptionsMisc.SetClickChangeRotation( pOpts->IsClickChangeRotation() );

        maOptionsMisc.SetSolidDragging( pOpts->IsSolidDragging() );

        maOptionsMisc.SetDragThreshold(pOpts->GetDragThresholdPixels());

    }

}

SdOptionsMiscItem* SdOptionsMiscItem::Clone( SfxItemPool* ) const

{

    return new SdOptionsMiscItem( *this );

}

bool SdOptionsMiscItem::operator==( const SfxPoolItem& rAttr ) const

{

    assert(SfxPoolItem::operator==(rAttr));

    return maOptionsMisc == static_cast<const SdOptionsMiscItem&>(rAttr).maOptionsMisc;

}

void SdOptionsMiscItem::SetOptions( SdOptions* pOpts ) const

{

    if( !pOpts )

        return;

    //this needs to reflect all settings from SdTpOptionsMisc::FillItemSet()

    pOpts->SetStartWithTemplate( maOptionsMisc.IsStartWithTemplate() );

    pOpts->SetMarkedHitMovesAlways( maOptionsMisc.IsMarkedHitMovesAlways() );

    pOpts->SetQuickEdit(maOptionsMisc.IsQuickEdit());

    pOpts->SetPickThrough( maOptionsMisc.IsPickThrough() );

    pOpts->SetMasterPagePaintCaching( maOptionsMisc.IsMasterPagePaintCaching() );

    pOpts->SetDragWithCopy( maOptionsMisc.IsDragWithCopy() );

    pOpts->SetSummationOfParagraphs( maOptionsMisc.IsSummationOfParagraphs() );

    pOpts->SetCrookNoContortion( maOptionsMisc.IsCrookNoContortion() );

}

/*************************************************************************

|*

|* SdOptionsGrid

|*

\************************************************************************/

SdOptionsGrid::SdOptionsGrid(bool bImpress) :

    SdOptionsGeneric( bImpress,

                      bImpress ?

                        u"Office.Impress/Grid"_ustr :

                        u"Office.Draw/Grid"_ustr

                    )

{

    EnableModify( false );

    SetDefaults();

    EnableModify( true );

}

SdOptionsGrid::~SdOptionsGrid()

{

}

void SdOptionsGrid::SetDefaults()

{

    const sal_uInt32 nVal = 1000;

    SetFieldDivisionX( nVal );

    SetFieldDivisionY( nVal );

    SetFieldDrawX( nVal );

    SetFieldDrawY( nVal );

    SetUseGridSnap( false );

    SetSynchronize( true );

    SetGridVisible( false );

    SetEqualGrid( true );

}

void SdOptionsGrid::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const

{

    if( isMetricSystem() )

    {

        static const char* aPropNamesMetric[] =

        {

            "Resolution/XAxis/Metric",

            "Resolution/YAxis/Metric",

            "Subdivision/XAxis",

            "Subdivision/YAxis",

            "Option/SnapToGrid",

            "Option/Synchronize",

            "Option/VisibleGrid",

            "SnapGrid/Size"

        };

        ppNames = aPropNamesMetric;

        rCount = SAL_N_ELEMENTS(aPropNamesMetric);

    }

    else

    {

        static const char* aPropNamesNonMetric[] =

        {

            "Resolution/XAxis/NonMetric",

            "Resolution/YAxis/NonMetric",

            "Subdivision/XAxis",

            "Subdivision/YAxis",

            "Option/SnapToGrid",

            "Option/Synchronize",

            "Option/VisibleGrid",

            "SnapGrid/Size"

        };

        ppNames = aPropNamesNonMetric;

        rCount = SAL_N_ELEMENTS(aPropNamesNonMetric);

    }

}

bool SdOptionsGrid::ReadData( const Any* pValues )

{

    if( pValues[0].hasValue() ) SetFieldDrawX( *o3tl::doAccess<sal_Int32>(pValues[ 0 ]) );

    if( pValues[1].hasValue() ) SetFieldDrawY( *o3tl::doAccess<sal_Int32>(pValues[ 1 ]) );

    if( pValues[2].hasValue() )

    {

        const sal_uInt32 nDivX = basegfx::fround<sal_uInt32>(*o3tl::doAccess<double>(pValues[2]));

        SetFieldDivisionX( SvxOptionsGrid::GetFieldDrawX() / ( nDivX + 1 ) );

    }

    if( pValues[3].hasValue() )

    {

        const sal_uInt32 nDivY = basegfx::fround<sal_uInt32>(*o3tl::doAccess<double>(pValues[3]));

        SetFieldDivisionY( SvxOptionsGrid::GetFieldDrawY() / ( nDivY + 1 ) );

    }

    if( pValues[4].hasValue() ) SetUseGridSnap( *o3tl::doAccess<bool>(pValues[ 4 ]) );

    if( pValues[5].hasValue() ) SetSynchronize( *o3tl::doAccess<bool>(pValues[ 5 ]) );

    if( pValues[6].hasValue() ) SetGridVisible( *o3tl::doAccess<bool>(pValues[ 6 ]) );

    if( pValues[7].hasValue() ) SetEqualGrid( *o3tl::doAccess<bool>(pValues[ 7 ]) );

    return true;

}

bool SdOptionsGrid::WriteData( Any* pValues ) const

{

    pValues[ 0 ] <<= static_cast<sal_Int32>(GetFieldDrawX());

    pValues[ 1 ] <<= static_cast<sal_Int32>(GetFieldDrawY());

    pValues[ 2 ] <<= ( GetFieldDivisionX() ? ( static_cast<double>(GetFieldDrawX()) / GetFieldDivisionX() - 1.0 ) : double(0) );

    pValues[ 3 ] <<= ( GetFieldDivisionY() ? ( static_cast<double>(GetFieldDrawY()) / GetFieldDivisionY() - 1.0 ) : double(0) );

    pValues[ 4 ] <<= IsUseGridSnap();

    pValues[ 5 ] <<= IsSynchronize();

    pValues[ 6 ] <<= IsGridVisible();

    pValues[ 7 ] <<= IsEqualGrid();

    return true;

}

/*************************************************************************

|*

|* SdOptionsGridItem

|*

\************************************************************************/

SdOptionsGridItem::SdOptionsGridItem( SdOptions const * pOpts ) :

    SvxGridItem( SID_ATTR_GRID_OPTIONS )

{

    SetSynchronize( pOpts->IsSynchronize() );

    SetEqualGrid( pOpts->IsEqualGrid() );

    SetFieldDrawX( pOpts->GetFieldDrawX() );

    SetFieldDrawY( pOpts->GetFieldDrawY() );

    SetFieldDivisionX( pOpts->GetFieldDivisionX() ? ( pOpts->GetFieldDrawX() / pOpts->GetFieldDivisionX() - 1 ) : 0 );

    SetFieldDivisionY( pOpts->GetFieldDivisionY() ? ( pOpts->GetFieldDrawY() / pOpts->GetFieldDivisionY() - 1 ) : 0 );

    SetUseGridSnap( pOpts->IsUseGridSnap() );

    SetGridVisible( pOpts->IsGridVisible() );

}

void SdOptionsGridItem::SetOptions( SdOptions* pOpts ) const

{

    pOpts->SetFieldDrawX( GetFieldDrawX() );

    pOpts->SetFieldDivisionX( GetFieldDrawX() / ( GetFieldDivisionX() + 1 ) );

    pOpts->SetFieldDrawY( GetFieldDrawY() );

    pOpts->SetFieldDivisionY( GetFieldDrawY() / ( GetFieldDivisionY() + 1 ) );

    pOpts->SetUseGridSnap( GetUseGridSnap() );

    pOpts->SetSynchronize( GetSynchronize() );

    pOpts->SetGridVisible( GetGridVisible() );

    pOpts->SetEqualGrid( GetEqualGrid() );

}

/*************************************************************************

|*

|* SdOptionsPrint

|*

\************************************************************************/

SdOptionsPrint::SdOptionsPrint( bool bImpress, bool bUseConfig ) :

    SdOptionsGeneric( bImpress, bUseConfig ?

                      ( bImpress ?

                        u"Office.Impress/Print"_ustr :

                        u"Office.Draw/Print"_ustr ) :

                      OUString() ),

    bDraw( true ),

    bNotes( false ),

    bHandout( false ),

    bOutline( false ),

    bDate( false ),

    bTime( false ),

    bPagename( false ),

    bHiddenPages( true ),

    bPagesize( false ),

    bPagetile( false ),

    bWarningPrinter( true ),

    bWarningSize( false ),

    bWarningOrientation( false ),

    bBooklet( false ),

    bFront( true ),

    bBack( true ),

    bCutPage( false ),

    bPaperbin( false ),

    mbHandoutHorizontal( true ),

    mnHandoutPages( 6 ),

    nQuality( 0 )

{

    EnableModify( true );

}

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

{

    if (IsImpress())

    {

        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"

        };

        rCount = SAL_N_ELEMENTS(aImpressPropNames);

        ppNames = aImpressPropNames;

    }

    else

    {

        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",

        };

        rCount = SAL_N_ELEMENTS(aDrawPropNames);

        ppNames = aDrawPropNames;

    }

}

bool SdOptionsPrint::ReadData( const Any* pValues )

{

    if( pValues[0].hasValue() ) SetDate( *o3tl::doAccess<bool>(pValues[ 0 ]) );

    if( pValues[1].hasValue() ) SetTime( *o3tl::doAccess<bool>(pValues[ 1 ]) );

    if( pValues[2].hasValue() ) SetPagename( *o3tl::doAccess<bool>(pValues[ 2 ]) );

    if( pValues[3].hasValue() ) SetHiddenPages( *o3tl::doAccess<bool>(pValues[ 3 ]) );

    if( pValues[4].hasValue() ) SetPagesize( *o3tl::doAccess<bool>(pValues[ 4 ]) );

    if( pValues[5].hasValue() ) SetPagetile( *o3tl::doAccess<bool>(pValues[ 5 ]) );

    if( pValues[6].hasValue() ) SetBooklet( *o3tl::doAccess<bool>(pValues[ 6 ]) );

    if( pValues[7].hasValue() ) SetFrontPage( *o3tl::doAccess<bool>(pValues[ 7 ]) );

    if( pValues[8].hasValue() ) SetBackPage( *o3tl::doAccess<bool>(pValues[ 8 ]) );

    if( pValues[9].hasValue() ) SetPaperbin( *o3tl::doAccess<bool>(pValues[ 9 ]) );

    if( pValues[10].hasValue() ) SetOutputQuality( static_cast<sal_uInt16>(*o3tl::doAccess<sal_Int32>(pValues[ 10 ])) );

    if( pValues[11].hasValue() ) SetDraw( *o3tl::doAccess<bool>(pValues[ 11 ]) );

    // just for impress

    if (IsImpress())

    {

        if( pValues[12].hasValue() ) SetNotes( *o3tl::doAccess<bool>(pValues[ 12 ]) );

        if( pValues[13].hasValue() ) SetHandout( *o3tl::doAccess<bool>(pValues[ 13 ]) );

        if( pValues[14].hasValue() ) SetOutline( *o3tl::doAccess<bool>(pValues[ 14 ]) );

        if( pValues[15].hasValue() ) SetHandoutHorizontal( *o3tl::doAccess<bool>(pValues[15]) );

        if( pValues[16].hasValue() ) SetHandoutPages( static_cast<sal_uInt16>(*o3tl::doAccess<sal_Int32>(pValues[16])) );

    }

    return true;

}

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 ] <<= static_cast<sal_Int32>(GetOutputQuality());

    pValues[ 11 ] <<= IsDraw();

    // just for impress

    if (IsImpress())

    {

        pValues[ 12 ] <<= IsNotes();

        pValues[ 13 ] <<= IsHandout();

        pValues[ 14 ] <<= IsOutline();

        pValues[ 15 ] <<= IsHandoutHorizontal();

        pValues[ 16 ] <<= GetHandoutPages();

    }

    return true;

}

/*************************************************************************

|*

|* SdOptionsPrintItem

|*

\************************************************************************/

SdOptionsPrintItem::SdOptionsPrintItem()

:   SfxPoolItem     ( ATTR_OPTIONS_PRINT )

,   maOptionsPrint  ( false, false )

{

}

SdOptionsPrintItem::SdOptionsPrintItem( SdOptions const * pOpts )

:   SfxPoolItem     ( ATTR_OPTIONS_PRINT )

,   maOptionsPrint  ( false, false )

{

    if( !pOpts )

        return;

    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() );

}

SdOptionsPrintItem* SdOptionsPrintItem::Clone( SfxItemPool* ) const

{

    return new SdOptionsPrintItem( *this );

}

bool SdOptionsPrintItem::operator==( const SfxPoolItem& rAttr ) const

{

    assert(SfxPoolItem::operator==(rAttr));

    return maOptionsPrint == static_cast<const SdOptionsPrintItem&>(rAttr).maOptionsPrint;

}

void SdOptionsPrintItem::SetOptions( SdOptions* pOpts ) const

{

    if( !pOpts )

        return;

    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(bool bImpress) :

    SdOptionsMisc( bImpress, true ),

    SdOptionsGrid( bImpress ),

    SdOptionsPrint( bImpress, true )

{

}

SdOptions::~SdOptions()

{

}

void SdOptions::StoreConfig()

{

    SdOptionsMisc::Store();

    SdOptionsGrid::Store();

    SdOptionsPrint::Store();

}

sal_Int32 SdOptionsMisc::GetDragThresholdPixels() const

{

    Init();

    return mnDragThresholdPixels;

}

void SdOptionsMisc::SetDragThreshold(sal_Int32 nDragThresholdPixels)

{

    if (mnDragThresholdPixels != nDragThresholdPixels)

    {

        OptionsChanged();

        mnDragThresholdPixels = nDragThresholdPixels;

    }

}

sal_Int32 SdOptionsMisc::GetDisplay() const

{

    Init();

    return mnDisplay;

}

void SdOptionsMisc::SetDisplay( sal_Int32 nDisplay )

{

    if( mnDisplay != nDisplay )

    {

        OptionsChanged();

        mnDisplay = nDisplay;

    }

}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */