strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/sw/source/uibase/shells/basesh.cxx
Juergen Funk 7303a0375b tdf#160163 improvment when reset placeholder in Text field 
- this patch improve e8a271dd53
   when replace the empty-placholder, it was missing the selection
   of the whole placeholders.
 - with this change have solved a other problem, when select with
   the field with mouse or tab, and press backspace, then the cursor
   has the wrong position, after tip text the view was wrong.
 - reduce code

Change-Id: I6c2c7b2849298552770ea2d257ab844d250a97a1
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/174965
Tested-by: Gabor Kelemen <gabor.kelemen.extern@allotropia.de>
Reviewed-by: Michael Stahl <michael.stahl@allotropia.de>
Tested-by: Jenkins
2024-10-17 13:53:28 +02:00

3391 lines
126 KiB
C++
Raw Blame History

/* -*- 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 <config_fuzzers.h>
#include <sal/config.h>
#include <hintids.hxx>
#include <comphelper/servicehelper.hxx>
#include <svl/languageoptions.hxx>
#include <sfx2/docfile.hxx>
#include <sfx2/linkmgr.hxx>
#include <sfx2/htmlmode.hxx>
#include <svx/imapdlg.hxx>
#include <sfx2/dispatch.hxx>
#include <sfx2/viewfrm.hxx>
#include <sfx2/request.hxx>
#include <svl/whiter.hxx>
#include <svl/visitem.hxx>
#include <editeng/langitem.hxx>
#include <svx/clipfmtitem.hxx>
#include <svx/contdlg.hxx>
#include <vcl/graph.hxx>
#include <vcl/inputctx.hxx>
#include <svl/slstitm.hxx>
#include <svl/ptitem.hxx>
#include <svl/stritem.hxx>
#include <editeng/colritem.hxx>
#include <editeng/fhgtitem.hxx>
#include <editeng/fontitem.hxx>
#include <editeng/shaditem.hxx>
#include <editeng/boxitem.hxx>
#include <editeng/brushitem.hxx>
#include <editeng/opaqitem.hxx>
#include <editeng/sizeitem.hxx>
#include <svx/flagsdef.hxx>
#include <editeng/scripttypeitem.hxx>
#include <sfx2/objface.hxx>
#include <fmturl.hxx>
#include <fmthdft.hxx>
#include <fmtclds.hxx>
#include <docsh.hxx>
#include <wrtsh.hxx>
#include <view.hxx>
#include <swmodule.hxx>
#include <swundo.hxx>
#include <fldbas.hxx>
#include <uitool.hxx>
#include <basesh.hxx>
#include <viewopt.hxx>
#include <fontcfg.hxx>
#include <fmtsrnd.hxx>
#include <fldmgr.hxx>
#include <frmmgr.hxx>
#include <tablemgr.hxx>
#include <mdiexp.hxx>
#include <swdtflvr.hxx>
#include <pagedesc.hxx>
#include <fmtcol.hxx>
#include <edtwin.hxx>
#include <tblafmt.hxx>
#include <swwait.hxx>
#include <cmdid.h>
#include <strings.hrc>
#include <unotxdoc.hxx>
#include <doc.hxx>
#include <drawdoc.hxx>
#include <IDocumentSettingAccess.hxx>
#include <IDocumentDrawModelAccess.hxx>
#include <IDocumentUndoRedo.hxx>
#include <ThemeColorChanger.hxx>
#include <swabstdlg.hxx>
#include <modcfg.hxx>
#include <svx/fmshell.hxx>
#include <SwRewriter.hxx>
#include <GraphicSizeCheck.hxx>
#include <svx/galleryitem.hxx>
#include <sfx2/devtools/DevelopmentToolChildWindow.hxx>
#include <com/sun/star/gallery/GalleryItemType.hpp>
#include <com/sun/star/beans/PropertyValues.hpp>
#include <memory>
#include <svx/unobrushitemhelper.hxx>
#include <svx/dialog/ThemeDialog.hxx>
#include <comphelper/scopeguard.hxx>
#include <comphelper/lok.hxx>
#include <LibreOfficeKit/LibreOfficeKitEnums.h>
#include <osl/diagnose.h>
#include <svx/svxdlg.hxx>
#include <comphelper/sequenceashashmap.hxx>
#include <shellres.hxx>
#include <UndoTable.hxx>
#include <ndtxt.hxx>
#include <UndoManager.hxx>
#include <fmtrfmrk.hxx>
#include <txtrfmrk.hxx>
#include <translatehelper.hxx>
FlyMode SwBaseShell::s_eFrameMode = FLY_DRAG_END;
// These variables keep the state of Gallery (slot SID_GALLERY_BG_BRUSH)
// detected by GetGalleryState() for the subsequent ExecuteGallery() call.
static sal_uInt8 nParagraphPos;
static sal_uInt8 nGraphicPos;
static sal_uInt8 nOlePos;
static sal_uInt8 nFramePos;
static sal_uInt8 nTablePos;
static sal_uInt8 nTableRowPos;
static sal_uInt8 nTableCellPos;
static sal_uInt8 nPagePos;
static sal_uInt8 nHeaderPos;
static sal_uInt8 nFooterPos;
#define ShellClass_SwBaseShell
#include <sfx2/msg.hxx>
#include <swslots.hxx>
#include <AccessibilityCheck.hxx>
namespace
{
SvxContourDlg* GetContourDlg(SwView const &rView)
{
SfxChildWindow *pWnd = rView.GetViewFrame().GetChildWindow(SvxContourDlgChildWindow::GetChildWindowId());
return pWnd ? static_cast<SvxContourDlg*>(pWnd->GetController().get()) : nullptr;
}
SvxIMapDlg* GetIMapDlg(SwView const &rView)
{
SfxChildWindow* pWnd = rView.GetViewFrame().GetChildWindow(SvxIMapDlgChildWindow::GetChildWindowId());
return pWnd ? static_cast<SvxIMapDlg*>(pWnd->GetController().get()) : nullptr;
}
}
using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::frame;
SFX_IMPL_SUPERCLASS_INTERFACE(SwBaseShell, SfxShell)
void SwBaseShell::InitInterface_Impl()
{
GetStaticInterface()->RegisterChildWindow(SvxIMapDlgChildWindow::GetChildWindowId());
GetStaticInterface()->RegisterChildWindow(SvxContourDlgChildWindow::GetChildWindowId());
GetStaticInterface()->RegisterChildWindow(DevelopmentToolChildWindow::GetChildWindowId());
}
static void lcl_UpdateIMapDlg( SwWrtShell& rSh )
{
Graphic aGrf( rSh.GetIMapGraphic() );
GraphicType nGrfType = aGrf.GetType();
void* pEditObj = GraphicType::NONE != nGrfType && GraphicType::Default != nGrfType
? rSh.GetIMapInventor() : nullptr;
TargetList aList;
SfxFrame::GetDefaultTargetList(aList);
SfxItemSetFixed<RES_URL, RES_URL> aSet( rSh.GetAttrPool() );
rSh.GetFlyFrameAttr( aSet );
const SwFormatURL &rURL = aSet.Get( RES_URL );
SvxIMapDlgChildWindow::UpdateIMapDlg(
aGrf, rURL.GetMap(), &aList, pEditObj );
}
static bool lcl_UpdateContourDlg( SwWrtShell &rSh, SelectionType nSel )
{
Graphic aGraf( rSh.GetIMapGraphic() );
GraphicType nGrfType = aGraf.GetType();
bool bRet = GraphicType::NONE != nGrfType && GraphicType::Default != nGrfType;
if( bRet )
{
OUString aGrfName;
if ( nSel & SelectionType::Graphic )
rSh.GetGrfNms( &aGrfName, nullptr );
SvxContourDlg *pDlg = GetContourDlg(rSh.GetView());
if (pDlg)
{
pDlg->Update(aGraf, !aGrfName.isEmpty(),
rSh.GetGraphicPolygon(), rSh.GetIMapInventor());
}
}
return bRet;
}
void SwBaseShell::ExecDelete(SfxRequest &rReq)
{
SwWrtShell &rSh = GetShell();
SwEditWin& rTmpEditWin = GetView().GetEditWin();
switch(rReq.GetSlot())
{
case SID_DELETE:
if (rSh.GetViewOptions()->IsShowOutlineContentVisibilityButton())
{
// Disallow if the cursor is at the end of a paragraph and the document model
// node at this position is an outline node with folded content or the next node
// is an outline node with folded content.
if (rSh.IsEndPara())
{
SwNodeIndex aIdx(rSh.GetCursor()->GetPointNode());
if (aIdx.GetNode().IsTextNode())
{
bool bVisible = true;
aIdx.GetNode().GetTextNode()->GetAttrOutlineContentVisible(bVisible);
if (!bVisible)
break;
++aIdx;
if (aIdx.GetNode().IsTextNode())
{
bVisible = true;
aIdx.GetNode().GetTextNode()->GetAttrOutlineContentVisible(bVisible);
if (!bVisible)
break;
}
}
}
}
rSh.DelRight();
break;
case FN_BACKSPACE:
if (rSh.GetViewOptions()->IsShowOutlineContentVisibilityButton())
{
// Disallow if the cursor is at the start of a paragraph and the document model
// node at this position is an outline node with folded content or the previous
// node is a content node without a layout frame.
if (rSh.IsSttPara())
{
SwNodeIndex aIdx(rSh.GetCursor()->GetPointNode());
if (aIdx.GetNode().IsTextNode())
{
bool bVisible = true;
aIdx.GetNode().GetTextNode()->GetAttrOutlineContentVisible(bVisible);
if (!bVisible)
break;
--aIdx;
if (aIdx.GetNode().IsContentNode() &&
!aIdx.GetNode().GetContentNode()->getLayoutFrame(rSh.GetLayout()))
break;
}
}
}
if( rSh.IsNoNum() )
{
rSh.SttCursorMove();
bool bLeft = rSh.Left( SwCursorSkipMode::Chars, true, 1, false );
if( bLeft )
{
rSh.DelLeft();
}
else
// JP 15.07.96: If it no longer goes forward, cancel
// the numbering. For example at the beginning
// of a doc, frame, table or an area.
rSh.DelNumRules();
rSh.EndCursorMove();
break;
}
[[fallthrough]]; // otherwise call DelLeft
case FN_SHIFT_BACKSPACE:
rSh.DelLeft();
break;
default:
OSL_FAIL("wrong Dispatcher");
return;
}
rReq.Done();
//#i42732# - notify the edit window that from now on we do not use the input language
rTmpEditWin.SetUseInputLanguage( false );
// Test Fieldmark when empty reset the Placeholders
const IDocumentMarkAccess* pMarksAccess = rSh.GetDoc()->getIDocumentMarkAccess();
for (SwPaM &rPaM : rSh.GetCursor()->GetRingContainer())
{
const SwPosition* sp = rPaM.Start();
// Legacy text/combo/checkbox: never return read-only when inside these form fields.
sw::mark::Fieldmark* pA = pMarksAccess->getInnerFieldmarkFor(*sp);
if (pA != nullptr)
{
if ((IDocumentMarkAccess::GetType(*pA) == IDocumentMarkAccess::MarkType::TEXT_FIELDMARK) &&
(pA->GetContent().getLength() == 0)
)
{
pA->ReplaceContent(vEnSpaces);
rSh.GotoFieldmark(pA);
}
}
}
}
void SwBaseShell::ExecClpbrd(SfxRequest &rReq)
{
// Attention: At risk of suicide!
// After paste, paste special the shell can be destroy.
SwWrtShell &rSh = GetShell();
sal_uInt16 nId = rReq.GetSlot();
bool bIgnore = false;
PasteTableType ePasteTable = PasteTableType::PASTE_DEFAULT;
switch( nId )
{
case SID_CUT:
case SID_COPY:
m_rView.GetEditWin().FlushInBuffer();
if ( rSh.HasSelection() )
{
rtl::Reference<SwTransferable> pTransfer = new SwTransferable( rSh );
if ( nId == SID_CUT && FlyProtectFlags::NONE == rSh.IsSelObjProtected(FlyProtectFlags::Content|FlyProtectFlags::Parent) )
pTransfer->Cut();
else
{
const bool bLockedView = rSh.IsViewLocked();
rSh.LockView( true ); //lock visible section
pTransfer->Copy();
rSh.LockView( bLockedView );
}
break;
}
return;
case FN_PASTE_NESTED_TABLE:
case FN_TABLE_PASTE_ROW_BEFORE:
case FN_TABLE_PASTE_COL_BEFORE:
switch ( nId )
{
case FN_PASTE_NESTED_TABLE:
ePasteTable = PasteTableType::PASTE_TABLE;
break;
case FN_TABLE_PASTE_ROW_BEFORE:
ePasteTable = PasteTableType::PASTE_ROW;
break;
case FN_TABLE_PASTE_COL_BEFORE:
ePasteTable = PasteTableType::PASTE_COLUMN;
break;
default:
;
}
[[fallthrough]];
case SID_PASTE:
{
TransferableDataHelper aDataHelper(
TransferableDataHelper::CreateFromSystemClipboard( &rSh.GetView().GetEditWin() ) );
if( aDataHelper.GetXTransferable().is()
&& SwTransferable::IsPaste( rSh, aDataHelper ) )
{
// Temporary variables, because the shell could already be
// destroyed after the paste.
SwView* pView = &m_rView;
RndStdIds nAnchorType = RndStdIds::FLY_AT_PARA;
const SfxUInt16Item* pAnchorType = rReq.GetArg<SfxUInt16Item>(FN_PARAM_1);
if (pAnchorType)
nAnchorType = static_cast<RndStdIds>(pAnchorType->GetValue());
bool bIgnoreComments = false;
const SfxBoolItem* pIgnoreComments = rReq.GetArg<SfxBoolItem>(FN_PARAM_2);
if (pIgnoreComments)
bIgnoreComments = pIgnoreComments->GetValue();
SwTransferable::Paste(rSh, aDataHelper, nAnchorType, bIgnoreComments, ePasteTable);
if( rSh.IsFrameSelected() || rSh.IsObjSelected() )
rSh.EnterSelFrameMode();
pView->AttrChangedNotify(nullptr);
// Fold pasted outlines that have outline content visible attribute false
MakeAllOutlineContentTemporarilyVisible a(rSh.GetDoc());
}
else
return;
}
break;
case SID_CLIPBOARD_FORMAT_ITEMS:
{
const SfxItemSet* pArgs = rReq.GetArgs();
const SfxPoolItem* pFormat;
if( pArgs && SfxItemState::SET == pArgs->GetItemState( nId, false, &pFormat ) )
{
TransferableDataHelper aDataHelper(
TransferableDataHelper::CreateFromSystemClipboard(
&rSh.GetView().GetEditWin()) );
if( aDataHelper.GetXTransferable().is()
/*&& SwTransferable::IsPaste( rSh, aDataHelper )*/ )
{
// Temporary variables, because the shell could already be
// destroyed after the paste.
SwView* pView = &m_rView;
SwTransferable::PasteFormat( rSh, aDataHelper,
static_cast<SotClipboardFormatId>(static_cast<const SfxUInt32Item*>(pFormat)->GetValue()) );
//Done() has to be called before the shell has been removed
rReq.Done();
bIgnore = true;
if( rSh.IsFrameSelected() || rSh.IsObjSelected())
rSh.EnterSelFrameMode();
pView->AttrChangedNotify(nullptr);
// Fold pasted outlines that have outline content visible attribute false
MakeAllOutlineContentTemporarilyVisible a(rSh.GetDoc());
}
}
}
break;
case SID_PASTE_UNFORMATTED:
{
TransferableDataHelper aDataHelper(
TransferableDataHelper::CreateFromSystemClipboard( &rSh.GetView().GetEditWin()) );
if( aDataHelper.GetXTransferable().is()
&& SwTransferable::IsPaste( rSh, aDataHelper ) )
{
// Temporary variables, because the shell could already be
// destroyed after the paste.
SwView* pView = &m_rView;
rReq.Ignore();
bIgnore = true;
if(SwTransferable::PasteUnformatted( rSh, aDataHelper ))
{
SfxViewFrame& rViewFrame = pView->GetViewFrame();
uno::Reference< frame::XDispatchRecorder > xRecorder =
rViewFrame.GetBindings().GetRecorder();
if(xRecorder.is()) {
SfxRequest aReq(rViewFrame, SID_CLIPBOARD_FORMAT_ITEMS);
aReq.AppendItem( SfxUInt32Item( SID_CLIPBOARD_FORMAT_ITEMS, static_cast<sal_uInt32>(SotClipboardFormatId::STRING) ) );
aReq.Done();
}
}
if (rSh.IsFrameSelected() || rSh.IsObjSelected())
rSh.EnterSelFrameMode();
pView->AttrChangedNotify(nullptr);
// Fold pasted outlines that have outline content visible attribute false
MakeAllOutlineContentTemporarilyVisible a(rSh.GetDoc());
}
else
return;
}
break;
case SID_PASTE_SPECIAL:
{
std::shared_ptr<const TransferableDataHelper> aDataHelper =
std::make_shared<TransferableDataHelper>(TransferableDataHelper::CreateFromSystemClipboard( &rSh.GetView().GetEditWin()));
if( aDataHelper->GetXTransferable().is()
&& SwTransferable::IsPaste( rSh, *aDataHelper )
&& !rSh.CursorInsideInputField() )
{
rReq.Ignore();
bIgnore = true;
SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
VclPtr<SfxAbstractPasteDialog> pDlg(pFact->CreatePasteDialog( rReq.GetFrameWeld() ));
// Prepare the dialog
SwTransferable::PrePasteSpecial(rSh, *aDataHelper, pDlg);
pDlg->PreGetFormat(*aDataHelper);
pDlg->StartExecuteAsync(
[aDataHelper=std::move(aDataHelper), pDlg, &rSh, this](sal_Int32 nResult)
{
if (nResult == RET_OK)
{
// Temporary variables, because the shell could already be
// destroyed after the paste.
SwView* pView = &m_rView;
bool bRet = false;
SotClipboardFormatId nFormatId = pDlg->GetFormatOnly();
if( nFormatId != SotClipboardFormatId::NONE )
bRet = SwTransferable::PasteFormat( rSh, *aDataHelper, nFormatId );
if (bRet)
{
SfxViewFrame& rViewFrame = pView->GetViewFrame();
uno::Reference< frame::XDispatchRecorder > xRecorder =
rViewFrame.GetBindings().GetRecorder();
if(xRecorder.is()) {
SfxRequest aReq(rViewFrame, SID_CLIPBOARD_FORMAT_ITEMS);
aReq.AppendItem( SfxUInt32Item( SID_CLIPBOARD_FORMAT_ITEMS, static_cast<sal_uInt32>(nFormatId) ) );
aReq.Done();
}
}
if (rSh.IsFrameSelected() || rSh.IsObjSelected())
rSh.EnterSelFrameMode();
pView->AttrChangedNotify(nullptr);
// Fold pasted outlines that have outline content visible attribute false
MakeAllOutlineContentTemporarilyVisible a(rSh.GetDoc());
}
pDlg->disposeOnce();
}
);
}
else
return;
}
break;
default:
OSL_FAIL("wrong Dispatcher");
return;
}
if(!bIgnore)
rReq.Done();
}
// ClipBoard state
void SwBaseShell::StateClpbrd(SfxItemSet &rSet)
{
SwWrtShell &rSh = GetShell();
SfxWhichIter aIter(rSet);
const bool bCopy = rSh.HasSelection();
sal_uInt16 nWhich = aIter.FirstWhich();
while(nWhich)
{
switch(nWhich)
{
case SID_CUT:
if( FlyProtectFlags::NONE != rSh.IsSelObjProtected(FlyProtectFlags::Content|FlyProtectFlags::Parent ) )
{
rSet.DisableItem( nWhich );
break;
}
[[fallthrough]];
case SID_COPY:
if( !bCopy || GetObjectShell()->isContentExtractionLocked())
rSet.DisableItem( nWhich );
break;
case FN_PASTE_NESTED_TABLE:
case FN_TABLE_PASTE_ROW_BEFORE:
case FN_TABLE_PASTE_COL_BEFORE:
if( !rSh.IsCursorInTable()
|| !GetView().IsPasteSpecialAllowed()
|| rSh.CursorInsideInputField()
// disable if not a native Writer table and not a spreadsheet format
|| !GetView().IsPasteSpreadsheet(rSh.GetTableCopied()) )
{
rSet.DisableItem( nWhich );
}
break;
case SID_PASTE:
if( !GetView().IsPasteAllowed() )
{
rSet.DisableItem( nWhich );
}
break;
case SID_PASTE_SPECIAL:
if( !GetView().IsPasteSpecialAllowed()
|| rSh.CursorInsideInputField() )
{
rSet.DisableItem( nWhich );
}
break;
case SID_PASTE_UNFORMATTED:
if( !GetView().IsPasteSpecialAllowed() )
{
rSet.DisableItem( nWhich );
}
break;
case SID_CLIPBOARD_FORMAT_ITEMS:
{
TransferableDataHelper aDataHelper(
TransferableDataHelper::CreateFromSystemClipboard(
&rSh.GetView().GetEditWin()) );
SvxClipboardFormatItem aFormatItem( SID_CLIPBOARD_FORMAT_ITEMS );
SwTransferable::FillClipFormatItem( rSh, aDataHelper, aFormatItem );
rSet.Put( aFormatItem );
}
break;
}
nWhich = aIter.NextWhich();
}
}
// Perform undo
void SwBaseShell::ExecUndo(SfxRequest &rReq)
{
MakeAllOutlineContentTemporarilyVisible a(GetShell().GetDoc(), true);
SwWrtShell &rWrtShell = GetShell();
SwUndoId nUndoId(SwUndoId::EMPTY);
sal_uInt16 nId = rReq.GetSlot(), nCnt = 1;
const SfxItemSet* pArgs = rReq.GetArgs();
const SfxPoolItem* pItem;
if( pArgs && SfxItemState::SET == pArgs->GetItemState( nId, false, &pItem ))
nCnt = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
// Repair mode: allow undo/redo of all undo actions, even if access would
// be limited based on the view shell ID.
bool bRepair = false;
const SfxBoolItem* pRepairItem;
if (pArgs && (pRepairItem = pArgs->GetItemIfSet(SID_REPAIRPACKAGE, false)))
bRepair = pRepairItem->GetValue();
// #i106349#: save pointer: undo/redo may delete the shell, i.e., this!
SfxViewFrame& rViewFrame( GetView().GetViewFrame() );
IDocumentUndoRedo& rUndoRedo = rWrtShell.GetIDocumentUndoRedo();
bool bWasRepair = rUndoRedo.DoesRepair();
rUndoRedo.DoRepair(bRepair);
comphelper::ScopeGuard aGuard([&rUndoRedo, bWasRepair]()
{
rUndoRedo.DoRepair(bWasRepair);
});
switch( nId )
{
case SID_UNDO:
if (rUndoRedo.GetLastUndoInfo(nullptr, &nUndoId, &rWrtShell.GetView()))
{
for (SwViewShell& rShell : rWrtShell.GetRingContainer())
rShell.LockPaint(LockPaintReason::Undo);
sal_uInt16 nUndoOffset = 0;
if (comphelper::LibreOfficeKit::isActive() && !bRepair && nCnt == 1)
{
sw::UndoManager& rManager = rWrtShell.GetDoc()->GetUndoManager();
const SfxUndoAction* pAction = rManager.GetUndoAction();
SwView& rView = rWrtShell.GetView();
ViewShellId nViewShellId = rView.GetViewShellId();
sal_uInt16 nOffset = 0;
if (pAction->GetViewShellId() != nViewShellId
&& rManager.IsViewUndoActionIndependent(&rView, nOffset))
{
// Execute the undo with an offset: don't undo the top action, but an
// earlier one, since it's independent and that belongs to our view.
nUndoOffset += nOffset;
}
}
rWrtShell.Do(SwWrtShell::UNDO, nCnt, nUndoOffset);
for (SwViewShell& rShell : rWrtShell.GetRingContainer())
rShell.UnlockPaint();
}
break;
case SID_REDO:
if (rUndoRedo.GetFirstRedoInfo(nullptr, &nUndoId, &rWrtShell.GetView()))
{
for (SwViewShell& rShell : rWrtShell.GetRingContainer())
rShell.LockPaint(LockPaintReason::Redo);
rWrtShell.Do( SwWrtShell::REDO, nCnt );
for (SwViewShell& rShell : rWrtShell.GetRingContainer())
rShell.UnlockPaint();
}
break;
case SID_REPEAT:
rWrtShell.Do( SwWrtShell::REPEAT );
break;
default:
OSL_FAIL("wrong Dispatcher");
}
if (nUndoId == SwUndoId::CONFLICT)
{
rReq.SetReturnValue( SfxUInt32Item(nId, static_cast<sal_uInt32>(SID_REPAIRPACKAGE)) );
}
rViewFrame.GetBindings().InvalidateAll(false);
}
// State of undo
void SwBaseShell::StateUndo(SfxItemSet &rSet)
{
SwUndoId nUndoId(SwUndoId::EMPTY);
SwWrtShell &rSh = GetShell();
SfxWhichIter aIter(rSet);
sal_uInt16 nWhich = aIter.FirstWhich();
while(nWhich)
{
switch(nWhich)
{
case SID_UNDO:
{
if (rSh.GetLastUndoInfo(nullptr, &nUndoId, &rSh.GetView()))
{
rSet.Put( SfxStringItem(nWhich,
rSh.GetDoString(SwWrtShell::UNDO)));
}
else if (nUndoId == SwUndoId::CONFLICT)
{
rSet.Put( SfxUInt32Item(nWhich, static_cast<sal_uInt32>(SID_REPAIRPACKAGE)) );
}
else
rSet.DisableItem(nWhich);
break;
}
case SID_REDO:
{
if (rSh.GetFirstRedoInfo(nullptr, &nUndoId, &rSh.GetView()))
{
rSet.Put(SfxStringItem(nWhich,
rSh.GetDoString(SwWrtShell::REDO)));
}
else if (nUndoId == SwUndoId::CONFLICT)
{
rSet.Put( SfxInt32Item(nWhich, static_cast<sal_uInt32>(SID_REPAIRPACKAGE)) );
}
else
rSet.DisableItem(nWhich);
break;
}
case SID_REPEAT:
{ // Repeat is only possible if no REDO is possible - UI-Restriction
if ((!rSh.GetFirstRedoInfo(nullptr, nullptr)) &&
!rSh.IsSelFrameMode() &&
(SwUndoId::EMPTY != rSh.GetRepeatInfo(nullptr)))
{
rSet.Put(SfxStringItem(nWhich, rSh.GetRepeatString()));
}
else
rSet.DisableItem(nWhich);
break;
}
case SID_GETUNDOSTRINGS:
if (rSh.GetLastUndoInfo(nullptr, nullptr))
{
SfxStringListItem aStrLst( nWhich );
rSh.GetDoStrings( SwWrtShell::UNDO, aStrLst );
rSet.Put( aStrLst );
}
else
rSet.DisableItem( nWhich );
break;
case SID_GETREDOSTRINGS:
if (rSh.GetFirstRedoInfo(nullptr, nullptr))
{
SfxStringListItem aStrLst( nWhich );
rSh.GetDoStrings( SwWrtShell::REDO, aStrLst );
rSet.Put( aStrLst );
}
else
rSet.DisableItem( nWhich );
break;
}
nWhich = aIter.NextWhich();
}
}
namespace
{
/// Searches for the specified field type and field name prefix and update the matching fields to
/// have the provided new name and content.
bool UpdateFieldContents(SfxRequest& rReq, SwWrtShell& rWrtSh)
{
const SfxStringItem* pTypeName = rReq.GetArg<SfxStringItem>(FN_PARAM_1);
if (!pTypeName || pTypeName->GetValue() != "SetRef")
{
// This is implemented so far only for reference marks.
return false;
}
const SfxStringItem* pNamePrefix = rReq.GetArg<SfxStringItem>(FN_PARAM_2);
if (!pNamePrefix)
{
return false;
}
const OUString& rNamePrefix = pNamePrefix->GetValue();
const SfxUnoAnyItem* pFields = rReq.GetArg<SfxUnoAnyItem>(FN_PARAM_3);
if (!pFields)
{
return false;
}
uno::Sequence<beans::PropertyValues> aFields;
pFields->GetValue() >>= aFields;
SwDoc* pDoc = rWrtSh.GetDoc();
pDoc->GetIDocumentUndoRedo().StartUndo(SwUndoId::UPDATE_FIELDS, nullptr);
rWrtSh.StartAction();
std::vector<const SwFormatRefMark*> aRefMarks;
pDoc->GetRefMarks(aRefMarks);
std::sort(aRefMarks.begin(), aRefMarks.end(),
[](const SwFormatRefMark* pMark1, const SwFormatRefMark* pMark2) -> bool {
const SwTextRefMark* pTextRefMark1 = pMark1->GetTextRefMark();
const SwTextRefMark* pTextRefMark2 = pMark2->GetTextRefMark();
SwPosition aPos1(pTextRefMark1->GetTextNode(), pTextRefMark1->GetStart());
SwPosition aPos2(pTextRefMark2->GetTextNode(), pTextRefMark2->GetStart());
return aPos1 < aPos2;
});
sal_uInt16 nFieldIndex = 0;
for (auto& pIntermediateRefMark : aRefMarks)
{
auto pRefMark = const_cast<SwFormatRefMark*>(pIntermediateRefMark);
if (!pRefMark->GetRefName().startsWith(rNamePrefix))
{
continue;
}
if (nFieldIndex >= aFields.getLength())
{
break;
}
comphelper::SequenceAsHashMap aMap(aFields[nFieldIndex++]);
pRefMark->GetRefName() = aMap[u"Name"_ustr].get<OUString>();
auto pTextRefMark = const_cast<SwTextRefMark*>(pRefMark->GetTextRefMark());
pTextRefMark->UpdateFieldContent(pDoc, rWrtSh, aMap[u"Content"_ustr].get<OUString>());
}
rWrtSh.EndAction();
pDoc->GetIDocumentUndoRedo().EndUndo(SwUndoId::UPDATE_FIELDS, nullptr);
return true;
}
/// Searches for the specified field type and field name prefix under cursor and update the matching
/// field to have the provided new name and content.
void UpdateFieldContent(SfxRequest& rReq, SwWrtShell& rWrtSh)
{
const SfxStringItem* pTypeName = rReq.GetArg<SfxStringItem>(FN_PARAM_1);
if (!pTypeName || pTypeName->GetValue() != "SetRef")
{
// This is implemented so far only for reference marks.
return;
}
const SfxStringItem* pNamePrefix = rReq.GetArg<SfxStringItem>(FN_PARAM_2);
if (!pNamePrefix)
{
return;
}
const OUString& rNamePrefix = pNamePrefix->GetValue();
const SfxUnoAnyItem* pField = rReq.GetArg<SfxUnoAnyItem>(FN_PARAM_3);
if (!pField)
{
return;
}
uno::Sequence<beans::PropertyValue> aField;
pField->GetValue() >>= aField;
SwPosition& rCursor = *rWrtSh.GetCursor()->GetPoint();
SwTextNode* pTextNode = rCursor.GetNode().GetTextNode();
std::vector<SwTextAttr*> aAttrs
= pTextNode->GetTextAttrsAt(rCursor.GetContentIndex(), RES_TXTATR_REFMARK);
if (aAttrs.empty())
{
return;
}
auto& rRefmark = const_cast<SwFormatRefMark&>(aAttrs[0]->GetRefMark());
if (!rRefmark.GetRefName().startsWith(rNamePrefix))
{
return;
}
SwDoc* pDoc = rWrtSh.GetDoc();
SwRewriter aRewriter;
aRewriter.AddRule(UndoArg1, rRefmark.GetRefName());
pDoc->GetIDocumentUndoRedo().StartUndo(SwUndoId::UPDATE_FIELD, &aRewriter);
rWrtSh.StartAction();
comphelper::ScopeGuard g(
[&rWrtSh, &aRewriter]
{
rWrtSh.EndAction();
rWrtSh.GetDoc()->GetIDocumentUndoRedo().EndUndo(SwUndoId::UPDATE_FIELD, &aRewriter);
});
comphelper::SequenceAsHashMap aMap(aField);
rRefmark.GetRefName() = aMap[u"Name"_ustr].get<OUString>();
OUString aContent = aMap[u"Content"_ustr].get<OUString>();
auto pTextRefMark = const_cast<SwTextRefMark*>(rRefmark.GetTextRefMark());
pTextRefMark->UpdateFieldContent(pDoc, rWrtSh, aContent);
}
}
// Evaluate respectively dispatching the slot Id
void SwBaseShell::Execute(SfxRequest &rReq)
{
const SfxPoolItem *pItem;
SwWrtShell &rSh = GetShell();
const SfxItemSet* pArgs = rReq.GetArgs();
bool bMore = false;
sal_uInt16 nSlot = rReq.GetSlot();
switch(nSlot)
{
case FN_REPAGINATE:
{
Reference < XModel > xModel = GetView().GetDocShell()->GetModel();
auto pDoc = comphelper::getFromUnoTunnel<SwXTextDocument>(xModel);
pDoc->NotifyRefreshListeners();
rSh.CalcLayout();
}
break;
case FN_UPDATE_FIELDS:
{
if (UpdateFieldContents(rReq, rSh))
{
// Parameters indicated that the name / content of fields has to be updated to
// the provided values, don't do an actual fields update.
break;
}
rSh.UpdateDocStat();
rSh.EndAllTableBoxEdit();
rSh.SwViewShell::UpdateFields(true);
if( rSh.IsCursorInTable() )
{
if( !rSh.IsTableComplexForChart() )
SwTableFUNC( &rSh ).UpdateChart();
rSh.ClearTableBoxContent();
rSh.SaveTableBoxContent();
}
}
break;
case FN_UPDATE_FIELD:
{
UpdateFieldContent(rReq, rSh);
}
break;
case FN_UPDATE_CHARTS:
{
SwWait aWait( *m_rView.GetDocShell(), true );
rSh.UpdateAllCharts();
}
break;
case FN_UPDATE_ALL:
{
comphelper::EmbeddedObjectContainer& rEmbeddedObjectContainer
= GetObjectShell()->getEmbeddedObjectContainer();
rEmbeddedObjectContainer.setUserAllowsLinkUpdate(true);
SwView& rTempView = GetView();
rSh.EnterStdMode();
if( !rSh.GetLinkManager().GetLinks().empty() )
{
rSh.StartAllAction();
SfxMedium * medium = nullptr;
if (auto const sh = rSh.GetDoc()->GetDocShell()) {
medium = sh->GetMedium();
}
rSh.GetLinkManager().UpdateAllLinks(
false, true, nullptr, medium == nullptr ? OUString() : medium->GetName() );
rSh.EndAllAction();
}
SfxDispatcher &rDis = *rTempView.GetViewFrame().GetDispatcher();
rDis.Execute( FN_UPDATE_FIELDS );
rDis.Execute( FN_UPDATE_TOX );
rDis.Execute( FN_UPDATE_CHARTS );
rSh.Reformat();
rSh.UpdateOleObjectPreviews();
}
break;
case FN_UPDATE_INPUTFIELDS:
rSh.UpdateInputFields();
break;
case FN_PREV_BOOKMARK:
rReq.SetReturnValue(SfxBoolItem( nSlot, rSh.GoPrevBookmark()));
break;
case FN_NEXT_BOOKMARK:
rReq.SetReturnValue(SfxBoolItem( nSlot, rSh.GoNextBookmark()));
break;
case FN_GOTO_NEXT_MARK:
case FN_GOTO_PREV_MARK:
{
SwFieldMgr aFieldMgr;
SwFieldType* pFieldType = aFieldMgr.GetFieldType(SwFieldIds::JumpEdit);
if (pFieldType)
{
if (rSh.IsSelFrameMode())
{
rSh.UnSelectFrame();
rSh.LeaveSelFrameMode();
}
if (rSh.HasMark())
{
SwMvContext aMvContext(&rSh);
if (rSh.IsCursorPtAtEnd())
rSh.SwapPam();
rSh.ClearMark();
rSh.EndSelect();
}
bool bRet = rSh.MoveFieldType( pFieldType, nSlot == FN_GOTO_NEXT_MARK );
SwField* pCurField = bRet ? rSh.GetCurField() : nullptr;
if (pCurField)
rSh.ClickToField(*pCurField, /*bExecHyperlinks=*/false);
rReq.SetReturnValue(SfxBoolItem( nSlot, bRet));
}
}
break;
case FN_START_DOC_DIRECT:
case FN_END_DOC_DIRECT:
{
if (rSh.IsSelFrameMode())
{
rSh.UnSelectFrame();
rSh.LeaveSelFrameMode();
}
rSh.EnterStdMode();
nSlot == FN_START_DOC_DIRECT ?
rSh.SttEndDoc(true) :
rSh.SttEndDoc(false);
}
break;
case FN_GOTO_PREV_OBJ:
case FN_GOTO_NEXT_OBJ:
{
bool bSuccess = rSh.GotoObj( nSlot == FN_GOTO_NEXT_OBJ );
rReq.SetReturnValue(SfxBoolItem(nSlot, bSuccess));
if (bSuccess && !rSh.IsSelFrameMode())
{
rSh.HideCursor();
rSh.EnterSelFrameMode();
GetView().AttrChangedNotify(nullptr);
}
}
break;
case SID_GALLERY_FORMATS:
{
const SvxGalleryItem* pGalleryItem = SfxItemSet::GetItem<SvxGalleryItem>(pArgs, SID_GALLERY_FORMATS, false);
if ( !pGalleryItem )
break;
const SelectionType nSelType = rSh.GetSelectionType();
sal_Int8 nGalleryItemType( pGalleryItem->GetType() );
if ( (!rSh.IsSelFrameMode() || nSelType & SelectionType::Graphic) &&
nGalleryItemType == css::gallery::GalleryItemType::GRAPHIC )
{
SwWait aWait( *m_rView.GetDocShell(), true );
OUString aGrfName, aFltName;
const Graphic aGrf( pGalleryItem->GetGraphic() );
if ( nSelType & SelectionType::Graphic )
rSh.ReRead( aGrfName, aFltName, &aGrf );
else
rSh.InsertGraphic( aGrfName, aFltName, aGrf );
GetView().GetEditWin().GrabFocus();
}
else if(!rSh.IsSelFrameMode() &&
nGalleryItemType == css::gallery::GalleryItemType::MEDIA )
{
const SfxStringItem aMediaURLItem( SID_INSERT_AVMEDIA, pGalleryItem->GetURL() );
GetView().GetViewFrame().GetDispatcher()->ExecuteList(
SID_INSERT_AVMEDIA, SfxCallMode::SYNCHRON,
{ &aMediaURLItem });
}
}
break;
case FN_PAGE_STYLE_SET_COLS:
{
if (pArgs)
{
// Determine the current PageDescriptor and fill the set with that.
const size_t nCurIdx = rSh.GetCurPageDesc();
SwPageDesc aPageDesc(rSh.GetPageDesc(nCurIdx));
SwFrameFormat &rFormat = aPageDesc.GetMaster();
SwFormatCol aFormatCol = rFormat.GetCol();
sal_uInt16 nCount;
if(SfxItemState::SET == pArgs->GetItemState(nSlot))
nCount = static_cast<const SfxUInt16Item &>(pArgs->Get(nSlot)).GetValue();
else
nCount = pArgs->Get(SID_ATTR_COLUMNS).GetValue();
sal_uInt16 nGutterWidth = DEF_GUTTER_WIDTH;
aFormatCol.Init(nCount ? nCount : 1, nGutterWidth, USHRT_MAX);
aFormatCol.SetWishWidth(USHRT_MAX);
aFormatCol.SetGutterWidth(nGutterWidth, USHRT_MAX);
rFormat.SetFormatAttr(aFormatCol);
rSh.ChgPageDesc(nCurIdx, aPageDesc);
}
else
GetView().GetViewFrame().GetDispatcher()->Execute(FN_FORMAT_PAGE_COLUMN_DLG);
}
break;
case FN_CONVERT_TABLE_TO_TEXT:
case FN_CONVERT_TEXT_TO_TABLE:
case FN_CONVERT_TEXT_TABLE:
{
sal_Unicode cDelim = 0;
bool bToTable = false;
if( nSlot == FN_CONVERT_TEXT_TO_TABLE ||
( nSlot == FN_CONVERT_TEXT_TABLE && nullptr == rSh.GetTableFormat() ))
bToTable = true;
SwInsertTableOptions aInsTableOpts( SwInsertTableFlags::All, 1 );
SwTableAutoFormat const* pTAFormat = nullptr;
std::unique_ptr<SwTableAutoFormatTable> pAutoFormatTable;
bool bDeleteFormat = true;
if(pArgs && SfxItemState::SET == pArgs->GetItemState( FN_PARAM_1, true, &pItem))
{
aInsTableOpts.mnInsMode = SwInsertTableFlags::NONE;
// Delimiter
OUString sDelim = static_cast< const SfxStringItem* >(pItem)->GetValue();
if(!sDelim.isEmpty())
cDelim = sDelim[0];
// AutoFormat
if(SfxItemState::SET == pArgs->GetItemState( FN_PARAM_2, true, &pItem))
{
OUString sAutoFormat = static_cast< const SfxStringItem* >(pItem)->GetValue();
pAutoFormatTable.reset(new SwTableAutoFormatTable);
pAutoFormatTable->Load();
for( sal_uInt16 i = 0, nCount = pAutoFormatTable->size(); i < nCount; i++ )
{
SwTableAutoFormat const*const pFormat = &(*pAutoFormatTable)[ i ];
if( pFormat->GetName() == sAutoFormat )
{
pTAFormat = pFormat;
bDeleteFormat = false;
break;
}
}
}
//WithHeader
if(SfxItemState::SET == pArgs->GetItemState( FN_PARAM_3, true, &pItem) &&
static_cast< const SfxBoolItem* >(pItem)->GetValue())
aInsTableOpts.mnInsMode |= SwInsertTableFlags::Headline;
// RepeatHeaderLines
if(SfxItemState::SET == pArgs->GetItemState( FN_PARAM_4, true, &pItem))
aInsTableOpts.mnRowsToRepeat =
o3tl::narrowing<sal_uInt16>(static_cast< const SfxInt16Item* >(pItem)->GetValue());
//WithBorder
if(SfxItemState::SET == pArgs->GetItemState( FN_PARAM_5, true, &pItem) &&
static_cast< const SfxBoolItem* >(pItem)->GetValue())
aInsTableOpts.mnInsMode |= SwInsertTableFlags::DefaultBorder;
//DontSplitTable
if(SfxItemState::SET == pArgs->GetItemState( FN_PARAM_6, true, &pItem) &&
!static_cast< const SfxBoolItem* >(pItem)->GetValue() )
aInsTableOpts.mnInsMode |= SwInsertTableFlags::SplitLayout;
}
else
{
SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
ScopedVclPtr<AbstractSwConvertTableDlg> pDlg(pFact->CreateSwConvertTableDlg(GetView(), bToTable));
if( RET_OK == pDlg->Execute() )
{
pDlg->GetValues( cDelim, aInsTableOpts, pTAFormat );
}
}
if( cDelim )
{
//Shell change!
SwView& rSaveView = m_rView;
bool bInserted = false;
//recording:
SfxViewFrame& rViewFrame = GetView().GetViewFrame();
if (SfxRequest::HasMacroRecorder(rViewFrame))
{
SfxRequest aReq(rViewFrame, nSlot);
aReq.AppendItem( SfxStringItem( FN_PARAM_1, OUString(cDelim) ));
if(bToTable)
{
if(pTAFormat)
aReq.AppendItem( SfxStringItem( FN_PARAM_2, pTAFormat->GetName()));
aReq.AppendItem( SfxBoolItem ( FN_PARAM_3, bool(aInsTableOpts.mnInsMode & SwInsertTableFlags::Headline)));
aReq.AppendItem( SfxInt16Item( FN_PARAM_4, static_cast<short>(aInsTableOpts.mnRowsToRepeat) ));
aReq.AppendItem( SfxBoolItem ( FN_PARAM_5, bool(aInsTableOpts.mnInsMode & SwInsertTableFlags::DefaultBorder) ));
aReq.AppendItem( SfxBoolItem ( FN_PARAM_6, !(aInsTableOpts.mnInsMode & SwInsertTableFlags::SplitLayout)));
}
aReq.Done();
}
if( !bToTable )
rSh.TableToText( cDelim );
else
{
bInserted = rSh.TextToTable( aInsTableOpts, cDelim, pTAFormat );
}
rSh.EnterStdMode();
if( bInserted )
rSaveView.AutoCaption( TABLE_CAP );
}
if(bDeleteFormat)
delete pTAFormat;
}
break;
case SID_STYLE_WATERCAN:
case SID_STYLE_UPDATE_BY_EXAMPLE:
case SID_STYLE_NEW_BY_EXAMPLE:
case SID_STYLE_APPLY:
{
ShellMode eMode = GetView().GetShellMode();
if ( ShellMode::Draw != eMode &&
ShellMode::DrawForm != eMode &&
ShellMode::DrawText != eMode &&
ShellMode::Bezier != eMode )
{
// oj #107754#
if ( SID_STYLE_WATERCAN == nSlot )
{
const bool bLockedView = rSh.IsViewLocked();
rSh.LockView( true ); //lock visible section
GetView().GetDocShell()->ExecStyleSheet(rReq);
rSh.LockView( bLockedView );
}
else
// Will be recorded from the DocShell
GetView().GetDocShell()->ExecStyleSheet(rReq);
}
}
break;
case SID_CLASSIFICATION_APPLY:
{
GetView().GetDocShell()->Execute(rReq);
}
break;
case SID_CLASSIFICATION_DIALOG:
{
GetView().GetDocShell()->Execute(rReq);
}
break;
case SID_PARAGRAPH_SIGN_CLASSIFY_DLG:
{
GetView().GetDocShell()->Execute(rReq);
}
break;
case SID_WATERMARK:
{
GetView().GetDocShell()->Execute(rReq);
}
break;
case FN_ESCAPE:
GetView().ExecuteSlot(rReq);
break;
case SID_IMAP:
{
sal_uInt16 nId = SvxIMapDlgChildWindow::GetChildWindowId();
SfxViewFrame& rVFrame = GetView().GetViewFrame();
rVFrame.ToggleChildWindow( nId );
rVFrame.GetBindings().Invalidate( SID_IMAP );
if ( rVFrame.HasChildWindow( nId ) && rSh.IsFrameSelected() )
lcl_UpdateIMapDlg( rSh );
}
break;
case SID_IMAP_EXEC:
{
SvxIMapDlg* pDlg = GetIMapDlg(GetView());
// Check, if the allocation is useful or allowed at all.
if ( rSh.IsFrameSelected() &&
pDlg->GetEditingObject() == rSh.GetIMapInventor() )
{
SfxItemSetFixed<RES_URL, RES_URL> aSet( rSh.GetAttrPool() );
rSh.GetFlyFrameAttr( aSet );
SwFormatURL aURL( aSet.Get( RES_URL ) );
aURL.SetMap( &pDlg->GetImageMap() );
aSet.Put( aURL );
rSh.SetFlyFrameAttr( aSet );
}
}
break;
case FN_SET_TRACKED_CHANGES_IN_TEXT:
case FN_SET_TRACKED_DELETIONS_IN_MARGIN:
case FN_SET_TRACKED_INSERTIONS_IN_MARGIN:
{
SwViewOption aViewOption = *rSh.GetViewOptions();
bool bAllInText = FN_SET_TRACKED_CHANGES_IN_TEXT == nSlot;
aViewOption.SetShowChangesInMargin( !bAllInText );
if ( !bAllInText )
aViewOption.SetShowChangesInMargin2( FN_SET_TRACKED_INSERTIONS_IN_MARGIN == nSlot );
rSh.ApplyViewOptions( aViewOption );
// tdf#140982 restore annotation ranges stored in temporary bookmarks
// (only remove temporary bookmarks during file saving to avoid possible
// conflict with lazy deletion of the bookmarks of the moved tracked deletions)
if ( bAllInText || FN_SET_TRACKED_INSERTIONS_IN_MARGIN == nSlot )
rSh.GetDoc()->getIDocumentMarkAccess()->restoreAnnotationMarks(false);
}
break;
case SID_CONTOUR_DLG:
{
sal_uInt16 nId = SvxContourDlgChildWindow::GetChildWindowId();
SfxViewFrame& rVFrame = GetView().GetViewFrame();
rVFrame.ToggleChildWindow( nId );
rVFrame.GetBindings().Invalidate( SID_CONTOUR_DLG );
SelectionType nSel = rSh.GetSelectionType();
if ( rVFrame.HasChildWindow( nId ) &&
(nSel & (SelectionType::Graphic|SelectionType::Ole)) )
{
lcl_UpdateContourDlg( rSh, nSel );
}
}
break;
case SID_CONTOUR_EXEC:
{
SvxContourDlg *pDlg = GetContourDlg(GetView());
// Check, if the allocation is useful or allowed at all.
SelectionType nSel = rSh.GetSelectionType();
if ( nSel & (SelectionType::Graphic|SelectionType::Ole) )
{
if (pDlg && pDlg->GetEditingObject() == rSh.GetIMapInventor())
{
rSh.StartAction();
SfxItemSetFixed<RES_SURROUND, RES_SURROUND> aSet( rSh.GetAttrPool() );
rSh.GetFlyFrameAttr( aSet );
SwFormatSurround aSur( aSet.Get( RES_SURROUND ) );
if ( !aSur.IsContour() )
{
aSur.SetContour( true );
if ( aSur.GetSurround() == css::text::WrapTextMode_NONE )
aSur.SetSurround( css::text::WrapTextMode_PARALLEL );
aSet.Put( aSur );
rSh.SetFlyFrameAttr( aSet );
}
const tools::PolyPolygon aPoly( pDlg->GetPolyPolygon() );
rSh.SetGraphicPolygon( &aPoly );
if ( pDlg->IsGraphicChanged() )
rSh.ReRead( OUString(), OUString(), &pDlg->GetGraphic());
rSh.EndAction();
}
}
}
break;
case FN_FRAME_TO_ANCHOR:
{
rSh.GotoFlyAnchor();
rSh.EnterStdMode();
rSh.CallChgLnk();
}
break;
case FN_TOOL_ANCHOR_PAGE:
case FN_TOOL_ANCHOR_PARAGRAPH:
case FN_TOOL_ANCHOR_CHAR:
case FN_TOOL_ANCHOR_AT_CHAR:
case FN_TOOL_ANCHOR_FRAME:
{
RndStdIds eSet = nSlot == FN_TOOL_ANCHOR_PAGE
? RndStdIds::FLY_AT_PAGE
: nSlot == FN_TOOL_ANCHOR_PARAGRAPH
? RndStdIds::FLY_AT_PARA
: nSlot == FN_TOOL_ANCHOR_FRAME
? RndStdIds::FLY_AT_FLY
: nSlot == FN_TOOL_ANCHOR_CHAR
? RndStdIds::FLY_AS_CHAR
: RndStdIds::FLY_AT_CHAR;
rSh.StartUndo();
if (rSh.IsObjSelected())
rSh.ChgAnchor(eSet);
else if (rSh.IsFrameSelected())
{
SwFormatAnchor aAnc(eSet, eSet == RndStdIds::FLY_AT_PAGE ? rSh.GetPhyPageNum() : 0);
SfxItemSet aSet(SwFEShell::makeItemSetFromFormatAnchor(GetPool(), aAnc));
rSh.SetFlyFrameAttr(aSet);
}
// if new anchor is 'as char' and it is a Math object and the usual
// pre-conditions are met then align the formula to the baseline of the text
const uno::Reference < embed::XEmbeddedObject > xObj( rSh.GetOleRef() );
const bool bDoMathBaselineAlignment = xObj.is() && SotExchange::IsMath( xObj->getClassID() )
&& RndStdIds::FLY_AS_CHAR == eSet && rSh.GetDoc()->getIDocumentSettingAccess().get( DocumentSettingId::MATH_BASELINE_ALIGNMENT );
if (bDoMathBaselineAlignment)
rSh.AlignFormulaToBaseline( xObj );
sal_uInt16 nHtmlMode = ::GetHtmlMode(GetView().GetDocShell());
if( nHtmlMode )
{
SfxItemSetFixed<RES_SURROUND, RES_HORI_ORIENT> aSet(GetPool());
rSh.GetFlyFrameAttr(aSet);
const SwFormatSurround& rSurround = aSet.Get(RES_SURROUND);
const SwFormatVertOrient& rVert = aSet.Get(RES_VERT_ORIENT);
const SwFormatHoriOrient& rHori = aSet.Get(RES_HORI_ORIENT);
sal_Int16 eVOrient = rVert.GetVertOrient();
sal_Int16 eHOrient = rHori.GetHoriOrient();
css::text::WrapTextMode eSurround = rSurround.GetSurround();
switch( eSet )
{
case RndStdIds::FLY_AT_FLY:
case RndStdIds::FLY_AT_PAGE:
//Wrap through, left or from left, top, from top
if(eSurround != css::text::WrapTextMode_THROUGH)
aSet.Put(SwFormatSurround(css::text::WrapTextMode_THROUGH));
if( eVOrient != text::VertOrientation::TOP && eVOrient != text::VertOrientation::NONE)
aSet.Put(SwFormatVertOrient(0, text::VertOrientation::TOP));
if (eHOrient != text::HoriOrientation::NONE && eHOrient != text::HoriOrientation::LEFT)
aSet.Put(SwFormatHoriOrient(0, text::HoriOrientation::LEFT));
break;
case RndStdIds::FLY_AT_PARA:
// left, from left, right, top, no wrap, wrap left and right
if (eSurround != css::text::WrapTextMode_LEFT && eSurround != css::text::WrapTextMode_RIGHT)
aSet.Put(SwFormatSurround(css::text::WrapTextMode_LEFT));
if( eVOrient != text::VertOrientation::TOP)
aSet.Put(SwFormatVertOrient(0, text::VertOrientation::TOP));
if (eHOrient != text::HoriOrientation::NONE && eHOrient != text::HoriOrientation::LEFT && eHOrient != text::HoriOrientation::RIGHT)
aSet.Put(SwFormatHoriOrient(0, text::HoriOrientation::LEFT));
break;
case RndStdIds::FLY_AT_CHAR:
// left, from left, right, top, wrap through
if(eSurround != css::text::WrapTextMode_THROUGH)
aSet.Put(SwFormatSurround(css::text::WrapTextMode_THROUGH));
if( eVOrient != text::VertOrientation::TOP)
aSet.Put(SwFormatVertOrient(0, text::VertOrientation::TOP));
if (eHOrient != text::HoriOrientation::NONE && eHOrient != text::HoriOrientation::LEFT && eHOrient != text::HoriOrientation::RIGHT)
aSet.Put(SwFormatHoriOrient(0, text::HoriOrientation::LEFT));
break;
default:
;
}
if( aSet.Count() )
rSh.SetFlyFrameAttr( aSet );
}
rSh.EndUndo();
GetView().GetViewFrame().GetBindings().Invalidate( SID_ANCHOR_MENU );
}
break;
case FN_FRAME_NOWRAP:
case FN_FRAME_WRAP:
case FN_FRAME_WRAP_IDEAL:
case FN_FRAME_WRAPTHRU:
case FN_FRAME_WRAPTHRU_TRANSP:
case FN_FRAME_WRAPTHRU_TOGGLE:
case FN_FRAME_WRAP_CONTOUR:
case FN_WRAP_ANCHOR_ONLY:
case FN_FRAME_WRAP_LEFT:
case FN_FRAME_WRAP_RIGHT:
SetWrapMode( nSlot );
break;
case FN_UPDATE_ALL_LINKS:
{
if( !rSh.GetLinkManager().GetLinks().empty() )
{
rSh.EnterStdMode();
rSh.StartAllAction();
SfxMedium * medium = nullptr;
if (auto const sh = rSh.GetDoc()->GetDocShell()) {
medium = sh->GetMedium();
}
rSh.GetLinkManager().UpdateAllLinks(
false, false, nullptr, medium == nullptr ? OUString() : medium->GetName() );
rSh.EndAllAction();
}
}
break;
case FN_XFORMS_DESIGN_MODE:
if (pArgs && pArgs->GetItemState(nSlot, true, &pItem) == SfxItemState::SET)
{
if (const SfxBoolItem* pBoolItem = dynamic_cast<const SfxBoolItem*>(pItem))
{
bool bDesignMode = pBoolItem->GetValue();
// set from design mode
OSL_ENSURE( GetView().GetFormShell() != nullptr, "form shell?" );
SfxRequest aReq(GetView().GetViewFrame(), SID_FM_DESIGN_MODE);
aReq.AppendItem( SfxBoolItem( SID_FM_DESIGN_MODE, bDesignMode ) );
GetView().GetFormShell()->Execute( aReq );
aReq.Done();
// also set suitable view options
SwViewOption aViewOption = *rSh.GetViewOptions();
aViewOption.SetFormView( ! bDesignMode );
rSh.ApplyViewOptions( aViewOption );
}
}
break;
default:
bMore = true;
}
if(!bMore || !pArgs)
return;
pItem = nullptr;
pArgs->GetItemState(GetPool().GetWhichIDFromSlotID(nSlot), false, &pItem);
if(!pItem)
return;
switch(nSlot)
{
case SID_ATTR_BRUSH:
case SID_ATTR_BORDER_SHADOW:
case RES_SHADOW:
{
rSh.StartAllAction();
// Table cell(s) selected?
if ( rSh.IsTableMode() )
{
SwFrameFormat *pFormat = rSh.GetTableFormat();
pFormat->SetFormatAttr( *pItem );
}
else if ( rSh.IsFrameSelected() )
{
// Set border attributes via Frame-Manager.
SwFlyFrameAttrMgr aMgr( false, &rSh, Frmmgr_Type::NONE, nullptr );
aMgr.SetAttrSet( *pArgs );
aMgr.UpdateFlyFrame();
}
else
{
rSh.SetAttrSet( *pArgs );
}
rSh.EndAllAction();
}
break;
case FN_PAGE_STYLE_SET_LR_MARGIN:
case FN_PAGE_STYLE_SET_UL_MARGIN:
case FN_PAGE_STYLE_SET_NUMBER_FORMAT:
case FN_PAGE_STYLE_SET_PAPER_SIZE:
case FN_PAGE_STYLE_SET_PAPER_BIN:
{
OSL_FAIL("not implemented");
}
break;
case SID_ATTR_BORDER_OUTER:
{
// Table cell(s) selected?
if ( rSh.IsTableMode() )
{
// Set border attributes Get/SetTabBorders()
rSh.SetTabBorders(*pArgs);
}
else if ( rSh.IsFrameSelected() )
{
// Set border attributes via Frame-Manager.
SwFlyFrameAttrMgr aMgr( false, &rSh, Frmmgr_Type::NONE, nullptr );
aMgr.SetAttrSet(*pArgs);
aMgr.UpdateFlyFrame();
}
else
{
// Set border attributes via shell quite normally.
rSh.SetAttrItem( *pItem );
}
}
break;
default:
OSL_FAIL("wrong Dispatcher");
}
}
// Here the state for SID_IMAP / SID_CONTOUR will be handled
// until the swapping of the graphic is finished.
IMPL_LINK_NOARG(SwBaseShell, GraphicArrivedHdl, SwCursorShell&, void)
{
SwWrtShell &rSh = GetShell();
if (CNT_GRF != rSh.SwEditShell::GetCntType())
return;
GraphicType const nGrfType(rSh.GetGraphicType());
if (GraphicType::NONE == nGrfType || m_aGrfUpdateSlots.empty())
return;
bool bProtect = FlyProtectFlags::NONE != rSh.IsSelObjProtected(FlyProtectFlags::Content|FlyProtectFlags::Parent);
SfxViewFrame& rVFrame = GetView().GetViewFrame();
for( const auto nSlot : m_aGrfUpdateSlots )
{
bool bSetState = false;
bool bState = false;
switch( nSlot )
{
case SID_IMAP:
case SID_IMAP_EXEC:
{
sal_uInt16 nId = SvxIMapDlgChildWindow::GetChildWindowId();
SfxChildWindow *pChildWindow = rVFrame.HasChildWindow(nId) ?
rVFrame.GetChildWindow(nId) : nullptr;
SvxIMapDlg *pDlg = pChildWindow ?
static_cast<SvxIMapDlg*>(pChildWindow->GetController().get()) : nullptr;
if( pDlg && ( SID_IMAP_EXEC == nSlot ||
( SID_IMAP == nSlot && !bProtect)) &&
pDlg->GetEditingObject() != rSh.GetIMapInventor())
lcl_UpdateIMapDlg( rSh );
if( !bProtect && SID_IMAP == nSlot )
{
bSetState = true;
bState = nullptr != pDlg;
}
}
break;
case SID_CONTOUR_DLG:
if( !bProtect )
{
sal_uInt16 nId = SvxContourDlgChildWindow::GetChildWindowId();
SfxChildWindow *pChildWindow = rVFrame.HasChildWindow(nId) ?
rVFrame.GetChildWindow(nId) : nullptr;
SvxIMapDlg *pDlg = pChildWindow ?
static_cast<SvxIMapDlg*>(pChildWindow->GetController().get()) : nullptr;
if( pDlg && pDlg->GetEditingObject() !=
rSh.GetIMapInventor() )
lcl_UpdateContourDlg( rSh, SelectionType::Graphic );
bSetState = true;
bState = nullptr != pDlg;
}
break;
case FN_FRAME_WRAP_CONTOUR:
if( !bProtect )
{
SfxItemSetFixed<RES_SURROUND, RES_SURROUND> aSet(GetPool());
rSh.GetFlyFrameAttr(aSet);
const SwFormatSurround& rWrap = aSet.Get(RES_SURROUND);
bSetState = true;
bState = rWrap.IsContour();
}
break;
case SID_GRFFILTER:
case SID_GRFFILTER_INVERT:
case SID_GRFFILTER_SMOOTH:
case SID_GRFFILTER_SHARPEN:
case SID_GRFFILTER_REMOVENOISE:
case SID_GRFFILTER_SOBEL:
case SID_GRFFILTER_MOSAIC:
case SID_GRFFILTER_EMBOSS:
case SID_GRFFILTER_POSTER:
case SID_GRFFILTER_POPART:
case SID_GRFFILTER_SEPIA:
case SID_GRFFILTER_SOLARIZE:
bSetState = bState = GraphicType::Bitmap == nGrfType;
break;
}
if( bSetState )
{
SfxBoolItem aBool( nSlot, bState );
if( m_pGetStateSet )
m_pGetStateSet->Put( aBool );
else
rVFrame.GetBindings().SetState( aBool );
}
}
m_aGrfUpdateSlots.clear();
}
void SwBaseShell::GetState( SfxItemSet &rSet )
{
SwWrtShell &rSh = GetShell();
SfxViewFrame& rVFrame = GetView().GetViewFrame();
SfxWhichIter aIter( rSet );
sal_uInt16 nWhich = aIter.FirstWhich();
m_pGetStateSet = &rSet;
while ( nWhich )
{
switch ( nWhich )
{
case SID_GALLERY_FORMATS:
if ( rSh.IsObjSelected() ||
(rSh.IsSelFrameMode() &&
!(rSh.GetSelectionType() & SelectionType::Graphic)) )
rSet.DisableItem( nWhich );
break;
case SID_GALLERY_ENABLE_ADDCOPY:
// #108230# allow copy from gallery in Writer AND Writer/Web!
rSet.Put( SfxBoolItem( SID_GALLERY_ENABLE_ADDCOPY, true ) );
break;
case FN_EDIT_REGION:
if( !rSh.IsAnySectionInDoc() )
rSet.DisableItem(nWhich);
break;
case FN_EDIT_CURRENT_REGION:
//tdf#112808 if cursor is in an index, don't show the edit section.
if( !rSh.GetCurrSection() ||
(rSh.GetCurrSection()->GetType() != SectionType::Content &&
rSh.GetCurrSection()->GetType() != SectionType::FileLink ))
{
rSet.DisableItem(nWhich);
}
break;
case FN_INSERT_REGION:
if( rSh.CursorInsideInputField()
|| rSh.IsSelFrameMode()
|| !rSh.IsInsRegionAvailable() )
{
rSet.DisableItem( nWhich );
}
break;
case FN_CONVERT_TABLE_TO_TEXT:
{
FrameTypeFlags eFrameType = rSh.GetFrameType(nullptr,true);
if( (eFrameType & FrameTypeFlags::FOOTNOTE) ||
!rSh.GetTableFormat() )
rSet.DisableItem( nWhich );
}
break;
case FN_CONVERT_TEXT_TO_TABLE:
{
FrameTypeFlags eFrameType = rSh.GetFrameType(nullptr,true);
if( (eFrameType & FrameTypeFlags::FOOTNOTE) ||
!rSh.IsTextToTableAvailable() )
rSet.DisableItem( nWhich );
}
break;
case FN_CONVERT_TEXT_TABLE:
{
FrameTypeFlags eFrameType = rSh.GetFrameType(nullptr,true);
if( (eFrameType & FrameTypeFlags::FOOTNOTE) ||
(!rSh.GetTableFormat() && !rSh.IsTextToTableAvailable() ) )
rSet.DisableItem( nWhich );
}
break;
case RES_SHADOW:
{
SfxItemSetFixed<RES_SHADOW, RES_SHADOW> aSet( rSh.GetAttrPool());
// Table cell(s) selected?
if ( rSh.IsTableMode() )
{
SwFrameFormat *pFormat = rSh.GetTableFormat();
aSet.Put(pFormat->GetFormatAttr( nWhich ));
}
else if( rSh.IsFrameSelected() )
{
SwFlyFrameAttrMgr aMgr( false, &rSh, Frmmgr_Type::NONE, nullptr );
aSet.Put( aMgr.GetAttrSet() );
}
else
rSh.GetCurAttr( aSet );
const SvxShadowItem& rShItem = static_cast<const SvxShadowItem&>(aSet.Get(nWhich));
rSet.Put(rShItem);
}
break;
case SID_IMAP:
{
// #i59688#
// Improve efficiency:
// If selected object is protected, item has to disabled.
const bool bProtect = FlyProtectFlags::NONE != rSh.IsSelObjProtected(FlyProtectFlags::Content|FlyProtectFlags::Parent);
if ( bProtect )
{
rSet.DisableItem( nWhich );
}
else
{
const sal_uInt16 nId = SvxIMapDlgChildWindow::GetChildWindowId();
const bool bHas = rVFrame.HasChildWindow( nId );
const bool bFrameSel = rSh.IsFrameSelected();
const bool bIsGraphicSelection =
rSh.GetSelectionType() == SelectionType::Graphic;
// #i59688#
// Avoid unnecessary loading of selected graphic.
// The graphic is only needed, if the dialog is open.
// If the swapping of the graphic is finished, the status
// must be determined asynchronously, until this the slot
// will be disabled.
if ( bHas && bIsGraphicSelection && rSh.IsLinkedGrfSwapOut() )
{
if( AddGrfUpdateSlot( nWhich ))
rSh.GetGraphic(false); // start the loading
}
else
{
if ( !bHas &&
( !bFrameSel ||
( bIsGraphicSelection &&
rSh.GetGraphicType() == GraphicType::NONE ) ) )
{
rSet.DisableItem( nWhich );
}
else
{
SfxBoolItem aBool(nWhich, bHas);
if ( bHas && bFrameSel )
lcl_UpdateIMapDlg( rSh );
rSet.Put(aBool);
}
}
}
}
break;
case SID_IMAP_EXEC:
{
bool bDisable = false;
if( !rSh.IsFrameSelected())
bDisable = true;
sal_uInt16 nId = SvxIMapDlgChildWindow::GetChildWindowId();
if(!bDisable && rVFrame.HasChildWindow( nId ))
{
if(rSh.GetSelectionType() == SelectionType::Graphic
&& rSh.IsLinkedGrfSwapOut())
{
if( AddGrfUpdateSlot( nWhich ))
rSh.GetGraphic(false); // start the loading
}
else
{
SvxIMapDlg *pDlg = GetIMapDlg(GetView());
if (pDlg && pDlg->GetEditingObject() != rSh.GetIMapInventor())
lcl_UpdateIMapDlg( rSh );
}
}
rSet.Put(SfxBoolItem(nWhich, bDisable));
}
break;
case FN_BACKSPACE:
case SID_DELETE:
if ( ( rSh.HasReadonlySel() && !rSh.CursorInsideInputField() )
|| rSh.IsSelObjProtected( FlyProtectFlags::Content|FlyProtectFlags::Parent ) != FlyProtectFlags::NONE )
{
rSet.DisableItem( nWhich );
}
break;
case SID_CONTOUR_DLG:
{
bool bParentCntProt = FlyProtectFlags::NONE != rSh.IsSelObjProtected(FlyProtectFlags::Content|FlyProtectFlags::Parent );
if( bParentCntProt || 0 != (HTMLMODE_ON & ::GetHtmlMode(
GetView().GetDocShell() )) )
rSet.DisableItem( nWhich );
else
{
sal_uInt16 nId = SvxContourDlgChildWindow::GetChildWindowId();
bool bHas = GetView().GetViewFrame().HasChildWindow( nId );
SelectionType nSel = rSh.GetSelectionType();
bool bOk(nSel & (SelectionType::Graphic|SelectionType::Ole));
bool bDisable = false;
if( !bHas && !bOk )
bDisable = true;
// #i59688#
// Avoid unnecessary loading of selected graphic.
// The graphic is only needed, if the dialog is open.
// If the swapping of the graphic is finished, the status
// must be determined asynchronously, until this the slot
// will be disabled.
else if ( bHas && (nSel & SelectionType::Graphic) &&
rSh.IsLinkedGrfSwapOut() )
{
if( AddGrfUpdateSlot( nWhich ))
rSh.GetGraphic(false); // start the loading
// #i75481#
bDisable = true;
}
else if( bHas && bOk )
bDisable = !lcl_UpdateContourDlg( rSh, nSel );
else if( bOk )
{
// #i75481#
// apply fix #i59688# only for selected graphics
if ( nSel & SelectionType::Graphic )
bDisable = GraphicType::NONE == rSh.GetGraphicType();
else
bDisable = GraphicType::NONE == rSh.GetIMapGraphic().GetType();
}
if( bDisable )
rSet.DisableItem( nWhich );
else
rSet.Put( SfxBoolItem(nWhich, bHas) );
}
}
break;
case SID_CONTOUR_EXEC:
{
bool bDisable = false;
SelectionType nSel = rSh.GetSelectionType();
if( !(nSel & (SelectionType::Graphic|SelectionType::Ole)) )
bDisable = true;
sal_uInt16 nId = SvxContourDlgChildWindow::GetChildWindowId();
if( !bDisable && GetView().GetViewFrame().HasChildWindow( nId ))
{
SvxContourDlg *pDlg = GetContourDlg(GetView());
if (pDlg && pDlg->GetEditingObject() != rSh.GetIMapInventor())
bDisable = true;
}
rSet.Put(SfxBoolItem(nWhich, bDisable));
}
break;
case SID_ANCHOR_MENU:
case FN_TOOL_ANCHOR_PAGE:
case FN_TOOL_ANCHOR_PARAGRAPH:
case FN_TOOL_ANCHOR_CHAR:
case FN_TOOL_ANCHOR_AT_CHAR:
case FN_TOOL_ANCHOR_FRAME:
{
bool bObj = 0 != rSh.IsObjSelected();
bool bParentCntProt = rSh.IsSelObjProtected( FlyProtectFlags::Content|FlyProtectFlags::Parent ) != FlyProtectFlags::NONE;
if( !bParentCntProt && (bObj || rSh.IsFrameSelected()))
{
SfxItemSetFixed<RES_ANCHOR, RES_ANCHOR> aSet(GetPool());
if(bObj)
rSh.GetObjAttr(aSet);
else
rSh.GetFlyFrameAttr(aSet);
RndStdIds eSet = aSet.Get(RES_ANCHOR).GetAnchorId();
const bool bSet =
((nWhich == FN_TOOL_ANCHOR_PAGE) &&
(eSet == RndStdIds::FLY_AT_PAGE))
|| ((nWhich == FN_TOOL_ANCHOR_PARAGRAPH) &&
(eSet == RndStdIds::FLY_AT_PARA))
|| ((nWhich == FN_TOOL_ANCHOR_FRAME) &&
(eSet == RndStdIds::FLY_AT_FLY))
|| ((nWhich == FN_TOOL_ANCHOR_AT_CHAR) &&
(eSet == RndStdIds::FLY_AT_CHAR))
|| ((nWhich == FN_TOOL_ANCHOR_CHAR) &&
(eSet == RndStdIds::FLY_AS_CHAR));
if( nWhich == FN_TOOL_ANCHOR_FRAME && !rSh.IsFlyInFly() )
rSet.DisableItem(nWhich);
else if(nWhich != SID_ANCHOR_MENU)
rSet.Put(SfxBoolItem(nWhich, bSet));
if (comphelper::LibreOfficeKit::isActive())
{
if (nWhich == FN_TOOL_ANCHOR_PAGE || nWhich == FN_TOOL_ANCHOR_FRAME)
{
rSet.DisableItem(nWhich);
}
}
}
else
rSet.DisableItem( nWhich );
}
break;
case FN_FRAME_NOWRAP:
case FN_FRAME_WRAP:
case FN_FRAME_WRAP_IDEAL:
case FN_FRAME_WRAPTHRU:
case FN_FRAME_WRAPTHRU_TRANSP:
case FN_FRAME_WRAPTHRU_TOGGLE:
case FN_FRAME_WRAP_CONTOUR:
case FN_WRAP_ANCHOR_ONLY:
case FN_FRAME_WRAP_LEFT:
case FN_FRAME_WRAP_RIGHT:
{
bool bObj = 0 != rSh.IsObjSelected();
bool bParentCntProt = rSh.IsSelObjProtected( FlyProtectFlags::Content|FlyProtectFlags::Parent ) != FlyProtectFlags::NONE;
if( !bParentCntProt && (bObj || rSh.IsFrameSelected()))
{
SfxItemSetFixed<RES_OPAQUE, RES_ANCHOR> aSet(GetPool());
RndStdIds nAnchorType;
if(bObj)
{
rSh.GetObjAttr(aSet);
nAnchorType = rSh.GetAnchorId();
}
else
{
rSh.GetFlyFrameAttr(aSet);
nAnchorType = aSet.Get(RES_ANCHOR).GetAnchorId();
}
const SwFormatSurround& rWrap = aSet.Get(RES_SURROUND);
const SvxOpaqueItem& rOpaque = aSet.Get(RES_OPAQUE);
bool bOpaque = rOpaque.GetValue();
css::text::WrapTextMode nSurround = rWrap.GetSurround();
bool bSet = false;
bool bDisable =
(nAnchorType == RndStdIds::UNKNOWN) || (nAnchorType == RndStdIds::FLY_AS_CHAR);
const bool bHtmlMode =
0 != ::GetHtmlMode(GetView().GetDocShell());
switch( nWhich )
{
case FN_FRAME_NOWRAP:
bDisable |=
( (nAnchorType != RndStdIds::FLY_AT_PARA)
&& (nAnchorType != RndStdIds::FLY_AT_CHAR)
&& (nAnchorType != RndStdIds::FLY_AT_PAGE));
bSet = nSurround == css::text::WrapTextMode_NONE;
break;
case FN_FRAME_WRAP:
bDisable |= bHtmlMode;
bSet = nSurround == css::text::WrapTextMode_PARALLEL;
break;
case FN_FRAME_WRAP_IDEAL:
bDisable |= bHtmlMode;
bSet = nSurround == css::text::WrapTextMode_DYNAMIC;
break;
case FN_FRAME_WRAPTHRU:
bDisable |= (bHtmlMode ||
( (nAnchorType != RndStdIds::FLY_AT_PARA)
&& (nAnchorType != RndStdIds::FLY_AT_CHAR)
&& (nAnchorType != RndStdIds::FLY_AT_PAGE)));
if(bObj)
bSet = nSurround == css::text::WrapTextMode_THROUGH && rSh.GetLayerId();
else
bSet = nSurround == css::text::WrapTextMode_THROUGH && bOpaque;
break;
case FN_FRAME_WRAPTHRU_TRANSP:
case FN_FRAME_WRAPTHRU_TOGGLE:
bDisable |= bHtmlMode;
if(bObj)
bSet = nSurround == css::text::WrapTextMode_THROUGH && !rSh.GetLayerId();
else
bSet = nSurround == css::text::WrapTextMode_THROUGH && !bOpaque;
break;
case FN_FRAME_WRAP_CONTOUR:
bDisable |= bHtmlMode;
//no contour available when no wrap or wrap through is set
bDisable |= (nSurround == css::text::WrapTextMode_NONE || nSurround == css::text::WrapTextMode_THROUGH);
if( !bDisable )
{
SelectionType nSel = rSh.GetSelectionType();
if( (nSel & SelectionType::Graphic) &&
rSh.IsLinkedGrfSwapOut())
{
if( AddGrfUpdateSlot( nWhich ))
rSh.GetGraphic(false); // start the loading
}
else if( rSh.IsFrameSelected() )
{
// #i102253# applied patch from OD (see task)
bDisable =
nSel & SelectionType::Frame ||
GraphicType::NONE == rSh.GetIMapGraphic().GetType();
}
}
bSet = !bDisable && rWrap.IsContour();
break;
case FN_WRAP_ANCHOR_ONLY:
bDisable |= (bHtmlMode ||
(nAnchorType != RndStdIds::FLY_AT_PARA));
bSet = rWrap.IsAnchorOnly();
break;
case FN_FRAME_WRAP_LEFT:
bSet = nSurround == css::text::WrapTextMode_LEFT;
break;
case FN_FRAME_WRAP_RIGHT:
bSet = nSurround == css::text::WrapTextMode_RIGHT;
break;
}
if(bDisable)
rSet.DisableItem(nWhich);
else
rSet.Put(SfxBoolItem(nWhich, bSet));
}
else
rSet.DisableItem(nWhich);
}
break;
case FN_UPDATE_CHARTS:
if( !rSh.HasCharts() )
rSet.DisableItem( nWhich );
break;
case FN_UPDATE_ALL_LINKS:
if ( rSh.GetLinkManager().GetLinks().empty() )
rSet.DisableItem(nWhich);
break;
case FN_XFORMS_DESIGN_MODE:
// enable if in XForms document
if( rSh.GetDoc()->isXForms() )
{
// determine current state from view options
bool bValue = ! rSh.GetViewOptions()->IsFormView();
rSet.Put( SfxBoolItem( nWhich, bValue ) );
}
else
rSet.Put( SfxVisibilityItem( nWhich, false ) );
break;
case SID_GRAPHIC_SIZE_CHECK:
{
sal_Int32 nDPI = rSh.GetDoc()->getIDocumentSettingAccess().getImagePreferredDPI();
if (nDPI <= 0)
rSet.DisableItem(nWhich);
}
break;
case SID_THEME_DIALOG:
{
bool bDisable = true;
auto* pDocument = rSh.GetDoc();
auto* pDocumentShell = pDocument->GetDocShell();
if (pDocumentShell)
{
SdrModel* pModel = pDocument->getIDocumentDrawModelAccess().GetDrawModel();
if (pModel)
{
auto const& pTheme = pModel->getTheme();
if (pTheme)
bDisable = false;
}
}
if (bDisable)
rSet.DisableItem(nWhich);
}
break;
}
nWhich = aIter.NextWhich();
}
m_pGetStateSet = nullptr;
}
// Disable the slots with this status method
void SwBaseShell::StateDisableItems( SfxItemSet &rSet )
{
SfxWhichIter aIter(rSet);
sal_uInt16 nWhich = aIter.FirstWhich();
while (nWhich)
{
rSet.DisableItem( nWhich );
nWhich = aIter.NextWhich();
}
}
// Disable the slots with this status method
void SwBaseShell::StateStyle( SfxItemSet &rSet )
{
bool bParentCntProt = GetShell().IsSelObjProtected( FlyProtectFlags::Content|FlyProtectFlags::Parent ) != FlyProtectFlags::NONE;
ShellMode eMode = GetView().GetShellMode();
if ( bParentCntProt ||
ShellMode::Draw == eMode ||
ShellMode::DrawForm == eMode ||
ShellMode::DrawText == eMode ||
ShellMode::Bezier == eMode )
{
SfxWhichIter aIter( rSet );
sal_uInt16 nWhich = aIter.FirstWhich();
while ( nWhich )
{
rSet.DisableItem( nWhich );
nWhich = aIter.NextWhich();
}
}
else
GetView().GetDocShell()->StateStyleSheet(rSet, &GetShell());
}
void SwBaseShell::SetWrapMode( sal_uInt16 nSlot )
{
SwWrtShell &rSh = GetShell();
bool bObj = 0 != rSh.IsObjSelected();
if( !bObj && !rSh.IsFrameSelected())
return;
SfxItemSetFixed<RES_OPAQUE, RES_SURROUND> aSet(GetPool());
if(bObj)
rSh.GetObjAttr(aSet);
else
rSh.GetFlyFrameAttr(aSet);
SwFormatSurround aWrap( aSet.Get(RES_SURROUND) );
css::text::WrapTextMode nOldSurround(aWrap.GetSurround());
css::text::WrapTextMode nSurround = css::text::WrapTextMode_PARALLEL;
switch (nSlot)
{
case FN_FRAME_NOWRAP:
nSurround = css::text::WrapTextMode_NONE;
if (aWrap.IsContour())
aWrap.SetContour(false);
break;
case FN_FRAME_WRAP_IDEAL:
nSurround = css::text::WrapTextMode_DYNAMIC;
break;
case FN_WRAP_ANCHOR_ONLY:
aWrap.SetAnchorOnly(!aWrap.IsAnchorOnly());
// keep previous wrapping
// switch to wrap css::text::WrapTextMode_PARALLEL, if previous wrap is css::text::WrapTextMode_NONE
if ( nOldSurround != css::text::WrapTextMode_NONE )
{
nSurround = nOldSurround;
}
break;
case FN_FRAME_WRAP_CONTOUR:
aWrap.SetContour(!aWrap.IsContour());
// Contour is meaningless in no-wrap or wrap-through context. Otherwise keep existing wrap.
if ( !aWrap.IsContour() ||
( nOldSurround != css::text::WrapTextMode_NONE &&
nOldSurround != css::text::WrapTextMode_THROUGH ) )
{
nSurround = nOldSurround;
}
break;
case FN_FRAME_WRAPTHRU_TRANSP:
case FN_FRAME_WRAPTHRU_TOGGLE:
if (aWrap.IsContour())
aWrap.SetContour(false);
[[fallthrough]];
case FN_FRAME_WRAPTHRU:
nSurround = css::text::WrapTextMode_THROUGH;
break;
case FN_FRAME_WRAP_LEFT:
nSurround = css::text::WrapTextMode_LEFT;
break;
case FN_FRAME_WRAP_RIGHT:
nSurround = css::text::WrapTextMode_RIGHT;
break;
default:
break;
}
aWrap.SetSurround(nSurround);
if (nSlot != FN_FRAME_WRAP_CONTOUR)
{
// Defaulting the contour wrap on draw objects.
if (bObj && nOldSurround != nSurround &&
(nOldSurround == css::text::WrapTextMode_NONE || nOldSurround == css::text::WrapTextMode_THROUGH))
{
aWrap.SetContour(true);
}
}
aSet.Put( aWrap );
bool bOpaque = nSlot != FN_FRAME_WRAPTHRU_TRANSP && nSlot != FN_FRAME_WRAPTHRU_TOGGLE;
if( nSlot == FN_FRAME_WRAPTHRU_TOGGLE )
{
if( bObj )
bOpaque = !rSh.GetLayerId();
else
{
const SvxOpaqueItem& aOpaque( aSet.Get(RES_OPAQUE) );
bOpaque = !aOpaque.GetValue();
}
}
aSet.Put(SvxOpaqueItem(RES_OPAQUE, bOpaque ));
if(bObj)
{
rSh.SetObjAttr(aSet);
if ( bOpaque )
rSh.SelectionToHeaven();
else
rSh.SelectionToHell();
}
else
rSh.SetFlyFrameAttr(aSet);
}
//Force update of the status line
void SwBaseShell::SetFrameMode(FlyMode eMode, SwWrtShell *pSh )
{
s_eFrameMode = eMode;
SfxBindings &rBnd = pSh->GetView().GetViewFrame().GetBindings();
if( eMode == FLY_DRAG || pSh->IsFrameSelected() || pSh->IsObjSelected() )
{
const SfxPointItem aTmp1( SID_ATTR_POSITION, pSh->GetAnchorObjDiff());
const SvxSizeItem aTmp2( SID_ATTR_SIZE, pSh->GetObjSize());
rBnd.SetState( aTmp1 );
rBnd.SetState( aTmp2 );
}
else if( eMode == FLY_DRAG_END )
{
static sal_uInt16 aInval[] =
{
SID_ATTR_POSITION, SID_ATTR_SIZE, 0
};
rBnd.Invalidate(aInval);
}
}
SwBaseShell::SwBaseShell(SwView& rVw) :
SfxShell( &rVw ),
m_rView(rVw),
m_pGetStateSet(nullptr)
{
SwWrtShell& rWrtSh = m_rView.GetWrtShell();
SetPool(&rWrtSh.GetAttrPool());
SetName(u"Base"_ustr);
rWrtSh.SetGrfArrivedLnk( LINK( this, SwBaseShell, GraphicArrivedHdl));
}
SwBaseShell::~SwBaseShell()
{
if( m_rView.GetCurShell() == this )
m_rView.ResetSubShell();
Link<SwCursorShell&,void> aTmp( LINK( this, SwBaseShell, GraphicArrivedHdl));
if( aTmp == m_rView.GetWrtShell().GetGrfArrivedLnk() )
m_rView.GetWrtShell().SetGrfArrivedLnk( Link<SwCursorShell&,void>() );
}
void SwBaseShell::ExecTextCtrl( SfxRequest& rReq )
{
const SfxItemSet *pArgs = rReq.GetArgs();
const sal_uInt16 nSlot = rReq.GetSlot();
if( pArgs)
{
SwWrtShell &rSh = GetShell();
std::unique_ptr<SvxScriptSetItem> pSSetItem;
SfxItemPool& rPool = rSh.GetAttrPool();
sal_uInt16 nWhich = rPool.GetWhichIDFromSlotID( nSlot );
SvtScriptType nScripts = SvtScriptType::LATIN | SvtScriptType::ASIAN | SvtScriptType::COMPLEX;
SfxItemSetFixed<RES_CHRATR_FONTSIZE, RES_CHRATR_FONTSIZE,
RES_CHRATR_CJK_FONTSIZE, RES_CHRATR_CJK_FONTSIZE,
RES_CHRATR_CTL_FONTSIZE, RES_CHRATR_CTL_FONTSIZE>
aHeightSet( GetPool() );
switch( nSlot )
{
case SID_ATTR_CHAR_FONT:
{
nScripts = rSh.GetScriptType();
// #i42732# input language should be preferred over
// current cursor position to detect script type
if(!rSh.HasSelection())
{
LanguageType nInputLang = GetView().GetEditWin().GetInputLanguage();
if(nInputLang != LANGUAGE_DONTKNOW && nInputLang != LANGUAGE_SYSTEM)
nScripts = SvtLanguageOptions::GetScriptTypeOfLanguage( nInputLang );
}
[[fallthrough]];
}
case SID_ATTR_CHAR_POSTURE:
case SID_ATTR_CHAR_WEIGHT:
{
pSSetItem.reset(new SvxScriptSetItem( nSlot, rPool ));
pSSetItem->PutItemForScriptType( nScripts, pArgs->Get( nWhich ));
pArgs = &pSSetItem->GetItemSet();
}
break;
case SID_ATTR_CHAR_FONTHEIGHT:
{
if(rSh.HasSelection())
{
pSSetItem.reset(new SvxScriptSetItem( nSlot, rPool ));
pSSetItem->PutItemForScriptType( nScripts, pArgs->Get( nWhich ));
pArgs = &pSSetItem->GetItemSet();
}
else
{
nScripts = rSh.GetScriptType();
LanguageType nInputLang = GetView().GetEditWin().GetInputLanguage();
if(nInputLang != LANGUAGE_DONTKNOW && nInputLang != LANGUAGE_SYSTEM)
nScripts = SvtLanguageOptions::GetScriptTypeOfLanguage( nInputLang );
sal_uInt32 nHeight = static_cast< const SvxFontHeightItem& >(pArgs->Get( nWhich )).GetHeight();
SwStdFontConfig* pStdFont = SW_MOD()->GetStdFontConfig();
SfxItemSetFixed<RES_CHRATR_LANGUAGE, RES_CHRATR_LANGUAGE,
RES_CHRATR_CJK_LANGUAGE, RES_CHRATR_CJK_LANGUAGE,
RES_CHRATR_CTL_LANGUAGE, RES_CHRATR_CTL_LANGUAGE>
aLangSet( GetPool() );
rSh.GetCurAttr( aLangSet );
sal_Int32 nWesternSize =
pStdFont->GetFontHeight(FONT_STANDARD, FONT_GROUP_DEFAULT,
aLangSet.Get( RES_CHRATR_LANGUAGE).GetLanguage());
sal_Int32 nCJKSize =
pStdFont->GetFontHeight(FONT_STANDARD, FONT_GROUP_CJK,
aLangSet.Get( RES_CHRATR_CJK_LANGUAGE).GetLanguage());
sal_Int32 nCTLSize =
pStdFont->GetFontHeight(FONT_STANDARD, FONT_GROUP_CTL,
aLangSet.Get( RES_CHRATR_CTL_LANGUAGE).GetLanguage());
switch(nScripts)
{
case SvtScriptType::LATIN:
nCJKSize = nHeight * nCJKSize / nWesternSize;
nCTLSize = nHeight * nCTLSize / nWesternSize;
nWesternSize = static_cast<sal_Int32>(nHeight);
break;
case SvtScriptType::ASIAN:
nCTLSize = nHeight* nCTLSize / nCJKSize;
nWesternSize = nHeight * nWesternSize / nCJKSize;
nCJKSize = static_cast<sal_Int32>(nHeight);
break;
case SvtScriptType::COMPLEX:
nCJKSize = nHeight * nCJKSize / nCTLSize;
nWesternSize = nHeight * nWesternSize / nCTLSize;
nCTLSize = static_cast<sal_Int32>(nHeight);
break;
default: break;
}
aHeightSet.Put( SvxFontHeightItem( static_cast<sal_uInt32>(nWesternSize), 100, RES_CHRATR_FONTSIZE ));
aHeightSet.Put( SvxFontHeightItem( static_cast<sal_uInt32>(nCJKSize), 100, RES_CHRATR_CJK_FONTSIZE ));
aHeightSet.Put( SvxFontHeightItem( static_cast<sal_uInt32>(nCTLSize), 100, RES_CHRATR_CTL_FONTSIZE ));
pArgs = &aHeightSet;
}
}
break;
}
if( pArgs )
{
bool bAuto = false;
if ( !isCHRATR(nWhich) ||
( rSh.HasSelection() && rSh.IsSelFullPara() ) )
{
SwTextFormatColl * pColl = rSh.GetCurTextFormatColl();
if ( pColl && pColl->IsAutoUpdateOnDirectFormat() )
{
rSh.AutoUpdatePara( pColl, *pArgs );
bAuto = true;
}
}
if (!bAuto)
{
rSh.SetAttrSet( *pArgs );
}
}
}
else
{
if (nSlot == SID_ATTR_CHAR_KERNING)
GetView().GetViewFrame().GetDispatcher()->Execute(SID_CHAR_DLG_POSITION);
else if (nSlot == SID_ATTR_CHAR_COLOR)
GetView().GetViewFrame().GetDispatcher()->Execute(SID_CHAR_DLG_EFFECT);
else
GetView().GetViewFrame().GetDispatcher()->Execute(SID_CHAR_DLG);
}
rReq.Done();
}
void SwBaseShell::GetTextCtrlState( SfxItemSet& rSet )
{
SwWrtShell &rSh = GetShell();
rSh.GetCurAttr( rSet );
}
void SwBaseShell::GetTextFontCtrlState( SfxItemSet& rSet )
{
SwWrtShell &rSh = GetShell();
bool bFirst = true;
std::optional<SfxItemSet> pFntCoreSet;
SvtScriptType nScriptType = SvtScriptType::LATIN;
SfxWhichIter aIter( rSet );
sal_uInt16 nWhich = aIter.FirstWhich();
while( nWhich )
{
switch( nWhich )
{
case RES_CHRATR_FONT:
case RES_CHRATR_FONTSIZE:
case RES_CHRATR_WEIGHT:
case RES_CHRATR_POSTURE:
{
if( !pFntCoreSet )
{
pFntCoreSet.emplace( *rSet.GetPool(),
svl::Items<RES_CHRATR_BEGIN, RES_CHRATR_END-1> );
rSh.GetCurAttr( *pFntCoreSet );
nScriptType = rSh.GetScriptType();
// #i42732# input language should be preferred over
// current cursor position to detect script type
SwEditWin& rEditWin = GetView().GetEditWin();
if( rEditWin.IsUseInputLanguage() )
{
if(!rSh.HasSelection() && (
nWhich == RES_CHRATR_FONT ||
nWhich == RES_CHRATR_FONTSIZE ))
{
LanguageType nInputLang = rEditWin.GetInputLanguage();
if(nInputLang != LANGUAGE_DONTKNOW && nInputLang != LANGUAGE_SYSTEM)
nScriptType = SvtLanguageOptions::GetScriptTypeOfLanguage( nInputLang );
}
}
}
SfxItemPool& rPool = *rSet.GetPool();
SvxScriptSetItem aSetItem( rPool.GetSlotId( nWhich ), rPool );
aSetItem.GetItemSet().Put( *pFntCoreSet, false );
const SfxPoolItem* pI = aSetItem.GetItemOfScript( nScriptType );
if( pI )
{
rSet.Put( pI->CloneSetWhich(nWhich) );
}
else
rSet.InvalidateItem( nWhich );
// Set input context of the SwEditWin according to the selected font and script type
if(RES_CHRATR_FONT == nWhich)
{
vcl::Font aFont;
if (const SvxFontItem* pFontItem = dynamic_cast<const SvxFontItem*>(pI))
{
aFont.SetFamilyName(pFontItem->GetFamilyName());
aFont.SetStyleName(pFontItem->GetStyleName());
aFont.SetFamily(pFontItem->GetFamily());
aFont.SetPitch(pFontItem->GetPitch());
aFont.SetCharSet(pFontItem->GetCharSet());
}
bool bVertical = rSh.IsInVerticalText();
aFont.SetOrientation(Degree10(bVertical ? 2700 : 0));
aFont.SetVertical(bVertical);
GetView().GetEditWin().SetInputContext( InputContext( std::move(aFont), InputContextFlags::Text |
InputContextFlags::ExtText ) );
}
}
break;
default:
if( bFirst )
{
rSh.GetCurAttr( rSet );
bFirst = false;
}
}
nWhich = aIter.NextWhich();
}
}
void SwBaseShell::GetBckColState(SfxItemSet &rSet)
{
SwWrtShell &rSh = GetShell();
SfxWhichIter aIter(rSet);
sal_uInt16 nWhich(aIter.FirstWhich());
SelectionType nSelType(rSh.GetSelectionType());
std::unique_ptr<SvxBrushItem> aBrushItem(std::make_unique<SvxBrushItem>(RES_BACKGROUND));
if( nWhich == SID_TABLE_CELL_BACKGROUND_COLOR )
{
rSh.GetBoxBackground( aBrushItem );
}
else
{
// Adapt to new DrawingLayer FillStyle; use a parent which has XFILL_NONE set
SfxItemSetFixed<XATTR_FILL_FIRST, XATTR_FILL_LAST> aCoreSet(GetPool());
aCoreSet.SetParent(&GetView().GetDocShell()->GetDoc()->GetDfltFrameFormat()->GetAttrSet());
if(nSelType & SelectionType::Graphic || SelectionType::Frame & nSelType)
{
rSh.GetFlyFrameAttr(aCoreSet);
}
else
{
rSh.GetCurAttr(aCoreSet);
}
aBrushItem = getSvxBrushItemFromSourceSet(aCoreSet, RES_BACKGROUND);
}
while(nWhich)
{
switch(nWhich)
{
case SID_BACKGROUND_COLOR:
case SID_TABLE_CELL_BACKGROUND_COLOR:
{
SvxColorItem aColorItem(aBrushItem->GetColor(), aBrushItem->getComplexColor(), nWhich);
rSet.Put(aColorItem);
break;
}
case SID_ATTR_BRUSH:
case RES_BACKGROUND:
{
// if this was intended to have a independent copy of the Item to be set
// this is not needed due to the ItemSet/Pool cloning Items which get set anyways.
// Keeping code as reference - it may have had other reasons I do notz see (?!?)
// std::unique_ptr<SfxPoolItem> pNewItem(aBrushItem.CloneSetWhich(GetPool().GetWhich(nWhich)));
rSet.Put(*aBrushItem);
break;
}
}
nWhich = aIter.NextWhich();
}
}
void SwBaseShell::ExecBckCol(SfxRequest& rReq)
{
SwWrtShell &rSh = GetShell();
SelectionType nSelType(rSh.GetSelectionType());
const SfxItemSet* pArgs = rReq.GetArgs();
sal_uInt16 nSlot(rReq.GetSlot());
if (!pArgs && nSlot != SID_BACKGROUND_COLOR && nSlot != SID_TABLE_CELL_BACKGROUND_COLOR)
{
return;
}
std::unique_ptr<SvxBrushItem> aBrushItem(std::make_unique<SvxBrushItem>(RES_BACKGROUND));
if ( nSlot == SID_TABLE_CELL_BACKGROUND_COLOR )
{
rSh.GetBoxBackground( aBrushItem );
}
else
{
// Adapt to new DrawingLayer FillStyle; use a parent which has XFILL_NONE set
SfxItemSetFixed<XATTR_FILL_FIRST, XATTR_FILL_LAST> aCoreSet(GetPool());
aCoreSet.SetParent(&GetView().GetDocShell()->GetDoc()->GetDfltFrameFormat()->GetAttrSet());
if((SelectionType::Frame & nSelType) || (SelectionType::Graphic & nSelType))
{
rSh.GetFlyFrameAttr(aCoreSet);
}
else
{
rSh.GetCurAttr(aCoreSet);
}
aBrushItem = getSvxBrushItemFromSourceSet(aCoreSet, RES_BACKGROUND);
}
switch(nSlot)
{
case SID_BACKGROUND_COLOR:
case SID_TABLE_CELL_BACKGROUND_COLOR:
{
bool bIsTransparent = false;
aBrushItem->SetGraphicPos(GPOS_NONE);
sal_uInt16 nSlotId = (nSlot == SID_BACKGROUND_COLOR) ? SID_BACKGROUND_COLOR : SID_TABLE_CELL_BACKGROUND_COLOR;
if (pArgs)
{
const SvxColorItem& rNewColorItem = static_cast<const SvxColorItem&>(pArgs->Get(nSlotId));
aBrushItem->SetColor(rNewColorItem.GetValue());
aBrushItem->setComplexColor(rNewColorItem.getComplexColor());
GetView().GetViewFrame().GetBindings().SetState(rNewColorItem);
}
else
{
bIsTransparent = true;
}
if (bIsTransparent)
{
aBrushItem->SetColor(COL_TRANSPARENT);
rReq.AppendItem(SvxColorItem(COL_TRANSPARENT,nSlot));
}
break;
}
case SID_ATTR_BRUSH:
case RES_BACKGROUND:
{
assert(pArgs && "only SID_BACKGROUND_COLOR can have !pArgs, checked at entry");
aBrushItem.reset(static_cast<SvxBrushItem*>(pArgs->Get(GetPool().GetWhichIDFromSlotID(nSlot)).Clone()));
break;
}
default:
{
rReq.Ignore();
OSL_FAIL("unknown message in ExecuteAttr!" );
return;
}
}
if ( nSlot == SID_TABLE_CELL_BACKGROUND_COLOR )
{
rSh.SetBoxBackground( *aBrushItem );
}
else
{
// Adapt to new DrawingLayer FillStyle; use a parent which has XFILL_NONE set
SfxItemSetFixed<XATTR_FILL_FIRST, XATTR_FILL_LAST> aCoreSet(GetPool());
aCoreSet.SetParent(&GetView().GetDocShell()->GetDoc()->GetDfltFrameFormat()->GetAttrSet());
setSvxBrushItemAsFillAttributesToTargetSet(*aBrushItem, aCoreSet);
if((SelectionType::Frame & nSelType) || (SelectionType::Graphic & nSelType))
{
// Template autoupdate
SwFrameFormat* pFormat = rSh.GetSelectedFrameFormat();
if(pFormat && pFormat->IsAutoUpdateOnDirectFormat())
{
rSh.AutoUpdateFrame(pFormat, aCoreSet);
}
else
{
rSh.SetFlyFrameAttr(aCoreSet);
}
}
else
{
SwTextFormatColl* pColl = rSh.GetCurTextFormatColl();
if(pColl && pColl->IsAutoUpdateOnDirectFormat())
{
rSh.AutoUpdatePara(pColl, aCoreSet);
}
else
{
rSh.SetAttrSet(aCoreSet);
}
}
}
rReq.Done();
}
void SwBaseShell::GetBorderState(SfxItemSet &rSet)
{
SwWrtShell &rSh = GetShell();
// Table cell(s) selected?
bool bPrepare = true;
bool bTableMode = rSh.IsTableMode();
if ( bTableMode )
{
SfxItemSetFixed<RES_BOX, RES_BOX,
SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER> aCoreSet( GetPool() );
SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
aCoreSet.Put( aBoxInfo );
rSh.GetTabBorders( aCoreSet );
rSet.Put( aCoreSet );
}
else if ( rSh.IsFrameSelected() )
{
SwFlyFrameAttrMgr aMgr( false, &rSh, Frmmgr_Type::NONE, nullptr );
rSet.Put( aMgr.GetAttrSet() );
bPrepare = false;
}
else
// Get border attributes via shell quite normal
rSh.GetCurAttr( rSet );
if ( bPrepare )
::PrepareBoxInfo( rSet, rSh );
// Switch the border toolbox controller mode
rSet.Put( SfxBoolItem( SID_BORDER_REDUCED_MODE, !bTableMode ));
}
void SwBaseShell::ExecDlg(SfxRequest &rReq)
{
SwWrtShell &rSh = GetShell();
weld::Window* pMDI = GetView().GetFrameWeld();
// So that from the basic no dialogues for the background views are called:
bool bBackground = (&GetView() != GetActiveView());
const SfxPoolItem* pItem = nullptr;
const SfxItemSet* pArgs = rReq.GetArgs();
sal_uInt16 nSlot = rReq.GetSlot();
const SfxItemSet* pOutSet = nullptr;
bool bDone = false;
if(pArgs)
pArgs->GetItemState( GetPool().GetWhichIDFromSlotID(nSlot), false, &pItem );
switch ( nSlot )
{
case FN_FORMAT_TITLEPAGE_DLG:
{
SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
ScopedVclPtr<VclAbstractDialog> pDlg(pFact->CreateTitlePageDlg(pMDI));
VclAbstractDialog::AsyncContext aContext;
aContext.maEndDialogFn = [](sal_Int32){};
pDlg->StartExecuteAsync(aContext);
}
break;
case FN_FORMAT_PAGE_DLG:
case FN_FORMAT_PAGE_COLUMN_DLG:
case FN_FORMAT_PAGE_SETTING_DLG:
case FN_FORMAT_PAGE_AREA_DLG:
{
if( !bBackground )
{
const size_t nCurIdx = rSh.GetCurPageDesc();
const SwPageDesc& rPageDesc = rSh.GetPageDesc( nCurIdx );
// Temporary view, because the shell does not need to be valid after the dialog
// for example disable header
SwView& rTempView = GetView();
OUString sPageId;
switch (nSlot)
{
case FN_FORMAT_PAGE_COLUMN_DLG:
sPageId = "columns";
break;
case FN_FORMAT_PAGE_SETTING_DLG:
sPageId = "page";
break;
case FN_FORMAT_PAGE_AREA_DLG:
sPageId = "area";
break;
case FN_FORMAT_PAGE_DLG:
if (pItem)
sPageId = static_cast<const SfxStringItem*>(pItem)->GetValue();
break;
}
rTempView.GetDocShell()->FormatPage(rReq.GetFrameWeld(), rPageDesc.GetName(), sPageId, rSh, &rReq);
rTempView.InvalidateRulerPos();
bDone = true; // FormatPage() takes care of calling Done()
}
}
break;
case FN_FORMAT_BORDER_DLG:
{
SfxItemSetFixed<RES_BOX , RES_SHADOW,
SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER> aSet( rSh.GetAttrPool() );
ScopedVclPtr<SfxAbstractDialog> pDlg;
// Table cell(s) selected?
if ( rSh.IsTableMode() )
{
// Set border attributes Get/SetTabBorders()
::PrepareBoxInfo( aSet, rSh );
rSh.GetTabBorders( aSet );
SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
pDlg.disposeAndReset(pFact->CreateSwBorderDlg(pMDI, aSet, SwBorderModes::TABLE));
if ( pDlg->Execute() == RET_OK )
{
rSh.SetTabBorders( *pDlg->GetOutputItemSet() );
pOutSet = pDlg->GetOutputItemSet();
}
}
else if ( rSh.IsFrameSelected() )
{
// Set border attributes via Frame-Manager
SwFlyFrameAttrMgr aMgr( false, &rSh, Frmmgr_Type::NONE, nullptr );
aSet.Put( aMgr.GetAttrSet() );
SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
pDlg.disposeAndReset(pFact->CreateSwBorderDlg(pMDI, aSet, SwBorderModes::FRAME));
if ( pDlg->Execute() == RET_OK )
{
aMgr.SetAttrSet( *pDlg->GetOutputItemSet() );
aMgr.UpdateFlyFrame();
pOutSet = pDlg->GetOutputItemSet();
}
}
else
{
// Set border attributes via Shell quite normal
rSh.GetCurAttr( aSet );
::PrepareBoxInfo( aSet, rSh );
SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
pDlg.disposeAndReset(pFact->CreateSwBorderDlg(pMDI, aSet, SwBorderModes::PARA));
if ( pDlg->Execute() == RET_OK )
{
rSh.SetAttrSet( *pDlg->GetOutputItemSet() );
pOutSet = pDlg->GetOutputItemSet();
}
}
if(pOutSet)
{
rReq.Done(*pOutSet);
bDone = true;
}
}
break;
case FN_FORMAT_BACKGROUND_DLG:
{
SfxItemSetFixed<RES_BACKGROUND, RES_BACKGROUND,
XATTR_FILL_FIRST, XATTR_FILL_LAST> aSet( rSh.GetAttrPool() );
ScopedVclPtr<SfxAbstractDialog> pDlg;
SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
// Table cell(s) selected?
if ( rSh.IsTableMode() )
{
// Get background attributes of the table and put it in the set
// tdf#144843 calling GetBoxBackground *requires* an incarnation to be handed over
std::unique_ptr<SvxBrushItem> aBrush(std::make_unique<SvxBrushItem>(RES_BACKGROUND));
rSh.GetBoxBackground( aBrush );
pDlg.disposeAndReset(pFact->CreateSwBackgroundDialog(pMDI, aSet));
aSet.Put( std::move(aBrush) );
if ( pDlg->Execute() == RET_OK )
{
rSh.SetBoxBackground( pDlg->GetOutputItemSet()->Get( RES_BACKGROUND ) );
pOutSet = pDlg->GetOutputItemSet();
}
}
else if ( rSh.IsFrameSelected() )
{
rSh.GetFlyFrameAttr( aSet );
pDlg.disposeAndReset(pFact->CreateSwBackgroundDialog(pMDI, aSet));
if ( pDlg->Execute() == RET_OK )
{
rSh.SetFlyFrameAttr(const_cast<SfxItemSet &>(*pDlg->GetOutputItemSet()) );
pOutSet = pDlg->GetOutputItemSet();
}
}
else
{
// Set border attributes Umrandungsattribute with the shell quite normal.
rSh.GetCurAttr( aSet );
pDlg.disposeAndReset(pFact->CreateSwBackgroundDialog(pMDI, aSet));
if ( pDlg->Execute() == RET_OK )
{
rSh.SetAttrSet( *pDlg->GetOutputItemSet() );
pOutSet = pDlg->GetOutputItemSet();
}
}
if(pOutSet)
{
rReq.Done(*pOutSet);
bDone = true;
}
}
break;
case SID_GRAPHIC_SIZE_CHECK:
{
sw::GraphicSizeCheckGUIResult aResult(rSh.GetDoc());
svx::GenericCheckDialog aDialog(pMDI, aResult);
aDialog.run();
}
break;
case SID_THEME_DIALOG:
{
auto* pDocument = rSh.GetDoc();
auto* pDocumentShell = pDocument->GetDocShell();
if (pDocumentShell)
{
SdrModel* pModel = pDocument->getIDocumentDrawModelAccess().GetDrawModel();
auto const& pTheme = pModel->getTheme();
if (pTheme)
{
std::shared_ptr<svx::IThemeColorChanger> xChanger(new sw::ThemeColorChanger(pDocumentShell));
auto pDialog = std::make_shared<svx::ThemeDialog>(pMDI, pTheme.get());
weld::DialogController::runAsync(pDialog, [pDialog, xChanger=std::move(xChanger)](sal_uInt32 nResult) {
if (RET_OK != nResult)
return;
auto pColorSet = pDialog->getCurrentColorSet();
if (pColorSet)
{
xChanger->apply(pColorSet);
}
});
}
}
}
break;
default:OSL_FAIL("wrong Dispatcher (basesh.cxx)");
}
if(!bDone)
rReq.Done();
}
SwWrtShell& SwBaseShell::GetShell()
{
return m_rView.GetWrtShell();
}
SwWrtShell* SwBaseShell::GetShellPtr()
{
return m_rView.GetWrtShellPtr();
}
static void EndUndo(SwWrtShell& rSh)
{
SwRewriter aRewriter;
if (rSh.GetTableFormat())
{
aRewriter.AddRule(UndoArg1, SwResId(STR_START_QUOTE));
aRewriter.AddRule(UndoArg2, rSh.GetTableFormat()->GetName());
aRewriter.AddRule(UndoArg3, SwResId(STR_END_QUOTE));
}
rSh.EndUndo(SwUndoId::INSTABLE, &aRewriter); // If possible change the Shell
}
static void InsertTableImpl(SwWrtShell& rSh,
SwView &rTempView,
const OUString& aTableName,
sal_uInt16 nRows,
sal_uInt16 nCols,
SwInsertTableOptions aInsTableOpts,
const OUString& aAutoName,
const std::unique_ptr<SwTableAutoFormat>& pTAFormat)
{
rSh.StartUndo(SwUndoId::INSTABLE);
rSh.StartAllAction();
if( rSh.HasSelection() )
rSh.DelRight();
rSh.InsertTable( aInsTableOpts, nRows, nCols, pTAFormat.get() );
rSh.MoveTable( GotoPrevTable, fnTableStart );
if( !aTableName.isEmpty() && !rSh.GetTableStyle( aTableName ) )
rSh.GetTableFormat()->SetFormatName( aTableName );
if( pTAFormat != nullptr && !aAutoName.isEmpty()
&& aAutoName != SwViewShell::GetShellRes()->aStrNone )
{
SwTableNode* pTableNode = const_cast<SwTableNode*>( rSh.IsCursorInTable() );
if ( pTableNode )
{
pTableNode->GetTable().SetTableStyleName( aAutoName );
SwUndoTableAutoFormat* pUndo = new SwUndoTableAutoFormat( *pTableNode, *pTAFormat );
if ( pUndo )
rSh.GetIDocumentUndoRedo().AppendUndo( std::unique_ptr<SwUndo>(pUndo) );
}
}
rSh.EndAllAction();
rTempView.AutoCaption(TABLE_CAP);
}
void SwBaseShell::InsertTable( SfxRequest& _rRequest )
{
const SfxItemSet* pArgs = _rRequest.GetArgs();
SwWrtShell& rSh = GetShell();
if ( rSh.GetFrameType( nullptr, true ) & FrameTypeFlags::FOOTNOTE )
return;
SwView &rTempView = GetView(); // Because GetView() does not work after the shell exchange
bool bHTMLMode = 0 != (::GetHtmlMode(rTempView.GetDocShell())&HTMLMODE_ON);
bool bCallEndUndo = false;
if( !pArgs && rSh.IsSelection() && !rSh.IsInClickToEdit() &&
!rSh.IsTableMode() )
{
const SwModuleOptions* pModOpt = SW_MOD()->GetModuleConfig();
SwInsertTableOptions aInsTableOpts = pModOpt->GetInsTableFlags(bHTMLMode);
rSh.StartUndo(SwUndoId::INSTABLE);
bCallEndUndo = true;
bool bInserted = rSh.TextToTable( aInsTableOpts, '\t' );
rSh.EnterStdMode();
if (bInserted)
rTempView.AutoCaption(TABLE_CAP);
_rRequest.Done();
}
else
{
sal_uInt16 nColsIn = 0;
sal_uInt16 nRowsIn = 0;
SwInsertTableOptions aInsTableOptsIn( SwInsertTableFlags::All, 1 );
OUString aTableNameIn;
OUString aAutoNameIn;
std::unique_ptr<SwTableAutoFormat> pTAFormatIn;
if( pArgs && pArgs->Count() >= 2 )
{
const SfxStringItem* pName = _rRequest.GetArg<SfxStringItem>(FN_INSERT_TABLE);
const SfxUInt16Item* pCols = _rRequest.GetArg<SfxUInt16Item>(SID_ATTR_TABLE_COLUMN);
const SfxUInt16Item* pRows = _rRequest.GetArg<SfxUInt16Item>(SID_ATTR_TABLE_ROW);
const SfxInt32Item* pFlags = _rRequest.GetArg<SfxInt32Item>(FN_PARAM_1);
const SfxStringItem* pAuto = _rRequest.GetArg<SfxStringItem>(FN_PARAM_2);
if ( pName )
aTableNameIn = pName->GetValue();
if ( pCols )
nColsIn = pCols->GetValue();
if ( pRows )
nRowsIn = pRows->GetValue();
if ( pAuto )
{
aAutoNameIn = pAuto->GetValue();
if ( !aAutoNameIn.isEmpty() )
{
SwTableAutoFormatTable aTableTable;
aTableTable.Load();
for ( size_t n=0; n<aTableTable.size(); n++ )
{
if ( aTableTable[n].GetName() == aAutoNameIn )
{
pTAFormatIn.reset(new SwTableAutoFormat( aTableTable[n] ));
break;
}
}
}
}
if ( pFlags )
aInsTableOptsIn.mnInsMode = static_cast<SwInsertTableFlags>(pFlags->GetValue());
else
{
const SwModuleOptions* pModOpt = SW_MOD()->GetModuleConfig();
aInsTableOptsIn = pModOpt->GetInsTableFlags(bHTMLMode);
}
}
if( !nColsIn || !nRowsIn )
{
SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
std::shared_ptr<AbstractInsTableDlg> pAbstractDialog(pFact->CreateInsTableDlg(rTempView));
std::shared_ptr<weld::DialogController> pDialogController(pAbstractDialog->getDialogController());
weld::DialogController::runAsync(pDialogController,
[pAbstractDialog=std::move(pAbstractDialog), &rSh, &rTempView, aTableNameIn,
nRowsIn, nColsIn, aInsTableOptsIn, aAutoNameIn] (sal_Int32 nResult) {
if( RET_OK == nResult )
{
sal_uInt16 nCols = nColsIn;
sal_uInt16 nRows = nRowsIn;
SwInsertTableOptions aInsTableOpts = aInsTableOptsIn;
OUString aTableName = aTableNameIn;
OUString aAutoName = aAutoNameIn;
std::unique_ptr<SwTableAutoFormat> pTAFormat;
pAbstractDialog->GetValues( aTableName, nRows, nCols, aInsTableOpts, aAutoName, pTAFormat );
if( nCols && nRows )
{
InsertTableImpl( rSh, rTempView, aTableName, nRows, nCols, aInsTableOpts, aAutoName, pTAFormat );
EndUndo(rSh);
}
}
}
);
}
else
{
// record before shell change
_rRequest.AppendItem( SfxStringItem( FN_INSERT_TABLE, aTableNameIn ) );
if ( !aAutoNameIn.isEmpty() )
_rRequest.AppendItem( SfxStringItem( FN_PARAM_2, aAutoNameIn ) );
_rRequest.AppendItem( SfxUInt16Item( SID_ATTR_TABLE_COLUMN, nColsIn ) );
_rRequest.AppendItem( SfxUInt16Item( SID_ATTR_TABLE_ROW, nRowsIn ) );
_rRequest.AppendItem( SfxInt32Item( FN_PARAM_1, static_cast<sal_Int32>(aInsTableOptsIn.mnInsMode) ) );
_rRequest.Done();
InsertTableImpl( rSh, rTempView, aTableNameIn, nRowsIn, nColsIn, aInsTableOptsIn, aAutoNameIn, pTAFormatIn );
bCallEndUndo = true;
}
}
if( bCallEndUndo )
EndUndo(rSh);
}
void SwBaseShell::GetGalleryState( SfxItemSet &rSet )
{
SwWrtShell &rSh = GetShell();
SfxWhichIter aIter( rSet );
sal_uInt16 nWhich = aIter.FirstWhich();
switch ( nWhich )
{
case SID_GALLERY_BG_BRUSH:
{
SelectionType nSel = rSh.GetSelectionType();
SfxStringListItem aLst( nWhich );
std::vector<OUString> &rLst = aLst.GetList();
nParagraphPos = nGraphicPos = nOlePos = nFramePos = nTablePos =
nTableRowPos = nTableCellPos = nPagePos =
nHeaderPos = nFooterPos = 0;
sal_uInt8 nPos = 1;
rLst.push_back( SwResId( STR_SWBG_PAGE ) );
nPagePos = nPos++;
sal_uInt16 nHtmlMode = ::GetHtmlMode(GetView().GetDocShell());
bool bHtmlMode = 0 != (nHtmlMode & HTMLMODE_ON);
if ( (!bHtmlMode || (nHtmlMode & HTMLMODE_FULL_STYLES)) &&
(nSel & SelectionType::Text) )
{
rLst.push_back( SwResId( STR_SWBG_PARAGRAPH ) );
nParagraphPos = nPos++;
}
if ( (!bHtmlMode || (nHtmlMode & HTMLMODE_SOME_STYLES)) &&
nSel & (SelectionType::Table|SelectionType::TableCell) )
{
rLst.push_back( SwResId( STR_SWBG_TABLE ) );
nTablePos = nPos++;
if(!bHtmlMode)
{
rLst.push_back( SwResId( STR_SWBG_TABLE_ROW ) );
nTableRowPos = nPos++;
}
rLst.push_back( SwResId( STR_SWBG_TABLE_CELL) );
nTableCellPos = nPos++;
}
if(!bHtmlMode)
{
if ( nSel & SelectionType::Frame )
{
rLst.push_back( SwResId( STR_SWBG_FRAME ) );
nFramePos = nPos++;
}
if ( nSel & SelectionType::Graphic )
{
rLst.push_back( SwResId( STR_SWBG_GRAPHIC ) );
nGraphicPos = nPos++;
}
if ( nSel & SelectionType::Ole )
{
rLst.push_back( SwResId( STR_SWBG_OLE ) );
nOlePos = nPos++;
}
const FrameTypeFlags nType = rSh.GetFrameType(nullptr,true);
if ( nType & FrameTypeFlags::HEADER )
{
rLst.push_back( SwResId( STR_SWBG_HEADER ) );
nHeaderPos = nPos++;
}
if ( nType & FrameTypeFlags::FOOTER )
{
rLst.push_back( SwResId( STR_SWBG_FOOTER ) );
nFooterPos = nPos;
}
}
if ( rLst.empty() )
rSet.DisableItem( nWhich );
else
rSet.Put( aLst );
break;
}
}
}
void SwBaseShell::ExecuteGallery(SfxRequest &rReq)
{
SwWrtShell &rSh = GetShell();
rSh.StartAction();
const SfxItemSet* pArgs = rReq.GetArgs();
sal_uInt16 nSlot = rReq.GetSlot();
switch(nSlot)
{
case SID_GALLERY_BG_BRUSH:
{
if ( !pArgs )
break;
SelectionType nSel = rSh.GetSelectionType();
if ( nSel & SelectionType::DrawObjectEditMode )
break;
const SfxUInt16Item* pPos = rReq.GetArg<SfxUInt16Item>(SID_GALLERY_BG_POS);
const SvxBrushItem* pBrush = rReq.GetArg<SvxBrushItem>(SID_GALLERY_BG_BRUSH);
if ( !pPos || !pBrush )
break;
sal_uInt8 nPos = pPos->GetValue();
++nPos;
SvxBrushItem aBrush( *pBrush );
aBrush.SetWhich( RES_BACKGROUND );
if ( nPos == nParagraphPos )
rSh.SetAttrItem( aBrush );
else if ( nPos == nTablePos )
rSh.SetTabBackground( aBrush );
else if ( nPos == nTableRowPos )
rSh.SetRowBackground( aBrush );
else if ( nPos == nTableCellPos )
rSh.SetBoxBackground( aBrush );
else if ( nPos == nFramePos || nPos == nGraphicPos || nPos == nOlePos )
{
SfxItemSetFixed<RES_BACKGROUND, RES_BACKGROUND> aCoreSet(GetPool());
aCoreSet.Put( aBrush );
rSh.SetFlyFrameAttr( aCoreSet );
}
else if ( nPos == nPagePos || nPos == nHeaderPos || nPos == nFooterPos )
{
sal_uInt16 nDesc = rSh.GetCurPageDesc();
SwPageDesc aDesc( rSh.GetPageDesc( nDesc ) );
if ( nPos == nPagePos )
aDesc.GetMaster().SetFormatAttr( aBrush );
else if ( nPos == nHeaderPos )
{
SwFormatHeader aHead( aDesc.GetMaster().GetHeader() );
aHead.GetHeaderFormat()->SetFormatAttr( aBrush );
aDesc.GetMaster().SetFormatAttr( aHead );
}
else if ( nPos == nFooterPos )
{
SwFormatFooter aFoot( aDesc.GetMaster().GetFooter() );
aFoot.GetFooterFormat()->SetFormatAttr( aBrush );
aDesc.GetMaster().SetFormatAttr( aFoot );
}
rSh.ChgPageDesc( nDesc, aDesc );
}
break;
}
}
rSh.EndAction();
rReq.Done();
}
void SwBaseShell::ExecField( SfxRequest const & rReq )
{
sal_uInt16 nSlot = rReq.GetSlot();
switch( nSlot )
{
#if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
case FN_CHANGE_DBFIELD:
{
SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
VclPtr<AbstractChangeDbDialog> pDlg(pFact->CreateSwChangeDBDlg(GetView()));
pDlg->StartExecuteAsync(
[pDlg] (sal_Int32 nResult)->void
{
if (nResult == RET_OK)
pDlg->UpdateFields();
pDlg->disposeOnce();
}
);
}
break;
#endif
default:
OSL_FAIL("wrong dispatcher");
}
}
std::shared_ptr<std::vector<std::unique_ptr<SwPaM>>> SwBaseShell::CopyPaMRing(SwPaM& rOrig)
{
auto vCursors = std::make_shared<std::vector<std::unique_ptr<SwPaM>>>();
vCursors->emplace_back(std::make_unique<SwPaM>(rOrig, nullptr));
for (auto& rCursor : rOrig.GetRingContainer())
{
if (&rCursor != &rOrig)
vCursors->emplace_back(std::make_unique<SwPaM>(rCursor, vCursors->front().get()));
}
return vCursors;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Reference in a new issue View git blame Copy permalink