diff options
Diffstat (limited to '')
| -rw-r--r-- | sd/source/ui/view/drviews7.cxx | 1991 |
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: */ |