/* -*- 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 <config_features.h>
#include <ViewShellImplementation.hxx>
#include <sdpage.hxx>
#include <drawdoc.hxx>
#include <sdresid.hxx>
#include <unokywds.hxx>
#include <strings.hrc>
#include <app.hrc>
#include <unmodpg.hxx>
#include <DrawDocShell.hxx>
#include <FactoryIds.hxx>
#include <ViewShellBase.hxx>
#include <sfx2/bindings.hxx>
#include <sfx2/dispatch.hxx>
#include <sfx2/request.hxx>
#include <sfx2/sfxsids.hrc>
#include <sfx2/viewfrm.hxx>
#include <sfx2/sidebar/Sidebar.hxx>
#include <svl/intitem.hxx>
#include <svl/stritem.hxx>
#include <svx/imapdlg.hxx>
#include <basic/sbstar.hxx>
#include <basic/sberrors.hxx>
#include <xmloff/autolayout.hxx>
#include <vcl/svapp.hxx>
#include <undo/undoobjects.hxx>
#include <com/sun/star/drawing/framework/XControllerManager.hpp>
namespace sd {
ViewShell::Implementation::Implementation (ViewShell& rViewShell)
: mbIsMainViewShell(
false),
mbIsInitialized(
false),
mbArrangeActive(
false),
mrViewShell(rViewShell)
{
}
ViewShell::Implementation::~Implementation() COVERITY_NOEXCEPT_FALSE
{
if ( ! mpUpdateLockForMouse.expired())
{
std::shared_ptr<ToolBarManagerLock> pLock(mpUpdateLockForMouse);
if (pLock != nullptr)
{
// Force the ToolBarManagerLock to be released even when the
// IsUICaptured() returns <TRUE/>.
pLock->Release(
true);
}
}
}
void ViewShell::Implementation::ProcessModifyPageSlot (
SfxRequest& rRequest,
SdPage* pCurrentPage,
PageKind ePageKind)
{
SdDrawDocument* pDocument = mrViewShell.GetDoc();
SdrLayerAdmin& rLayerAdmin = pDocument->GetLayerAdmin();
SdrLayerIDSet aVisibleLayers;
bool bHandoutMode =
false;
SdPage* pHandoutMPage = nullptr;
OUString aNewName;
AutoLayout aNewAutoLayout;
bool bBVisible;
bool bBObjsVisible;
const SfxItemSet* pArgs = rRequest.GetArgs();
if (pCurrentPage != nullptr && pCurrentPage->TRG_HasMasterPage())
aVisibleLayers = pCurrentPage->TRG_GetMasterPageVisibleLayers();
else
aVisibleLayers.SetAll();
do
{
if (pCurrentPage == nullptr)
break;
if (!pArgs || pArgs->Count() == 1 || pArgs->Count() == 2 )
{
// First make sure that the sidebar is visible
mrViewShell.GetDrawView()->SdrEndTextEdit();
mrViewShell.GetDrawView()->UnmarkAll();
if (SfxViewFrame* pViewFrame = mrViewShell.GetViewFrame())
{
pViewFrame->ShowChildWindow(SID_SIDEBAR);
sfx2::sidebar::Sidebar::TogglePanel(
u
"SdLayoutsPanel",
pViewFrame->GetFrame().GetFrameInterface());
}
break;
}
else if (pArgs->Count() == 4)
{
const SfxStringItem* pNewName = rRequest.GetArg<SfxStringItem>(ID_VAL_PAGENAME);
const SfxUInt32Item* pNewAutoLayout = rRequest.GetArg<SfxUInt32Item>(ID_VAL_WHATLAYOUT
);
const SfxBoolItem* pBVisible = rRequest.GetArg<SfxBoolItem>(ID_VAL_ISPAGEBACK);
const SfxBoolItem* pBObjsVisible = rRequest.GetArg<SfxBoolItem>(ID_VAL_ISPAGEOBJ);
assert(pNewName && pNewAutoLayout && pBVisible && pBObjsVisible && "must be present");
AutoLayout aLayout (static_cast<AutoLayout>(pNewAutoLayout->GetValue ()));
if (aLayout >= AUTOLAYOUT_START
&& aLayout < AUTOLAYOUT_END)
{
aNewName = pNewName->GetValue ();
aNewAutoLayout = static_cast<AutoLayout>(pNewAutoLayout->GetValue ());
bBVisible = pBVisible->GetValue ();
bBObjsVisible = pBObjsVisible->GetValue ();
}
else
{
#if HAVE_FEATURE_SCRIPTING
StarBASIC::FatalError (ERRCODE_BASIC_BAD_PROP_VALUE);
#endif
rRequest.Ignore ();
break;
}
if (ePageKind == PageKind::Handout)
{
bHandoutMode = true;
pHandoutMPage = pDocument->GetMasterSdPage(0, PageKind::Handout);
}
}
else
{
#if HAVE_FEATURE_SCRIPTING
StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
#endif
rRequest.Ignore ();
break;
}
SdPage* pUndoPage =
bHandoutMode ? pHandoutMPage : pCurrentPage;
SfxUndoManager* pUndoManager = mrViewShell.GetDocSh()->GetUndoManager();
DBG_ASSERT(pUndoManager, "No UNDO MANAGER ?!?");
if( pUndoManager )
{
OUString aComment( SdResId(STR_UNDO_MODIFY_PAGE) );
pUndoManager->EnterListAction(aComment, aComment, 0, mrViewShell.GetViewShellBase().GetViewShellId());
pUndoManager->AddUndoAction(
std::make_unique<ModifyPageUndoAction>(
*pDocument, pUndoPage, aNewName, aNewAutoLayout, bBVisible, bBObjsVisible));
// Clear the selection because the selected object may be removed as
// a result of the assignment of the layout.
mrViewShell.GetDrawView()->UnmarkAll();
if (!bHandoutMode)
{
if (pCurrentPage->GetName() != aNewName)
{
pCurrentPage->SetName(aNewName);
if (ePageKind == PageKind::Standard)
{
sal_uInt16 nPage = (pCurrentPage->GetPageNum()-1) / 2;
SdPage* pNotesPage = pDocument->GetSdPage(nPage, PageKind::Notes);
if (pNotesPage != nullptr)
pNotesPage->SetName(aNewName);
}
}
pCurrentPage->SetAutoLayout(aNewAutoLayout, true);
SdrLayerID aBckgrnd = rLayerAdmin.GetLayerID(sUNO_LayerName_background);
SdrLayerID aBckgrndObj = rLayerAdmin.GetLayerID(sUNO_LayerName_background_objects);
aVisibleLayers.Set(aBckgrnd, bBVisible);
aVisibleLayers.Set(aBckgrndObj, bBObjsVisible);
pCurrentPage->TRG_SetMasterPageVisibleLayers(aVisibleLayers);
}
else
{
pHandoutMPage->SetAutoLayout(aNewAutoLayout, true);
}
mrViewShell.GetViewFrame()->GetDispatcher()->Execute(SID_SWITCHPAGE,
SfxCallMode::ASYNCHRON | SfxCallMode::RECORD);
bool bSetModified = true;
if (pArgs->Count() == 1)
{
bSetModified = static_cast<const SfxBoolItem&>(pArgs->Get(SID_MODIFYPAGE)).GetValue();
}
pUndoManager->AddUndoAction( std::make_unique<UndoAutoLayoutPosAndSize>( *pUndoPage ) );
pUndoManager->LeaveListAction();
pDocument->SetChanged(bSetModified);
}
}
while (false);
mrViewShell.Cancel();
rRequest.Done ();
}
void ViewShell::Implementation::AssignLayout ( SfxRequest const & rRequest, PageKind ePageKind )
{
const SfxUInt32Item* pWhatPage = rRequest.GetArg<SfxUInt32Item>(ID_VAL_WHATPAGE);
const SfxUInt32Item* pWhatLayout = rRequest.GetArg<SfxUInt32Item>(ID_VAL_WHATLAYOUT);
SdDrawDocument* pDocument = mrViewShell.GetDoc();
if( !pDocument )
return;
SdPage* pPage = nullptr;
if( pWhatPage )
{
pPage = pDocument->GetSdPage(static_cast<sal_uInt16>(pWhatPage->GetValue()), ePageKind);
}
if( pPage == nullptr )
pPage = mrViewShell.getCurrentPage();
if( !pPage )
return;
AutoLayout eLayout = pPage->GetAutoLayout();
if( pWhatLayout )
eLayout = static_cast< AutoLayout >( pWhatLayout->GetValue() );
// Transform the given request into the four argument form that is
// understood by ProcessModifyPageSlot().
SdrLayerAdmin& rLayerAdmin (mrViewShell.GetViewShellBase().GetDocument()->GetLayerAdmin());
SdrLayerID aBackground (rLayerAdmin.GetLayerID(sUNO_LayerName_background));
SdrLayerID aBackgroundObject (rLayerAdmin.GetLayerID(sUNO_LayerName_background_objects));
SdrLayerIDSet aVisibleLayers;
if( pPage->GetPageKind() == PageKind::Handout )
aVisibleLayers.SetAll();
else
aVisibleLayers = pPage->TRG_GetMasterPageVisibleLayers();
SfxRequest aRequest(mrViewShell.GetViewShellBase().GetViewFrame(), SID_MODIFYPAGE);
aRequest.AppendItem(SfxStringItem (ID_VAL_PAGENAME, pPage->GetName()));
aRequest.AppendItem(SfxUInt32Item (ID_VAL_WHATLAYOUT, eLayout));
aRequest.AppendItem(SfxBoolItem(ID_VAL_ISPAGEBACK, aVisibleLayers.IsSet(aBackground)));
aRequest.AppendItem(SfxBoolItem(ID_VAL_ISPAGEOBJ, aVisibleLayers.IsSet(aBackgroundObject)));
// Forward the call with the new arguments.
ProcessModifyPageSlot( aRequest, pPage, pPage->GetPageKind());
}
SfxInterfaceId ViewShell::Implementation::GetViewId() const
{
switch (mrViewShell.GetShellType())
{
case ViewShell::ST_IMPRESS:
case ViewShell::ST_NOTES:
case ViewShell::ST_HANDOUT:
return IMPRESS_FACTORY_ID;
case ViewShell::ST_DRAW:
return DRAW_FACTORY_ID;
case ViewShell::ST_OUTLINE:
return OUTLINE_FACTORY_ID;
case ViewShell::ST_SLIDE_SORTER:
return SLIDE_SORTER_FACTORY_ID;
case ViewShell::ST_PRESENTATION:
return PRESENTATION_FACTORY_ID;
// Since we have to return a view id for every possible shell type
// and there is not (yet) a proper ViewShellBase sub class for the
// remaining types we chose the Impress factory as a fall back.
case ViewShell::ST_NOTESPANEL:
case ViewShell::ST_SIDEBAR:
case ViewShell::ST_NONE:
default:
return IMPRESS_FACTORY_ID;
}
}
SvxIMapDlg* ViewShell::Implementation::GetImageMapDialog()
{
SfxViewFrame* pViewFrm = SfxViewFrame::Current();
if (!pViewFrm)
return nullptr;
SfxChildWindow* pChildWindow = pViewFrm->GetChildWindow(
SvxIMapDlgChildWindow::GetChildWindowId());
if (pChildWindow == nullptr)
return nullptr;
return dynamic_cast<SvxIMapDlg*>(pChildWindow->GetController().get());
}
//===== ToolBarManagerLock ====================================================
class ViewShell::Implementation::ToolBarManagerLock::Deleter { public:
void operator() (ToolBarManagerLock* pObject) { delete pObject; }
};
std::shared_ptr<ViewShell::Implementation::ToolBarManagerLock>
ViewShell::Implementation::ToolBarManagerLock::Create (
const std::shared_ptr<ToolBarManager>& rpManager)
{
std::shared_ptr<ToolBarManagerLock> pLock (
new ViewShell::Implementation::ToolBarManagerLock(rpManager),
ViewShell::Implementation::ToolBarManagerLock::Deleter());
pLock->mpSelf = pLock;
return pLock;
}
ViewShell::Implementation::ToolBarManagerLock::ToolBarManagerLock (
const std::shared_ptr<ToolBarManager>& rpManager)
: mpLock(new ToolBarManager::UpdateLock(rpManager)),
maTimer("sd ToolBarManagerLock maTimer")
{
// Start a timer that will unlock the ToolBarManager update lock when
// that is not done explicitly by calling Release().
maTimer.SetInvokeHandler(LINK(this,ToolBarManagerLock,TimeoutCallback));
maTimer.SetTimeout(100);
maTimer.Start();
}
IMPL_LINK_NOARG(ViewShell::Implementation::ToolBarManagerLock, TimeoutCallback, Timer *, void)
{
// If possible then release the lock now. Otherwise start the timer
// and try again later.
if (Application::IsUICaptured())
{
maTimer.Start();
}
else
{
mpSelf.reset();
}
}
void ViewShell::Implementation::ToolBarManagerLock::Release (bool bForce)
{
// If possible then release the lock now. Otherwise try again when the
// timer expires.
if (bForce || ! Application::IsUICaptured())
{
mpSelf.reset();
}
}
ViewShell::Implementation::ToolBarManagerLock::~ToolBarManagerLock()
{
mpLock.reset();
}
} // end of namespace sd
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
