Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 977 insertions, 0 deletions

diff --git a/svx/source/tbxctrls/grafctrl.cxx b/svx/source/tbxctrls/grafctrl.cxx
new file mode 100644
index 000000000..1db6225da
--- /dev/null
+++ b/svx/source/tbxctrls/grafctrl.cxx
@@ -0,0 +1,977 @@
+/* -*- 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 <vcl/toolbox.hxx>
+#include <vcl/idle.hxx>
+#include <svl/intitem.hxx>
+#include <svl/itempool.hxx>
+#include <svl/eitem.hxx>
+#include <svl/whiter.hxx>
+#include <sfx2/viewsh.hxx>
+#include <sfx2/request.hxx>
+#include <sfx2/basedlgs.hxx>
+#include <vcl/InterimItemWindow.hxx>
+#include <sfx2/sfxdlg.hxx>
+#include <tools/urlobj.hxx>
+
+#include <svx/dialogs.hrc>
+#include <svx/svxids.hrc>
+#include <svx/strings.hrc>
+#include <editeng/brushitem.hxx>
+#include <editeng/sizeitem.hxx>
+#include <svx/sdgcpitm.hxx>
+
+#include <svx/dialmgr.hxx>
+#include <svx/svdview.hxx>
+#include <svx/svdmodel.hxx>
+#include <svx/svdograf.hxx>
+#include <svx/svdundo.hxx>
+#include <svx/svdtrans.hxx>
+#include <svx/grafctrl.hxx>
+#include <svx/tbxcolor.hxx>
+#include <sdgcoitm.hxx>
+#include <svx/sdggaitm.hxx>
+#include <svx/sdgluitm.hxx>
+#include <svx/sdgmoitm.hxx>
+#include <sdgtritm.hxx>
+#include <bitmaps.hlst>
+
+#include <com/sun/star/frame/XDispatchProvider.hpp>
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::lang;
+
+#define TOOLBOX_NAME                "colorbar"
+#define RID_SVXSTR_UNDO_GRAFCROP    RID_SVXSTR_GRAFCROP
+
+namespace {
+
+class ImplGrafControl final : public InterimItemWindow
+{
+private:
+    Idle maIdle;
+    OUString maCommand;
+    Reference<XFrame> mxFrame;
+    std::unique_ptr<weld::Image> mxImage;
+    std::unique_ptr<weld::MetricSpinButton> mxField;
+
+    DECL_LINK(ValueChangedHdl, weld::MetricSpinButton&, void);
+    DECL_LINK(KeyInputHdl, const KeyEvent&, bool);
+    DECL_LINK(ImplModifyHdl, Timer*, void);
+
+public:
+    ImplGrafControl( vcl::Window* pParent, const OUString& rCmd, const Reference< XFrame >& rFrame );
+    virtual ~ImplGrafControl() override;
+    virtual void            dispose() override;
+
+    virtual void            GetFocus() override;
+    void Update( const SfxPoolItem* pItem );
+    void set_field_text(const OUString& rStr) { mxField->set_text(rStr); }
+    void set_sensitive(bool bSensitive)
+    {
+        Enable(bSensitive);
+        mxImage->set_sensitive(bSensitive);
+        mxField->set_sensitive(bSensitive);
+    }
+};
+
+}
+
+IMPL_LINK_NOARG(ImplGrafControl, ValueChangedHdl, weld::MetricSpinButton&, void)
+{
+    maIdle.Start();
+}
+
+IMPL_LINK_NOARG(ImplGrafControl, ImplModifyHdl, Timer*, void)
+{
+    const sal_Int64 nVal = mxField->get_value(FieldUnit::NONE);
+
+    // Convert value to an any to be usable with dispatch API
+    Any a;
+    if ( maCommand == ".uno:GrafRed" ||
+         maCommand == ".uno:GrafGreen" ||
+         maCommand == ".uno:GrafBlue" ||
+         maCommand == ".uno:GrafLuminance" ||
+         maCommand == ".uno:GrafContrast" )
+        a <<= sal_Int16( nVal );
+    else if ( maCommand == ".uno:GrafGamma" ||
+              maCommand == ".uno:GrafTransparence" )
+        a <<= sal_Int32( nVal );
+
+    if ( a.hasValue() )
+    {
+        INetURLObject aObj( maCommand );
+
+        Sequence< PropertyValue > aArgs( 1 );
+        aArgs[0].Name = aObj.GetURLPath();
+        aArgs[0].Value = a;
+
+        SfxToolBoxControl::Dispatch(
+            Reference< XDispatchProvider >( mxFrame->getController(), UNO_QUERY ),
+            maCommand,
+            aArgs );
+    }
+}
+
+void ImplGrafControl::Update( const SfxPoolItem* pItem )
+{
+    if( pItem )
+    {
+        long nValue;
+
+        if ( maCommand == ".uno:GrafTransparence" )
+            nValue = static_cast<const SfxUInt16Item*>( pItem )->GetValue();
+        else if ( maCommand == ".uno:GrafGamma" )
+            nValue = static_cast<const SfxUInt32Item*>( pItem )->GetValue();
+        else
+            nValue = static_cast<const SfxInt16Item*>( pItem )->GetValue();
+
+        mxField->set_value(nValue, FieldUnit::NONE);
+    }
+    else
+        mxField->set_text(OUString());
+}
+
+namespace {
+
+struct CommandToRID
+{
+    const char* pCommand;
+    const char* sResId;
+};
+
+}
+
+static OUString ImplGetRID( const OUString& aCommand )
+{
+    static const CommandToRID aImplCommandToResMap[] =
+    {
+        { ".uno:GrafRed",           RID_SVXBMP_GRAF_RED             },
+        { ".uno:GrafGreen",         RID_SVXBMP_GRAF_GREEN           },
+        { ".uno:GrafBlue",          RID_SVXBMP_GRAF_BLUE            },
+        { ".uno:GrafLuminance",     RID_SVXBMP_GRAF_LUMINANCE       },
+        { ".uno:GrafContrast",      RID_SVXBMP_GRAF_CONTRAST        },
+        { ".uno:GrafGamma",         RID_SVXBMP_GRAF_GAMMA           },
+        { ".uno:GrafTransparence",  RID_SVXBMP_GRAF_TRANSPARENCE    },
+        { nullptr, "" }
+    };
+
+    OUString sRID;
+
+    sal_Int32 i( 0 );
+    while ( aImplCommandToResMap[ i ].pCommand )
+    {
+        if ( aCommand.equalsAscii( aImplCommandToResMap[ i ].pCommand ))
+        {
+            sRID = OUString::createFromAscii(aImplCommandToResMap[i].sResId);
+            break;
+        }
+        ++i;
+    }
+
+    return sRID;
+}
+
+ImplGrafControl::ImplGrafControl(
+    vcl::Window* pParent,
+    const OUString& rCmd,
+    const Reference< XFrame >& rFrame)
+    : InterimItemWindow(pParent, "svx/ui/grafctrlbox.ui", "GrafCtrlBox")
+    , maCommand(rCmd)
+    , mxFrame(rFrame)
+    , mxImage(m_xBuilder->weld_image("image"))
+    , mxField(m_xBuilder->weld_metric_spin_button("spinfield", FieldUnit::NONE))
+{
+    OUString sResId(ImplGetRID(rCmd));
+    mxImage->set_from_icon_name(sResId);
+    mxImage->set_toolbar_background();
+
+    SetBackground( Wallpaper() ); // transparent background
+
+    mxField->set_help_id(OUStringToOString(rCmd, RTL_TEXTENCODING_UTF8));
+    mxField->get_widget().connect_key_press(LINK(this, ImplGrafControl, KeyInputHdl));
+    mxField->connect_value_changed(LINK(this, ImplGrafControl, ValueChangedHdl));
+
+    if (maCommand == ".uno:GrafGamma")
+    {
+        mxField->set_digits(2);
+
+        mxField->set_range(10, 1000, FieldUnit::NONE);
+        mxField->set_increments(10, 100, FieldUnit::NONE);
+    }
+    else
+    {
+        const long nMinVal = maCommand == ".uno:GrafTransparence" ? 0 : -100;
+
+        mxField->set_unit(FieldUnit::PERCENT);
+        mxField->set_digits(0);
+
+        mxField->set_range(nMinVal, 100, FieldUnit::PERCENT);
+        mxField->set_increments(1, 10, FieldUnit::PERCENT);
+    }
+
+    maIdle.SetInvokeHandler( LINK( this, ImplGrafControl, ImplModifyHdl ) );
+
+    SetSizePixel(m_xContainer->get_preferred_size());
+}
+
+IMPL_LINK(ImplGrafControl, KeyInputHdl, const KeyEvent&, rKEvt, bool)
+{
+    return ChildKeyInput(rKEvt);
+}
+
+ImplGrafControl::~ImplGrafControl()
+{
+    disposeOnce();
+}
+
+void ImplGrafControl::dispose()
+{
+    mxImage.reset();
+    mxField.reset();
+    InterimItemWindow::dispose();
+}
+
+void ImplGrafControl::GetFocus()
+{
+    if (mxField)
+        mxField->grab_focus();
+    InterimItemWindow::GetFocus();
+}
+
+namespace {
+
+class ImplGrafModeControl final : public InterimItemWindow
+{
+private:
+    sal_uInt16 mnCurPos;
+    Reference< XFrame > mxFrame;
+    std::unique_ptr<weld::ComboBox> m_xWidget;
+
+    DECL_LINK(SelectHdl, weld::ComboBox&, void);
+    DECL_LINK(KeyInputHdl, const KeyEvent&, bool);
+    DECL_LINK(FocusInHdl, weld::Widget&, void);
+
+    static void     ImplReleaseFocus();
+
+public:
+    ImplGrafModeControl( vcl::Window* pParent, const Reference< XFrame >& rFrame );
+    virtual void dispose() override;
+    virtual ~ImplGrafModeControl() override;
+
+    virtual void GetFocus() override
+    {
+        if (m_xWidget)
+            m_xWidget->grab_focus();
+        InterimItemWindow::GetFocus();
+    }
+
+    void set_sensitive(bool bSensitive)
+    {
+        Enable(bSensitive);
+        m_xWidget->set_sensitive(true);
+    }
+
+    void set_active(int nActive)
+    {
+        m_xWidget->set_active(nActive);
+    }
+
+    void            Update( const SfxPoolItem* pItem );
+};
+
+}
+
+ImplGrafModeControl::ImplGrafModeControl(vcl::Window* pParent, const Reference<XFrame>& rFrame)
+    : InterimItemWindow(pParent, "svx/ui/grafmodebox.ui", "GrafModeBox")
+    , mnCurPos(0)
+    , mxFrame(rFrame)
+    , m_xWidget(m_xBuilder->weld_combo_box("grafmode"))
+{
+    m_xWidget->append_text( SvxResId( RID_SVXSTR_GRAFMODE_STANDARD  ) );
+    m_xWidget->append_text( SvxResId( RID_SVXSTR_GRAFMODE_GREYS     ) );
+    m_xWidget->append_text( SvxResId( RID_SVXSTR_GRAFMODE_MONO      ) );
+    m_xWidget->append_text( SvxResId( RID_SVXSTR_GRAFMODE_WATERMARK ) );
+
+    m_xWidget->connect_changed(LINK(this, ImplGrafModeControl, SelectHdl));
+    m_xWidget->connect_key_press(LINK(this, ImplGrafModeControl, KeyInputHdl));
+    m_xWidget->connect_focus_in(LINK(this, ImplGrafModeControl, FocusInHdl));
+
+    SetSizePixel(m_xWidget->get_preferred_size());
+}
+
+void ImplGrafModeControl::dispose()
+{
+    m_xWidget.reset();
+    InterimItemWindow::dispose();
+}
+
+ImplGrafModeControl::~ImplGrafModeControl()
+{
+    disposeOnce();
+}
+
+IMPL_LINK(ImplGrafModeControl, SelectHdl, weld::ComboBox&, rBox, void)
+{
+    Sequence< PropertyValue > aArgs( 1 );
+    aArgs[0].Name = "GrafMode";
+    aArgs[0].Value <<= sal_Int16(rBox.get_active());
+
+    /*  #i33380# DR 2004-09-03 Moved the following line above the Dispatch() call.
+        This instance may be deleted in the meantime (i.e. when a dialog is opened
+        while in Dispatch()), accessing members will crash in this case. */
+    ImplReleaseFocus();
+
+    SfxToolBoxControl::Dispatch(
+        Reference< XDispatchProvider >( mxFrame->getController(), UNO_QUERY ),
+        ".uno:GrafMode",
+        aArgs );
+}
+
+IMPL_LINK(ImplGrafModeControl, KeyInputHdl, const KeyEvent&, rKEvt, bool)
+{
+    bool bHandled(false);
+
+    if (rKEvt.GetKeyCode().GetCode() == KEY_ESCAPE)
+    {
+        m_xWidget->set_active(mnCurPos);
+        ImplReleaseFocus();
+        bHandled = true;
+    }
+
+    return bHandled || ChildKeyInput(rKEvt);
+}
+
+IMPL_LINK_NOARG(ImplGrafModeControl, FocusInHdl, weld::Widget&, void)
+{
+    mnCurPos = m_xWidget->get_active();
+}
+
+void ImplGrafModeControl::ImplReleaseFocus()
+{
+    if( SfxViewShell::Current() )
+    {
+        vcl::Window* pShellWnd = SfxViewShell::Current()->GetWindow();
+
+        if( pShellWnd )
+            pShellWnd->GrabFocus();
+    }
+}
+
+void ImplGrafModeControl::Update( const SfxPoolItem* pItem )
+{
+    if( pItem )
+        m_xWidget->set_active(static_cast<const SfxUInt16Item*>(pItem)->GetValue());
+    else
+        m_xWidget->set_active(-1);
+}
+
+SvxGrafToolBoxControl::SvxGrafToolBoxControl( sal_uInt16 nSlotId, sal_uInt16 nId, ToolBox& rTbx) :
+    SfxToolBoxControl( nSlotId, nId, rTbx )
+{
+    rTbx.SetItemBits( nId, ToolBoxItemBits::DROPDOWN | rTbx.GetItemBits( nId ) );
+    rTbx.Invalidate();
+}
+
+SvxGrafToolBoxControl::~SvxGrafToolBoxControl()
+{
+}
+
+void SvxGrafToolBoxControl::StateChanged( sal_uInt16, SfxItemState eState, const SfxPoolItem* pState )
+{
+    ImplGrafControl* pCtrl = static_cast<ImplGrafControl*>( GetToolBox().GetItemWindow( GetId() ) );
+    DBG_ASSERT( pCtrl, "Control not found" );
+
+    if( eState == SfxItemState::DISABLED )
+    {
+        pCtrl->set_sensitive(false);
+        pCtrl->set_field_text( OUString() );
+    }
+    else
+    {
+        pCtrl->set_sensitive(true);
+
+        if( eState == SfxItemState::DEFAULT )
+            pCtrl->Update( pState );
+        else
+            pCtrl->Update( nullptr );
+    }
+}
+
+VclPtr<InterimItemWindow> SvxGrafToolBoxControl::CreateItemWindow( vcl::Window *pParent )
+{
+    return VclPtr<ImplGrafControl>::Create( pParent, m_aCommandURL, m_xFrame ).get();
+}
+
+SFX_IMPL_TOOLBOX_CONTROL( SvxGrafRedToolBoxControl, SfxInt16Item );
+
+SvxGrafRedToolBoxControl::SvxGrafRedToolBoxControl( sal_uInt16 nSlotId, sal_uInt16 nId, ToolBox& rTbx ) :
+    SvxGrafToolBoxControl( nSlotId, nId, rTbx )
+{
+}
+
+SFX_IMPL_TOOLBOX_CONTROL( SvxGrafGreenToolBoxControl, SfxInt16Item );
+
+SvxGrafGreenToolBoxControl::SvxGrafGreenToolBoxControl( sal_uInt16 nSlotId, sal_uInt16 nId, ToolBox& rTbx ) :
+    SvxGrafToolBoxControl( nSlotId, nId, rTbx )
+{
+}
+
+SFX_IMPL_TOOLBOX_CONTROL( SvxGrafBlueToolBoxControl, SfxInt16Item );
+
+SvxGrafBlueToolBoxControl::SvxGrafBlueToolBoxControl( sal_uInt16 nSlotId, sal_uInt16 nId, ToolBox& rTbx ) :
+    SvxGrafToolBoxControl( nSlotId, nId, rTbx )
+{
+}
+
+SFX_IMPL_TOOLBOX_CONTROL( SvxGrafLuminanceToolBoxControl, SfxInt16Item );
+
+SvxGrafLuminanceToolBoxControl::SvxGrafLuminanceToolBoxControl( sal_uInt16 nSlotId, sal_uInt16 nId, ToolBox& rTbx ) :
+    SvxGrafToolBoxControl( nSlotId, nId, rTbx )
+{
+}
+
+SFX_IMPL_TOOLBOX_CONTROL( SvxGrafContrastToolBoxControl, SfxInt16Item );
+
+SvxGrafContrastToolBoxControl::SvxGrafContrastToolBoxControl( sal_uInt16 nSlotId, sal_uInt16 nId, ToolBox& rTbx ) :
+    SvxGrafToolBoxControl( nSlotId, nId, rTbx )
+{
+}
+
+SFX_IMPL_TOOLBOX_CONTROL( SvxGrafGammaToolBoxControl, SfxUInt32Item );
+
+SvxGrafGammaToolBoxControl::SvxGrafGammaToolBoxControl( sal_uInt16 nSlotId, sal_uInt16 nId, ToolBox& rTbx ) :
+    SvxGrafToolBoxControl( nSlotId, nId, rTbx )
+{
+}
+
+SFX_IMPL_TOOLBOX_CONTROL( SvxGrafTransparenceToolBoxControl, SfxUInt16Item );
+
+SvxGrafTransparenceToolBoxControl::SvxGrafTransparenceToolBoxControl( sal_uInt16 nSlotId, sal_uInt16 nId, ToolBox& rTbx ) :
+    SvxGrafToolBoxControl( nSlotId, nId, rTbx )
+{
+}
+
+SFX_IMPL_TOOLBOX_CONTROL( SvxGrafModeToolBoxControl, SfxUInt16Item );
+
+SvxGrafModeToolBoxControl::SvxGrafModeToolBoxControl( sal_uInt16 nSlotId, sal_uInt16 nId, ToolBox& rTbx ) :
+    SfxToolBoxControl( nSlotId, nId, rTbx )
+{
+}
+
+SvxGrafModeToolBoxControl::~SvxGrafModeToolBoxControl()
+{
+}
+
+void SvxGrafModeToolBoxControl::StateChanged( sal_uInt16, SfxItemState eState, const SfxPoolItem* pState )
+
+{
+    ImplGrafModeControl* pCtrl = static_cast<ImplGrafModeControl*>( GetToolBox().GetItemWindow( GetId() ) );
+    DBG_ASSERT( pCtrl, "Control not found" );
+
+    if( eState == SfxItemState::DISABLED )
+    {
+        pCtrl->set_sensitive(false);
+        pCtrl->set_active(-1);
+    }
+    else
+    {
+        pCtrl->set_sensitive(true);
+
+        if( eState == SfxItemState::DEFAULT )
+            pCtrl->Update( pState );
+        else
+            pCtrl->Update( nullptr );
+    }
+}
+
+VclPtr<InterimItemWindow> SvxGrafModeToolBoxControl::CreateItemWindow( vcl::Window *pParent )
+{
+    return VclPtr<ImplGrafModeControl>::Create( pParent, m_xFrame ).get();
+}
+
+void SvxGrafAttrHelper::ExecuteGrafAttr( SfxRequest& rReq, SdrView& rView )
+{
+    SfxItemPool&    rPool = rView.GetModel()->GetItemPool();
+    SfxItemSet      aSet( rPool, svl::Items<SDRATTR_GRAF_FIRST, SDRATTR_GRAF_LAST>{} );
+    OUString        aUndoStr;
+    const bool      bUndo = rView.IsUndoEnabled();
+
+    if( bUndo )
+    {
+        aUndoStr = rView.GetDescriptionOfMarkedObjects() + " ";
+    }
+
+    const SfxItemSet*   pArgs = rReq.GetArgs();
+    const SfxPoolItem*  pItem;
+    sal_uInt16              nSlot = rReq.GetSlot();
+
+    if( !pArgs || SfxItemState::SET != pArgs->GetItemState( nSlot, false, &pItem ))
+        pItem = nullptr;
+
+    switch( nSlot )
+    {
+        case SID_ATTR_GRAF_RED:
+        {
+            if( pItem )
+            {
+                aSet.Put( SdrGrafRedItem( static_cast<const SfxInt16Item*>(pItem)->GetValue() ));
+                if( bUndo )
+                    aUndoStr += SvxResId( RID_SVXSTR_UNDO_GRAFRED );
+            }
+        }
+        break;
+
+        case SID_ATTR_GRAF_GREEN:
+        {
+            if( pItem )
+            {
+                aSet.Put( SdrGrafGreenItem( static_cast<const SfxInt16Item*>(pItem)->GetValue() ));
+                if( bUndo )
+                    aUndoStr += SvxResId( RID_SVXSTR_UNDO_GRAFGREEN );
+            }
+        }
+        break;
+
+        case SID_ATTR_GRAF_BLUE:
+        {
+            if( pItem )
+            {
+                aSet.Put( SdrGrafBlueItem( static_cast<const SfxInt16Item*>(pItem)->GetValue() ));
+                if( bUndo )
+                    aUndoStr += SvxResId( RID_SVXSTR_UNDO_GRAFBLUE );
+            }
+        }
+        break;
+
+        case SID_ATTR_GRAF_LUMINANCE:
+        {
+            if( pItem )
+            {
+                aSet.Put( SdrGrafLuminanceItem( static_cast<const SfxInt16Item*>(pItem)->GetValue() ));
+                if( bUndo )
+                    aUndoStr += SvxResId( RID_SVXSTR_UNDO_GRAFLUMINANCE );
+            }
+        }
+        break;
+
+        case SID_ATTR_GRAF_CONTRAST:
+        {
+            if( pItem )
+            {
+                aSet.Put( SdrGrafContrastItem( static_cast<const SfxInt16Item*>(pItem)->GetValue() ));
+                if( bUndo )
+                    aUndoStr += SvxResId( RID_SVXSTR_UNDO_GRAFCONTRAST );
+            }
+        }
+        break;
+
+        case SID_ATTR_GRAF_GAMMA:
+        {
+            if( pItem )
+            {
+                aSet.Put( SdrGrafGamma100Item( static_cast<const SfxUInt32Item*>(pItem)->GetValue() ));
+                if( bUndo )
+                    aUndoStr += SvxResId( RID_SVXSTR_UNDO_GRAFGAMMA );
+            }
+        }
+        break;
+
+        case SID_ATTR_GRAF_TRANSPARENCE:
+        {
+            if( pItem )
+            {
+                aSet.Put( SdrGrafTransparenceItem( static_cast<const SfxUInt16Item*>(pItem)->GetValue() ));
+                if( bUndo )
+                    aUndoStr += SvxResId( RID_SVXSTR_UNDO_GRAFTRANSPARENCY );
+            }
+        }
+        break;
+
+        case SID_ATTR_GRAF_MODE:
+        {
+            if( pItem )
+            {
+                aSet.Put( SdrGrafModeItem( static_cast<GraphicDrawMode>(static_cast<const SfxUInt16Item*>(pItem)->GetValue()) ));
+                if( bUndo )
+                    aUndoStr += SvxResId( RID_SVXSTR_UNDO_GRAFMODE );
+            }
+        }
+        break;
+
+        case SID_ATTR_GRAF_CROP:
+        {
+            const SdrMarkList& rMarkList = rView.GetMarkedObjectList();
+
+            if( 0 < rMarkList.GetMarkCount() )
+            {
+                SdrGrafObj* pObj = static_cast<SdrGrafObj*>( rMarkList.GetMark( 0 )->GetMarkedSdrObj() );
+
+                if( ( pObj->GetGraphicType() != GraphicType::NONE ) &&
+                    ( pObj->GetGraphicType() != GraphicType::Default ) )
+                {
+                    SfxItemSet          aGrfAttr( rPool, svl::Items<SDRATTR_GRAFCROP, SDRATTR_GRAFCROP>{} );
+                    const MapUnit       eOldMetric = rPool.GetMetric( 0 );
+                    const MapMode       aMap100( MapUnit::Map100thMM );
+                    const MapMode       aMapTwip( MapUnit::MapTwip );
+
+                    aGrfAttr.Put(pObj->GetMergedItemSet());
+                    rPool.SetDefaultMetric( MapUnit::MapTwip );
+
+                    SfxItemSet  aCropDlgAttr(
+                        rPool,
+                        svl::Items<
+                            SDRATTR_GRAFCROP, SDRATTR_GRAFCROP,
+                            SID_ATTR_PAGE_SIZE, SID_ATTR_PAGE_SIZE,
+                            SID_ATTR_GRAF_CROP, SID_ATTR_GRAF_FRMSIZE,
+                            SID_ATTR_GRAF_GRAPHIC, SID_ATTR_GRAF_GRAPHIC>{});
+
+                    aCropDlgAttr.Put( SvxBrushItem( pObj->GetGraphic(), GPOS_MM, SID_ATTR_GRAF_GRAPHIC ) );
+                    aCropDlgAttr.Put( SvxSizeItem( SID_ATTR_PAGE_SIZE,
+                                                OutputDevice::LogicToLogic(
+                                                        Size( 200000, 200000 ), aMap100, aMapTwip ) ) );
+                    aCropDlgAttr.Put( SvxSizeItem( SID_ATTR_GRAF_FRMSIZE, OutputDevice::LogicToLogic(
+                                                pObj->GetLogicRect().GetSize(), aMap100, aMapTwip ) ) );
+
+                    const SdrGrafCropItem&  rCrop = aGrfAttr.Get( SDRATTR_GRAFCROP );
+                    Size                    aLTSize( OutputDevice::LogicToLogic(
+                                                    Size( rCrop.GetLeft(), rCrop.GetTop() ), aMap100, aMapTwip ) );
+                    Size                    aRBSize( OutputDevice::LogicToLogic(
+                                                    Size( rCrop.GetRight(), rCrop.GetBottom() ), aMap100, aMapTwip ) );
+
+                    aCropDlgAttr.Put( SdrGrafCropItem( aLTSize.Width(), aLTSize.Height(),
+                                                    aRBSize.Width(), aRBSize.Height() ) );
+
+                    vcl::Window* pParent(SfxViewShell::Current() ? SfxViewShell::Current()->GetWindow() : nullptr);
+                    SfxSingleTabDialogController aCropDialog(pParent ? pParent->GetFrameWeld() : nullptr,
+                        &aCropDlgAttr);
+                    const OUString aCropStr(SvxResId(RID_SVXSTR_GRAFCROP));
+
+                    SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();
+                    ::CreateTabPage fnCreatePage = pFact->GetTabPageCreatorFunc( RID_SVXPAGE_GRFCROP );
+                    std::unique_ptr<SfxTabPage> xTabPage = (*fnCreatePage)(aCropDialog.get_content_area(), &aCropDialog, &aCropDlgAttr);
+                    xTabPage->SetPageTitle(aCropStr);
+                    aCropDialog.SetTabPage(std::move(xTabPage));
+
+                    if (aCropDialog.run() == RET_OK)
+                    {
+                        const SfxItemSet* pOutAttr = aCropDialog.GetOutputItemSet();
+
+                        if( pOutAttr )
+                        {
+                            aUndoStr += SvxResId( RID_SVXSTR_UNDO_GRAFCROP );
+
+                            // set crop attributes
+                            if( SfxItemState::SET <= pOutAttr->GetItemState( SDRATTR_GRAFCROP ) )
+                            {
+                                const SdrGrafCropItem& rNewCrop = pOutAttr->Get( SDRATTR_GRAFCROP );
+
+                                aLTSize = OutputDevice::LogicToLogic( Size( rNewCrop.GetLeft(), rNewCrop.GetTop() ), aMapTwip, aMap100 );
+                                aRBSize = OutputDevice::LogicToLogic( Size( rNewCrop.GetRight(), rNewCrop.GetBottom() ), aMapTwip, aMap100 );
+                                aSet.Put( SdrGrafCropItem( aLTSize.Width(), aLTSize.Height(), aRBSize.Width(), aRBSize.Height() ) );
+                            }
+
+                            // set new logic rect
+                            if( SfxItemState::SET <= pOutAttr->GetItemState( SID_ATTR_GRAF_FRMSIZE ) )
+                            {
+                                Point       aNewOrigin( pObj->GetLogicRect().TopLeft() );
+                                const Size& rGrfSize = static_cast<const SvxSizeItem&>( pOutAttr->Get( SID_ATTR_GRAF_FRMSIZE ) ).GetSize();
+                                Size        aNewGrfSize( OutputDevice::LogicToLogic( rGrfSize, aMapTwip, aMap100 ) );
+                                Size        aOldGrfSize( pObj->GetLogicRect().GetSize() );
+
+                                tools::Rectangle aNewRect( aNewOrigin, aNewGrfSize );
+                                Point aOffset( (aNewGrfSize.Width() - aOldGrfSize.Width()) >> 1,
+                                            (aNewGrfSize.Height() - aOldGrfSize.Height()) >> 1 );
+
+                                // #106181# rotate snap rect before setting it
+                                const GeoStat& aGeo = pObj->GetGeoStat();
+
+                                if (aGeo.nRotationAngle!=0 || aGeo.nShearAngle!=0)
+                                {
+                                    tools::Polygon aPol(aNewRect);
+
+                                    // also transform origin offset
+                                    if (aGeo.nShearAngle!=0)
+                                    {
+                                        ShearPoly(aPol,
+                                                aNewRect.TopLeft(),
+                                                aGeo.nTan);
+                                        ShearPoint(aOffset, Point(0,0), aGeo.nTan);
+                                    }
+                                    if (aGeo.nRotationAngle!=0)
+                                    {
+                                        RotatePoly(aPol,
+                                                aNewRect.TopLeft(),
+                                                aGeo.nSin,aGeo.nCos);
+                                        RotatePoint(aOffset, Point(0,0), aGeo.nSin,aGeo.nCos);
+                                    }
+
+                                    // apply offset
+                                    aPol.Move( -aOffset.X(), -aOffset.Y() );
+                                    aNewRect=aPol.GetBoundRect();
+                                }
+                                else
+                                {
+                                    aNewRect.Move( -aOffset.X(), -aOffset.Y() );
+                                }
+
+                                if( !aSet.Count() )
+                                    rView.SetMarkedObjRect( aNewRect );
+                                else
+                                {
+                                    if( bUndo )
+                                    {
+                                        rView.BegUndo( aUndoStr );
+                                        rView.AddUndo( rView.GetModel()->GetSdrUndoFactory().CreateUndoGeoObject( *pObj ) );
+                                    }
+                                    pObj->SetSnapRect( aNewRect );
+                                    rView.SetAttributes( aSet );
+
+                                    if( bUndo )
+                                        rView.EndUndo();
+                                    aSet.ClearItem();
+                                }
+                            }
+                        }
+                    }
+
+                    rPool.SetDefaultMetric( eOldMetric );
+                }
+            }
+        }
+        break;
+
+        case SID_COLOR_SETTINGS:
+        {
+            svx::ToolboxAccess aToolboxAccess( TOOLBOX_NAME );
+            aToolboxAccess.toggleToolbox();
+            rReq.Done();
+            break;
+        }
+
+        default:
+            break;
+    }
+
+    if( aSet.Count() )
+    {
+        if( bUndo )
+            rView.BegUndo( aUndoStr );
+
+        rView.SetAttributes( aSet );
+
+        if( bUndo )
+            rView.EndUndo();
+    }
+}
+
+void SvxGrafAttrHelper::GetGrafAttrState( SfxItemSet& rSet, SdrView const & rView )
+{
+    SfxItemPool&    rPool = rView.GetModel()->GetItemPool();
+    SfxItemSet      aAttrSet( rPool );
+    SfxWhichIter    aIter( rSet );
+    sal_uInt16      nWhich = aIter.FirstWhich();
+    const           SdrMarkList& rMarkList = rView.GetMarkedObjectList();
+    bool            bEnableColors = true;
+    bool            bEnableTransparency = true;
+    bool            bEnableCrop = ( 1 == rMarkList.GetMarkCount() );
+
+    for( size_t i = 0, nCount = rMarkList.GetMarkCount(); i < nCount; ++i )
+    {
+        SdrGrafObj* pGrafObj = dynamic_cast< SdrGrafObj* >( rMarkList.GetMark( i )->GetMarkedSdrObj() );
+
+        if( !pGrafObj ||
+            ( pGrafObj->GetGraphicType() == GraphicType::NONE ) ||
+            ( pGrafObj->GetGraphicType() == GraphicType::Default  ))
+        {
+            bEnableColors = bEnableTransparency = bEnableCrop = false;
+            break;
+        }
+        else if( bEnableTransparency && ( pGrafObj->HasGDIMetaFile() || pGrafObj->IsAnimated() ) )
+        {
+            bEnableTransparency = false;
+        }
+    }
+
+    rView.GetAttributes( aAttrSet );
+
+    while( nWhich )
+    {
+        sal_uInt16 nSlotId = SfxItemPool::IsWhich( nWhich ) ? rPool.GetSlotId( nWhich ) : nWhich;
+
+        switch( nSlotId )
+        {
+            case SID_ATTR_GRAF_MODE:
+            {
+                if( SfxItemState::DEFAULT <= aAttrSet.GetItemState( SDRATTR_GRAFMODE ) )
+                {
+                    if( bEnableColors )
+                    {
+                        rSet.Put( SfxUInt16Item( nSlotId,
+                            sal::static_int_cast< sal_uInt16 >( aAttrSet.Get(SDRATTR_GRAFMODE).GetValue() ) ) );
+                    }
+                    else
+                    {
+                        rSet.DisableItem( SID_ATTR_GRAF_MODE );
+                    }
+                }
+            }
+            break;
+
+            case SID_ATTR_GRAF_RED:
+            {
+                if( SfxItemState::DEFAULT <= aAttrSet.GetItemState( SDRATTR_GRAFRED ) )
+                {
+                    if( bEnableColors )
+                    {
+                        rSet.Put( SfxInt16Item( nSlotId, aAttrSet.Get(SDRATTR_GRAFRED).GetValue() ) );
+                    }
+                    else
+                    {
+                        rSet.DisableItem( SID_ATTR_GRAF_RED );
+                    }
+                }
+            }
+            break;
+
+            case SID_ATTR_GRAF_GREEN:
+            {
+                if( SfxItemState::DEFAULT <= aAttrSet.GetItemState( SDRATTR_GRAFGREEN ) )
+                {
+                    if( bEnableColors )
+                    {
+                        rSet.Put( SfxInt16Item( nSlotId, aAttrSet.Get(SDRATTR_GRAFGREEN).GetValue()) );
+                    }
+                    else
+                    {
+                        rSet.DisableItem( SID_ATTR_GRAF_GREEN );
+                    }
+                }
+            }
+            break;
+
+            case SID_ATTR_GRAF_BLUE:
+            {
+                if( SfxItemState::DEFAULT <= aAttrSet.GetItemState( SDRATTR_GRAFBLUE ) )
+                {
+                    if( bEnableColors )
+                    {
+                        rSet.Put( SfxInt16Item( nSlotId, aAttrSet.Get(SDRATTR_GRAFBLUE).GetValue()) );
+                    }
+                    else
+                    {
+                        rSet.DisableItem( SID_ATTR_GRAF_BLUE );
+                    }
+                }
+            }
+            break;
+
+            case SID_ATTR_GRAF_LUMINANCE:
+            {
+                if( SfxItemState::DEFAULT <= aAttrSet.GetItemState( SDRATTR_GRAFLUMINANCE ) )
+                {
+                    if( bEnableColors )
+                    {
+                        rSet.Put( SfxInt16Item( nSlotId, aAttrSet.Get(SDRATTR_GRAFLUMINANCE).GetValue()) );
+                    }
+                    else
+                    {
+                        rSet.DisableItem( SID_ATTR_GRAF_LUMINANCE );
+                    }
+                }
+            }
+            break;
+
+            case SID_ATTR_GRAF_CONTRAST:
+            {
+                if( SfxItemState::DEFAULT <= aAttrSet.GetItemState( SDRATTR_GRAFCONTRAST ) )
+                {
+                    if( bEnableColors )
+                    {
+                        rSet.Put( SfxInt16Item( nSlotId,
+                            aAttrSet.Get(SDRATTR_GRAFCONTRAST).GetValue()) );
+                    }
+                    else
+                    {
+                        rSet.DisableItem( SID_ATTR_GRAF_CONTRAST );
+                    }
+                }
+            }
+            break;
+
+            case SID_ATTR_GRAF_GAMMA:
+            {
+                if( SfxItemState::DEFAULT <= aAttrSet.GetItemState( SDRATTR_GRAFGAMMA ) )
+                {
+                    if( bEnableColors )
+                    {
+                        rSet.Put( SfxUInt32Item( nSlotId,
+                            aAttrSet.Get(SDRATTR_GRAFGAMMA).GetValue() ) );
+                    }
+                    else
+                    {
+                        rSet.DisableItem( SID_ATTR_GRAF_GAMMA );
+                    }
+                }
+            }
+            break;
+
+            case SID_ATTR_GRAF_TRANSPARENCE:
+            {
+                if( SfxItemState::DEFAULT <= aAttrSet.GetItemState( SDRATTR_GRAFTRANSPARENCE ) )
+                {
+                    if( bEnableTransparency )
+                    {
+                        rSet.Put( SfxUInt16Item( nSlotId,
+                            aAttrSet.Get(SDRATTR_GRAFTRANSPARENCE).GetValue() ) );
+                    }
+                    else
+                    {
+                        rSet.DisableItem( SID_ATTR_GRAF_TRANSPARENCE );
+                    }
+                }
+            }
+            break;
+
+            case SID_ATTR_GRAF_CROP:
+            {
+                if( !bEnableCrop )
+                    rSet.DisableItem( nSlotId );
+            }
+            break;
+
+            case SID_COLOR_SETTINGS :
+            {
+                svx::ToolboxAccess aToolboxAccess( TOOLBOX_NAME );
+                rSet.Put( SfxBoolItem( nWhich, aToolboxAccess.isToolboxVisible() ) );
+                break;
+            }
+
+            default:
+            break;
+        }
+
+        nWhich = aIter.NextWhich();
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */