summaryrefslogtreecommitdiffstats
path: root/sd/source/ui/view/drviews7.cxx
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--sd/source/ui/view/drviews7.cxx1991
1 files changed, 1991 insertions, 0 deletions
diff --git a/sd/source/ui/view/drviews7.cxx b/sd/source/ui/view/drviews7.cxx
new file mode 100644
index 000000000..4f375dc6a
--- /dev/null
+++ b/sd/source/ui/view/drviews7.cxx
@@ -0,0 +1,1991 @@
+/* -*- 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 <memory>
+
+#include <sal/config.h>
+#include <sal/log.hxx>
+
+#include <utility>
+
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/linguistic2/XThesaurus.hpp>
+#include <svx/pageitem.hxx>
+#include <svx/rulritem.hxx>
+#include <svx/svdouno.hxx>
+#include <editeng/eeitem.hxx>
+#include <editeng/sizeitem.hxx>
+#include <editeng/urlfieldhelper.hxx>
+#include <officecfg/Office/Impress.hxx>
+#include <svx/svxids.hrc>
+#include <svx/svdpagv.hxx>
+#include <svx/clipfmtitem.hxx>
+#include <svl/eitem.hxx>
+#include <svl/intitem.hxx>
+#include <svl/itemset.hxx>
+#include <svl/stritem.hxx>
+#include <svl/visitem.hxx>
+#include <svl/whiter.hxx>
+#include <svx/svdograf.hxx>
+#include <svx/xfillit0.hxx>
+#include <svx/xflclit.hxx>
+#include <svx/xflgrit.hxx>
+#include <svx/xflhtit.hxx>
+#include <svx/xbtmpit.hxx>
+#include <editeng/unolingu.hxx>
+#include <svx/extrusionbar.hxx>
+#include <svx/fontworkbar.hxx>
+
+// #UndoRedo#
+#include <svtools/insdlg.hxx>
+#include <unotools/moduleoptions.hxx>
+#include <svl/cjkoptions.hxx>
+#include <comphelper/processfactory.hxx>
+#include <sfx2/request.hxx>
+
+#include <svtools/cliplistener.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/viewfrm.hxx>
+
+#include <app.hrc>
+
+#include <PresentationViewShell.hxx>
+
+#include <drawdoc.hxx>
+#include <DrawViewShell.hxx>
+#include <sdmod.hxx>
+#include <unokywds.hxx>
+#include <sdpage.hxx>
+#include <DrawDocShell.hxx>
+#include <zoomlist.hxx>
+#include <slideshow.hxx>
+#include <drawview.hxx>
+#include <ViewShellBase.hxx>
+#include <ViewShellManager.hxx>
+#include <LayerTabBar.hxx>
+#include <fupoor.hxx>
+#include <Window.hxx>
+#include <fuediglu.hxx>
+#include <fubullet.hxx>
+#include <fuconcs.hxx>
+#include <fuformatpaintbrush.hxx>
+#include <stlsheet.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::linguistic2;
+
+/** Create a list of clipboard formats that are supported both from the
+ current clipboard content and the DrawViewShell.
+ The list is stored in a new instance of SvxClipboardFormatItem.
+*/
+static ::std::unique_ptr<SvxClipboardFormatItem> GetSupportedClipboardFormats (
+ TransferableDataHelper& rDataHelper)
+{
+ ::std::unique_ptr<SvxClipboardFormatItem> pResult (
+ new SvxClipboardFormatItem(SID_CLIPBOARD_FORMAT_ITEMS));
+
+ sal_uInt32 nFormatCount (rDataHelper.GetFormatCount());
+ for (sal_uInt32 i=0; i<nFormatCount; i++)
+ {
+ const SotClipboardFormatId nTestFormat = rDataHelper.GetFormat(i);
+
+ // Check if the current format is the same as one that has already
+ // been handled.
+ bool bDuplicate (false);
+ for (sal_uInt32 j=0; j<i; j++)
+ {
+ if (nTestFormat == rDataHelper.GetFormat(j))
+ {
+ bDuplicate = true;
+ break;
+ }
+ }
+
+ // Look up the format among those that are supported by the
+ // DrawViewShell.
+ if ( ! bDuplicate)
+ {
+ switch (nTestFormat)
+ {
+ case SotClipboardFormatId::EMBED_SOURCE:
+ {
+ OUString sName;
+
+ TransferableObjectDescriptor aDescriptor;
+ if (rDataHelper.GetTransferableObjectDescriptor(
+ SotClipboardFormatId::OBJECTDESCRIPTOR, aDescriptor))
+ {
+ sName = aDescriptor.maTypeName;
+ }
+ if (!sName.isEmpty())
+ pResult->AddClipbrdFormat(nTestFormat, sName);
+ else
+ pResult->AddClipbrdFormat(nTestFormat);
+
+ break;
+ }
+
+
+ case SotClipboardFormatId::LINK_SOURCE:
+ case SotClipboardFormatId::DRAWING:
+ case SotClipboardFormatId::SVXB:
+ case SotClipboardFormatId::GDIMETAFILE:
+ case SotClipboardFormatId::BITMAP:
+ case SotClipboardFormatId::NETSCAPE_BOOKMARK:
+ case SotClipboardFormatId::STRING:
+ case SotClipboardFormatId::HTML:
+ case SotClipboardFormatId::RTF:
+ case SotClipboardFormatId::RICHTEXT:
+ case SotClipboardFormatId::EDITENGINE_ODF_TEXT_FLAT:
+ pResult->AddClipbrdFormat(nTestFormat);
+ break;
+ default: break;
+ }
+ }
+ }
+
+ // Check some OLE formats whose names are handled differently.
+ SotClipboardFormatId nFormat (SotClipboardFormatId::EMBED_SOURCE_OLE);
+ bool bHasFormat (rDataHelper.HasFormat(nFormat));
+ if ( ! bHasFormat)
+ {
+ bHasFormat = rDataHelper.HasFormat(nFormat);
+ }
+ if (bHasFormat)
+ {
+ OUString sName;
+ OUString sSource;
+ if (SvPasteObjectHelper::GetEmbeddedName (rDataHelper, sName, sSource, nFormat))
+ pResult->AddClipbrdFormat (nFormat, sName);
+ }
+
+ return pResult;
+}
+
+namespace sd {
+
+IMPL_LINK( DrawViewShell, ClipboardChanged, TransferableDataHelper*, pDataHelper, void )
+{
+ mbPastePossible = ( pDataHelper->GetFormatCount() != 0 );
+
+ // Update the list of supported clipboard formats according to the
+ // new clipboard content.
+ // There are some stack traces that indicate the possibility of the
+ // DrawViewShell destructor called during the call to
+ // GetSupportedClipboardFormats(). If that really has happened then
+ // exit immediately.
+ TransferableDataHelper aDataHelper (
+ TransferableDataHelper::CreateFromSystemClipboard(GetActiveWindow()));
+ ::std::unique_ptr<SvxClipboardFormatItem> pFormats (GetSupportedClipboardFormats(aDataHelper));
+ if (mpDrawView == nullptr)
+ return;
+ mpCurrentClipboardFormats = std::move(pFormats);
+
+ SfxBindings& rBindings = GetViewFrame()->GetBindings();
+ rBindings.Invalidate( SID_PASTE );
+ rBindings.Invalidate( SID_PASTE_SPECIAL );
+ rBindings.Invalidate( SID_PASTE_UNFORMATTED );
+ rBindings.Invalidate( SID_CLIPBOARD_FORMAT_ITEMS );
+}
+
+void DrawViewShell::GetDrawAttrState(SfxItemSet& rSet)
+{
+ SfxItemSet aSet( mpDrawView->GetGeoAttrFromMarked() );
+ rSet.Put(aSet,false);
+}
+
+::Outliner* DrawViewShell::GetOutlinerForMasterPageOutlineTextObj(ESelection &rSel)
+{
+ if( !mpDrawView )
+ return nullptr;
+
+ //when there is one object selected
+ if (!mpDrawView->AreObjectsMarked() || (mpDrawView->GetMarkedObjectList().GetMarkCount() != 1))
+ return nullptr;
+
+ //and we are editing the outline object
+ if (!mpDrawView->IsTextEdit())
+ return nullptr;
+
+ SdrPageView* pPageView = mpDrawView->GetSdrPageView();
+ if (!pPageView)
+ return nullptr;
+
+ SdPage* pPage = static_cast<SdPage*>(pPageView->GetPage());
+ //only show these in a normal master page
+ if (!pPage || (pPage->GetPageKind() != PageKind::Standard) || !pPage->IsMasterPage())
+ return nullptr;
+
+ OutlinerView* pOLV = mpDrawView->GetTextEditOutlinerView();
+ ::Outliner* pOL = pOLV ? pOLV->GetOutliner() : nullptr;
+ if (!pOL)
+ return nullptr;
+ rSel = pOLV->GetSelection();
+
+ return pOL;
+}
+
+void DrawViewShell::GetMarginProperties( SfxItemSet &rSet )
+{
+ SdPage *pPage = getCurrentPage();
+ SfxWhichIter aIter( rSet );
+ sal_uInt16 nWhich = aIter.FirstWhich();
+ while ( nWhich )
+ {
+ switch ( nWhich )
+ {
+ case SID_ATTR_PAGE_LRSPACE:
+ {
+ // const SvxLRSpaceItem aTmpPageLRSpace ( rDesc.GetMaster().GetLRSpace() );
+ const SvxLongLRSpaceItem aLongLR(
+ static_cast<::tools::Long>(pPage->GetLeftBorder()),
+ static_cast<::tools::Long>(pPage->GetRightBorder()),
+ SID_ATTR_PAGE_LRSPACE );
+ rSet.Put( aLongLR );
+ }
+ break;
+
+ case SID_ATTR_PAGE_ULSPACE:
+ {
+ // const SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() );
+ SvxLongULSpaceItem aLongUL(
+ static_cast<::tools::Long>(pPage->GetUpperBorder()),
+ static_cast<::tools::Long>(pPage->GetLowerBorder()),
+ SID_ATTR_PAGE_ULSPACE );
+ rSet.Put( aLongUL );
+ }
+ break;
+
+ default:
+ break;
+ }
+ nWhich = aIter.NextWhich();
+ }
+}
+
+bool DrawViewShell::ShouldDisableEditHyperlink() const
+{
+ if (!mpDrawView)
+ return true;
+ if (!mpDrawView->AreObjectsMarked())
+ return true;
+ if (mpDrawView->GetMarkedObjectList().GetMarkCount() != 1)
+ return true;
+
+ bool bDisableEditHyperlink = true;
+ if( mpDrawView->IsTextEdit() )
+ {
+ if (URLFieldHelper::IsCursorAtURLField(mpDrawView->GetTextEditOutlinerView()))
+ bDisableEditHyperlink = false;
+ }
+ else
+ {
+ SdrUnoObj* pUnoCtrl = dynamic_cast<SdrUnoObj*>( mpDrawView->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj() );
+
+ if ( pUnoCtrl && SdrInventor::FmForm == pUnoCtrl->GetObjInventor() )
+ {
+ const uno::Reference< awt::XControlModel >& xControlModel( pUnoCtrl->GetUnoControlModel() );
+ if( xControlModel.is() )
+ {
+ uno::Reference< beans::XPropertySet > xPropSet( xControlModel, uno::UNO_QUERY );
+ if( xPropSet.is() )
+ {
+ uno::Reference< beans::XPropertySetInfo > xPropInfo( xPropSet->getPropertySetInfo() );
+ if( xPropInfo.is() && xPropInfo->hasPropertyByName( "TargetURL") )
+ {
+ bDisableEditHyperlink = false;
+ }
+ }
+ }
+ }
+ }
+ return bDisableEditHyperlink;
+}
+
+void DrawViewShell::GetMenuState( SfxItemSet &rSet )
+{
+ if (mpDrawView == nullptr)
+ {
+ // This assertion and return are here to prevent crashes.
+ DBG_ASSERT(mpDrawView!=nullptr, "Please report this assertion to the Impress team.");
+ return;
+ }
+
+ ViewShell::GetMenuState(rSet);
+ bool bDisableVerticalText = !SvtCJKOptions::IsVerticalTextEnabled();
+
+ if ( bDisableVerticalText )
+ {
+ rSet.DisableItem( SID_DRAW_FONTWORK_VERTICAL );
+ rSet.DisableItem( SID_DRAW_CAPTION_VERTICAL );
+ rSet.DisableItem( SID_TEXT_FITTOSIZE_VERTICAL );
+ rSet.DisableItem( SID_DRAW_TEXT_VERTICAL );
+ }
+
+ bool bConvertToPathPossible = mpDrawView->IsConvertToPathObjPossible();
+
+ const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList();
+ const size_t nMarkCount = rMarkList.GetMarkCount();
+
+ if( nMarkCount == 1 )
+ {
+ bool bDisable = true;
+ SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
+ if( auto pGrafObj = dynamic_cast<const SdrGrafObj*>( pObj) )
+ if( pGrafObj->getQrCode() )
+ bDisable = false;
+ if(bDisable)
+ {
+ rSet.DisableItem(SID_EDIT_QRCODE);
+ }
+ }
+
+ //format paintbrush
+ FuFormatPaintBrush::GetMenuState( *this, rSet );
+
+ // State of SfxChild-Windows (Animator, Fontwork etc.)
+ SetChildWindowState( rSet );
+
+ if(HasCurrentFunction())
+ {
+ sal_uInt16 nSId = GetCurrentFunction()->GetSlotID();
+ rSet.Put( SfxBoolItem( nSId, true ) );
+ }
+
+ SdrPageView* pPageView = mpDrawView->GetSdrPageView();
+
+ GetMenuStateSel(rSet);
+
+ if (SfxItemState::DEFAULT == rSet.GetItemState(SID_ASSIGN_LAYOUT))
+ {
+ bool bDisable = true;
+ if( pPageView )
+ {
+ SdPage* pPage = dynamic_cast< SdPage* >( pPageView->GetPage() );
+
+ if( pPage && !pPage->IsMasterPage() )
+ {
+ rSet.Put( SfxUInt32Item( SID_ASSIGN_LAYOUT, static_cast< sal_uInt32 >(pPage->GetAutoLayout()) ) );
+ bDisable = false;
+ }
+ }
+
+ if(bDisable)
+ {
+ rSet.DisableItem(SID_ASSIGN_LAYOUT);
+ }
+ }
+
+ if (SfxItemState::DEFAULT == rSet.GetItemState(SID_EXPAND_PAGE))
+ {
+ bool bDisable = true;
+ if( pPageView )
+ {
+ SdPage* pPage = dynamic_cast< SdPage* >( pPageView->GetPage() );
+
+ if( pPage && (pPage->GetPageKind() == PageKind::Standard) && !pPage->IsMasterPage() )
+ {
+ SdrObject* pObj = pPage->GetPresObj(PresObjKind::Outline);
+
+ if (pObj!=nullptr )
+ {
+ if( !pObj->IsEmptyPresObj() )
+ {
+ bDisable = false;
+ }
+ else
+ {
+ // check if the object is in edit, then if it's temporarily not empty
+ SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( pObj );
+ if( pTextObj )
+ {
+ if( pTextObj->CanCreateEditOutlinerParaObject() )
+ {
+ bDisable = false;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if(bDisable)
+ {
+ rSet.DisableItem(SID_EXPAND_PAGE);
+ }
+ }
+
+ if (SfxItemState::DEFAULT == rSet.GetItemState(SID_SUMMARY_PAGE))
+ {
+ bool bDisable = true;
+ if( pPageView )
+ {
+ SdPage* pPage = dynamic_cast< SdPage* >( pPageView->GetPage() );
+
+ if( pPage && (pPage->GetPageKind() == PageKind::Standard) && !pPage->IsMasterPage() )
+ {
+ SdrObject* pObj = pPage->GetPresObj(PresObjKind::Title);
+
+ if(pObj && !pObj->IsEmptyPresObj())
+ {
+ bDisable = false;
+ }
+ }
+ }
+
+ if(bDisable)
+ {
+ rSet.DisableItem(SID_SUMMARY_PAGE);
+ }
+ }
+
+ if (SfxItemState::DEFAULT == rSet.GetItemState(SID_ASSIGN_LAYOUT))
+ {
+ bool bDisable = true;
+ if( pPageView )
+ {
+ SdPage* pPage = dynamic_cast< SdPage* >( pPageView->GetPage() );
+
+ if( pPage && !pPage->IsMasterPage() )
+ {
+ rSet.Put( SfxUInt32Item(SID_ASSIGN_LAYOUT, pPage->GetAutoLayout()) );
+ bDisable = false;
+ }
+ }
+
+ if(bDisable)
+ {
+ rSet.DisableItem(SID_ASSIGN_LAYOUT);
+ }
+ }
+
+ // is it possible to start the presentation?
+ if( SfxItemState::DEFAULT == rSet.GetItemState( SID_PRESENTATION ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_REHEARSE_TIMINGS ) )
+ {
+ bool bDisable = true;
+ sal_uInt16 nCount = GetDoc()->GetSdPageCount( PageKind::Standard );
+
+ for( sal_uInt16 i = 0; i < nCount && bDisable; i++ )
+ {
+ SdPage* pPage = GetDoc()->GetSdPage(i, PageKind::Standard);
+
+ if( !pPage->IsExcluded() )
+ bDisable = false;
+ }
+
+ if( bDisable || GetDocSh()->IsPreview())
+ {
+ rSet.DisableItem( SID_PRESENTATION );
+ rSet.DisableItem( SID_REHEARSE_TIMINGS );
+ }
+ }
+
+ // gluepoints
+ if( SfxItemState::DEFAULT == rSet.GetItemState( SID_GLUE_EDITMODE ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_GLUE_INSERT_POINT ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_GLUE_PERCENT ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_GLUE_ESCDIR ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_GLUE_ESCDIR_LEFT ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_GLUE_ESCDIR_RIGHT ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_GLUE_ESCDIR_TOP ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_GLUE_ESCDIR_BOTTOM ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_GLUE_HORZALIGN_CENTER ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_GLUE_HORZALIGN_LEFT ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_GLUE_HORZALIGN_RIGHT ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_GLUE_VERTALIGN_CENTER ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_GLUE_VERTALIGN_TOP ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_GLUE_VERTALIGN_BOTTOM ) )
+ {
+ // percent
+ TriState eState = mpDrawView->IsMarkedGluePointsPercent();
+ if( eState == TRISTATE_INDET )
+ rSet.InvalidateItem( SID_GLUE_PERCENT );
+ else
+ rSet.Put( SfxBoolItem( SID_GLUE_PERCENT, eState == TRISTATE_TRUE ) );
+
+ // alignment has no effect by percent
+ if( eState == TRISTATE_TRUE )
+ {
+ rSet.DisableItem( SID_GLUE_HORZALIGN_CENTER );
+ rSet.DisableItem( SID_GLUE_HORZALIGN_LEFT );
+ rSet.DisableItem( SID_GLUE_HORZALIGN_RIGHT );
+ rSet.DisableItem( SID_GLUE_VERTALIGN_CENTER );
+ rSet.DisableItem( SID_GLUE_VERTALIGN_TOP );
+ rSet.DisableItem( SID_GLUE_VERTALIGN_BOTTOM );
+ }
+ else
+ {
+ // horizontal alignment
+ SdrAlign nHorz = mpDrawView->GetMarkedGluePointsAlign( false );
+ rSet.Put( SfxBoolItem( SID_GLUE_HORZALIGN_CENTER, nHorz == SdrAlign::HORZ_CENTER ) );
+ rSet.Put( SfxBoolItem( SID_GLUE_HORZALIGN_LEFT, nHorz == SdrAlign::HORZ_LEFT ) );
+ rSet.Put( SfxBoolItem( SID_GLUE_HORZALIGN_RIGHT, nHorz == SdrAlign::HORZ_RIGHT ) );
+ // vertical alignment
+ SdrAlign nVert = mpDrawView->GetMarkedGluePointsAlign( true );
+ rSet.Put( SfxBoolItem( SID_GLUE_VERTALIGN_CENTER, nVert == SdrAlign::VERT_CENTER ) );
+ rSet.Put( SfxBoolItem( SID_GLUE_VERTALIGN_TOP, nVert == SdrAlign::VERT_TOP ) );
+ rSet.Put( SfxBoolItem( SID_GLUE_VERTALIGN_BOTTOM, nVert == SdrAlign::VERT_BOTTOM ) );
+ }
+
+ // insert point
+ rSet.Put( SfxBoolItem( SID_GLUE_INSERT_POINT, mpDrawView->IsInsGluePointMode() ) );
+
+ // Escape direction
+ // left
+ eState = mpDrawView->IsMarkedGluePointsEscDir( SdrEscapeDirection::LEFT );
+ if( eState == TRISTATE_INDET )
+ rSet.InvalidateItem( SID_GLUE_ESCDIR_LEFT );
+ else
+ rSet.Put( SfxBoolItem( SID_GLUE_ESCDIR_LEFT, eState == TRISTATE_TRUE ) );
+ // right
+ eState = mpDrawView->IsMarkedGluePointsEscDir( SdrEscapeDirection::RIGHT );
+ if( eState == TRISTATE_INDET )
+ rSet.InvalidateItem( SID_GLUE_ESCDIR_RIGHT );
+ else
+ rSet.Put( SfxBoolItem( SID_GLUE_ESCDIR_RIGHT, eState == TRISTATE_TRUE ) );
+ // top
+ eState = mpDrawView->IsMarkedGluePointsEscDir( SdrEscapeDirection::TOP );
+ if( eState == TRISTATE_INDET )
+ rSet.InvalidateItem( SID_GLUE_ESCDIR_TOP );
+ else
+ rSet.Put( SfxBoolItem( SID_GLUE_ESCDIR_TOP, eState == TRISTATE_TRUE ) );
+ // bottom
+ eState = mpDrawView->IsMarkedGluePointsEscDir( SdrEscapeDirection::BOTTOM );
+ if( eState == TRISTATE_INDET )
+ rSet.InvalidateItem( SID_GLUE_ESCDIR_BOTTOM );
+ else
+ rSet.Put( SfxBoolItem( SID_GLUE_ESCDIR_BOTTOM, eState == TRISTATE_TRUE ) );
+ }
+
+ if( SfxItemState::DEFAULT == rSet.GetItemState( SID_GRID_FRONT ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_HELPLINES_FRONT ) )
+ {
+ rSet.Put( SfxBoolItem( SID_GRID_FRONT, mpDrawView->IsGridFront() ) );
+ rSet.Put( SfxBoolItem( SID_HELPLINES_FRONT, mpDrawView->IsHlplFront() ) );
+ }
+
+ if (!mpDrawView->IsFrameDragSingles())
+ rSet.Put(SfxBoolItem(SID_BEZIER_EDIT, true));
+ else
+ rSet.Put(SfxBoolItem(SID_BEZIER_EDIT, false));
+
+ if(dynamic_cast<FuEditGluePoints*>( GetCurrentFunction().get()))
+ rSet.Put(SfxBoolItem(SID_GLUE_EDITMODE, true));
+ else
+ rSet.Put(SfxBoolItem(SID_GLUE_EDITMODE, false));
+
+ if( !mpDrawView->IsMirrorAllowed( true, true ) )
+ {
+ rSet.DisableItem( SID_HORIZONTAL );
+ rSet.DisableItem( SID_VERTICAL );
+ rSet.DisableItem( SID_FLIP_HORIZONTAL );
+ rSet.DisableItem( SID_FLIP_VERTICAL );
+ }
+
+ if( !mpDrawView->IsMirrorAllowed() )
+ {
+ rSet.DisableItem( SID_OBJECT_MIRROR );
+// rSet.DisableItem( SID_CONVERT_TO_3D_LATHE );
+// rSet.DisableItem( SID_CONVERT_TO_3D_LATHE_FAST );
+ }
+
+ // interactive transparence control
+ if(!mpDrawView->IsTransparenceAllowed())
+ {
+ rSet.DisableItem( SID_OBJECT_TRANSPARENCE );
+ }
+
+ // interactive gradient control
+ if(!mpDrawView->IsGradientAllowed())
+ {
+ rSet.DisableItem( SID_OBJECT_GRADIENT );
+ }
+
+ // disable morphing if necessary
+ if ( !mpDrawView->IsMorphingAllowed() )
+ rSet.DisableItem( SID_POLYGON_MORPHING );
+
+ if( !mpDrawView->IsReverseOrderPossible() )
+ {
+ rSet.DisableItem( SID_REVERSE_ORDER );
+ }
+
+ if ( !bConvertToPathPossible &&
+ !mpDrawView->IsCrookAllowed( mpDrawView->IsCrookNoContortion() ) )
+ {
+ // implicit transformation into curve not possible
+ rSet.DisableItem(SID_OBJECT_CROOK_ROTATE);
+ rSet.DisableItem(SID_OBJECT_CROOK_SLANT);
+ rSet.DisableItem(SID_OBJECT_CROOK_STRETCH);
+ }
+
+ if ( !mpDrawView->IsGroupEntered() )
+ {
+ rSet.DisableItem( SID_LEAVE_GROUP );
+ rSet.Put( SfxBoolItem( SID_LEAVE_ALL_GROUPS, false ) );
+ rSet.ClearItem( SID_LEAVE_ALL_GROUPS );
+ rSet.DisableItem( SID_LEAVE_ALL_GROUPS );
+ }
+ else
+ rSet.Put( SfxBoolItem( SID_LEAVE_ALL_GROUPS, true ) );
+
+ if( SfxItemState::DEFAULT == rSet.GetItemState( SID_THESAURUS ) )
+ {
+ if ( !mpDrawView->IsTextEdit() )
+ {
+ rSet.DisableItem( SID_THESAURUS );
+ }
+ else
+ {
+ LanguageType eLang = GetDoc()->GetLanguage( EE_CHAR_LANGUAGE );
+ Reference< XThesaurus > xThesaurus( LinguMgr::GetThesaurus() );
+
+ if (!xThesaurus.is() || eLang == LANGUAGE_NONE || !xThesaurus->hasLocale( LanguageTag::convertToLocale( eLang)) )
+ rSet.DisableItem( SID_THESAURUS );
+ }
+ }
+
+ if ( !mpDrawView->IsTextEdit() )
+ {
+ rSet.DisableItem( SID_THESAURUS );
+ }
+
+ if( SfxItemState::DEFAULT == rSet.GetItemState( SID_SELECTALL ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_SIZE_ALL ) )
+ {
+ if( pPageView && pPageView->GetObjList()->GetObjCount() == 0 )
+ {
+ // should be disabled if there is no object on the draw area:
+ rSet.DisableItem( SID_SELECTALL );
+ rSet.DisableItem( SID_SIZE_ALL );
+ }
+ }
+
+ if( SfxItemState::DEFAULT == rSet.GetItemState( SID_CONTEXT ) )
+ rSet.Put( SfxStringItem( SID_CONTEXT, mpDrawView->GetStatusText() ) );
+
+ // clipboard (paste)
+ if( SfxItemState::DEFAULT == rSet.GetItemState( SID_PASTE ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_PASTE_SPECIAL ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_PASTE_UNFORMATTED ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_CLIPBOARD_FORMAT_ITEMS ) )
+ {
+ if ( !mxClipEvtLstnr.is() )
+ {
+ // avoid clipboard initialization for
+ // read-only presentation views (workaround for NT4.0
+ // clipboard prob...)
+ if( dynamic_cast< const PresentationViewShell *>( this ) == nullptr )
+ {
+ // create listener
+ mxClipEvtLstnr = new TransferableClipboardListener( LINK( this, DrawViewShell, ClipboardChanged ) );
+ mxClipEvtLstnr->AddListener( GetActiveWindow() );
+
+ // get initial state
+ TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( GetActiveWindow() ) );
+ mbPastePossible = ( aDataHelper.GetFormatCount() != 0 );
+ mpCurrentClipboardFormats = GetSupportedClipboardFormats( aDataHelper );
+ }
+ else
+ mbPastePossible = false;
+ }
+
+ if( !mbPastePossible )
+ {
+ rSet.DisableItem( SID_PASTE );
+ rSet.DisableItem( SID_PASTE_SPECIAL );
+ rSet.DisableItem( SID_PASTE_UNFORMATTED );
+ rSet.DisableItem( SID_CLIPBOARD_FORMAT_ITEMS );
+ }
+ else if( SfxItemState::DEFAULT == rSet.GetItemState( SID_CLIPBOARD_FORMAT_ITEMS ) )
+ {
+ if (mpCurrentClipboardFormats != nullptr)
+ rSet.Put(*mpCurrentClipboardFormats);
+ }
+ }
+
+ if ( !bConvertToPathPossible )
+ {
+ rSet.DisableItem(SID_CHANGEBEZIER);
+ }
+
+ if (mpDrawView == nullptr)
+ {
+ // The mpDrawView was not NULL but is now.
+ // The reason for this may be that the DrawViewShell has been
+ // destroyed in the meantime.
+ // We can only return immediately and hope that the deleted
+ // DrawViewShell is not called again.
+ DBG_ASSERT(mpDrawView!=nullptr, "Please report this assertion to the Impress team.");
+ return;
+ }
+
+ if( !( mpDrawView->IsConvertToPolyObjPossible() || mpDrawView->IsVectorizeAllowed() ) )
+ rSet.DisableItem(SID_CHANGEPOLYGON);
+
+ if( !( mpDrawView->IsConvertToPolyObjPossible() || mpDrawView->IsConvertToContourPossible() ) )
+ rSet.DisableItem(SID_CONVERT_TO_CONTOUR);
+
+ if ( !mpDrawView->IsConvertTo3DObjPossible() )
+ {
+ rSet.DisableItem(SID_CONVERT_TO_3D);
+ rSet.DisableItem(SID_CONVERT_TO_3D_LATHE);
+ rSet.DisableItem(SID_CONVERT_TO_3D_LATHE_FAST);
+ }
+
+ if( SfxItemState::DEFAULT == rSet.GetItemState( SID_MANAGE_LINKS ) )
+ {
+ if ( GetDoc()->GetLinkCount() == 0 )
+ {
+ rSet.DisableItem(SID_MANAGE_LINKS);
+ }
+ }
+
+ if (mePageKind == PageKind::Handout)
+ {
+ rSet.DisableItem(SID_PRESENTATION_LAYOUT);
+ rSet.DisableItem(SID_SELECT_BACKGROUND);
+ rSet.DisableItem(SID_SAVE_BACKGROUND);
+ }
+
+ if (mePageKind == PageKind::Notes)
+ {
+ rSet.DisableItem(SID_INSERTPAGE);
+ rSet.DisableItem(SID_RENAMEPAGE);
+ rSet.DisableItem(SID_RENAMEPAGE_QUICK);
+ rSet.DisableItem(SID_DUPLICATE_PAGE);
+ rSet.ClearItem(SID_ANIMATION_OBJECTS);
+ rSet.DisableItem(SID_ANIMATION_OBJECTS);
+ rSet.DisableItem(SID_ANIMATION_EFFECTS);
+ rSet.DisableItem(SID_EXECUTE_ANIMATION_EFFECT);
+
+ if (meEditMode == EditMode::MasterPage)
+ rSet.DisableItem(SID_MODIFYPAGE);
+
+ rSet.DisableItem(SID_SELECT_BACKGROUND);
+ rSet.DisableItem(SID_SAVE_BACKGROUND);
+ rSet.DisableItem(SID_INSERTLAYER);
+ rSet.DisableItem(SID_LAYERMODE);
+ rSet.DisableItem(SID_INSERTFILE);
+ }
+ else if (mePageKind == PageKind::Handout)
+ {
+ rSet.DisableItem(SID_INSERTPAGE);
+ rSet.DisableItem(SID_DUPLICATE_PAGE);
+ rSet.ClearItem(SID_ANIMATION_OBJECTS);
+ rSet.DisableItem(SID_ANIMATION_OBJECTS);
+ rSet.DisableItem(SID_ANIMATION_EFFECTS);
+ rSet.DisableItem(SID_EXECUTE_ANIMATION_EFFECT);
+ rSet.DisableItem(SID_RENAMEPAGE);
+ rSet.DisableItem(SID_RENAMEPAGE_QUICK);
+ rSet.DisableItem(SID_INSERTLAYER);
+ rSet.DisableItem(SID_MODIFYLAYER);
+ rSet.DisableItem(SID_RENAMELAYER);
+ rSet.DisableItem(SID_LAYERMODE);
+ rSet.DisableItem(SID_INSERTFILE);
+ rSet.DisableItem(SID_PAGEMODE);
+ rSet.DisableItem(SID_SELECT_BACKGROUND);
+ rSet.DisableItem(SID_SAVE_BACKGROUND);
+ }
+ else
+ {
+ if (meEditMode == EditMode::MasterPage)
+ {
+ rSet.DisableItem(SID_INSERTPAGE);
+ rSet.DisableItem(SID_DUPLICATE_PAGE);
+ rSet.DisableItem(SID_MODIFYPAGE);
+ rSet.ClearItem(SID_ANIMATION_OBJECTS);
+ rSet.DisableItem(SID_ANIMATION_OBJECTS);
+ }
+
+ rSet.Put (SfxBoolItem (SID_LAYERMODE, IsLayerModeActive()));
+ }
+
+ if ( ! IsLayerModeActive())
+ {
+ rSet.DisableItem( SID_INSERTLAYER );
+ rSet.DisableItem( SID_MODIFYLAYER );
+ rSet.DisableItem( SID_DELETE_LAYER );
+ rSet.DisableItem( SID_RENAMELAYER );
+ }
+
+ if (meEditMode == EditMode::Page)
+ {
+ /**********************************************************************
+ * page mode
+ **********************************************************************/
+ rSet.Put(SfxBoolItem(SID_PAGEMODE, true));
+ rSet.Put(SfxBoolItem(SID_MASTERPAGE, false));
+ rSet.Put(SfxBoolItem(SID_SLIDE_MASTER_MODE, false));
+ rSet.Put(SfxBoolItem(SID_NOTES_MASTER_MODE, false));
+ rSet.Put(SfxBoolItem(SID_HANDOUT_MASTER_MODE, false));
+
+ rSet.DisableItem (SID_INSERT_MASTER_PAGE);
+ rSet.DisableItem (SID_DELETE_MASTER_PAGE);
+ rSet.DisableItem (SID_RENAME_MASTER_PAGE);
+ rSet.DisableItem (SID_CLOSE_MASTER_VIEW);
+ }
+ else
+ {
+ rSet.Put(SfxBoolItem(SID_PAGEMODE, false));
+ rSet.Put(SfxBoolItem(SID_MASTERPAGE, true));
+
+ /**********************************************************************
+ * Background page mode
+ **********************************************************************/
+ if (mePageKind == PageKind::Standard)
+ {
+ rSet.Put(SfxBoolItem(SID_SLIDE_MASTER_MODE, true));
+ rSet.Put(SfxBoolItem(SID_NOTES_MASTER_MODE, false));
+ rSet.Put(SfxBoolItem(SID_HANDOUT_MASTER_MODE, false));
+
+ }
+ else if (mePageKind == PageKind::Notes)
+ {
+ rSet.Put(SfxBoolItem(SID_SLIDE_MASTER_MODE, false));
+ rSet.Put(SfxBoolItem(SID_NOTES_MASTER_MODE, true));
+ rSet.Put(SfxBoolItem(SID_HANDOUT_MASTER_MODE, false));
+ }
+ else if (mePageKind == PageKind::Handout)
+ {
+ rSet.Put(SfxBoolItem(SID_SLIDE_MASTER_MODE, false));
+ rSet.Put(SfxBoolItem(SID_NOTES_MASTER_MODE, false));
+ rSet.Put(SfxBoolItem(SID_HANDOUT_MASTER_MODE, true));
+ }
+ }
+
+ // set state of the ruler
+ if( SfxItemState::DEFAULT == rSet.GetItemState( SID_RULER ) )
+ rSet.Put( SfxBoolItem( SID_RULER, HasRuler() ) );
+
+ // do not delete the last page or a master page
+ if( SfxItemState::DEFAULT == rSet.GetItemState( SID_DELETE_PAGE )
+ || SfxItemState::DEFAULT == rSet.GetItemState( SID_DELETE_MASTER_PAGE ) )
+ {
+ if (maTabControl->GetPageCount() == 1 ||
+ meEditMode == EditMode::MasterPage ||
+ mePageKind == PageKind::Notes ||
+ mePageKind == PageKind::Handout ||
+ (GetShellType()!=ST_DRAW&&IsLayerModeActive()))
+ {
+ if (rSet.GetItemState(SID_DELETE_PAGE) == SfxItemState::DEFAULT)
+ rSet.DisableItem(SID_DELETE_PAGE);
+ if (rSet.GetItemState(SID_DELETE_MASTER_PAGE)==SfxItemState::DEFAULT)
+ rSet.DisableItem(SID_DELETE_MASTER_PAGE);
+ }
+ }
+
+ // is it allowed to delete the current layer?
+ if( SfxItemState::DEFAULT == rSet.GetItemState( SID_DELETE_LAYER )
+ || SfxItemState::DEFAULT == rSet.GetItemState( SID_RENAMELAYER ) )
+ {
+ if(GetLayerTabControl()) // #i87182#
+ {
+ sal_uInt16 nCurrentLayer = GetLayerTabControl()->GetCurPageId();
+ const OUString& rName = GetLayerTabControl()->GetLayerName(nCurrentLayer);
+
+ if (!IsLayerModeActive() || LayerTabBar::IsRealNameOfStandardLayer(rName))
+ {
+ rSet.DisableItem(SID_DELETE_LAYER);
+ rSet.DisableItem(SID_RENAMELAYER);
+ }
+ }
+ else
+ {
+ OSL_ENSURE(false, "No LayerTabBar (!)");
+ }
+ }
+
+ if( SfxItemState::DEFAULT == rSet.GetItemState( SID_CUT ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_COPY ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_OUTLINE_BULLET ))
+ {
+ OutlinerView* pOlView = mpDrawView->GetTextEditOutlinerView();
+
+ // special treatment of for SID_OUTLINE_BULLET if objects with different
+ // kinds of NumBullets are marked
+ bool bHasOutliner = false;
+ bool bHasOther = false;
+ for(size_t nNum = 0; nNum < nMarkCount; ++nNum)
+ {
+ SdrObject* pObj = rMarkList.GetMark(nNum)->GetMarkedSdrObj();
+ if( pObj->GetObjInventor() == SdrInventor::Default )
+ {
+ if( pObj->GetObjIdentifier() == SdrObjKind::OutlineText )
+ {
+ bHasOutliner = true;
+ if(bHasOther)
+ break;
+ }
+ else
+ {
+ bHasOther = true;
+ if(bHasOutliner)
+ break;
+ }
+ }
+ }
+
+ if( bHasOther && bHasOutliner )
+ rSet.DisableItem( SID_OUTLINE_BULLET );
+
+ if (pOlView)
+ {
+ if (pOlView->GetSelected().isEmpty() || GetObjectShell()->isContentExtractionLocked())
+ {
+ rSet.DisableItem( SID_CUT );
+ rSet.DisableItem( SID_COPY );
+ }
+ }
+
+ }
+
+ FuBullet::GetSlotState( rSet, this, GetViewFrame() );
+
+ if ( GetDocSh()->IsUIActive() )
+ {
+ rSet.DisableItem( SID_INSERT_OBJECT );
+ rSet.DisableItem( SID_INSERT_FLOATINGFRAME );
+ rSet.DisableItem( SID_INSERT_MATH );
+ rSet.DisableItem( SID_INSERT_DIAGRAM );
+ rSet.DisableItem( SID_ATTR_TABLE );
+ rSet.DisableItem( SID_SIZE_REAL );
+ rSet.DisableItem( SID_SIZE_OPTIMAL );
+ rSet.DisableItem( SID_SIZE_ALL );
+ rSet.DisableItem( SID_SIZE_PAGE_WIDTH );
+ rSet.DisableItem( SID_SIZE_PAGE );
+ rSet.DisableItem( SID_DUPLICATE_PAGE );
+ rSet.DisableItem( SID_ZOOM_TOOLBOX );
+ }
+
+ // Zoom-State
+ if( SfxItemState::DEFAULT == rSet.GetItemState( SID_ZOOM_IN ) ||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_ZOOM_OUT )||
+ SfxItemState::DEFAULT == rSet.GetItemState( SID_ZOOM_PANNING ) )
+ {
+ if( GetActiveWindow()->GetZoom() <= GetActiveWindow()->GetMinZoom() || GetDocSh()->IsUIActive() )
+ {
+ rSet.DisableItem( SID_ZOOM_OUT );
+ rSet.DisableItem( SID_ZOOM_PANNING );
+ }
+ if( GetActiveWindow()->GetZoom() >= GetActiveWindow()->GetMaxZoom() || GetDocSh()->IsUIActive() )
+ rSet.DisableItem( SID_ZOOM_IN );
+ }
+
+ if (!mpZoomList->IsNextPossible())
+ {
+ rSet.DisableItem(SID_ZOOM_NEXT);
+ }
+ if (!mpZoomList->IsPreviousPossible())
+ {
+ rSet.DisableItem(SID_ZOOM_PREV);
+ }
+
+ if( SfxItemState::DEFAULT == rSet.GetItemState( SID_REMOTE_DLG ) )
+ {
+
+ bool bDisableSdremoteForGood = false;
+#ifndef ENABLE_SDREMOTE
+ bDisableSdremoteForGood = true;
+#endif
+ bDisableSdremoteForGood |= ! ( /*officecfg::Office::Common::Misc::ExperimentalMode::get() &&*/
+ officecfg::Office::Impress::Misc::Start::EnableSdremote::get() );
+
+ // This dialog is only useful for TCP/IP remote control
+ // which is unusual, under-tested and a security issue.
+ if ( bDisableSdremoteForGood )
+ {
+ rSet.Put(SfxVisibilityItem(SID_REMOTE_DLG, false));
+ }
+ }
+
+ // EditText active
+ if (GetViewShellBase().GetViewShellManager()->GetShell(ToolbarId::Draw_Text_Toolbox_Sd) != nullptr)
+ {
+ sal_uInt16 nCurrentSId = SID_ATTR_CHAR;
+
+ if(HasCurrentFunction())
+ {
+ nCurrentSId = GetCurrentFunction()->GetSlotID();
+ }
+ if( nCurrentSId != SID_TEXT_FITTOSIZE &&
+ nCurrentSId != SID_TEXT_FITTOSIZE_VERTICAL &&
+ nCurrentSId != SID_ATTR_CHAR_VERTICAL )
+ nCurrentSId = SID_ATTR_CHAR;
+
+ rSet.Put( SfxBoolItem( nCurrentSId, true ) );
+ }
+
+ if ( GetDocSh()->IsReadOnly() )
+ {
+ rSet.DisableItem( SID_AUTOSPELL_CHECK );
+ }
+ else
+ {
+ if (GetDoc()->GetOnlineSpell())
+ {
+ rSet.Put(SfxBoolItem(SID_AUTOSPELL_CHECK, true));
+ }
+ else
+ {
+ rSet.Put(SfxBoolItem(SID_AUTOSPELL_CHECK, false));
+ }
+ }
+
+ SdrPageView* pPV = mpDrawView->GetSdrPageView();
+ OUString aActiveLayer = mpDrawView->GetActiveLayer();
+
+ if ( ( !aActiveLayer.isEmpty() && pPV && ( pPV->IsLayerLocked(aActiveLayer) ||
+ !pPV->IsLayerVisible(aActiveLayer) ) ) ||
+ SD_MOD()->GetWaterCan() )
+ {
+ rSet.DisableItem( SID_PASTE );
+ rSet.DisableItem( SID_PASTE_SPECIAL );
+ rSet.DisableItem( SID_PASTE_UNFORMATTED );
+ rSet.DisableItem( SID_CLIPBOARD_FORMAT_ITEMS );
+
+ rSet.DisableItem( SID_INSERT_FLD_DATE_FIX );
+ rSet.DisableItem( SID_INSERT_FLD_DATE_VAR );
+ rSet.DisableItem( SID_INSERT_FLD_TIME_FIX );
+ rSet.DisableItem( SID_INSERT_FLD_TIME_VAR );
+ rSet.DisableItem( SID_INSERT_FLD_AUTHOR );
+ rSet.DisableItem( SID_INSERT_FLD_PAGE );
+ rSet.DisableItem( SID_INSERT_FLD_PAGE_TITLE );
+ rSet.DisableItem( SID_INSERT_FLD_PAGES );
+ rSet.DisableItem( SID_INSERT_FLD_FILE );
+
+ rSet.DisableItem( SID_INSERT_GRAPHIC );
+ rSet.DisableItem( SID_INSERT_AVMEDIA );
+ rSet.DisableItem( SID_INSERT_DIAGRAM );
+ rSet.DisableItem( SID_INSERT_OBJECT );
+ rSet.DisableItem( SID_INSERT_FLOATINGFRAME );
+
+ rSet.DisableItem( SID_INSERT_MATH );
+ rSet.DisableItem( SID_INSERT_FRAME );
+ rSet.DisableItem( SID_INSERTFILE );
+ rSet.DisableItem( SID_ATTR_TABLE );
+ rSet.DisableItem( SID_COPYOBJECTS );
+
+ rSet.DisableItem( SID_SCAN );
+ rSet.DisableItem( SID_TWAIN_SELECT );
+ rSet.DisableItem( SID_TWAIN_TRANSFER );
+
+// rSet.DisableItem( SID_BEZIER_EDIT );
+ rSet.DisableItem( SID_GLUE_EDITMODE );
+ rSet.DisableItem( SID_OBJECT_ROTATE );
+ rSet.DisableItem( SID_OBJECT_SHEAR );
+ rSet.DisableItem( SID_OBJECT_MIRROR );
+ rSet.DisableItem( SID_OBJECT_CROP );
+ rSet.DisableItem( SID_ATTR_GRAF_CROP );
+ rSet.DisableItem( SID_OBJECT_TRANSPARENCE );
+ rSet.DisableItem( SID_OBJECT_GRADIENT );
+ rSet.DisableItem( SID_OBJECT_CROOK_ROTATE );
+ rSet.DisableItem( SID_OBJECT_CROOK_SLANT );
+ rSet.DisableItem( SID_OBJECT_CROOK_STRETCH );
+
+ // Disable all object-creating tools
+ rSet.ClearItem( SID_ATTR_CHAR );
+ rSet.DisableItem( SID_ATTR_CHAR );
+ rSet.ClearItem( SID_ATTR_CHAR_VERTICAL );
+ rSet.DisableItem( SID_ATTR_CHAR_VERTICAL );
+ rSet.ClearItem(SID_DRAW_LINE);
+ rSet.DisableItem(SID_DRAW_LINE);
+ rSet.ClearItem(SID_DRAW_MEASURELINE);
+ rSet.DisableItem(SID_DRAW_MEASURELINE);
+ rSet.ClearItem(SID_DRAW_XLINE);
+ rSet.DisableItem(SID_DRAW_XLINE);
+ rSet.ClearItem( SID_LINE_ARROW_START );
+ rSet.DisableItem( SID_LINE_ARROW_START );
+ rSet.ClearItem( SID_LINE_ARROW_END );
+ rSet.DisableItem( SID_LINE_ARROW_END );
+ rSet.ClearItem( SID_LINE_ARROWS );
+ rSet.DisableItem( SID_LINE_ARROWS );
+ rSet.ClearItem( SID_LINE_ARROW_CIRCLE );
+ rSet.DisableItem( SID_LINE_ARROW_CIRCLE );
+ rSet.ClearItem( SID_LINE_CIRCLE_ARROW );
+ rSet.DisableItem( SID_LINE_CIRCLE_ARROW );
+ rSet.ClearItem( SID_LINE_ARROW_SQUARE );
+ rSet.DisableItem( SID_LINE_ARROW_SQUARE );
+ rSet.ClearItem( SID_LINE_SQUARE_ARROW );
+ rSet.DisableItem( SID_LINE_SQUARE_ARROW );
+
+ rSet.ClearItem(SID_DRAW_RECT);
+ rSet.DisableItem(SID_DRAW_RECT);
+ rSet.ClearItem(SID_DRAW_RECT_NOFILL);
+ rSet.DisableItem(SID_DRAW_RECT_NOFILL);
+ rSet.ClearItem(SID_DRAW_RECT_ROUND);
+ rSet.DisableItem(SID_DRAW_RECT_ROUND);
+ rSet.ClearItem(SID_DRAW_RECT_ROUND_NOFILL);
+ rSet.DisableItem(SID_DRAW_RECT_ROUND_NOFILL);
+ rSet.ClearItem(SID_DRAW_SQUARE);
+ rSet.DisableItem(SID_DRAW_SQUARE);
+ rSet.ClearItem(SID_DRAW_SQUARE_NOFILL);
+ rSet.DisableItem(SID_DRAW_SQUARE_NOFILL);
+ rSet.ClearItem(SID_DRAW_SQUARE_ROUND);
+ rSet.DisableItem(SID_DRAW_SQUARE_ROUND);
+ rSet.ClearItem(SID_DRAW_SQUARE_ROUND_NOFILL);
+ rSet.DisableItem(SID_DRAW_SQUARE_ROUND_NOFILL);
+ rSet.ClearItem(SID_DRAW_ELLIPSE);
+ rSet.DisableItem(SID_DRAW_ELLIPSE);
+ rSet.ClearItem(SID_DRAW_ELLIPSE_NOFILL);
+ rSet.DisableItem(SID_DRAW_ELLIPSE_NOFILL);
+ rSet.ClearItem(SID_DRAW_CIRCLE);
+ rSet.DisableItem(SID_DRAW_CIRCLE);
+ rSet.ClearItem(SID_DRAW_CIRCLE_NOFILL);
+ rSet.DisableItem(SID_DRAW_CIRCLE_NOFILL);
+ rSet.ClearItem(SID_DRAW_CAPTION);
+ rSet.DisableItem(SID_DRAW_CAPTION);
+ rSet.ClearItem(SID_DRAW_FONTWORK);
+ rSet.DisableItem(SID_DRAW_FONTWORK);
+ rSet.ClearItem(SID_DRAW_FONTWORK_VERTICAL);
+ rSet.DisableItem(SID_DRAW_FONTWORK_VERTICAL);
+ rSet.ClearItem(SID_DRAW_CAPTION_VERTICAL);
+ rSet.DisableItem(SID_DRAW_CAPTION_VERTICAL);
+ rSet.ClearItem(SID_TEXT_FITTOSIZE);
+ rSet.DisableItem(SID_TEXT_FITTOSIZE);
+ rSet.ClearItem(SID_TEXT_FITTOSIZE_VERTICAL);
+ rSet.DisableItem(SID_TEXT_FITTOSIZE_VERTICAL);
+ rSet.ClearItem(SID_TOOL_CONNECTOR);
+ rSet.DisableItem(SID_TOOL_CONNECTOR);
+ rSet.ClearItem(SID_CONNECTOR_ARROW_START);
+ rSet.DisableItem(SID_CONNECTOR_ARROW_START);
+ rSet.ClearItem(SID_CONNECTOR_ARROW_END);
+ rSet.DisableItem(SID_CONNECTOR_ARROW_END);
+ rSet.ClearItem(SID_CONNECTOR_ARROWS);
+ rSet.DisableItem(SID_CONNECTOR_ARROWS);
+ rSet.ClearItem(SID_CONNECTOR_CIRCLE_START);
+ rSet.DisableItem(SID_CONNECTOR_CIRCLE_START);
+ rSet.ClearItem(SID_CONNECTOR_CIRCLE_END);
+ rSet.DisableItem(SID_CONNECTOR_CIRCLE_END);
+ rSet.ClearItem(SID_CONNECTOR_CIRCLES);
+ rSet.DisableItem(SID_CONNECTOR_CIRCLES);
+ rSet.ClearItem(SID_CONNECTOR_LINE);
+ rSet.DisableItem(SID_CONNECTOR_LINE);
+ rSet.ClearItem(SID_CONNECTOR_LINE_ARROW_START);
+ rSet.DisableItem(SID_CONNECTOR_LINE_ARROW_START);
+ rSet.ClearItem(SID_CONNECTOR_LINE_ARROW_END);
+ rSet.DisableItem(SID_CONNECTOR_LINE_ARROW_END);
+ rSet.ClearItem(SID_CONNECTOR_LINE_ARROWS);
+ rSet.DisableItem(SID_CONNECTOR_LINE_ARROWS);
+ rSet.ClearItem(SID_CONNECTOR_LINE_CIRCLE_START);
+ rSet.DisableItem(SID_CONNECTOR_LINE_CIRCLE_START);
+ rSet.ClearItem(SID_CONNECTOR_LINE_CIRCLE_END);
+ rSet.DisableItem(SID_CONNECTOR_LINE_CIRCLE_END);
+ rSet.ClearItem(SID_CONNECTOR_LINE_CIRCLES);
+ rSet.DisableItem(SID_CONNECTOR_LINE_CIRCLES);
+ rSet.ClearItem(SID_CONNECTOR_CURVE);
+ rSet.DisableItem(SID_CONNECTOR_CURVE);
+ rSet.ClearItem(SID_CONNECTOR_CURVE_ARROW_START);
+ rSet.DisableItem(SID_CONNECTOR_CURVE_ARROW_START);
+ rSet.ClearItem(SID_CONNECTOR_CURVE_ARROW_END);
+ rSet.DisableItem(SID_CONNECTOR_CURVE_ARROW_END);
+ rSet.ClearItem(SID_CONNECTOR_CURVE_ARROWS);
+ rSet.DisableItem(SID_CONNECTOR_CURVE_ARROWS);
+ rSet.ClearItem(SID_CONNECTOR_CURVE_CIRCLE_START);
+ rSet.DisableItem(SID_CONNECTOR_CURVE_CIRCLE_START);
+ rSet.ClearItem(SID_CONNECTOR_CURVE_CIRCLE_END);
+ rSet.DisableItem(SID_CONNECTOR_CURVE_CIRCLE_END);
+ rSet.ClearItem(SID_CONNECTOR_CURVE_CIRCLES);
+ rSet.DisableItem(SID_CONNECTOR_CURVE_CIRCLES);
+ rSet.ClearItem(SID_CONNECTOR_LINES);
+ rSet.DisableItem(SID_CONNECTOR_LINES);
+ rSet.ClearItem(SID_CONNECTOR_LINES_ARROW_START);
+ rSet.DisableItem(SID_CONNECTOR_LINES_ARROW_START);
+ rSet.ClearItem(SID_CONNECTOR_LINES_ARROW_END);
+ rSet.DisableItem(SID_CONNECTOR_LINES_ARROW_END);
+ rSet.ClearItem(SID_CONNECTOR_LINES_ARROWS);
+ rSet.DisableItem(SID_CONNECTOR_LINES_ARROWS);
+ rSet.ClearItem(SID_CONNECTOR_LINES_CIRCLE_START);
+ rSet.DisableItem(SID_CONNECTOR_LINES_CIRCLE_START);
+ rSet.ClearItem(SID_CONNECTOR_LINES_CIRCLE_END);
+ rSet.DisableItem(SID_CONNECTOR_LINES_CIRCLE_END);
+ rSet.ClearItem(SID_CONNECTOR_LINES_CIRCLES);
+ rSet.DisableItem(SID_CONNECTOR_LINES_CIRCLES);
+ rSet.ClearItem(SID_DRAW_ARC);
+ rSet.DisableItem(SID_DRAW_ARC);
+ rSet.ClearItem(SID_DRAW_CIRCLEARC);
+ rSet.DisableItem(SID_DRAW_CIRCLEARC);
+ rSet.ClearItem(SID_DRAW_PIE);
+ rSet.DisableItem(SID_DRAW_PIE);
+ rSet.ClearItem(SID_DRAW_PIE_NOFILL);
+ rSet.DisableItem(SID_DRAW_PIE_NOFILL);
+ rSet.ClearItem(SID_DRAW_CIRCLEPIE);
+ rSet.DisableItem(SID_DRAW_CIRCLEPIE);
+ rSet.ClearItem(SID_DRAW_CIRCLEPIE_NOFILL);
+ rSet.DisableItem(SID_DRAW_CIRCLEPIE_NOFILL);
+ rSet.ClearItem(SID_DRAW_ELLIPSECUT);
+ rSet.DisableItem(SID_DRAW_ELLIPSECUT);
+ rSet.ClearItem(SID_DRAW_ELLIPSECUT_NOFILL);
+ rSet.DisableItem(SID_DRAW_ELLIPSECUT_NOFILL);
+ rSet.ClearItem(SID_DRAW_CIRCLECUT);
+ rSet.DisableItem(SID_DRAW_CIRCLECUT);
+ rSet.ClearItem(SID_DRAW_CIRCLECUT_NOFILL);
+ rSet.DisableItem(SID_DRAW_CIRCLECUT_NOFILL);
+ rSet.ClearItem(SID_DRAW_POLYGON);
+ rSet.DisableItem(SID_DRAW_POLYGON);
+ rSet.ClearItem(SID_DRAW_POLYGON_NOFILL);
+ rSet.DisableItem(SID_DRAW_POLYGON_NOFILL);
+ rSet.ClearItem(SID_DRAW_FREELINE);
+ rSet.DisableItem(SID_DRAW_FREELINE);
+ rSet.ClearItem(SID_DRAW_FREELINE_NOFILL);
+ rSet.DisableItem(SID_DRAW_FREELINE_NOFILL);
+ rSet.ClearItem(SID_DRAW_XPOLYGON);
+ rSet.DisableItem(SID_DRAW_XPOLYGON);
+ rSet.ClearItem(SID_DRAW_XPOLYGON_NOFILL);
+ rSet.DisableItem(SID_DRAW_XPOLYGON_NOFILL);
+ rSet.ClearItem(SID_DRAW_BEZIER_FILL);
+ rSet.DisableItem(SID_DRAW_BEZIER_FILL);
+ rSet.ClearItem(SID_DRAW_BEZIER_NOFILL);
+ rSet.DisableItem(SID_DRAW_BEZIER_NOFILL);
+ rSet.ClearItem(SID_3D_CUBE);
+ rSet.DisableItem(SID_3D_CUBE);
+ rSet.ClearItem(SID_3D_SHELL);
+ rSet.DisableItem(SID_3D_SHELL);
+ rSet.ClearItem(SID_3D_SPHERE);
+ rSet.DisableItem(SID_3D_SPHERE);
+ rSet.ClearItem(SID_3D_HALF_SPHERE);
+ rSet.DisableItem(SID_3D_HALF_SPHERE);
+ rSet.ClearItem(SID_3D_CYLINDER);
+ rSet.DisableItem(SID_3D_CYLINDER);
+ rSet.ClearItem(SID_3D_CONE);
+ rSet.DisableItem(SID_3D_CONE);
+ rSet.ClearItem(SID_3D_TORUS);
+ rSet.DisableItem(SID_3D_TORUS);
+ rSet.ClearItem(SID_3D_PYRAMID);
+ rSet.DisableItem(SID_3D_PYRAMID);
+ }
+
+ // are the modules available?
+
+ if (!SvtModuleOptions().IsCalc())
+ {
+ // remove menu entry if module is not available
+ rSet.Put( SfxVisibilityItem( SID_ATTR_TABLE, false ) );
+ }
+ if (!SvtModuleOptions().IsChart())
+ {
+ rSet.DisableItem( SID_INSERT_DIAGRAM );
+ }
+ if (!SvtModuleOptions().IsMath())
+ {
+ rSet.DisableItem( SID_INSERT_MATH );
+ }
+
+ rtl::Reference< sd::SlideShow > xSlideshow( SlideShow::GetSlideShow( GetViewShellBase() ) );
+ if( (xSlideshow.is() && xSlideshow->isRunning() && (xSlideshow->getAnimationMode() != ANIMATIONMODE_PREVIEW) ) || GetDocSh()->IsPreview() )
+ {
+ // Own Slots
+ rSet.DisableItem( SID_PRESENTATION );
+ rSet.DisableItem( SID_ZOOM_IN );
+ rSet.DisableItem( SID_ZOOM_OUT );
+ rSet.DisableItem( SID_ZOOM_PANNING );
+ rSet.DisableItem( SID_ZOOM_MODE );
+ rSet.DisableItem( SID_ZOOM_NEXT );
+ rSet.DisableItem( SID_ZOOM_PREV );
+ rSet.DisableItem( SID_SIZE_REAL );
+ rSet.DisableItem( SID_SIZE_OPTIMAL );
+ rSet.DisableItem( SID_SIZE_ALL );
+ rSet.DisableItem( SID_SIZE_PAGE_WIDTH );
+ rSet.DisableItem( SID_SIZE_PAGE );
+ rSet.DisableItem( SID_INSERTPAGE );
+ rSet.DisableItem( SID_DUPLICATE_PAGE );
+ rSet.DisableItem( SID_MODIFYPAGE );
+ rSet.DisableItem( SID_RENAMEPAGE );
+ rSet.DisableItem( SID_RENAMEPAGE_QUICK );
+ rSet.DisableItem( SID_DELETE_PAGE );
+ rSet.DisableItem( SID_PAGESETUP );
+
+ if( xSlideshow.is() && xSlideshow->isRunning() )
+ {
+ rSet.ClearItem(SID_INSERTFILE);
+ rSet.ClearItem(SID_OBJECT_ROTATE);
+ rSet.ClearItem(SID_FM_CONFIG);
+ rSet.ClearItem(SID_ANIMATION_EFFECTS);
+ rSet.ClearItem(SID_EXECUTE_ANIMATION_EFFECT);
+ rSet.ClearItem(SID_ANIMATION_OBJECTS);
+ rSet.ClearItem(SID_3D_WIN);
+
+ rSet.DisableItem(SID_OBJECT_ALIGN);
+ rSet.DisableItem(SID_ZOOM_TOOLBOX);
+ rSet.DisableItem(SID_OBJECT_CHOOSE_MODE);
+ rSet.DisableItem(SID_DRAWTBX_TEXT);
+ rSet.DisableItem(SID_DRAWTBX_RECTANGLES);
+ rSet.DisableItem(SID_DRAWTBX_ELLIPSES);
+ rSet.DisableItem(SID_DRAWTBX_LINES);
+ rSet.DisableItem(SID_DRAWTBX_ARROWS);
+ rSet.DisableItem(SID_DRAWTBX_3D_OBJECTS);
+ rSet.DisableItem(SID_DRAWTBX_CONNECTORS);
+ rSet.DisableItem(SID_OBJECT_CHOOSE_MODE );
+ rSet.DisableItem(SID_DRAWTBX_INSERT);
+ rSet.DisableItem(SID_INSERTFILE);
+ rSet.DisableItem(SID_OBJECT_ROTATE);
+ rSet.DisableItem(SID_POSITION);
+ rSet.DisableItem(SID_FM_CONFIG);
+ rSet.DisableItem(SID_ANIMATION_EFFECTS);
+ rSet.DisableItem(SID_EXECUTE_ANIMATION_EFFECT);
+ rSet.DisableItem(SID_ANIMATION_OBJECTS);
+ rSet.DisableItem(SID_3D_WIN);
+ }
+ }
+
+ // Menuoption: Change->Convert->To Bitmap, Change->Convert->To Metafile
+ // disable, if there only Bitmap or Metafiles marked
+ // Menuoption: Format->Area, Format->Line
+ // disabled, if the marked objects not able to handle
+ // these attributes
+
+ bool bSingleGraphicSelected = false;
+
+ if (!mpDrawView->AreObjectsMarked())
+ {
+ rSet.DisableItem (SID_CONVERT_TO_METAFILE);
+ rSet.DisableItem (SID_CONVERT_TO_BITMAP);
+ }
+ else
+ {
+ // get marklist
+ SdrMarkList aMarkList = mpDrawView->GetMarkedObjectList();
+
+ bool bFoundBitmap = false;
+ bool bFoundMetafile = false;
+ bool bFoundObjNoArea = false;
+ bool bFoundNoGraphicObj = false;
+ bool bFoundAny = false;
+ bool bFoundTable = false;
+
+// const size_t nMarkCount = aMarkList.GetMarkCount();
+ for (size_t i=0; i < nMarkCount && !bFoundAny; ++i)
+ {
+ SdrObject* pObj = aMarkList.GetMark(i)->GetMarkedSdrObj();
+ SdrObjKind nId = pObj->GetObjIdentifier();
+ SdrInventor nInv = pObj->GetObjInventor();
+
+ if(nInv == SdrInventor::Default)
+ {
+ // 2D objects
+ switch( nId )
+ {
+ case SdrObjKind::PathLine :
+ case SdrObjKind::PolyLine :
+ case SdrObjKind::Line:
+ case SdrObjKind::FreehandLine :
+ case SdrObjKind::Edge:
+ case SdrObjKind::CircleArc :
+ bFoundObjNoArea = true;
+ bFoundNoGraphicObj = true;
+ break;
+ case SdrObjKind::OLE2 :
+ // #i118485# #i118525# Allow Line, Area and Graphic (Metafile, Bitmap)
+ bSingleGraphicSelected = nMarkCount == 1;
+ bFoundBitmap = true;
+ bFoundMetafile = true;
+ break;
+ case SdrObjKind::Graphic :
+ {
+ bSingleGraphicSelected = nMarkCount == 1;
+ const SdrGrafObj* pSdrGrafObj = static_cast< const SdrGrafObj* >(pObj);
+
+ // Current size of the OBJ_GRAF
+ const ::tools::Rectangle aRect = pObj->GetLogicRect();
+ const Size aCurrentSizeofObj = aRect.GetSize();
+
+ // Original size of the OBJ_GRAF
+ const Size aOriginalSizeofObj = pSdrGrafObj->getOriginalSize();
+
+ if(aCurrentSizeofObj == aOriginalSizeofObj )
+ rSet.DisableItem(SID_ORIGINAL_SIZE);
+
+ switch(pSdrGrafObj->GetGraphicType())
+ {
+ case GraphicType::Bitmap :
+ bFoundBitmap = true;
+ if(pSdrGrafObj->isEmbeddedVectorGraphicData())
+ {
+ bFoundMetafile = true;
+ }
+ break;
+ case GraphicType::GdiMetafile :
+ bFoundMetafile = true;
+ break;
+ default:
+ break;
+ }
+ break;
+ }
+ case SdrObjKind::Table:
+ bFoundTable = true;
+ break;
+ default :
+ bFoundAny = true;
+ }
+ }
+ else if(nInv == SdrInventor::E3d)
+ {
+ // 3D objects
+ bFoundAny = true;
+ }
+ }
+
+ if( bFoundTable )
+ rSet.DisableItem( SID_ATTRIBUTES_LINE );
+
+ if (!bFoundAny)
+ {
+ // Disable menuitem for area-dialog
+ if( bFoundObjNoArea ) // #i25616#
+ rSet.DisableItem( SID_ATTRIBUTES_AREA );
+
+ if( bFoundBitmap && !bFoundMetafile && !bFoundNoGraphicObj ) // only Bitmaps marked
+ rSet.DisableItem( SID_CONVERT_TO_BITMAP );
+ else if( !bFoundBitmap && bFoundMetafile && !bFoundNoGraphicObj ) // only Metafiles marked
+ rSet.DisableItem( SID_CONVERT_TO_METAFILE );
+ else if( !bFoundBitmap && !bFoundMetafile && !bFoundNoGraphicObj ) // nothing to do
+ {
+ rSet.DisableItem( SID_CONVERT_TO_BITMAP );
+ rSet.DisableItem( SID_CONVERT_TO_METAFILE );
+ }
+ }
+ }
+
+ if( !bSingleGraphicSelected )
+ {
+ rSet.DisableItem (SID_OBJECT_CROP);
+ rSet.DisableItem (SID_ATTR_GRAF_CROP);
+ }
+
+ // Menuoption: Edit->Hyperlink
+ // Disable, if there is no hyperlink
+ bool bDisableEditHyperlink;
+ if (!moAtContextMenu_DisableEditHyperlink)
+ bDisableEditHyperlink = ShouldDisableEditHyperlink();
+ else
+ {
+ // tdf#137445 if a popup menu was active, use the state as of when the popup was launched and then drop
+ // moAtContextMenu_DisableEditHyperlink
+ bDisableEditHyperlink = *moAtContextMenu_DisableEditHyperlink;
+ moAtContextMenu_DisableEditHyperlink.reset();
+ }
+
+ //highlight selected custom shape
+ {
+ if(HasCurrentFunction())
+ {
+ rtl::Reference< FuPoor > xFunc( GetCurrentFunction() );
+ FuConstructCustomShape* pShapeFunc = dynamic_cast< FuConstructCustomShape* >( xFunc.get() );
+
+ static const sal_uInt16 nCSTbArray[] = { SID_DRAWTBX_CS_BASIC, SID_DRAWTBX_CS_SYMBOL,
+ SID_DRAWTBX_CS_ARROW, SID_DRAWTBX_CS_FLOWCHART,
+ SID_DRAWTBX_CS_CALLOUT, SID_DRAWTBX_CS_STAR };
+
+ const sal_uInt16 nCurrentSId = GetCurrentFunction()->GetSlotID();
+ for (sal_uInt16 i : nCSTbArray)
+ {
+ rSet.ClearItem( i ); // Why is this necessary?
+ rSet.Put( SfxStringItem( i, nCurrentSId == i && pShapeFunc
+ ? pShapeFunc->GetShapeType() : OUString() ) );
+ }
+ }
+ }
+
+ if ( bDisableEditHyperlink || GetDocSh()->IsReadOnly() )
+ rSet.DisableItem( SID_EDIT_HYPERLINK );
+
+ if ( bDisableEditHyperlink )
+ {
+ rSet.DisableItem( SID_OPEN_HYPERLINK );
+ rSet.DisableItem( SID_COPY_HYPERLINK_LOCATION );
+ }
+
+ //fdo#78151 enable show next level/hide last level if editing a master page
+ //PresObjKind::Outline object and the current selection allow that to happen
+ {
+ bool bDisableShowNextLevel = true;
+ bool bDisableHideLastLevel = true;
+
+ ESelection aSel;
+ ::Outliner* pOL = GetOutlinerForMasterPageOutlineTextObj(aSel);
+ if (pOL)
+ {
+ //and are on the last paragraph
+ aSel.Adjust();
+ if (aSel.nEndPara == pOL->GetParagraphCount() - 1)
+ {
+ sal_uInt16 nDepth = pOL->GetDepth(aSel.nEndPara);
+ if (nDepth != sal_uInt16(-1))
+ {
+ //there exists another numbering level that
+ //is currently hidden
+ if (nDepth < 8)
+ bDisableShowNextLevel = false;
+ //there exists a previous numbering level
+ if (nDepth > 0)
+ bDisableHideLastLevel = false;
+ }
+ }
+ }
+
+ if (bDisableShowNextLevel)
+ rSet.DisableItem(SID_SHOW_NEXT_LEVEL);
+
+ if (bDisableHideLastLevel)
+ rSet.DisableItem(SID_HIDE_LAST_LEVEL);
+ }
+
+#if defined(_WIN32) || defined UNX
+ if( !mxScannerManager.is() )
+ {
+ rSet.DisableItem( SID_TWAIN_SELECT );
+ rSet.DisableItem( SID_TWAIN_TRANSFER );
+ }
+#endif
+
+ // Set the state of two entries in the 'Slide' context sub-menu
+ // concerning the visibility of master page background and master page
+ // shapes.
+ if (rSet.GetItemState(SID_DISPLAY_MASTER_BACKGROUND) == SfxItemState::DEFAULT
+ || rSet.GetItemState(SID_DISPLAY_MASTER_OBJECTS) == SfxItemState::DEFAULT)
+ {
+ SdPage* pPage = GetActualPage();
+ if (pPage != nullptr && GetDoc() != nullptr)
+ {
+ SdrLayerIDSet aVisibleLayers = pPage->TRG_GetMasterPageVisibleLayers();
+ SdrLayerAdmin& rLayerAdmin = GetDoc()->GetLayerAdmin();
+ SdrLayerID aBackgroundId = rLayerAdmin.GetLayerID(sUNO_LayerName_background);
+ SdrLayerID aObjectId = rLayerAdmin.GetLayerID(sUNO_LayerName_background_objects);
+ rSet.Put(SfxBoolItem(SID_DISPLAY_MASTER_BACKGROUND,
+ aVisibleLayers.IsSet(aBackgroundId)));
+ rSet.Put(SfxBoolItem(SID_DISPLAY_MASTER_OBJECTS,
+ aVisibleLayers.IsSet(aObjectId)));
+ }
+ }
+
+ if (rSet.GetItemState(SID_SAVE_BACKGROUND) == SfxItemState::DEFAULT)
+ {
+ bool bDisableSaveBackground = true;
+ SdPage* pPage = GetActualPage();
+ if (pPage != nullptr && GetDoc() != nullptr)
+ {
+ SfxItemSetFixed<XATTR_FILL_FIRST, XATTR_FILL_LAST> aMergedAttr(GetDoc()->GetPool());
+ SdStyleSheet* pStyleSheet = pPage->getPresentationStyle(HID_PSEUDOSHEET_BACKGROUND);
+ MergePageBackgroundFilling(pPage, pStyleSheet, meEditMode == EditMode::MasterPage, aMergedAttr);
+ if (drawing::FillStyle_BITMAP == aMergedAttr.Get(XATTR_FILLSTYLE).GetValue())
+ {
+ bDisableSaveBackground = false;
+ }
+ }
+ if (bDisableSaveBackground)
+ rSet.DisableItem(SID_SAVE_BACKGROUND);
+ }
+
+ if (GetObjectShell()->isExportLocked())
+ rSet.DisableItem(SID_PRESENTATION_MINIMIZER);
+
+ if (rSet.GetItemState(SID_INSERT_SIGNATURELINE) == SfxItemState::DEFAULT)
+ {
+ if (!GetObjectShell()->IsSignPDF())
+ {
+ // Currently SID_INSERT_SIGNATURELINE assumes a PDF that was opened for signing, disable
+ // it otherwise.
+ rSet.DisableItem(SID_INSERT_SIGNATURELINE);
+ }
+ }
+
+ GetModeSwitchingMenuState (rSet);
+}
+
+void DrawViewShell::GetModeSwitchingMenuState (SfxItemSet &rSet)
+{
+ //DrawView
+ rSet.Put(SfxBoolItem(SID_SLIDE_SORTER_MODE, false));
+ rSet.Put(SfxBoolItem(SID_OUTLINE_MODE, false));
+ rSet.Put(SfxBoolItem(SID_SLIDE_MASTER_MODE, false));
+ rSet.Put(SfxBoolItem(SID_NOTES_MASTER_MODE, false));
+ if (mePageKind == PageKind::Notes)
+ {
+ rSet.Put(SfxBoolItem(SID_DRAWINGMODE, false));
+ rSet.Put(SfxBoolItem(SID_NOTES_MODE, true));
+ rSet.Put(SfxBoolItem(SID_HANDOUT_MASTER_MODE, false));
+ }
+ else if (mePageKind == PageKind::Handout)
+ {
+ rSet.Put(SfxBoolItem(SID_DRAWINGMODE, false));
+ rSet.Put(SfxBoolItem(SID_NOTES_MODE, false));
+ rSet.Put(SfxBoolItem(SID_HANDOUT_MASTER_MODE, true));
+ }
+ else
+ {
+ rSet.Put(SfxBoolItem(SID_DRAWINGMODE, true));
+ rSet.Put(SfxBoolItem(SID_NOTES_MODE, false));
+ rSet.Put(SfxBoolItem(SID_HANDOUT_MASTER_MODE, false));
+ }
+
+ // Removed [GetDocSh()->GetCurrentFunction() ||] from the following
+ // clause because the current function of the docshell can only be
+ // search and replace or spell checking and in that case switching the
+ // view mode is allowed.
+ const bool bIsRunning = SlideShow::IsRunning(GetViewShellBase());
+
+ if (GetViewFrame()->GetFrame().IsInPlace() || bIsRunning)
+ {
+ if ( !GetViewFrame()->GetFrame().IsInPlace() )
+ {
+ rSet.ClearItem( SID_DRAWINGMODE );
+ rSet.DisableItem( SID_DRAWINGMODE );
+ }
+
+ rSet.ClearItem( SID_NOTES_MODE );
+ rSet.DisableItem( SID_NOTES_MODE );
+
+ rSet.ClearItem( SID_HANDOUT_MASTER_MODE );
+ rSet.DisableItem( SID_HANDOUT_MASTER_MODE );
+
+ rSet.ClearItem( SID_OUTLINE_MODE );
+ rSet.DisableItem( SID_OUTLINE_MODE );
+
+ rSet.ClearItem( SID_SLIDE_MASTER_MODE );
+ rSet.DisableItem( SID_SLIDE_MASTER_MODE );
+
+ rSet.ClearItem( SID_NOTES_MASTER_MODE );
+ rSet.DisableItem( SID_NOTES_MASTER_MODE );
+
+ rSet.ClearItem( SID_SLIDE_SORTER_MODE );
+ rSet.DisableItem( SID_SLIDE_SORTER_MODE );
+ }
+
+ if (GetDocSh()->GetCreateMode() == SfxObjectCreateMode::EMBEDDED)
+ {
+ // Outplace-Edit: do not allow switch
+ rSet.ClearItem( SID_OUTLINE_MODE );
+ rSet.DisableItem( SID_OUTLINE_MODE );
+
+ rSet.ClearItem( SID_SLIDE_SORTER_MODE );
+ rSet.DisableItem( SID_SLIDE_SORTER_MODE );
+
+ rSet.ClearItem( SID_NOTES_MODE );
+ rSet.DisableItem( SID_NOTES_MODE );
+
+ rSet.ClearItem( SID_HANDOUT_MASTER_MODE );
+ rSet.DisableItem( SID_HANDOUT_MASTER_MODE );
+
+ rSet.ClearItem( SID_SLIDE_MASTER_MODE );
+ rSet.DisableItem( SID_SLIDE_MASTER_MODE );
+
+ rSet.ClearItem( SID_NOTES_MASTER_MODE );
+ rSet.DisableItem( SID_NOTES_MASTER_MODE );
+ }
+
+ svx::ExtrusionBar::getState( mpDrawView.get(), rSet );
+ svx::FontworkBar::getState( mpDrawView.get(), rSet );
+}
+
+void DrawViewShell::GetPageProperties( SfxItemSet &rSet )
+{
+ SdPage *pPage = getCurrentPage();
+
+ if (pPage == nullptr || GetDoc() == nullptr)
+ return;
+
+ SvxPageItem aPageItem(SID_ATTR_PAGE);
+ aPageItem.SetLandscape( pPage->GetOrientation() == Orientation::Landscape );
+
+ rSet.Put(SvxSizeItem( SID_ATTR_PAGE_SIZE, pPage->GetSize() ));
+ rSet.Put(aPageItem);
+
+ const SfxItemSet &rPageAttr = pPage->getSdrPageProperties().GetItemSet();
+ const XFillStyleItem* pFillStyle = rPageAttr.GetItem(XATTR_FILLSTYLE);
+ if (!pFillStyle)
+ return;
+
+ drawing::FillStyle eXFS = pFillStyle->GetValue();
+ XFillStyleItem aFillStyleItem( eXFS );
+ aFillStyleItem.SetWhich( SID_ATTR_PAGE_FILLSTYLE );
+ rSet.Put(aFillStyleItem);
+
+ switch (eXFS)
+ {
+ case drawing::FillStyle_SOLID:
+ if (const XFillColorItem* pColorItem = rPageAttr.GetItem(XATTR_FILLCOLOR))
+ {
+ Color aColor = pColorItem->GetColorValue();
+ XFillColorItem aFillColorItem( OUString(), aColor );
+ aFillColorItem.SetWhich( SID_ATTR_PAGE_COLOR );
+ rSet.Put( aFillColorItem );
+ }
+ break;
+
+ case drawing::FillStyle_GRADIENT:
+ {
+ const XFillGradientItem *pGradient = rPageAttr.GetItem( XATTR_FILLGRADIENT );
+ XFillGradientItem aFillGradientItem( pGradient->GetName(), pGradient->GetGradientValue(), SID_ATTR_PAGE_GRADIENT );
+ rSet.Put( aFillGradientItem );
+ }
+ break;
+
+ case drawing::FillStyle_HATCH:
+ {
+ const XFillHatchItem *pFillHatchItem( rPageAttr.GetItem( XATTR_FILLHATCH ) );
+ XFillHatchItem aFillHatchItem( pFillHatchItem->GetName(), pFillHatchItem->GetHatchValue());
+ aFillHatchItem.SetWhich( SID_ATTR_PAGE_HATCH );
+ rSet.Put( aFillHatchItem );
+ }
+ break;
+
+ case drawing::FillStyle_BITMAP:
+ {
+ const XFillBitmapItem *pFillBitmapItem = rPageAttr.GetItem( XATTR_FILLBITMAP );
+ XFillBitmapItem aFillBitmapItem( pFillBitmapItem->GetName(), pFillBitmapItem->GetGraphicObject() );
+ aFillBitmapItem.SetWhich( SID_ATTR_PAGE_BITMAP );
+ rSet.Put( aFillBitmapItem );
+ }
+ break;
+
+ default:
+ break;
+ }
+}
+
+void DrawViewShell::SetPageProperties (SfxRequest& rReq)
+{
+ SdPage *pPage = getCurrentPage();
+ if (!pPage)
+ return;
+ sal_uInt16 nSlotId = rReq.GetSlot();
+ const SfxItemSet *pArgs = rReq.GetArgs();
+ if (!pArgs)
+ return;
+
+ if ( ( nSlotId >= SID_ATTR_PAGE_COLOR ) && ( nSlotId <= SID_ATTR_PAGE_FILLSTYLE ) )
+ {
+ SdrPageProperties& rPageProperties = pPage->getSdrPageProperties();
+ const SfxItemSet &aPageItemSet = rPageProperties.GetItemSet();
+ SfxItemSet aTempSet = aPageItemSet.CloneAsValue(false, &mpDrawView->GetModel()->GetItemPool());
+ const SfxPoolItem* pItem = nullptr;
+
+ rPageProperties.ClearItem(XATTR_FILLSTYLE);
+ rPageProperties.ClearItem(XATTR_FILLGRADIENT);
+ rPageProperties.ClearItem(XATTR_FILLHATCH);
+ rPageProperties.ClearItem(XATTR_FILLBITMAP);
+
+ switch (nSlotId)
+ {
+ case SID_ATTR_PAGE_FILLSTYLE:
+ {
+ XFillStyleItem aFSItem( pArgs->Get( XATTR_FILLSTYLE ) );
+ drawing::FillStyle eXFS = aFSItem.GetValue();
+
+ if ( eXFS == drawing::FillStyle_NONE )
+ rPageProperties.PutItem( XFillStyleItem( eXFS ) );
+ }
+ break;
+
+ case SID_ATTR_PAGE_COLOR:
+ {
+ if (SfxItemState::SET == pArgs->GetItemState(SID_ATTR_COLOR_STR, false, &pItem))
+ {
+ Color aColor;
+ OUString sColor;
+
+ sColor = static_cast<const SfxStringItem*>(pItem)->GetValue();
+
+ if (sColor == "transparent")
+ aColor = COL_TRANSPARENT;
+ else
+ aColor = Color(ColorTransparency, sColor.toInt32(16));
+
+ XFillColorItem aColorItem(OUString(), aColor);
+ rPageProperties.PutItem( XFillStyleItem( drawing::FillStyle_SOLID ) );
+ rPageProperties.PutItem( aColorItem );
+ }
+ else
+ {
+ XFillColorItem aColorItem( pArgs->Get( XATTR_FILLCOLOR ) );
+ rPageProperties.PutItem( XFillStyleItem( drawing::FillStyle_SOLID ) );
+ rPageProperties.PutItem( aColorItem );
+ }
+ }
+ break;
+
+ case SID_ATTR_PAGE_GRADIENT:
+ {
+ if (SfxItemState::SET == pArgs->GetItemState(SID_FILL_GRADIENT_JSON, false, &pItem))
+ {
+ const SfxStringItem* pJSON = static_cast<const SfxStringItem*>(pItem);
+ XFillGradientItem aGradientItem( XGradient::fromJSON(pJSON->GetValue()) );
+
+ // MigrateItemSet guarantees unique gradient names
+ SfxItemSetFixed<XATTR_FILLGRADIENT, XATTR_FILLGRADIENT> aMigrateSet( mpDrawView->GetModel()->GetItemPool() );
+ aMigrateSet.Put( aGradientItem );
+ SdrModel::MigrateItemSet( &aMigrateSet, &aTempSet, mpDrawView->GetModel() );
+
+ rPageProperties.PutItem( XFillStyleItem( drawing::FillStyle_GRADIENT ) );
+ rPageProperties.PutItemSet( aTempSet );
+ }
+ else
+ {
+ XFillGradientItem aGradientItem( pArgs->Get( XATTR_FILLGRADIENT ) );
+
+ // MigrateItemSet guarantees unique gradient names
+ SfxItemSetFixed<XATTR_FILLGRADIENT, XATTR_FILLGRADIENT> aMigrateSet( mpDrawView->GetModel()->GetItemPool() );
+ aMigrateSet.Put( aGradientItem );
+ SdrModel::MigrateItemSet( &aMigrateSet, &aTempSet, mpDrawView->GetModel() );
+
+ rPageProperties.PutItem( XFillStyleItem( drawing::FillStyle_GRADIENT ) );
+ rPageProperties.PutItemSet( aTempSet );
+ }
+ }
+ break;
+
+ case SID_ATTR_PAGE_HATCH:
+ {
+ XFillHatchItem aHatchItem( pArgs->Get( XATTR_FILLHATCH ) );
+ rPageProperties.PutItem( XFillStyleItem( drawing::FillStyle_HATCH ) );
+ rPageProperties.PutItem( aHatchItem );
+ }
+ break;
+
+ case SID_ATTR_PAGE_BITMAP:
+ {
+ XFillBitmapItem aBitmapItem( pArgs->Get( XATTR_FILLBITMAP ) );
+ rPageProperties.PutItem( XFillStyleItem( drawing::FillStyle_BITMAP ) );
+ rPageProperties.PutItem( aBitmapItem );
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ rReq.Done();
+ }
+ else
+ {
+ PageKind ePageKind = GetPageKind();
+ const SfxPoolItem* pPoolItem = nullptr;
+ Size aNewSize(pPage->GetSize());
+ sal_Int32 nLeft = -1, nRight = -1, nUpper = -1, nLower = -1;
+ bool bScaleAll = true;
+ Orientation eOrientation = pPage->GetOrientation();
+ SdPage* pMasterPage = pPage->IsMasterPage() ? pPage : &static_cast<SdPage&>(pPage->TRG_GetMasterPage());
+ bool bFullSize = pMasterPage->IsBackgroundFullSize();
+ sal_uInt16 nPaperBin = pPage->GetPaperBin();
+
+ switch (nSlotId)
+ {
+ case SID_ATTR_PAGE_LRSPACE:
+ if( pArgs->GetItemState(SID_ATTR_PAGE_LRSPACE,
+ true,&pPoolItem) == SfxItemState::SET )
+ {
+ nLeft = static_cast<const SvxLongLRSpaceItem*>(pPoolItem)->GetLeft();
+ nRight = static_cast<const SvxLongLRSpaceItem*>(pPoolItem)->GetRight();
+ if (nLeft != -1)
+ {
+ nUpper = pPage->GetUpperBorder();
+ nLower = pPage->GetLowerBorder();
+ }
+ SetPageSizeAndBorder(ePageKind, aNewSize, nLeft, nRight, nUpper, nLower, bScaleAll, eOrientation, nPaperBin, bFullSize );
+ }
+ break;
+
+ case SID_ATTR_PAGE_ULSPACE:
+ if( pArgs->GetItemState(SID_ATTR_PAGE_ULSPACE,
+ true,&pPoolItem) == SfxItemState::SET )
+ {
+ nUpper = static_cast<const SvxLongULSpaceItem*>(pPoolItem)->GetUpper();
+ nLower = static_cast<const SvxLongULSpaceItem*>(pPoolItem)->GetLower();
+ if (nUpper != -1)
+ {
+ nLeft = pPage->GetLeftBorder();
+ nRight = pPage->GetRightBorder();
+ }
+ SetPageSizeAndBorder(ePageKind, aNewSize, nLeft, nRight, nUpper, nLower, bScaleAll, eOrientation, nPaperBin, bFullSize );
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+}
+
+void DrawViewShell::GetState (SfxItemSet& rSet)
+{
+ // Iterate over all requested items in the set.
+ SfxWhichIter aIter( rSet );
+ sal_uInt16 nWhich = aIter.FirstWhich();
+ while (nWhich)
+ {
+ switch (nWhich)
+ {
+ case SID_SEARCH_ITEM:
+ case SID_SEARCH_OPTIONS:
+ // Forward this request to the common (old) code of the
+ // document shell.
+ GetDocSh()->GetState (rSet);
+ break;
+ default:
+ SAL_WARN("sd", "DrawViewShell::GetState(): can not handle which id " << nWhich);
+ break;
+ }
+ nWhich = aIter.NextWhich();
+ }
+}
+
+void DrawViewShell::Execute (SfxRequest& rReq)
+{
+ if(SlideShow::IsRunning(GetViewShellBase()))
+ {
+ // Do not execute anything during a native slide show.
+ return;
+ }
+
+ switch (rReq.GetSlot())
+ {
+ case SID_SEARCH_ITEM:
+ // Forward this request to the common (old) code of the
+ // document shell.
+ GetDocSh()->Execute (rReq);
+ break;
+
+ case SID_SPELL_DIALOG:
+ {
+ SfxViewFrame* pViewFrame = GetViewFrame();
+ if (rReq.GetArgs() != nullptr)
+ pViewFrame->SetChildWindow (SID_SPELL_DIALOG,
+ static_cast<const SfxBoolItem&>(rReq.GetArgs()->
+ Get(SID_SPELL_DIALOG)).GetValue());
+ else
+ pViewFrame->ToggleChildWindow(SID_SPELL_DIALOG);
+
+ pViewFrame->GetBindings().Invalidate(SID_SPELL_DIALOG);
+ rReq.Ignore ();
+ }
+ break;
+
+ default:
+ SAL_WARN("sd", "DrawViewShell::Execute(): can not handle slot " << rReq.GetSlot());
+ break;
+ }
+}
+
+} // end of namespace sd
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */