summaryrefslogtreecommitdiffstats
path: root/sw/source/uibase/uiview
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-15 05:54:39 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-15 05:54:39 +0000
commit267c6f2ac71f92999e969232431ba04678e7437e (patch)
tree358c9467650e1d0a1d7227a21dac2e3d08b622b2 /sw/source/uibase/uiview
parentInitial commit. (diff)
downloadlibreoffice-267c6f2ac71f92999e969232431ba04678e7437e.tar.xz
libreoffice-267c6f2ac71f92999e969232431ba04678e7437e.zip
Adding upstream version 4:24.2.0.upstream/4%24.2.0
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'sw/source/uibase/uiview')
-rw-r--r--sw/source/uibase/uiview/formatclipboard.cxx590
-rw-r--r--sw/source/uibase/uiview/pview.cxx1905
-rw-r--r--sw/source/uibase/uiview/scroll.cxx116
-rw-r--r--sw/source/uibase/uiview/srcview.cxx839
-rw-r--r--sw/source/uibase/uiview/swcli.cxx193
-rw-r--r--sw/source/uibase/uiview/uivwimp.cxx333
-rw-r--r--sw/source/uibase/uiview/view.cxx2120
-rw-r--r--sw/source/uibase/uiview/view0.cxx770
-rw-r--r--sw/source/uibase/uiview/view1.cxx213
-rw-r--r--sw/source/uibase/uiview/view2.cxx3197
-rw-r--r--sw/source/uibase/uiview/viewcoll.cxx78
-rw-r--r--sw/source/uibase/uiview/viewdlg.cxx66
-rw-r--r--sw/source/uibase/uiview/viewdlg2.cxx305
-rw-r--r--sw/source/uibase/uiview/viewdraw.cxx755
-rw-r--r--sw/source/uibase/uiview/viewfunc.hxx54
-rw-r--r--sw/source/uibase/uiview/viewling.cxx856
-rw-r--r--sw/source/uibase/uiview/viewmdi.cxx791
-rw-r--r--sw/source/uibase/uiview/viewport.cxx1262
-rw-r--r--sw/source/uibase/uiview/viewprt.cxx376
-rw-r--r--sw/source/uibase/uiview/viewsrch.cxx895
-rw-r--r--sw/source/uibase/uiview/viewstat.cxx691
-rw-r--r--sw/source/uibase/uiview/viewtab.cxx2562
22 files changed, 18967 insertions, 0 deletions
diff --git a/sw/source/uibase/uiview/formatclipboard.cxx b/sw/source/uibase/uiview/formatclipboard.cxx
new file mode 100644
index 0000000000..e722c04e90
--- /dev/null
+++ b/sw/source/uibase/uiview/formatclipboard.cxx
@@ -0,0 +1,590 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <memory>
+#include <utility>
+
+#include <formatclipboard.hxx>
+
+#include <cmdid.h>
+#include <charfmt.hxx>
+#include <frmfmt.hxx>
+#include <docstyle.hxx>
+#include <fchrfmt.hxx>
+#include <svx/svdview.hxx>
+#include <editeng/brushitem.hxx>
+#include <editeng/shaditem.hxx>
+#include <editeng/boxitem.hxx>
+#include <editeng/formatbreakitem.hxx>
+#include <fmtlsplt.hxx>
+#include <editeng/keepitem.hxx>
+#include <editeng/frmdiritem.hxx>
+#include <fmtpdsc.hxx>
+#include <fmtrowsplt.hxx>
+#include <frmatr.hxx>
+
+namespace
+{
+
+std::unique_ptr<SfxItemSet> lcl_CreateEmptyItemSet( SelectionType nSelectionType, SfxItemPool& rPool, bool bNoParagraphFormats = false )
+{
+ std::unique_ptr<SfxItemSet> pItemSet;
+ if( nSelectionType & (SelectionType::Frame | SelectionType::Ole | SelectionType::Graphic) )
+ {
+ pItemSet = std::make_unique<SfxItemSetFixed<
+ RES_FRMATR_BEGIN, RES_FILL_ORDER,
+ // no RES_FRM_SIZE
+ RES_PAPER_BIN, RES_SURROUND,
+ // no RES_VERT_ORIENT
+ // no RES_HORI_ORIENT
+ // no RES_ANCHOR
+ RES_BACKGROUND, RES_SHADOW,
+ // no RES_FRMMACRO
+ RES_COL, RES_KEEP,
+ // no RES_URL
+ RES_EDIT_IN_READONLY, RES_LAYOUT_SPLIT,
+ // no RES_CHAIN
+ RES_TEXTGRID, RES_FRMATR_END - 1>>(rPool);
+ }
+ else if( nSelectionType & SelectionType::DrawObject )
+ {
+ //is handled different
+ }
+ else if( nSelectionType & SelectionType::Text )
+ {
+ if( bNoParagraphFormats )
+ pItemSet = std::make_unique<SfxItemSetFixed
+ <RES_CHRATR_BEGIN, RES_CHRATR_END - 1>>(rPool);
+ else
+ pItemSet = std::make_unique<SfxItemSetFixed<
+ RES_CHRATR_BEGIN, RES_CHRATR_END - 1,
+ RES_PARATR_BEGIN, RES_FILL_ORDER,
+ // no RES_FRM_SIZE
+ RES_PAPER_BIN, RES_SURROUND,
+ // no RES_VERT_ORIENT
+ // no RES_HORI_ORIENT
+ // no RES_ANCHOR
+ RES_BACKGROUND, RES_SHADOW,
+ // no RES_FRMMACRO
+ RES_COL, RES_KEEP,
+ // no RES_URL
+ RES_EDIT_IN_READONLY, RES_LAYOUT_SPLIT,
+ // no RES_CHAIN
+ RES_TEXTGRID, RES_FRMATR_END - 1>>(rPool);
+ }
+ return pItemSet;
+}
+
+void lcl_getTableAttributes( SfxItemSet& rSet, SwWrtShell &rSh )
+{
+ std::unique_ptr<SvxBrushItem> aBrush(std::make_unique<SvxBrushItem>(RES_BACKGROUND));
+ rSh.GetBoxBackground(aBrush);
+ rSet.Put( *aBrush );
+ if(rSh.GetRowBackground(aBrush))
+ {
+ aBrush->SetWhich(SID_ATTR_BRUSH_ROW);
+ rSet.Put( *aBrush );
+ }
+ else
+ rSet.InvalidateItem(SID_ATTR_BRUSH_ROW);
+ rSh.GetTabBackground(aBrush);
+ aBrush->SetWhich(SID_ATTR_BRUSH_TABLE);
+ rSet.Put( *aBrush );
+
+ SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
+ rSet.Put(aBoxInfo);
+ rSh.GetTabBorders( rSet );
+
+ std::unique_ptr<SvxFrameDirectionItem> aBoxDirection(std::make_unique<SvxFrameDirectionItem>(SvxFrameDirection::Environment, RES_FRAMEDIR));
+ if(rSh.GetBoxDirection( aBoxDirection ))
+ {
+ aBoxDirection->SetWhich(FN_TABLE_BOX_TEXTORIENTATION);
+ rSet.Put(std::move(aBoxDirection));
+ }
+
+ rSet.Put(SfxUInt16Item(FN_TABLE_SET_VERT_ALIGN, rSh.GetBoxAlign()));
+
+ rSet.Put( SfxUInt16Item( FN_PARAM_TABLE_HEADLINE, rSh.GetRowsToRepeat() ) );
+
+ SwFrameFormat *pFrameFormat = rSh.GetTableFormat();
+ if(pFrameFormat)
+ {
+ rSet.Put( pFrameFormat->GetShadow() );
+ rSet.Put( pFrameFormat->GetBreak() );
+ rSet.Put( pFrameFormat->GetPageDesc() );
+ rSet.Put( pFrameFormat->GetLayoutSplit() );
+ rSet.Put( pFrameFormat->GetKeep() );
+ rSet.Put( pFrameFormat->GetFrameDir() );
+ }
+
+ std::unique_ptr<SwFormatRowSplit> pSplit = rSh.GetRowSplit();
+ if(pSplit)
+ rSet.Put(std::move(pSplit));
+}
+
+void lcl_setTableAttributes( const SfxItemSet& rSet, SwWrtShell &rSh )
+{
+ bool bBorder = ( SfxItemState::SET == rSet.GetItemState( RES_BOX ) ||
+ SfxItemState::SET == rSet.GetItemState( SID_ATTR_BORDER_INNER ) );
+ const SvxBrushItem* pBackgroundItem = rSet.GetItemIfSet( RES_BACKGROUND, false );
+ const SvxBrushItem* pRowItem = rSet.GetItemIfSet( SID_ATTR_BRUSH_ROW, false );
+ const SvxBrushItem* pTableItem = rSet.GetItemIfSet( SID_ATTR_BRUSH_TABLE, false );
+ bool bBackground = pBackgroundItem || pRowItem || pTableItem;
+
+ if(bBackground)
+ {
+ if(pBackgroundItem)
+ rSh.SetBoxBackground( *pBackgroundItem );
+ if(pRowItem)
+ {
+ std::unique_ptr<SvxBrushItem> aBrush(pRowItem->Clone());
+ aBrush->SetWhich(RES_BACKGROUND);
+ rSh.SetRowBackground(*aBrush);
+ }
+ if(pTableItem)
+ {
+ std::unique_ptr<SvxBrushItem> aBrush(pTableItem->Clone());
+ aBrush->SetWhich(RES_BACKGROUND);
+ rSh.SetTabBackground(*aBrush);
+ }
+ }
+ if(bBorder)
+ rSh.SetTabBorders( rSet );
+
+ if( const SfxUInt16Item* pHeadlineItem = rSet.GetItemIfSet( FN_PARAM_TABLE_HEADLINE, false) )
+ rSh.SetRowsToRepeat( pHeadlineItem->GetValue() );
+
+ SwFrameFormat* pFrameFormat = rSh.GetTableFormat();
+ if(pFrameFormat)
+ {
+ //RES_SHADOW
+ const SfxPoolItem* pItem = rSet.GetItemIfSet(rSet.GetPool()->GetWhich(RES_SHADOW), false);
+ if(pItem)
+ pFrameFormat->SetFormatAttr( *pItem );
+
+ //RES_BREAK
+ pItem = rSet.GetItemIfSet(rSet.GetPool()->GetWhich(RES_BREAK), false);
+ if(pItem)
+ pFrameFormat->SetFormatAttr( *pItem );
+
+ //RES_PAGEDESC
+ pItem = rSet.GetItemIfSet(rSet.GetPool()->GetWhich(RES_PAGEDESC), false);
+ if(pItem)
+ pFrameFormat->SetFormatAttr( *pItem );
+
+ //RES_LAYOUT_SPLIT
+ pItem = rSet.GetItemIfSet(rSet.GetPool()->GetWhich(RES_LAYOUT_SPLIT), false);
+ if(pItem)
+ pFrameFormat->SetFormatAttr( *pItem );
+
+ //RES_KEEP
+ pItem = rSet.GetItemIfSet(rSet.GetPool()->GetWhich(RES_KEEP), false);
+ if(pItem)
+ pFrameFormat->SetFormatAttr( *pItem );
+
+ //RES_FRAMEDIR
+ pItem = rSet.GetItemIfSet(rSet.GetPool()->GetWhich(RES_FRAMEDIR), false);
+ if(pItem)
+ pFrameFormat->SetFormatAttr( *pItem );
+ }
+
+ if( const SvxFrameDirectionItem* pTextOriItem = rSet.GetItemIfSet( FN_TABLE_BOX_TEXTORIENTATION, false ) )
+ {
+ SvxFrameDirectionItem aDirection( SvxFrameDirection::Environment, RES_FRAMEDIR );
+ aDirection.SetValue(pTextOriItem->GetValue());
+ rSh.SetBoxDirection(aDirection);
+ }
+
+ if( const SfxUInt16Item* pVertAlignItem = rSet.GetItemIfSet( FN_TABLE_SET_VERT_ALIGN, false ))
+ rSh.SetBoxAlign(pVertAlignItem->GetValue());
+
+ if( const SwFormatRowSplit* pSplitItem = rSet.GetItemIfSet( RES_ROW_SPLIT, false ) )
+ rSh.SetRowSplit(*pSplitItem);
+}
+}//end anonymous namespace
+
+SwFormatClipboard::SwFormatClipboard()
+ : m_nSelectionType(SelectionType::NONE)
+ , m_bPersistentCopy(false)
+{
+}
+
+bool SwFormatClipboard::HasContent() const
+{
+ return m_pItemSet_TextAttr!=nullptr
+ || m_pItemSet_ParAttr!=nullptr
+ || m_pTableItemSet != nullptr
+ || !m_aCharStyle.isEmpty()
+ || !m_aParaStyle.isEmpty()
+ ;
+}
+bool SwFormatClipboard::HasContentForThisType( SelectionType nSelectionType ) const
+{
+ if( !HasContent() )
+ return false;
+
+ if( m_nSelectionType == nSelectionType )
+ return true;
+
+ if( ( nSelectionType & (SelectionType::Frame | SelectionType::Ole | SelectionType::Graphic) )
+ &&
+ ( m_nSelectionType & (SelectionType::Frame | SelectionType::Ole | SelectionType::Graphic) )
+ )
+ return true;
+
+ if( nSelectionType & SelectionType::Text && m_nSelectionType & SelectionType::Text )
+ return true;
+
+ return false;
+}
+
+bool SwFormatClipboard::CanCopyThisType( SelectionType nSelectionType )
+{
+ return bool(nSelectionType
+ & (SelectionType::Frame | SelectionType::Ole | SelectionType::Graphic
+ | SelectionType::Text | SelectionType::DrawObject | SelectionType::Table | SelectionType::TableCell ));
+}
+
+void SwFormatClipboard::Copy( SwWrtShell& rWrtShell, SfxItemPool& rPool, bool bPersistentCopy )
+{
+ // first clear the previously stored attributes
+ Erase();
+ m_bPersistentCopy = bPersistentCopy;
+
+ SelectionType nSelectionType = rWrtShell.GetSelectionType();
+ auto pItemSet_TextAttr = lcl_CreateEmptyItemSet( nSelectionType, rPool, true );
+ auto pItemSet_ParAttr = lcl_CreateEmptyItemSet( nSelectionType, rPool );
+
+ rWrtShell.StartAction();
+ rWrtShell.Push();
+
+ // modify the "Point and Mark" of the cursor
+ // in order to select only the last character of the
+ // selection(s) and then to get the attributes of this single character
+ if( nSelectionType == SelectionType::Text )
+ {
+ // get the current PaM, the cursor
+ // if there several selection it currently point
+ // on the last (sort by there creation time) selection
+ SwPaM* pCursor = rWrtShell.GetCursor();
+
+ bool bHasSelection = pCursor->HasMark();
+ bool bForwardSelection = false;
+
+ if(!bHasSelection && pCursor->IsMultiSelection())
+ {
+ // if cursor has multiple selections
+
+ // clear all the selections except the last
+ rWrtShell.KillPams();
+
+ // reset the cursor to the remaining selection
+ pCursor = rWrtShell.GetCursor();
+ bHasSelection = true;
+ }
+
+ bool dontMove = false;
+ if (bHasSelection)
+ {
+ bForwardSelection = (*pCursor->GetPoint()) > (*pCursor->GetMark());
+
+ // clear the selection leaving just the cursor
+ pCursor->DeleteMark();
+ pCursor->SetMark();
+ }
+ else
+ {
+ bool rightToLeft = rWrtShell.IsInRightToLeftText();
+ // if there were no selection (only a cursor) and the cursor was at
+ // the end of the paragraph then don't move
+ if ( rWrtShell.IsEndPara() && !rightToLeft )
+ dontMove = true;
+
+ // revert left and right
+ if ( rightToLeft )
+ {
+ if (pCursor->GetPoint()->GetContentIndex() == 0)
+ dontMove = true;
+ else
+ bForwardSelection = !bForwardSelection;
+ }
+ }
+
+ // move the cursor in order to select one character
+ if (!dontMove)
+ pCursor->Move( bForwardSelection ? fnMoveBackward : fnMoveForward );
+ }
+
+ if(pItemSet_TextAttr)
+ {
+ if( nSelectionType & (SelectionType::Frame | SelectionType::Ole | SelectionType::Graphic) )
+ rWrtShell.GetFlyFrameAttr(*pItemSet_TextAttr);
+ else
+ {
+ // get the text attributes from named and automatic formatting
+ rWrtShell.GetCurAttr(*pItemSet_TextAttr);
+
+ if( nSelectionType & SelectionType::Text )
+ {
+ // get the paragraph attributes (could be character properties)
+ // from named and automatic formatting
+ rWrtShell.GetCurParAttr(*pItemSet_ParAttr);
+ }
+ }
+ }
+ else if ( nSelectionType & SelectionType::DrawObject )
+ {
+ SdrView* pDrawView = rWrtShell.GetDrawView();
+ if(pDrawView)
+ {
+ if( pDrawView->AreObjectsMarked() )
+ {
+ pItemSet_TextAttr = std::make_unique<SfxItemSet>( pDrawView->GetAttrFromMarked(true/*bOnlyHardAttr*/) );
+ //remove attributes defining the type/data of custom shapes
+ pItemSet_TextAttr->ClearItem(SDRATTR_CUSTOMSHAPE_ENGINE);
+ pItemSet_TextAttr->ClearItem(SDRATTR_CUSTOMSHAPE_DATA);
+ pItemSet_TextAttr->ClearItem(SDRATTR_CUSTOMSHAPE_GEOMETRY);
+ }
+ }
+ }
+
+ if( nSelectionType & SelectionType::TableCell )//only copy table attributes if really cells are selected (not only text in tables)
+ {
+ m_pTableItemSet = std::make_unique<SfxItemSetFixed<
+ RES_PAGEDESC, RES_BREAK,
+ RES_BACKGROUND, RES_SHADOW, // RES_BOX is inbetween
+ RES_KEEP, RES_KEEP,
+ RES_LAYOUT_SPLIT, RES_LAYOUT_SPLIT,
+ RES_FRAMEDIR, RES_FRAMEDIR,
+ RES_ROW_SPLIT, RES_ROW_SPLIT,
+ SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_SHADOW,
+ // SID_ATTR_BORDER_OUTER is inbetween
+ SID_ATTR_BRUSH_ROW, SID_ATTR_BRUSH_TABLE,
+ FN_TABLE_SET_VERT_ALIGN, FN_TABLE_SET_VERT_ALIGN,
+ FN_TABLE_BOX_TEXTORIENTATION, FN_TABLE_BOX_TEXTORIENTATION,
+ FN_PARAM_TABLE_HEADLINE, FN_PARAM_TABLE_HEADLINE>>(rPool);
+ lcl_getTableAttributes( *m_pTableItemSet, rWrtShell );
+ }
+
+ m_nSelectionType = nSelectionType;
+ m_pItemSet_TextAttr = std::move(pItemSet_TextAttr);
+ m_pItemSet_ParAttr = std::move(pItemSet_ParAttr);
+
+ if( nSelectionType & SelectionType::Text )
+ {
+ // if text is selected save the named character format
+ SwFormat* pFormat = rWrtShell.GetCurCharFormat();
+ if( pFormat )
+ m_aCharStyle = pFormat->GetName();
+
+ // and the named paragraph format
+ pFormat = rWrtShell.GetCurTextFormatColl();
+ if( pFormat )
+ m_aParaStyle = pFormat->GetName();
+ }
+
+ rWrtShell.Pop(SwCursorShell::PopMode::DeleteCurrent);
+ rWrtShell.EndAction();
+}
+
+typedef std::vector< std::unique_ptr< SfxPoolItem > > ItemVector;
+// collect all PoolItems from the applied styles
+static void lcl_AppendSetItems( ItemVector& rItemVector, const SfxItemSet& rStyleAttrSet )
+{
+ const WhichRangesContainer& pRanges = rStyleAttrSet.GetRanges();
+ for(const auto & rPair : pRanges)
+ {
+ for ( sal_uInt16 nWhich = rPair.first; nWhich <= rPair.second; ++nWhich )
+ {
+ const SfxPoolItem* pItem;
+ if( SfxItemState::SET == rStyleAttrSet.GetItemState( nWhich, false, &pItem ) )
+ {
+ rItemVector.emplace_back( pItem->Clone() );
+ }
+ }
+ }
+}
+// remove all items that are inherited from the styles
+static void lcl_RemoveEqualItems( SfxItemSet& rTemplateItemSet, const ItemVector& rItemVector )
+{
+ for( const auto& rItem : rItemVector )
+ {
+ const SfxPoolItem* pItem;
+ if( SfxItemState::SET == rTemplateItemSet.GetItemState( rItem->Which(), true, &pItem ) &&
+ *pItem == *rItem )
+ {
+ rTemplateItemSet.ClearItem( rItem->Which() );
+ }
+ }
+}
+
+void SwFormatClipboard::Paste( SwWrtShell& rWrtShell, SfxStyleSheetBasePool* pPool
+ , bool bNoCharacterFormats, bool bNoParagraphFormats )
+{
+ SelectionType nSelectionType = rWrtShell.GetSelectionType();
+ if( !HasContentForThisType(nSelectionType) )
+ {
+ if(!m_bPersistentCopy)
+ Erase();
+ return;
+ }
+
+ rWrtShell.StartAction();
+ rWrtShell.StartUndo(SwUndoId::INSATTR);
+
+ ItemVector aItemVector;
+
+ if (m_pItemSet_TextAttr && !( nSelectionType & SelectionType::DrawObject))
+ {
+ // reset all direct formatting before applying anything
+ o3tl::sorted_vector<sal_uInt16> aAttrs;
+ for (sal_uInt16 nWhich = RES_CHRATR_BEGIN; nWhich < RES_CHRATR_END; nWhich++)
+ aAttrs.insert(nWhich);
+ rWrtShell.ResetAttr({ aAttrs });
+ }
+
+ if( nSelectionType & SelectionType::Text )
+ {
+ // apply the named text and paragraph formatting
+ if( pPool )
+ {
+ // if there is a named text format recorded and the user wants to apply it
+ if(!m_aCharStyle.isEmpty() && !bNoCharacterFormats )
+ {
+ // look for the named text format in the pool
+ SwDocStyleSheet* pStyle = static_cast<SwDocStyleSheet*>(pPool->Find(m_aCharStyle, SfxStyleFamily::Char));
+
+ // if the style is found
+ if( pStyle )
+ {
+ SwFormatCharFormat aFormat(pStyle->GetCharFormat());
+ // store the attributes from this style in aItemVector in order
+ // not to apply them as automatic formatting attributes later in the code
+ lcl_AppendSetItems( aItemVector, aFormat.GetCharFormat()->GetAttrSet());
+
+ // apply the named format
+ rWrtShell.SetAttrItem( aFormat );
+ }
+ }
+
+ // if there is a named paragraph format recorded and the user wants to apply it
+ if(!m_aParaStyle.isEmpty() && !bNoParagraphFormats )
+ {
+ // look for the named paragraph format in the pool
+ SwDocStyleSheet* pStyle = static_cast<SwDocStyleSheet*>(pPool->Find(m_aParaStyle, SfxStyleFamily::Para));
+ if( pStyle )
+ {
+ // store the attributes from this style in aItemVector in order
+ // not to apply them as automatic formatting attributes later in the code
+ lcl_AppendSetItems( aItemVector, pStyle->GetCollection()->GetAttrSet());
+
+ // apply the named format
+ rWrtShell.SetTextFormatColl( pStyle->GetCollection() );
+ }
+ }
+ }
+
+ // apply the paragraph automatic attributes
+ if ( m_pItemSet_ParAttr && m_pItemSet_ParAttr->Count() != 0 && !bNoParagraphFormats )
+ {
+ // temporary SfxItemSet
+ std::unique_ptr<SfxItemSet> pTemplateItemSet(lcl_CreateEmptyItemSet(
+ nSelectionType, *m_pItemSet_ParAttr->GetPool()));
+ // no need to verify the existence of pTemplateItemSet as we
+ // know that here the selection type is SEL_TXT
+
+ pTemplateItemSet->Put( *m_pItemSet_ParAttr );
+
+ // remove attribute that were applied by named text and paragraph formatting
+ lcl_RemoveEqualItems( *pTemplateItemSet, aItemVector );
+
+ // apply the paragraph automatic attributes to all the nodes in the selection
+ rWrtShell.SetAttrSet(*pTemplateItemSet);
+
+ // store the attributes in aItemVector in order not to apply them as
+ // text automatic formatting attributes later in the code
+ lcl_AppendSetItems( aItemVector, *pTemplateItemSet);
+ }
+ }
+
+ if(m_pItemSet_TextAttr)
+ {
+ if( nSelectionType & SelectionType::DrawObject )
+ {
+ SdrView* pDrawView = rWrtShell.GetDrawView();
+ if(pDrawView)
+ {
+ pDrawView->SetAttrToMarked(*m_pItemSet_TextAttr, true/*bReplaceAll*/);
+ }
+ }
+ else
+ {
+ // temporary SfxItemSet
+ std::unique_ptr<SfxItemSet> pTemplateItemSet(lcl_CreateEmptyItemSet(
+ nSelectionType, *m_pItemSet_TextAttr->GetPool(), true ));
+
+ if(pTemplateItemSet)
+ {
+ // copy the stored automatic text attributes in a temporary SfxItemSet
+ pTemplateItemSet->Put( *m_pItemSet_TextAttr );
+
+ // only attributes that were not apply by named style attributes and automatic
+ // paragraph attributes should be applied
+ lcl_RemoveEqualItems( *pTemplateItemSet, aItemVector );
+
+ // apply the character automatic attributes
+ if( nSelectionType & (SelectionType::Frame | SelectionType::Ole | SelectionType::Graphic) )
+ rWrtShell.SetFlyFrameAttr(*pTemplateItemSet);
+ else if ( !bNoCharacterFormats )
+ {
+ rWrtShell.SetAttrSet(*pTemplateItemSet);
+ }
+ }
+ }
+ }
+
+ if( m_pTableItemSet && nSelectionType & (SelectionType::Table | SelectionType::TableCell) )
+ lcl_setTableAttributes( *m_pTableItemSet, rWrtShell );
+
+ rWrtShell.EndUndo(SwUndoId::INSATTR);
+ rWrtShell.EndAction();
+
+ if(!m_bPersistentCopy)
+ Erase();
+}
+
+void SwFormatClipboard::Erase()
+{
+ m_nSelectionType = SelectionType::NONE;
+
+ m_pItemSet_TextAttr.reset();
+
+ m_pItemSet_ParAttr.reset();
+
+ m_pTableItemSet.reset();
+
+ if( !m_aCharStyle.isEmpty() )
+ m_aCharStyle.clear();
+ if( !m_aParaStyle.isEmpty() )
+ m_aParaStyle.clear();
+
+ m_bPersistentCopy = false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/pview.cxx b/sw/source/uibase/uiview/pview.cxx
new file mode 100644
index 0000000000..0b03a001d0
--- /dev/null
+++ b/sw/source/uibase/uiview/pview.cxx
@@ -0,0 +1,1905 @@
+/* -*- 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_wasm_strip.h>
+
+#include <sfx2/objface.hxx>
+#include <vcl/help.hxx>
+#include <vcl/commandevent.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/syswin.hxx>
+#include <vcl/weld.hxx>
+
+#include <svl/whiter.hxx>
+#include <svl/slstitm.hxx>
+#include <svl/eitem.hxx>
+#include <sfx2/printer.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/request.hxx>
+#include <sfx2/dispatch.hxx>
+#include <editeng/paperinf.hxx>
+#include <svx/svdview.hxx>
+#include <svx/viewlayoutitem.hxx>
+#include <svx/zoomslideritem.hxx>
+#include <tools/svborder.hxx>
+#include <osl/diagnose.h>
+
+#include <globdoc.hxx>
+#include <wdocsh.hxx>
+#include <pvprtdat.hxx>
+#include <swmodule.hxx>
+#include <wrtsh.hxx>
+#include <docsh.hxx>
+#include <viewopt.hxx>
+#include <doc.hxx>
+#include <IDocumentDeviceAccess.hxx>
+#include <pview.hxx>
+#include <view.hxx>
+#include <scroll.hxx>
+#include <prtopt.hxx>
+#include <usrpref.hxx>
+#include "viewfunc.hxx"
+
+#include <helpids.h>
+#include <cmdid.h>
+#include <strings.hrc>
+
+#define ShellClass_SwPagePreview
+#include <sfx2/msg.hxx>
+#include <swslots.hxx>
+#include <pagepreviewlayout.hxx>
+
+#include <svx/svxdlg.hxx>
+
+#include <memory>
+#include <vcl/EnumContext.hxx>
+#include <vcl/notebookbar/notebookbar.hxx>
+
+using namespace ::com::sun::star;
+SFX_IMPL_NAMED_VIEWFACTORY(SwPagePreview, "PrintPreview")
+{
+ SFX_VIEW_REGISTRATION(SwDocShell);
+ SFX_VIEW_REGISTRATION(SwWebDocShell);
+ SFX_VIEW_REGISTRATION(SwGlobalDocShell);
+}
+
+SFX_IMPL_INTERFACE(SwPagePreview, SfxViewShell)
+
+void SwPagePreview::InitInterface_Impl()
+{
+ GetStaticInterface()->RegisterPopupMenu("preview");
+ GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT,
+ SfxVisibilityFlags::Standard|SfxVisibilityFlags::Client|SfxVisibilityFlags::FullScreen|SfxVisibilityFlags::ReadonlyDoc,
+ ToolbarId::PView_Toolbox);
+}
+
+
+#define SWVIEWFLAGS SfxViewShellFlags::HAS_PRINTOPTIONS
+
+#define MIN_PREVIEW_ZOOM 25
+#define MAX_PREVIEW_ZOOM 600
+
+static sal_uInt16 lcl_GetNextZoomStep(sal_uInt16 nCurrentZoom, bool bZoomIn)
+{
+ static const sal_uInt16 aZoomArr[] =
+ {
+ 25, 50, 75, 100, 150, 200, 400, 600
+ };
+ const int nZoomArrSize = static_cast<int>(SAL_N_ELEMENTS(aZoomArr));
+ if (bZoomIn)
+ {
+ for(sal_uInt16 i : aZoomArr)
+ {
+ if(nCurrentZoom < i)
+ return i;
+ }
+ }
+ else
+ {
+ for(int i = nZoomArrSize - 1; i >= 0; --i)
+ {
+ if(nCurrentZoom > aZoomArr[i] || !i)
+ return aZoomArr[i];
+ }
+ }
+ return bZoomIn ? MAX_PREVIEW_ZOOM : MIN_PREVIEW_ZOOM;
+};
+
+static void lcl_InvalidateZoomSlots(SfxBindings& rBindings)
+{
+ static sal_uInt16 const aInval[] =
+ {
+ SID_ATTR_ZOOM, SID_ZOOM_OUT, SID_ZOOM_IN, SID_ATTR_ZOOMSLIDER, FN_PREVIEW_ZOOM, FN_STAT_ZOOM,
+ 0
+ };
+ rBindings.Invalidate( aInval );
+}
+
+namespace {
+
+// At first the zoom dialog
+class SwPreviewZoomDlg : public weld::GenericDialogController
+{
+ SwPagePreviewWin& m_rParent;
+ std::unique_ptr<weld::SpinButton> m_xRowEdit;
+ std::unique_ptr<weld::SpinButton> m_xColEdit;
+
+public:
+ SwPreviewZoomDlg(SwPagePreviewWin& rParent)
+ : GenericDialogController(rParent.GetFrameWeld(), "modules/swriter/ui/previewzoomdialog.ui", "PreviewZoomDialog")
+ , m_rParent(rParent)
+ , m_xRowEdit(m_xBuilder->weld_spin_button("rows"))
+ , m_xColEdit(m_xBuilder->weld_spin_button("cols"))
+ {
+ m_xRowEdit->set_value(rParent.GetRow());
+ m_xColEdit->set_value(rParent.GetCol());
+ }
+
+ void execute()
+ {
+ if (run() == RET_OK)
+ {
+ m_rParent.CalcWish(m_xRowEdit->get_value(), m_xColEdit->get_value());
+ }
+ }
+};
+
+}
+
+// all for SwPagePreviewWin
+SwPagePreviewWin::SwPagePreviewWin( vcl::Window *pParent, SwPagePreview& rPView )
+ : Window(pParent, WinBits(WB_CLIPCHILDREN))
+ , mpViewShell(nullptr)
+ , mrView(rPView)
+ , mbCalcScaleForPreviewLayout(true)
+ , maPaintedPreviewDocRect(tools::Rectangle(0,0,0,0))
+ , mpPgPreviewLayout(nullptr)
+{
+ GetOutDev()->SetOutDevViewType( OutDevViewType::PrintPreview );
+ SetHelpId(HID_PAGEPREVIEW);
+ GetOutDev()->SetFillColor( GetBackground().GetColor() );
+ GetOutDev()->SetLineColor( GetBackground().GetColor());
+ SetMapMode( MapMode(MapUnit::MapTwip) );
+
+ const SwMasterUsrPref *pUsrPref = SW_MOD()->GetUsrPref(false);
+ mnRow = pUsrPref->GetPagePrevRow(); // 1 row
+ mnCol = pUsrPref->GetPagePrevCol(); // 1 column
+ mnSttPage = USHRT_MAX;
+}
+
+SwPagePreviewWin::~SwPagePreviewWin()
+{
+}
+
+void SwPagePreviewWin::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect)
+{
+ if (!mpViewShell || !mpViewShell->GetLayout())
+ return;
+
+ if (USHRT_MAX == mnSttPage) // was never calculated ? (Init-Phase!)
+ {
+ // This is the size to which I always relate.
+ if (!maPxWinSize.Height() || !maPxWinSize.Width())
+ maPxWinSize = GetOutputSizePixel();
+
+ tools::Rectangle aRect(rRenderContext.LogicToPixel(rRect));
+ mpPgPreviewLayout->Prepare(1, Point(0,0), maPxWinSize,
+ mnSttPage, maPaintedPreviewDocRect);
+ SetSelectedPage(1);
+ mpPgPreviewLayout->Paint(rRenderContext, rRenderContext.PixelToLogic(aRect));
+ SetPagePreview(mnRow, mnCol);
+ }
+ else
+ {
+ MapMode aMM(rRenderContext.GetMapMode());
+ aMM.SetScaleX(maScale);
+ aMM.SetScaleY(maScale);
+ rRenderContext.SetMapMode(aMM);
+ mpPgPreviewLayout->GetParentViewShell().setOutputToWindow(true);
+ mpPgPreviewLayout->Paint(rRenderContext, rRect);
+ mpPgPreviewLayout->GetParentViewShell().setOutputToWindow(false);
+ }
+}
+
+void SwPagePreviewWin::CalcWish( sal_Int16 nNewRow, sal_Int16 nNewCol )
+{
+ if( !mpViewShell || !mpViewShell->GetLayout() )
+ return;
+
+ const sal_Int16 nOldCol = mnCol;
+ mnRow = nNewRow;
+ mnCol = nNewCol;
+ const sal_uInt16 nPages = mnRow * mnCol;
+ const sal_uInt16 nLastSttPg = mrView.GetPageCount()+1 > nPages
+ ? mrView.GetPageCount()+1 - nPages : 0;
+ if( mnSttPage > nLastSttPg )
+ mnSttPage = nLastSttPg;
+
+ mpPgPreviewLayout->Init( mnCol, mnRow, maPxWinSize );
+ mpPgPreviewLayout->Prepare( mnSttPage, Point(0,0), maPxWinSize,
+ mnSttPage, maPaintedPreviewDocRect );
+ SetSelectedPage( mnSttPage );
+ SetPagePreview(mnRow, mnCol);
+ maScale = GetMapMode().GetScaleX();
+
+ // If changes have taken place at the columns, the special case "single column"
+ // must be considered and corrected if necessary.
+ if( (1 == nOldCol) != (1 == mnCol) )
+ mrView.ScrollDocSzChg();
+
+ // Order must be maintained!
+ // additional invalidate page status.
+ static sal_uInt16 aInval[] =
+ {
+ SID_ATTR_ZOOM, SID_ZOOM_OUT, SID_ZOOM_IN,
+ FN_PREVIEW_ZOOM,
+ FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, FN_PAGEUP, FN_PAGEDOWN,
+ FN_STAT_PAGE, FN_STAT_ZOOM,
+ FN_SHOW_TWO_PAGES, FN_SHOW_MULTIPLE_PAGES,
+ 0
+ };
+ SfxBindings& rBindings = mrView.GetViewFrame().GetBindings();
+ rBindings.Invalidate( aInval );
+ rBindings.Update( FN_SHOW_TWO_PAGES );
+ rBindings.Update( FN_SHOW_MULTIPLE_PAGES );
+ // adjust scrollbars
+ mrView.ScrollViewSzChg();
+}
+
+// mnSttPage is Absolute
+bool SwPagePreviewWin::MovePage( int eMoveMode )
+{
+ // number of pages up
+ const sal_uInt16 nPages = mnRow * mnCol;
+ sal_uInt16 nNewSttPage = mnSttPage;
+ const sal_uInt16 nPageCount = mrView.GetPageCount();
+ const sal_uInt16 nDefSttPg = GetDefSttPage();
+ bool bPaintPageAtFirstCol = true;
+
+ switch( eMoveMode )
+ {
+ case MV_PAGE_UP:
+ {
+ const sal_uInt16 nRelSttPage = mpPgPreviewLayout->ConvertAbsoluteToRelativePageNum( mnSttPage );
+ const sal_uInt16 nNewAbsSttPage = nRelSttPage - nPages > 0 ?
+ mpPgPreviewLayout->ConvertRelativeToAbsolutePageNum( nRelSttPage - nPages ) :
+ nDefSttPg;
+ nNewSttPage = nNewAbsSttPage;
+
+ const sal_uInt16 nRelSelPage = mpPgPreviewLayout->ConvertAbsoluteToRelativePageNum( SelectedPage() );
+ const sal_uInt16 nNewRelSelPage = nRelSelPage - nPages > 0 ?
+ nRelSelPage - nPages :
+ 1;
+ SetSelectedPage( mpPgPreviewLayout->ConvertRelativeToAbsolutePageNum( nNewRelSelPage ) );
+
+ break;
+ }
+ case MV_PAGE_DOWN:
+ {
+ const sal_uInt16 nRelSttPage = mpPgPreviewLayout->ConvertAbsoluteToRelativePageNum( mnSttPage );
+ const sal_uInt16 nNewAbsSttPage = mpPgPreviewLayout->ConvertRelativeToAbsolutePageNum( nRelSttPage + nPages );
+ nNewSttPage = std::min(nNewAbsSttPage, nPageCount);
+
+ const sal_uInt16 nRelSelPage = mpPgPreviewLayout->ConvertAbsoluteToRelativePageNum( SelectedPage() );
+ const sal_uInt16 nNewAbsSelPage = mpPgPreviewLayout->ConvertRelativeToAbsolutePageNum( nRelSelPage + nPages );
+ SetSelectedPage( std::min(nNewAbsSelPage, nPageCount) );
+
+ break;
+ }
+ case MV_DOC_STT:
+ nNewSttPage = nDefSttPg;
+ SetSelectedPage( mpPgPreviewLayout->ConvertRelativeToAbsolutePageNum( nNewSttPage ? nNewSttPage : 1 ) );
+ break;
+ case MV_DOC_END:
+ // correct calculation of new start page.
+ nNewSttPage = nPageCount;
+ SetSelectedPage( nPageCount );
+ break;
+
+ case MV_SELPAGE:
+ // <nNewSttPage> and <SelectedPage()> are already set.
+ // not start at first column, only if the
+ // complete preview layout columns doesn't fit into window.
+ if ( !mpPgPreviewLayout->DoesPreviewLayoutColsFitIntoWindow() )
+ bPaintPageAtFirstCol = false;
+ break;
+ case MV_SCROLL:
+ // check, if paint page at first column
+ // has to be avoided
+ if ( !mpPgPreviewLayout->DoesPreviewLayoutRowsFitIntoWindow() ||
+ !mpPgPreviewLayout->DoesPreviewLayoutColsFitIntoWindow() )
+ bPaintPageAtFirstCol = false;
+ break;
+ case MV_NEWWINSIZE:
+ // nothing special to do.
+ break;
+ case MV_CALC:
+ // re-init page preview layout.
+ mpPgPreviewLayout->ReInit();
+
+ // correct calculation of new start page.
+ if( nNewSttPage > nPageCount )
+ nNewSttPage = nPageCount;
+
+ // correct selected page number
+ if( SelectedPage() > nPageCount )
+ SetSelectedPage( nNewSttPage ? nNewSttPage : 1 );
+ }
+
+ mpPgPreviewLayout->Prepare( nNewSttPage, Point(0,0), maPxWinSize,
+ nNewSttPage,
+ maPaintedPreviewDocRect, bPaintPageAtFirstCol );
+ if( nNewSttPage == mnSttPage &&
+ eMoveMode != MV_SELPAGE )
+ return false;
+
+ SetPagePreview(mnRow, mnCol);
+ mnSttPage = nNewSttPage;
+
+ // additional invalidate page status.
+ static sal_uInt16 aInval[] =
+ {
+ FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, FN_PAGEUP, FN_PAGEDOWN,
+ FN_STAT_PAGE, 0
+ };
+
+ SfxBindings& rBindings = mrView.GetViewFrame().GetBindings();
+ rBindings.Invalidate( aInval );
+
+ return true;
+}
+
+void SwPagePreviewWin::SetWinSize( const Size& rNewSize )
+{
+ // We always want the size as pixel units.
+ maPxWinSize = LogicToPixel( rNewSize );
+
+ if( USHRT_MAX == mnSttPage )
+ {
+ mnSttPage = GetDefSttPage();
+ SetSelectedPage( GetDefSttPage() );
+ }
+
+ if ( mbCalcScaleForPreviewLayout )
+ {
+ mpPgPreviewLayout->Init( mnCol, mnRow, maPxWinSize );
+ maScale = GetMapMode().GetScaleX();
+ }
+ mpPgPreviewLayout->Prepare( mnSttPage, Point(0,0), maPxWinSize,
+ mnSttPage, maPaintedPreviewDocRect );
+ if ( mbCalcScaleForPreviewLayout )
+ {
+ SetSelectedPage( mnSttPage );
+ mbCalcScaleForPreviewLayout = false;
+ }
+ SetPagePreview(mnRow, mnCol);
+ maScale = GetMapMode().GetScaleX();
+}
+
+OUString SwPagePreviewWin::GetStatusStr( sal_uInt16 nPageCnt ) const
+{
+ // show physical and virtual page number of
+ // selected page, if it's visible.
+ const sal_uInt16 nPageNum = mpPgPreviewLayout->IsPageVisible( mpPgPreviewLayout->SelectedPage() )
+ ? mpPgPreviewLayout->SelectedPage() : std::max<sal_uInt16>(mnSttPage, 1);
+
+ OUString aStatusStr;
+ const sal_uInt16 nVirtPageNum = mpPgPreviewLayout->GetVirtPageNumByPageNum( nPageNum );
+ if( nVirtPageNum && nVirtPageNum != nPageNum )
+ {
+ aStatusStr = OUString::number(nVirtPageNum) + " " ;
+ }
+ return aStatusStr + OUString::number(nPageNum) + " / " + OUString::number(nPageCnt);
+}
+
+void SwPagePreviewWin::KeyInput( const KeyEvent &rKEvt )
+{
+ const vcl::KeyCode& rKeyCode = rKEvt.GetKeyCode();
+ bool bHandled = false;
+ if(!rKeyCode.GetModifier())
+ {
+ sal_uInt16 nSlot = 0;
+ switch(rKeyCode.GetCode())
+ {
+ case KEY_ADD : nSlot = SID_ZOOM_IN; break;
+ case KEY_ESCAPE: nSlot = FN_CLOSE_PAGEPREVIEW; break;
+ case KEY_SUBTRACT : nSlot = SID_ZOOM_OUT; break;
+ }
+ if(nSlot)
+ {
+ bHandled = true;
+ mrView.GetViewFrame().GetDispatcher()->Execute(
+ nSlot, SfxCallMode::ASYNCHRON );
+ }
+ }
+ if( !bHandled && !mrView.KeyInput( rKEvt ) )
+ Window::KeyInput( rKEvt );
+}
+
+void SwPagePreviewWin::Command( const CommandEvent& rCEvt )
+{
+ bool bCallBase = true;
+ switch( rCEvt.GetCommand() )
+ {
+ case CommandEventId::ContextMenu:
+ SfxDispatcher::ExecutePopup();
+ bCallBase = false;
+ break;
+
+ case CommandEventId::Wheel:
+ case CommandEventId::StartAutoScroll:
+ case CommandEventId::AutoScroll:
+ {
+ const CommandWheelData* pData = rCEvt.GetWheelData();
+ if( pData )
+ {
+ const CommandWheelData aDataNew(pData->GetDelta(),pData->GetNotchDelta(),COMMAND_WHEEL_PAGESCROLL,
+ pData->GetMode(),pData->GetModifier(),pData->IsHorz(), pData->IsDeltaPixel());
+ const CommandEvent aEvent( rCEvt.GetMousePosPixel(),rCEvt.GetCommand(),rCEvt.IsMouseEvent(),&aDataNew);
+ bCallBase = !mrView.HandleWheelCommands( aEvent );
+ }
+ else
+ bCallBase = !mrView.HandleWheelCommands( rCEvt );
+ }
+ break;
+ default:
+ ;
+ }
+
+ if( bCallBase )
+ Window::Command( rCEvt );
+}
+
+void SwPagePreviewWin::MouseButtonDown( const MouseEvent& rMEvt )
+{
+ // consider single-click to set selected page
+ if( MOUSE_LEFT != ( rMEvt.GetModifier() + rMEvt.GetButtons() ) )
+ return;
+
+ Point aPreviewPos( PixelToLogic( rMEvt.GetPosPixel() ) );
+ Point aDocPos;
+ bool bPosInEmptyPage;
+ sal_uInt16 nNewSelectedPage;
+ bool bIsDocPos =
+ mpPgPreviewLayout->IsPreviewPosInDocPreviewPage( aPreviewPos,
+ aDocPos, bPosInEmptyPage, nNewSelectedPage );
+ if ( bIsDocPos && rMEvt.GetClicks() == 2 )
+ {
+ // close page preview, set new cursor position and switch to
+ // normal view.
+ OUString sNewCursorPos = OUString::number( aDocPos.X() ) + ";" +
+ OUString::number( aDocPos.Y() ) + ";";
+ mrView.SetNewCursorPos( sNewCursorPos );
+
+ SfxViewFrame& rTmpFrame = mrView.GetViewFrame();
+ rTmpFrame.GetBindings().Execute( SID_VIEWSHELL0, nullptr,
+ SfxCallMode::ASYNCHRON );
+ }
+ else if ( bIsDocPos || bPosInEmptyPage )
+ {
+ // show clicked page as the selected one
+ mpPgPreviewLayout->MarkNewSelectedPage( nNewSelectedPage );
+ GetViewShell()->ShowPreviewSelection( nNewSelectedPage );
+ // adjust position at vertical scrollbar.
+ if ( mpPgPreviewLayout->DoesPreviewLayoutRowsFitIntoWindow() )
+ {
+ mrView.SetVScrollbarThumbPos( nNewSelectedPage );
+ }
+ // invalidate page status.
+ static sal_uInt16 aInval[] =
+ {
+ FN_STAT_PAGE, 0
+ };
+ SfxBindings& rBindings = mrView.GetViewFrame().GetBindings();
+ rBindings.Invalidate( aInval );
+ }
+}
+
+// Set user prefs or view options
+
+void SwPagePreviewWin::SetPagePreview( sal_Int16 nRow, sal_Int16 nCol )
+{
+ SwMasterUsrPref *pOpt = const_cast<SwMasterUsrPref *>(SW_MOD()->GetUsrPref(false));
+
+ if (nRow != pOpt->GetPagePrevRow() || nCol != pOpt->GetPagePrevCol())
+ {
+ pOpt->SetPagePrevRow( nRow );
+ pOpt->SetPagePrevCol( nCol );
+ pOpt->SetModified();
+
+ // Update scrollbar!
+ mrView.ScrollViewSzChg();
+ }
+}
+
+/** get selected page in document preview */
+sal_uInt16 SwPagePreviewWin::SelectedPage() const
+{
+ return mpPgPreviewLayout->SelectedPage();
+}
+
+/** set selected page number in document preview */
+void SwPagePreviewWin::SetSelectedPage( sal_uInt16 _nSelectedPageNum )
+{
+ mpPgPreviewLayout->SetSelectedPage( _nSelectedPageNum );
+}
+
+/** method to enable/disable book preview */
+bool SwPagePreviewWin::SetBookPreviewMode( const bool _bBookPreview )
+{
+ return mpPgPreviewLayout->SetBookPreviewMode( _bBookPreview,
+ mnSttPage,
+ maPaintedPreviewDocRect );
+}
+
+void SwPagePreviewWin::DataChanged( const DataChangedEvent& rDCEvt )
+{
+ Window::DataChanged( rDCEvt );
+
+ switch( rDCEvt.GetType() )
+ {
+ case DataChangedEventType::SETTINGS:
+ // Rearrange the scrollbars or trigger resize, because the
+ // size of the scrollbars may have be changed. Also the
+ // size of the scrollbars has to be retrieved from the settings
+ // out of the resize handler.
+ if( rDCEvt.GetFlags() & AllSettingsFlags::STYLE )
+ mrView.InvalidateBorder(); // Scrollbar widths
+ // zoom has to be disabled if Accessibility support is switched on
+ lcl_InvalidateZoomSlots(mrView.GetViewFrame().GetBindings());
+ break;
+
+ case DataChangedEventType::PRINTER:
+ case DataChangedEventType::DISPLAY:
+ case DataChangedEventType::FONTS:
+ case DataChangedEventType::FONTSUBSTITUTION:
+ mrView.GetDocShell()->UpdateFontList(); // Font change
+ mpViewShell->InvalidateLayout(true);
+ if ( mpViewShell->GetWin() )
+ mpViewShell->GetWin()->Invalidate();
+ break;
+ default: break;
+ }
+}
+
+/** help method to execute SfxRequest FN_PAGEUP and FN_PAGEDOWN */
+void SwPagePreview::ExecPgUpAndPgDown( const bool _bPgUp,
+ SfxRequest* _pReq )
+{
+ SwPagePreviewLayout* pPagePreviewLay = GetViewShell()->PagePreviewLayout();
+ // check, if top/bottom of preview is *not* already visible.
+ if( pPagePreviewLay->GetWinPagesScrollAmount( _bPgUp ? -1 : 1 ) != 0 )
+ {
+ if ( pPagePreviewLay->DoesPreviewLayoutRowsFitIntoWindow() &&
+ pPagePreviewLay->DoesPreviewLayoutColsFitIntoWindow() )
+ {
+ const int eMvMode = _bPgUp ?
+ SwPagePreviewWin::MV_PAGE_UP :
+ SwPagePreviewWin::MV_PAGE_DOWN;
+ if ( ChgPage( eMvMode ) )
+ m_pViewWin->Invalidate();
+ }
+ else
+ {
+ SwTwips nScrollAmount;
+ sal_uInt16 nNewSelectedPageNum = 0;
+ const sal_uInt16 nVisPages = m_pViewWin->GetRow() * m_pViewWin->GetCol();
+ if( _bPgUp )
+ {
+ if ( pPagePreviewLay->DoesPreviewLayoutRowsFitIntoWindow() )
+ {
+ nScrollAmount = pPagePreviewLay->GetWinPagesScrollAmount( -1 );
+ if ( (m_pViewWin->SelectedPage() - nVisPages) > 0 )
+ nNewSelectedPageNum = m_pViewWin->SelectedPage() - nVisPages;
+ else
+ nNewSelectedPageNum = 1;
+ }
+ else
+ nScrollAmount = - std::min( m_pViewWin->GetOutDev()->GetOutputSize().Height(),
+ m_pViewWin->GetPaintedPreviewDocRect().Top() );
+ }
+ else
+ {
+ if ( pPagePreviewLay->DoesPreviewLayoutRowsFitIntoWindow() )
+ {
+ nScrollAmount = pPagePreviewLay->GetWinPagesScrollAmount( 1 );
+ if ( (m_pViewWin->SelectedPage() + nVisPages) <= mnPageCount )
+ nNewSelectedPageNum = m_pViewWin->SelectedPage() + nVisPages;
+ else
+ nNewSelectedPageNum = mnPageCount;
+ }
+ else
+ nScrollAmount = std::min( m_pViewWin->GetOutDev()->GetOutputSize().Height(),
+ ( pPagePreviewLay->GetPreviewDocSize().Height() -
+ m_pViewWin->GetPaintedPreviewDocRect().Bottom() ) );
+ }
+ m_pViewWin->Scroll( 0, nScrollAmount );
+ if ( nNewSelectedPageNum != 0 )
+ {
+ m_pViewWin->SetSelectedPage( nNewSelectedPageNum );
+ }
+ ScrollViewSzChg();
+ // additional invalidate page status.
+ static sal_uInt16 aInval[] =
+ {
+ FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, FN_PAGEUP, FN_PAGEDOWN,
+ FN_STAT_PAGE, 0
+ };
+ SfxBindings& rBindings = GetViewFrame().GetBindings();
+ rBindings.Invalidate( aInval );
+ m_pViewWin->Invalidate();
+ }
+ }
+
+ if ( _pReq )
+ _pReq->Done();
+}
+
+// Then all for the SwPagePreview
+void SwPagePreview::Execute( SfxRequest &rReq )
+{
+ int eMvMode = SwPagePreviewWin::MV_DOC_END;
+ sal_Int16 nRow = 1;
+ bool bRefresh = true;
+
+ switch(rReq.GetSlot())
+ {
+ case SID_REFRESH_VIEW:
+ case FN_STAT_PAGE:
+ case FN_STAT_ZOOM:
+ break;
+
+ case FN_SHOW_MULTIPLE_PAGES:
+ {
+ const SfxItemSet *pArgs = rReq.GetArgs();
+ if( pArgs && pArgs->Count() >= 2 )
+ {
+ sal_Int16 nCols = pArgs->Get(SID_ATTR_TABLE_COLUMN).GetValue();
+ sal_Int16 nRows = pArgs->Get(SID_ATTR_TABLE_ROW).GetValue();
+ m_pViewWin->CalcWish( nRows, nCols );
+
+ }
+ else
+ {
+ SwPreviewZoomDlg aDlg(*m_pViewWin);
+ aDlg.execute();
+ }
+ }
+ break;
+ case FN_SHOW_BOOKVIEW:
+ {
+ const SfxItemSet* pArgs = rReq.GetArgs();
+ const SfxPoolItem* pItem;
+ bool bBookPreview = GetViewShell()->GetViewOptions()->IsPagePrevBookview();
+ if( pArgs && SfxItemState::SET == pArgs->GetItemState( FN_SHOW_BOOKVIEW, false, &pItem ) )
+ {
+ bBookPreview = static_cast< const SfxBoolItem* >( pItem )->GetValue();
+ const_cast<SwViewOption*>(GetViewShell()->GetViewOptions())->SetPagePrevBookview( bBookPreview );
+ // cast is not gentleman like, but it's common use in writer and in this case
+ }
+ if ( m_pViewWin->SetBookPreviewMode( bBookPreview ) )
+ {
+ // book preview mode changed. Thus, adjust scrollbars and
+ // invalidate corresponding states.
+ ScrollViewSzChg();
+ static sal_uInt16 aInval[] =
+ {
+ FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, FN_PAGEUP, FN_PAGEDOWN,
+ FN_STAT_PAGE, FN_SHOW_BOOKVIEW, 0
+ };
+ SfxBindings& rBindings = GetViewFrame().GetBindings();
+ rBindings.Invalidate( aInval );
+ m_pViewWin->Invalidate();
+ }
+
+ }
+ break;
+ case FN_SHOW_TWO_PAGES:
+ m_pViewWin->CalcWish( nRow, 2 );
+ break;
+
+ case FN_SHOW_SINGLE_PAGE:
+ m_pViewWin->CalcWish( nRow, 1 );
+ break;
+
+ case FN_PREVIEW_ZOOM:
+ case SID_ATTR_ZOOM:
+ {
+ const SfxItemSet *pArgs = rReq.GetArgs();
+ ScopedVclPtr<AbstractSvxZoomDialog> pDlg;
+ if(!pArgs)
+ {
+ SfxItemSetFixed<SID_ATTR_ZOOM, SID_ATTR_ZOOM> aCoreSet(GetPool());
+ const SwViewOption* pVOpt = GetViewShell()->GetViewOptions();
+ SvxZoomItem aZoom( pVOpt->GetZoomType(), pVOpt->GetZoom() );
+ aZoom.SetValueSet(
+ SvxZoomEnableFlags::N50|
+ SvxZoomEnableFlags::N75|
+ SvxZoomEnableFlags::N100|
+ SvxZoomEnableFlags::N150|
+ SvxZoomEnableFlags::N200|
+ SvxZoomEnableFlags::WHOLEPAGE);
+ aCoreSet.Put( aZoom );
+
+ SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
+ pDlg.disposeAndReset(pFact->CreateSvxZoomDialog(GetViewFrame().GetFrameWeld(), aCoreSet));
+ pDlg->SetLimits( MINZOOM, MAXZOOM );
+
+ if( pDlg->Execute() != RET_CANCEL )
+ pArgs = pDlg->GetOutputItemSet();
+ }
+ if( pArgs )
+ {
+ SvxZoomType eType = SvxZoomType::PERCENT;
+ sal_uInt16 nZoomFactor = USHRT_MAX;
+ if(const SvxZoomItem* pZoomItem = pArgs->GetItemIfSet(SID_ATTR_ZOOM))
+ {
+ eType = pZoomItem->GetType();
+ nZoomFactor = pZoomItem->GetValue();
+ }
+ else if(const SfxUInt16Item* pPreviewItem = pArgs->GetItemIfSet(FN_PREVIEW_ZOOM))
+ nZoomFactor = pPreviewItem->GetValue();
+ if(USHRT_MAX != nZoomFactor)
+ SetZoom(eType, nZoomFactor);
+ }
+ }
+ break;
+ case SID_ATTR_ZOOMSLIDER :
+ {
+ const SfxItemSet *pArgs = rReq.GetArgs();
+ const SvxZoomSliderItem* pItem;
+
+ if ( pArgs && (pItem = pArgs->GetItemIfSet(SID_ATTR_ZOOMSLIDER ) ) )
+ {
+ const sal_uInt16 nCurrentZoom = pItem->GetValue();
+ SetZoom( SvxZoomType::PERCENT, nCurrentZoom );
+ }
+ }
+ break;
+ case SID_ZOOM_IN:
+ case SID_ZOOM_OUT:
+ {
+ const SwViewOption* pVOpt = GetViewShell()->GetViewOptions();
+ SetZoom(SvxZoomType::PERCENT,
+ lcl_GetNextZoomStep(pVOpt->GetZoom(), SID_ZOOM_IN == rReq.GetSlot()));
+ }
+ break;
+ case FN_CHAR_LEFT:
+ case FN_CHAR_RIGHT:
+ case FN_LINE_UP:
+ case FN_LINE_DOWN:
+ {
+ SwPagePreviewLayout* pPagePreviewLay = GetViewShell()->PagePreviewLayout();
+ sal_uInt16 nNewSelectedPage;
+ sal_uInt16 nNewStartPage;
+ Point aNewStartPos;
+ sal_Int16 nHoriMove = 0;
+ sal_Int16 nVertMove = 0;
+ switch(rReq.GetSlot())
+ {
+ case FN_CHAR_LEFT: nHoriMove = -1; break;
+ case FN_CHAR_RIGHT: nHoriMove = 1; break;
+ case FN_LINE_UP: nVertMove = -1; break;
+ case FN_LINE_DOWN: nVertMove = 1; break;
+ }
+ pPagePreviewLay->CalcStartValuesForSelectedPageMove( nHoriMove, nVertMove,
+ nNewSelectedPage, nNewStartPage, aNewStartPos );
+ if ( m_pViewWin->SelectedPage() != nNewSelectedPage )
+ {
+ if ( pPagePreviewLay->IsPageVisible( nNewSelectedPage ) )
+ {
+ pPagePreviewLay->MarkNewSelectedPage( nNewSelectedPage );
+ // adjust position at vertical scrollbar.
+ SetVScrollbarThumbPos( nNewSelectedPage );
+ bRefresh = false;
+ }
+ else
+ {
+ m_pViewWin->SetSelectedPage( nNewSelectedPage );
+ m_pViewWin->SetSttPage( nNewStartPage );
+ bRefresh = ChgPage( SwPagePreviewWin::MV_SELPAGE );
+ }
+ GetViewShell()->ShowPreviewSelection( nNewSelectedPage );
+ // invalidate page status.
+ static sal_uInt16 aInval[] =
+ {
+ FN_STAT_PAGE, 0
+ };
+ SfxBindings& rBindings = GetViewFrame().GetBindings();
+ rBindings.Invalidate( aInval );
+ rReq.Done();
+ }
+ else
+ {
+ bRefresh = false;
+ }
+ break;
+ }
+ case FN_PAGEUP:
+ case FN_PAGEDOWN:
+ {
+ ExecPgUpAndPgDown( rReq.GetSlot() == FN_PAGEUP, &rReq );
+ break;
+ }
+ case SID_JUMP_TO_SPECIFIC_PAGE:
+ {
+ const SfxItemSet *pArgs = rReq.GetArgs();
+ if( pArgs && pArgs->Count())
+ {
+ sal_uInt16 nPageNum = static_cast<const SfxUInt16Item &>(pArgs->Get(SID_JUMP_TO_SPECIFIC_PAGE)).GetValue();
+
+ if( nPageNum > 0 && nPageNum <= mnPageCount )
+ {
+ m_pViewWin->SetSttPage( nPageNum);
+ m_pViewWin->SetSelectedPage( nPageNum );
+ ChgPage( SwPagePreviewWin::MV_SPECIFIC_PAGE, false );
+ ScrollViewSzChg();
+ }
+ }
+ }
+ break;
+ case FN_START_OF_LINE:
+ case FN_START_OF_DOCUMENT:
+ eMvMode = SwPagePreviewWin::MV_DOC_STT;
+ [[fallthrough]];
+ case FN_END_OF_LINE:
+ case FN_END_OF_DOCUMENT:
+ m_pViewWin->SetSelectedPage(eMvMode == SwPagePreviewWin::MV_DOC_STT ? 1 : mnPageCount);
+ {
+ bool bRet = ChgPage( eMvMode );
+ // return value for Basic
+ rReq.SetReturnValue(SfxBoolItem(rReq.GetSlot(), !bRet));
+
+ bRefresh = bRet;
+ rReq.Done();
+ }
+ break;
+
+ case FN_PRINT_PAGEPREVIEW:
+ {
+ const SwPagePreviewPrtData* pPPVPD = m_pViewWin->GetViewShell()->GetDoc()->GetPreviewPrtData();
+ // The thing with the orientation
+ if(pPPVPD)
+ {
+ SfxPrinter* pPrinter = GetPrinter( true );
+ if((pPrinter->GetOrientation() == Orientation::Landscape)
+ != pPPVPD->GetLandscape())
+ pPrinter->SetOrientation(pPPVPD->GetLandscape() ? Orientation::Landscape : Orientation::Portrait);
+ }
+ ::SetAppPrintOptions( m_pViewWin->GetViewShell(), false );
+ m_bNormalPrint = false;
+ rReq.SetSlot( SID_PRINTDOC );
+ SfxViewShell::ExecuteSlot( rReq, SfxViewShell::GetInterface() );
+ rReq.SetSlot( FN_PRINT_PAGEPREVIEW );
+ return;
+ }
+ case SID_PRINTDOCDIRECT:
+ case SID_PRINTDOC:
+ ::SetAppPrintOptions( m_pViewWin->GetViewShell(), false );
+ m_bNormalPrint = true;
+ SfxViewShell::ExecuteSlot( rReq, SfxViewShell::GetInterface() );
+ return;
+ case FN_CLOSE_PAGEPREVIEW:
+ case SID_PRINTPREVIEW:
+ // print preview is now always in the same frame as the tab view
+ // -> always switch this frame back to normal view
+ // (ScTabViewShell ctor reads stored view data)
+ GetViewFrame().GetDispatcher()->Execute( SID_VIEWSHELL0, SfxCallMode::ASYNCHRON );
+ break;
+ case FN_INSERT_BREAK:
+ {
+ sal_uInt16 nSelPage = m_pViewWin->SelectedPage();
+ //if a dummy page is selected (e.g. a non-existing right/left page)
+ //the direct neighbor is used
+ if(GetViewShell()->IsDummyPage( nSelPage ) && GetViewShell()->IsDummyPage( --nSelPage ))
+ nSelPage +=2;
+ m_nNewPage = nSelPage;
+ SfxViewFrame& rTmpFrame = GetViewFrame();
+ rTmpFrame.GetBindings().Execute( SID_VIEWSHELL0, nullptr,
+ SfxCallMode::ASYNCHRON );
+ }
+ break;
+ default:
+ OSL_ENSURE(false, "wrong dispatcher");
+ return;
+ }
+
+ if( bRefresh )
+ m_pViewWin->Invalidate();
+}
+
+void SwPagePreview::GetState( SfxItemSet& rSet )
+{
+ SfxWhichIter aIter(rSet);
+ sal_uInt16 nWhich = aIter.FirstWhich();
+ OSL_ENSURE(nWhich, "empty set");
+ SwPagePreviewLayout* pPagePreviewLay = GetViewShell()->PagePreviewLayout();
+
+ while(nWhich)
+ {
+ switch(nWhich)
+ {
+ case SID_BROWSER_MODE:
+ case FN_PRINT_LAYOUT:
+ rSet.DisableItem(nWhich);
+ break;
+ case FN_START_OF_DOCUMENT:
+ {
+ if ( pPagePreviewLay->IsPageVisible( 1 ) )
+ rSet.DisableItem(nWhich);
+ break;
+ }
+ case FN_END_OF_DOCUMENT:
+ {
+ if ( pPagePreviewLay->IsPageVisible( mnPageCount ) )
+ rSet.DisableItem(nWhich);
+ break;
+ }
+ case FN_PAGEUP:
+ {
+ if( pPagePreviewLay->GetWinPagesScrollAmount( -1 ) == 0 )
+ rSet.DisableItem(nWhich);
+ break;
+ }
+ case FN_PAGEDOWN:
+ {
+ if( pPagePreviewLay->GetWinPagesScrollAmount( 1 ) == 0 )
+ rSet.DisableItem(nWhich);
+ break;
+ }
+
+ case FN_STAT_PAGE:
+ {
+ std::vector<OUString> aStringList
+ {
+ m_sPageStr + m_pViewWin->GetStatusStr(mnPageCount),
+ OUString()
+ };
+ rSet.Put(SfxStringListItem(FN_STAT_PAGE, &aStringList));
+ }
+ break;
+
+ case SID_ATTR_ZOOM:
+ case FN_STAT_ZOOM:
+ {
+ const SwViewOption* pVOpt = GetViewShell()->GetViewOptions();
+ SvxZoomItem aZoom(pVOpt->GetZoomType(), pVOpt->GetZoom());
+ aZoom.SetValueSet(
+ SvxZoomEnableFlags::N50|
+ SvxZoomEnableFlags::N75|
+ SvxZoomEnableFlags::N100|
+ SvxZoomEnableFlags::N150|
+ SvxZoomEnableFlags::N200);
+ rSet.Put( aZoom );
+ }
+ break;
+ case SID_ATTR_ZOOMSLIDER :
+ {
+ const SwViewOption* pVOpt = GetViewShell()->GetViewOptions();
+ const sal_uInt16 nCurrentZoom = pVOpt->GetZoom();
+ SvxZoomSliderItem aZoomSliderItem( nCurrentZoom, MINZOOM, MAXZOOM );
+ aZoomSliderItem.AddSnappingPoint( 100 );
+ rSet.Put( aZoomSliderItem );
+ }
+ break;
+ case FN_PREVIEW_ZOOM:
+ {
+ const SwViewOption* pVOpt = GetViewShell()->GetViewOptions();
+ rSet.Put(SfxUInt16Item(nWhich, pVOpt->GetZoom()));
+ }
+ break;
+ case SID_ZOOM_IN:
+ case SID_ZOOM_OUT:
+ {
+ const SwViewOption* pVOpt = GetViewShell()->GetViewOptions();
+ if((SID_ZOOM_IN == nWhich && pVOpt->GetZoom() >= MAX_PREVIEW_ZOOM) ||
+ (SID_ZOOM_OUT == nWhich && pVOpt->GetZoom() <= MIN_PREVIEW_ZOOM))
+ {
+ rSet.DisableItem(nWhich);
+ }
+ }
+ break;
+ case SID_ATTR_VIEWLAYOUT:
+ {
+ rSet.DisableItem( SID_ATTR_VIEWLAYOUT );
+ }
+ break;
+ case FN_SHOW_MULTIPLE_PAGES:
+ // should never be disabled
+ break;
+ case FN_SHOW_BOOKVIEW:
+ {
+ bool b = GetViewShell()->GetViewOptions()->IsPagePrevBookview();
+ rSet.Put(SfxBoolItem(nWhich, b));
+ }
+ break;
+
+ case FN_SHOW_TWO_PAGES:
+ if( 2 == m_pViewWin->GetCol() && 1 == m_pViewWin->GetRow() )
+ rSet.DisableItem( nWhich );
+ break;
+
+ case FN_PRINT_PAGEPREVIEW:
+ // has the same status like the normal printing
+ {
+ const SfxPoolItem* pItem;
+ SfxItemSetFixed<SID_PRINTDOC, SID_PRINTDOC> aSet( *rSet.GetPool() );
+ GetSlotState( SID_PRINTDOC, SfxViewShell::GetInterface(), &aSet );
+ if( SfxItemState::DISABLED == aSet.GetItemState( SID_PRINTDOC, false ))
+ rSet.DisableItem( nWhich );
+ else if( SfxItemState::SET == aSet.GetItemState( SID_PRINTDOC,
+ false, &pItem ))
+ {
+ const_cast<SfxPoolItem*>(pItem)->SetWhich( FN_PRINT_PAGEPREVIEW );
+ rSet.Put( *pItem );
+ }
+ }
+ break;
+
+ case SID_PRINTPREVIEW:
+ rSet.Put( SfxBoolItem( nWhich, true ) );
+ break;
+
+ case SID_PRINTDOC:
+ case SID_PRINTDOCDIRECT:
+ GetSlotState( nWhich, SfxViewShell::GetInterface(), &rSet );
+ break;
+ }
+ nWhich = aIter.NextWhich();
+ }
+}
+
+void SwPagePreview::StateUndo(SfxItemSet& rSet)
+{
+ SfxWhichIter aIter(rSet);
+ sal_uInt16 nWhich = aIter.FirstWhich();
+
+ while (nWhich)
+ {
+ rSet.DisableItem(nWhich);
+ nWhich = aIter.NextWhich();
+ }
+}
+
+void SwPagePreview::Init()
+{
+ if ( GetViewShell()->HasDrawView() )
+ GetViewShell()->GetDrawView()->SetAnimationEnabled( false );
+
+ m_bNormalPrint = true;
+
+ // Check and process the DocSize. The shell could not be found via
+ // the handler, because the shell is unknown to the SFX management
+ // within the CTOR phase.
+
+ const SwViewOption * pPrefs = SW_MOD()->GetUsrPref(false);
+
+ mbHScrollbarEnabled = pPrefs->IsViewHScrollBar();
+ mbVScrollbarEnabled = pPrefs->IsViewVScrollBar();
+
+ // Update the fields
+ // ATTENTION: Do cast the EditShell up, to use the SS.
+ // At the methods the current shell will be queried!
+ SwEditShell* pESh = dynamic_cast<SwEditShell*>(GetViewShell());
+ bool bIsModified = pESh != nullptr && pESh->IsModified();
+
+ SwViewOption aOpt( *pPrefs );
+ aOpt.SetPagePreview(true);
+ aOpt.SetTab( false );
+ aOpt.SetBlank( false );
+ aOpt.SetHardBlank( false );
+ aOpt.SetParagraph( false );
+ aOpt.SetLineBreak( false );
+ aOpt.SetPageBreak( false );
+ aOpt.SetColumnBreak( false );
+ aOpt.SetSoftHyph( false );
+ aOpt.SetFieldName( false );
+ aOpt.SetPostIts( false );
+ aOpt.SetShowBookmarks( false );
+ aOpt.SetShowHiddenChar( false );
+ aOpt.SetShowHiddenField( false );
+ aOpt.SetShowHiddenPara( false );
+ aOpt.SetViewHRuler( false );
+ aOpt.SetViewVRuler( false );
+ aOpt.SetGraphic( true );
+ aOpt.SetTable( true );
+ aOpt.SetSnap( false );
+ aOpt.SetGridVisible( false );
+ aOpt.SetOnlineSpell( false );
+ aOpt.SetHideWhitespaceMode( false );
+
+ GetViewShell()->ApplyViewOptions( aOpt );
+#if !ENABLE_WASM_STRIP_ACCESSIBILITY
+ GetViewShell()->ApplyAccessibilityOptions();
+#endif
+
+ // adjust view shell option to the same as for print
+ SwPrintData const aPrintOptions = *SW_MOD()->GetPrtOptions(false);
+ GetViewShell()->AdjustOptionsForPagePreview( aPrintOptions );
+
+ GetViewShell()->CalcLayout();
+ DocSzChgd( GetViewShell()->GetDocSize() );
+
+ if( !bIsModified && pESh != nullptr )
+ pESh->ResetModified();
+}
+
+SwPagePreview::SwPagePreview(SfxViewFrame& rViewFrame, SfxViewShell* pOldSh):
+ SfxViewShell(rViewFrame, SWVIEWFLAGS),
+ m_pViewWin( VclPtr<SwPagePreviewWin>::Create(&GetViewFrame().GetWindow(), *this ) ),
+ m_nNewPage(USHRT_MAX),
+ m_sPageStr(SwResId(STR_PAGE)),
+ m_pHScrollbar(nullptr),
+ m_pVScrollbar(nullptr),
+ mnPageCount( 0 ),
+ mbResetFormDesignMode( false ),
+ mbFormDesignModeToReset( false )
+{
+ SetName("PageView");
+ SetWindow( m_pViewWin );
+ CreateScrollbar( true );
+ CreateScrollbar( false );
+
+ SfxShell::SetContextName(vcl::EnumContext::GetContextName(vcl::EnumContext::Context::Printpreview));
+
+ SfxObjectShell* pObjShell = rViewFrame.GetObjectShell();
+ if ( !pOldSh )
+ {
+ // Exists already a view on the document?
+ SfxViewFrame *pF = SfxViewFrame::GetFirst( pObjShell );
+ if (pF == &rViewFrame)
+ pF = SfxViewFrame::GetNext( *pF, pObjShell );
+ if ( pF )
+ pOldSh = pF->GetViewShell();
+ }
+
+ SwViewShell *pVS, *pNew;
+
+ if (SwPagePreview* pPagePreview = dynamic_cast<SwPagePreview*>(pOldSh))
+ pVS = pPagePreview->GetViewShell();
+ else
+ {
+ if (SwView* pView = dynamic_cast<SwView *>(pOldSh))
+ {
+ pVS = pView->GetWrtShellPtr();
+ // save the current ViewData of the previous SwView
+ pOldSh->WriteUserData( m_sSwViewData );
+ }
+ else
+ pVS = GetDocShell()->GetWrtShell();
+ if( pVS )
+ {
+ // Set the current page as the first.
+ sal_uInt16 nPhysPg, nVirtPg;
+ static_cast<SwCursorShell*>(pVS)->GetPageNum( nPhysPg, nVirtPg, true, false );
+ if( 1 != m_pViewWin->GetCol() && 1 == nPhysPg )
+ --nPhysPg;
+ m_pViewWin->SetSttPage( nPhysPg );
+ }
+ }
+
+ // for form shell remember design mode of draw view
+ // of previous view shell
+ if ( pVS && pVS->HasDrawView() )
+ {
+ mbResetFormDesignMode = true;
+ mbFormDesignModeToReset = pVS->GetDrawView()->IsDesignMode();
+ }
+
+ if( pVS )
+ pNew = new SwViewShell( *pVS, m_pViewWin, nullptr, VSHELLFLAG_ISPREVIEW );
+ else
+ pNew = new SwViewShell(
+ *static_cast<SwDocShell*>(rViewFrame.GetObjectShell())->GetDoc(),
+ m_pViewWin, nullptr, nullptr, VSHELLFLAG_ISPREVIEW );
+
+ m_pViewWin->SetViewShell( pNew );
+ pNew->SetSfxViewShell( this );
+ Init();
+}
+
+SwPagePreview::~SwPagePreview()
+{
+ SetWindow( nullptr );
+ SwViewShell* pVShell = m_pViewWin->GetViewShell();
+ pVShell->SetWin(nullptr);
+ delete pVShell;
+
+ m_pViewWin.disposeAndClear();
+ m_pHScrollbar.disposeAndClear();
+ m_pVScrollbar.disposeAndClear();
+}
+
+void SwPagePreview::Activate(bool bMDI)
+{
+ SfxViewShell::Activate(bMDI);
+ SfxShell::Activate(bMDI);
+}
+
+SwDocShell* SwPagePreview::GetDocShell()
+{
+ return dynamic_cast<SwDocShell*>( GetViewFrame().GetObjectShell() );
+}
+
+void SwPagePreview::CreateScrollbar( bool bHori )
+{
+ vcl::Window *pMDI = &GetViewFrame().GetWindow();
+ VclPtr<SwScrollbar>& ppScrollbar = bHori ? m_pHScrollbar : m_pVScrollbar;
+
+ assert(!ppScrollbar); //check beforehand!
+ ppScrollbar = VclPtr<SwScrollbar>::Create( pMDI, bHori );
+
+ ScrollDocSzChg();
+
+ if (bHori)
+ ppScrollbar->SetScrollHdl( LINK( this, SwPagePreview, HoriScrollHdl ));
+ else
+ ppScrollbar->SetScrollHdl( LINK( this, SwPagePreview, VertScrollHdl ));
+
+ InvalidateBorder();
+ ppScrollbar->ExtendedShow();
+}
+
+bool SwPagePreview::ChgPage( int eMvMode, bool bUpdateScrollbar )
+{
+ tools::Rectangle aPixVisArea( m_pViewWin->LogicToPixel( m_aVisArea ) );
+ bool bChg = m_pViewWin->MovePage( eMvMode ) ||
+ eMvMode == SwPagePreviewWin::MV_CALC ||
+ eMvMode == SwPagePreviewWin::MV_NEWWINSIZE;
+ m_aVisArea = m_pViewWin->PixelToLogic( aPixVisArea );
+
+ if( bChg )
+ {
+ // Update statusbar
+ SfxBindings& rBindings = GetViewFrame().GetBindings();
+
+ if( bUpdateScrollbar )
+ {
+ ScrollViewSzChg();
+
+ static sal_uInt16 aInval[] =
+ {
+ FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT,
+ FN_PAGEUP, FN_PAGEDOWN, 0
+ };
+ rBindings.Invalidate( aInval );
+ }
+ std::vector<OUString> aStringList
+ {
+ m_sPageStr + m_pViewWin->GetStatusStr(mnPageCount),
+ OUString()
+ };
+ rBindings.SetState(SfxStringListItem(FN_STAT_PAGE, &aStringList));
+ }
+ return bChg;
+}
+
+// From here, everything was taken from the SwView.
+void SwPagePreview::CalcAndSetBorderPixel( SvBorder &rToFill )
+{
+ const StyleSettings &rSet = m_pViewWin->GetSettings().GetStyleSettings();
+ const tools::Long nTmp = rSet.GetScrollBarSize();
+ if (m_pVScrollbar->IsScrollbarVisible(true))
+ rToFill.Right() = nTmp;
+ if (m_pHScrollbar->IsScrollbarVisible(true))
+ rToFill.Bottom() = nTmp;
+ SetBorderPixel( rToFill );
+}
+
+void SwPagePreview::InnerResizePixel( const Point &rOfst, const Size &rSize, bool )
+{
+ SvBorder aBorder;
+ CalcAndSetBorderPixel( aBorder );
+ tools::Rectangle aRect( rOfst, rSize );
+ aRect += aBorder;
+ ViewResizePixel( *m_pViewWin->GetOutDev(), aRect.TopLeft(), aRect.GetSize(),
+ m_pViewWin->GetOutputSizePixel(),
+ *m_pVScrollbar, *m_pHScrollbar );
+
+ // Never set EditWin !
+ // Never set VisArea !
+}
+
+void SwPagePreview::OuterResizePixel( const Point &rOfst, const Size &rSize )
+{
+ SvBorder aBorder;
+ CalcAndSetBorderPixel( aBorder );
+
+ // Never set EditWin !
+
+ Size aTmpSize( m_pViewWin->GetOutputSizePixel() );
+ Point aBottomRight( m_pViewWin->PixelToLogic( Point( aTmpSize.Width(), aTmpSize.Height() ) ) );
+ SetVisArea( tools::Rectangle( Point(), aBottomRight ) );
+
+ // Call of the DocSzChgd-Method of the scrollbars is necessary,
+ // because from the maximum scroll range half the height of the
+ // VisArea is always deducted.
+ if ( m_pVScrollbar && !aTmpSize.IsEmpty() )
+ {
+ ScrollDocSzChg();
+ }
+
+ SvBorder aBorderNew;
+ CalcAndSetBorderPixel( aBorderNew );
+ ViewResizePixel( *m_pViewWin->GetOutDev(), rOfst, rSize, m_pViewWin->GetOutputSizePixel(),
+ *m_pVScrollbar, *m_pHScrollbar );
+}
+
+void SwPagePreview::SetVisArea( const tools::Rectangle &rRect )
+{
+ const Point aTopLeft(AlignToPixel(rRect.TopLeft()));
+ const Point aBottomRight(AlignToPixel(rRect.BottomRight()));
+ tools::Rectangle aLR(aTopLeft,aBottomRight);
+
+ if(aLR == m_aVisArea)
+ return;
+ // No negative position, no negative size
+
+ if(aLR.Top() < 0)
+ {
+ aLR.AdjustBottom(std::abs(aLR.Top()) );
+ aLR.SetTop( 0 );
+ }
+
+ if(aLR.Left() < 0)
+ {
+ aLR.AdjustRight(std::abs(aLR.Left()) );
+ aLR.SetLeft( 0 );
+ }
+ if(aLR.Right() < 0) aLR.SetRight( 0 );
+ if(aLR.Bottom() < 0) aLR.SetBottom( 0 );
+ if(aLR == m_aVisArea ||
+ // Ignore empty rectangle
+ ( 0 == aLR.Bottom() - aLR.Top() && 0 == aLR.Right() - aLR.Left() ) )
+ return;
+
+ if( aLR.Left() > aLR.Right() || aLR.Top() > aLR.Bottom() )
+ return;
+
+ // Before the data can be changed call an update if necessary.
+ // Thereby ensured, that adjacent paints are correctly converted into
+ // document coordinates.
+ // As a precaution, we do this only when at the shell runs an action,
+ // because then we do not really paint but the rectangles are just
+ // bookmarked (in document coordinates).
+ if( GetViewShell()->ActionPend() )
+ m_pViewWin->PaintImmediately();
+
+ // Set at View-Win the current size
+ m_aVisArea = aLR;
+ m_pViewWin->SetWinSize( aLR.GetSize() );
+ ChgPage( SwPagePreviewWin::MV_NEWWINSIZE );
+
+ m_pViewWin->Invalidate();
+}
+
+IMPL_LINK(SwPagePreview, HoriScrollHdl, weld::Scrollbar&, rScrollbar, void)
+{
+ ScrollHdl(rScrollbar, true);
+}
+
+IMPL_LINK(SwPagePreview, VertScrollHdl, weld::Scrollbar&, rScrollbar, void)
+{
+ ScrollHdl(rScrollbar, false);
+}
+
+void SwPagePreview::ScrollHdl(weld::Scrollbar& rScrollbar, bool bHori)
+{
+ if(!GetViewShell())
+ return;
+
+ EndScrollHdl(rScrollbar, bHori);
+
+ if( !bHori &&
+ rScrollbar.get_scroll_type() == ScrollType::Drag &&
+ Help::IsQuickHelpEnabled() &&
+ GetViewShell()->PagePreviewLayout()->DoesPreviewLayoutRowsFitIntoWindow())
+ {
+ // Scroll how many pages??
+ OUString sStateStr(m_sPageStr);
+ tools::Long nThmbPos = rScrollbar.adjustment_get_value();
+ if( 1 == m_pViewWin->GetCol() || !nThmbPos )
+ ++nThmbPos;
+ sStateStr += OUString::number( nThmbPos );
+ Point aPos = m_pVScrollbar->GetParent()->OutputToScreenPixel(
+ m_pVScrollbar->GetPosPixel());
+ aPos.setY( m_pVScrollbar->OutputToScreenPixel(m_pVScrollbar->GetPointerPosPixel()).Y() );
+ tools::Rectangle aRect;
+ aRect.SetLeft( aPos.X() -8 );
+ aRect.SetRight( aRect.Left() );
+ aRect.SetTop( aPos.Y() );
+ aRect.SetBottom( aRect.Top() );
+
+ Help::ShowQuickHelp(m_pVScrollbar, aRect, sStateStr,
+ QuickHelpFlags::Right|QuickHelpFlags::VCenter);
+
+ }
+}
+
+void SwPagePreview::EndScrollHdl(weld::Scrollbar& rScrollbar, bool bHori)
+{
+ if(!GetViewShell())
+ return;
+
+ // boolean to avoid unnecessary invalidation of the window.
+ bool bInvalidateWin = true;
+
+ if (!bHori) // scroll vertically
+ {
+ if ( Help::IsQuickHelpEnabled() )
+ Help::ShowQuickHelp(m_pVScrollbar, tools::Rectangle(), OUString());
+ if ( GetViewShell()->PagePreviewLayout()->DoesPreviewLayoutRowsFitIntoWindow() )
+ {
+ // Scroll how many pages ??
+ const sal_uInt16 nThmbPos = o3tl::narrowing<sal_uInt16>(rScrollbar.adjustment_get_value());
+ // adjust to new preview functionality
+ if( nThmbPos != m_pViewWin->SelectedPage() )
+ {
+ // consider case that page <nThmbPos>
+ // is already visible
+ SwPagePreviewLayout* pPagePreviewLay = GetViewShell()->PagePreviewLayout();
+ if ( pPagePreviewLay->IsPageVisible( nThmbPos ) )
+ {
+ pPagePreviewLay->MarkNewSelectedPage( nThmbPos );
+ // invalidation of window is unnecessary
+ bInvalidateWin = false;
+ }
+ else
+ {
+ // consider whether layout columns
+ // fit or not.
+ if ( !pPagePreviewLay->DoesPreviewLayoutColsFitIntoWindow() )
+ {
+ m_pViewWin->SetSttPage( nThmbPos );
+ m_pViewWin->SetSelectedPage( nThmbPos );
+ ChgPage( SwPagePreviewWin::MV_SCROLL, false );
+ // update scrollbars
+ ScrollViewSzChg();
+ }
+ else
+ {
+ // correct scroll amount
+ const sal_Int16 nPageDiff = nThmbPos - m_pViewWin->SelectedPage();
+ const sal_uInt16 nVisPages = m_pViewWin->GetRow() * m_pViewWin->GetCol();
+ sal_Int16 nWinPagesToScroll = nPageDiff / nVisPages;
+ if ( nPageDiff % nVisPages )
+ {
+ // decrease/increase number of preview pages to scroll
+ nPageDiff < 0 ? --nWinPagesToScroll : ++nWinPagesToScroll;
+ }
+ m_pViewWin->SetSelectedPage( nThmbPos );
+ m_pViewWin->Scroll( 0, pPagePreviewLay->GetWinPagesScrollAmount( nWinPagesToScroll ) );
+ }
+ }
+ // update accessibility
+ GetViewShell()->ShowPreviewSelection( nThmbPos );
+ }
+ else
+ {
+ // invalidation of window is unnecessary
+ bInvalidateWin = false;
+ }
+ }
+ else
+ {
+ tools::Long nThmbPos = rScrollbar.adjustment_get_value();
+ m_pViewWin->Scroll(0, nThmbPos - m_pViewWin->GetPaintedPreviewDocRect().Top());
+ }
+ }
+ else
+ {
+ tools::Long nThmbPos = rScrollbar.adjustment_get_value();
+ m_pViewWin->Scroll(nThmbPos - m_pViewWin->GetPaintedPreviewDocRect().Left(), 0);
+ }
+ // additional invalidate page status.
+ static sal_uInt16 aInval[] =
+ {
+ FN_START_OF_DOCUMENT, FN_END_OF_DOCUMENT, FN_PAGEUP, FN_PAGEDOWN,
+ FN_STAT_PAGE, 0
+ };
+ SfxBindings& rBindings = GetViewFrame().GetBindings();
+ rBindings.Invalidate( aInval );
+ // control invalidation of window
+ if ( bInvalidateWin )
+ {
+ m_pViewWin->Invalidate();
+ }
+}
+
+Point SwPagePreview::AlignToPixel(const Point &rPt) const
+{
+ return m_pViewWin->PixelToLogic( m_pViewWin->LogicToPixel( rPt ) );
+}
+
+void SwPagePreview::DocSzChgd( const Size &rSz )
+{
+ if( m_aDocSize == rSz )
+ return;
+
+ m_aDocSize = rSz;
+
+ // #i96726#
+ // Due to the multiple page layout it is needed to trigger recalculation
+ // of the page preview layout, even if the count of pages is not changing.
+ mnPageCount = GetViewShell()->GetNumPages();
+
+ if( m_aVisArea.GetWidth() )
+ {
+ ChgPage( SwPagePreviewWin::MV_CALC );
+ ScrollDocSzChg();
+
+ m_pViewWin->Invalidate();
+ }
+}
+
+void SwPagePreview::ScrollViewSzChg()
+{
+ if(!GetViewShell())
+ return ;
+
+ bool bShowVScrollbar = false, bShowHScrollbar = false;
+
+ if(m_pVScrollbar)
+ {
+ if(GetViewShell()->PagePreviewLayout()->DoesPreviewLayoutRowsFitIntoWindow())
+ {
+ //vertical scrolling by row
+ // adjust to new preview functionality
+ const sal_uInt16 nVisPages = m_pViewWin->GetRow() * m_pViewWin->GetCol();
+
+ m_pVScrollbar->SetVisibleSize( nVisPages );
+ // set selected page as scroll bar position,
+ // if it is visible.
+ SwPagePreviewLayout* pPagePreviewLay = GetViewShell()->PagePreviewLayout();
+ if ( pPagePreviewLay->IsPageVisible( m_pViewWin->SelectedPage() ) )
+ {
+ m_pVScrollbar->SetThumbPos( m_pViewWin->SelectedPage() );
+ }
+ else
+ {
+ m_pVScrollbar->SetThumbPos( m_pViewWin->GetSttPage() );
+ }
+ m_pVScrollbar->SetLineSize( m_pViewWin->GetCol() );
+ m_pVScrollbar->SetPageSize( nVisPages );
+ // calculate and set scrollbar range
+ Range aScrollbarRange( 1, mnPageCount );
+ // increase range by one, because left-top-corner is left blank.
+ ++aScrollbarRange.Max();
+ // increase range in order to access all pages
+ aScrollbarRange.Max() += ( nVisPages - 1 );
+ m_pVScrollbar->SetRange( aScrollbarRange );
+
+ bShowVScrollbar = nVisPages < mnPageCount;
+ }
+ else //vertical scrolling by pixel
+ {
+ const tools::Rectangle& rDocRect = m_pViewWin->GetPaintedPreviewDocRect();
+ const Size& rPreviewSize =
+ GetViewShell()->PagePreviewLayout()->GetPreviewDocSize();
+ m_pVScrollbar->SetRangeMax(rPreviewSize.Height()) ;
+ tools::Long nVisHeight = rDocRect.GetHeight();
+ m_pVScrollbar->SetVisibleSize( nVisHeight );
+ m_pVScrollbar->SetThumbPos( rDocRect.Top() );
+ m_pVScrollbar->SetLineSize( nVisHeight / 10 );
+ m_pVScrollbar->SetPageSize( nVisHeight / 2 );
+
+ bShowVScrollbar = true;
+ }
+
+ if (!mbVScrollbarEnabled)
+ bShowVScrollbar = false;
+
+ ShowVScrollbar(bShowVScrollbar);
+ }
+ if(m_pHScrollbar)
+ {
+ const tools::Rectangle& rDocRect = m_pViewWin->GetPaintedPreviewDocRect();
+ const Size& rPreviewSize =
+ GetViewShell()->PagePreviewLayout()->GetPreviewDocSize();
+ Range aRange(0,0);
+
+ if(rDocRect.GetWidth() < rPreviewSize.Width())
+ {
+ bShowHScrollbar = true;
+
+ tools::Long nVisWidth = rDocRect.GetWidth();
+ tools::Long nThumb = rDocRect.Left();
+ aRange = Range(0, rPreviewSize.Width());
+
+ m_pHScrollbar->SetRange( aRange );
+ m_pHScrollbar->SetVisibleSize( nVisWidth );
+ m_pHScrollbar->SetThumbPos( nThumb );
+ m_pHScrollbar->SetLineSize( nVisWidth / 10 );
+ m_pHScrollbar->SetPageSize( nVisWidth / 2 );
+ }
+
+ if (!mbHScrollbarEnabled)
+ bShowHScrollbar = false;
+
+ ShowHScrollbar(bShowHScrollbar);
+ }
+}
+
+void SwPagePreview::ScrollDocSzChg()
+{
+ ScrollViewSzChg();
+}
+
+// All about printing
+SfxPrinter* SwPagePreview::GetPrinter( bool bCreate )
+{
+ return m_pViewWin->GetViewShell()->getIDocumentDeviceAccess().getPrinter( bCreate );
+}
+
+sal_uInt16 SwPagePreview::SetPrinter( SfxPrinter *pNew, SfxPrinterChangeFlags nDiffFlags )
+{
+ SwViewShell &rSh = *GetViewShell();
+ SfxPrinter* pOld = rSh.getIDocumentDeviceAccess().getPrinter( false );
+ if ( pOld && pOld->IsPrinting() )
+ return SFX_PRINTERROR_BUSY;
+
+ SwEditShell &rESh = static_cast<SwEditShell&>(rSh); //Buh...
+ if( ( SfxPrinterChangeFlags::PRINTER | SfxPrinterChangeFlags::JOBSETUP ) & nDiffFlags )
+ {
+ rSh.getIDocumentDeviceAccess().setPrinter( pNew, true, true );
+ if( nDiffFlags & SfxPrinterChangeFlags::PRINTER )
+ rESh.SetModified();
+ }
+ if ( ( nDiffFlags & SfxPrinterChangeFlags::OPTIONS ) == SfxPrinterChangeFlags::OPTIONS )
+ ::SetPrinter( &rSh.getIDocumentDeviceAccess(), pNew, false );
+
+ const bool bChgOri = bool(nDiffFlags & SfxPrinterChangeFlags::CHG_ORIENTATION);
+ const bool bChgSize = bool(nDiffFlags & SfxPrinterChangeFlags::CHG_SIZE);
+ if ( bChgOri || bChgSize )
+ {
+ rESh.StartAllAction();
+ if ( bChgOri )
+ rSh.ChgAllPageOrientation( pNew->GetOrientation() );
+ if ( bChgSize )
+ {
+ Size aSz( SvxPaperInfo::GetPaperSize( pNew ) );
+ rSh.ChgAllPageSize( aSz );
+ }
+ if( !m_bNormalPrint )
+ m_pViewWin->CalcWish( m_pViewWin->GetRow(), m_pViewWin->GetCol() );
+ rESh.SetModified();
+ rESh.EndAllAction();
+
+ static sal_uInt16 aInval[] =
+ {
+ SID_ATTR_LONG_ULSPACE, SID_ATTR_LONG_LRSPACE,
+ SID_RULER_BORDERS, SID_RULER_PAGE_POS, 0
+ };
+#if OSL_DEBUG_LEVEL > 0
+ {
+ const sal_uInt16* pPtr = aInval + 1;
+ do {
+ OSL_ENSURE( *(pPtr - 1) < *pPtr, "wrong sorting!" );
+ } while( *++pPtr );
+ }
+#endif
+
+ GetViewFrame().GetBindings().Invalidate(aInval);
+ }
+
+ return 0;
+}
+
+bool SwPagePreview::HasPrintOptionsPage() const
+{
+ return true;
+}
+
+std::unique_ptr<SfxTabPage> SwPagePreview::CreatePrintOptionsPage(weld::Container* pPage, weld::DialogController* pController,
+ const SfxItemSet &rOptions)
+{
+ return ::CreatePrintOptionsPage(pPage, pController, rOptions, !m_bNormalPrint);
+}
+
+void SwPagePreviewWin::SetViewShell( SwViewShell* pShell )
+{
+ mpViewShell = pShell;
+ if ( mpViewShell && mpViewShell->IsPreview() )
+ {
+ mpPgPreviewLayout = mpViewShell->PagePreviewLayout();
+ }
+}
+
+void SwPagePreviewWin::RepaintCoreRect( const SwRect& rRect )
+{
+ // #i24183#
+ if ( mpPgPreviewLayout->PreviewLayoutValid() )
+ {
+ mpPgPreviewLayout->Repaint( tools::Rectangle( rRect.Pos(), rRect.SSize() ) );
+ }
+}
+
+/** method to adjust preview to a new zoom factor
+
+ #i19975# also consider zoom type - adding parameter <_eZoomType>
+*/
+void SwPagePreviewWin::AdjustPreviewToNewZoom( const sal_uInt16 _nZoomFactor,
+ const SvxZoomType _eZoomType )
+{
+ // #i19975# consider zoom type
+ if ( _eZoomType == SvxZoomType::WHOLEPAGE )
+ {
+ mnRow = 1;
+ mnCol = 1;
+ mpPgPreviewLayout->Init( mnCol, mnRow, maPxWinSize );
+ mpPgPreviewLayout->Prepare( mnSttPage, Point(0,0), maPxWinSize,
+ mnSttPage, maPaintedPreviewDocRect );
+ SetSelectedPage( mnSttPage );
+ SetPagePreview(mnRow, mnCol);
+ maScale = GetMapMode().GetScaleX();
+ }
+ else if ( _nZoomFactor != 0 )
+ {
+ // calculate new scaling and set mapping mode appropriately.
+ Fraction aNewScale( _nZoomFactor, 100 );
+ MapMode aNewMapMode = GetMapMode();
+ aNewMapMode.SetScaleX( aNewScale );
+ aNewMapMode.SetScaleY( aNewScale );
+ SetMapMode( aNewMapMode );
+
+ // calculate new start position for preview paint
+ Size aNewWinSize = PixelToLogic( maPxWinSize );
+ Point aNewPaintStartPos =
+ mpPgPreviewLayout->GetPreviewStartPosForNewScale( aNewScale, maScale, aNewWinSize );
+
+ // remember new scaling and prepare preview paint
+ // Note: paint of preview will be performed by a corresponding invalidate
+ // due to property changes.
+ maScale = aNewScale;
+ mpPgPreviewLayout->Prepare( 0, aNewPaintStartPos, maPxWinSize,
+ mnSttPage, maPaintedPreviewDocRect );
+ }
+
+}
+
+/**
+ * pixel scrolling - horizontally always or vertically
+ * when less than the desired number of rows fits into
+ * the view
+ */
+void SwPagePreviewWin::Scroll(tools::Long nXMove, tools::Long nYMove, ScrollFlags /*nFlags*/)
+{
+ maPaintedPreviewDocRect.Move(nXMove, nYMove);
+ mpPgPreviewLayout->Prepare( 0, maPaintedPreviewDocRect.TopLeft(),
+ maPxWinSize, mnSttPage,
+ maPaintedPreviewDocRect );
+
+}
+
+bool SwPagePreview::HandleWheelCommands( const CommandEvent& rCEvt )
+{
+ bool bOk = false;
+ const CommandWheelData* pWData = rCEvt.GetWheelData();
+ if( pWData && CommandWheelMode::ZOOM == pWData->GetMode() )
+ {
+ //only the Preference shouldn't control the Zoom, it is better to detect AT tools running. So the bridge can be used here
+ if (!Application::GetSettings().GetMiscSettings().GetEnableATToolSupport())
+ {
+ sal_uInt16 nFactor = GetViewShell()->GetViewOptions()->GetZoom();
+ const sal_uInt16 nOffset = 10;
+ if( 0L > pWData->GetDelta() )
+ {
+ nFactor -= nOffset;
+ if(nFactor < MIN_PREVIEW_ZOOM)
+ nFactor = MIN_PREVIEW_ZOOM;
+ }
+ else
+ {
+ nFactor += nOffset;
+ if(nFactor > MAX_PREVIEW_ZOOM)
+ nFactor = MAX_PREVIEW_ZOOM;
+ }
+ SetZoom(SvxZoomType::PERCENT, nFactor);
+ }
+ bOk = true;
+ }
+ else
+ bOk = m_pViewWin->HandleScrollCommand( rCEvt, m_pHScrollbar, m_pVScrollbar );
+ return bOk;
+}
+
+uno::Reference< css::accessibility::XAccessible >
+ SwPagePreviewWin::CreateAccessible()
+{
+ SolarMutexGuard aGuard; // this should have happened already!!!
+#if !ENABLE_WASM_STRIP_ACCESSIBILITY
+ OSL_ENSURE( GetViewShell() != nullptr, "We need a view shell" );
+ css::uno::Reference< css::accessibility::XAccessible > xAcc = GetAccessible( false );
+ if (xAcc.is())
+ {
+ return xAcc;
+ }
+ if (mpViewShell)
+ {
+ css::uno::Reference< css::accessibility::XAccessible > xAccPreview = mpViewShell->CreateAccessiblePreview();
+ SetAccessible(xAccPreview);
+ }
+#endif
+ return GetAccessible( false );
+}
+
+void SwPagePreview::ApplyAccessibilityOptions()
+{
+ GetViewShell()->ApplyAccessibilityOptions();
+}
+
+void SwPagePreview::ShowHScrollbar(bool bShow)
+{
+ m_pHScrollbar->Show(bShow);
+ InvalidateBorder();
+}
+
+void SwPagePreview::ShowVScrollbar(bool bShow)
+{
+ m_pVScrollbar->Show(bShow);
+ InvalidateBorder();
+}
+
+void SwPagePreview::EnableHScrollbar(bool bEnable)
+{
+ if (mbHScrollbarEnabled != bEnable)
+ {
+ mbHScrollbarEnabled = bEnable;
+ ScrollViewSzChg();
+ }
+}
+
+void SwPagePreview::EnableVScrollbar(bool bEnable)
+{
+ if (mbVScrollbarEnabled != bEnable)
+ {
+ mbVScrollbarEnabled = bEnable;
+ ScrollViewSzChg();
+ }
+}
+
+void SwPagePreview::SetZoom(SvxZoomType eType, sal_uInt16 nFactor)
+{
+ SwViewShell& rSh = *GetViewShell();
+ SwViewOption aOpt(*rSh.GetViewOptions());
+ // perform action only on changes of zoom or zoom type.
+ if ( aOpt.GetZoom() != nFactor ||
+ aOpt.GetZoomType() != eType )
+ {
+ aOpt.SetZoom(nFactor);
+ aOpt.SetZoomType(eType);
+ rSh.ApplyViewOptions( aOpt );
+ lcl_InvalidateZoomSlots(GetViewFrame().GetBindings());
+ // #i19975# also consider zoom type
+ m_pViewWin->AdjustPreviewToNewZoom( nFactor, eType );
+ ScrollViewSzChg();
+ }
+}
+
+/** adjust position of vertical scrollbar */
+void SwPagePreview::SetVScrollbarThumbPos( const sal_uInt16 _nNewThumbPos )
+{
+ if ( m_pVScrollbar )
+ {
+ m_pVScrollbar->SetThumbPos( _nNewThumbPos );
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/scroll.cxx b/sw/source/uibase/uiview/scroll.cxx
new file mode 100644
index 0000000000..7b1d7f915a
--- /dev/null
+++ b/sw/source/uibase/uiview/scroll.cxx
@@ -0,0 +1,116 @@
+/* -*- 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 <scroll.hxx>
+
+#define SCROLL_LINE_SIZE 250
+
+SwScrollbar::SwScrollbar(vcl::Window *pWin, bool bHoriz)
+ : ScrollAdaptor(pWin, bHoriz)
+ , m_bAuto(false)
+ , m_bVisible(false)
+ , m_bSizeSet(false)
+{
+ m_xScrollBar->show();
+
+ // No mirroring for horizontal scrollbars
+ if (bHoriz)
+ m_xScrollBar->set_direction(false);
+}
+
+// Will be called after a change of the document size
+// to refresh the range of the scrollbars.
+void SwScrollbar::DocSzChgd( const Size &rSize )
+{
+ m_aDocSz = rSize;
+ SetRange( Range( 0, m_bHori ? rSize.Width() : rSize.Height()) );
+ const tools::Long nVisSize = GetVisibleSize();
+ SetLineSize( SCROLL_LINE_SIZE );
+ SetPageSize( nVisSize * 77 / 100 );
+}
+
+// Will be called after a change of the visible view section.
+void SwScrollbar::ViewPortChgd( const tools::Rectangle &rRect )
+{
+ tools::Long nThumb, nVisible;
+ if( m_bHori )
+ {
+ nThumb = rRect.Left();
+ nVisible = rRect.GetWidth();
+ }
+ else
+ {
+ nThumb = rRect.Top();
+ nVisible = rRect.GetHeight();
+ }
+
+ SetVisibleSize( nVisible );
+ DocSzChgd(m_aDocSz);
+ SetThumbPos( nThumb );
+ if(m_bAuto)
+ AutoShow();
+}
+
+void SwScrollbar::ExtendedShow( bool bSet )
+{
+ m_bVisible = bSet;
+ if( (!bSet || !m_bAuto) && IsUpdateMode() && m_bSizeSet)
+ {
+ ScrollAdaptor::Show(bSet);
+ }
+}
+
+void SwScrollbar::SetPosSizePixel( const Point& rNewPos, const Size& rNewSize )
+{
+ ScrollAdaptor::SetPosSizePixel(rNewPos, rNewSize);
+ m_bSizeSet = true;
+ if(m_bVisible)
+ ExtendedShow();
+}
+
+void SwScrollbar::SetAuto(bool bSet)
+{
+ if(m_bAuto != bSet)
+ {
+ m_bAuto = bSet;
+
+ // hide automatically - then show
+ if(!m_bAuto && m_bVisible && !ScrollAdaptor::IsVisible())
+ ExtendedShow();
+ else if(m_bAuto)
+ AutoShow(); // or hide automatically
+ }
+}
+
+void SwScrollbar::AutoShow()
+{
+ tools::Long nVis = GetVisibleSize();
+ tools::Long nLen = GetRange().Len();
+ if (nVis >= nLen - 1)
+ {
+ if (ScrollAdaptor::IsVisible())
+ ScrollAdaptor::Show(false);
+ }
+ else if (!ScrollAdaptor::IsVisible())
+ {
+ ScrollAdaptor::Show();
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/srcview.cxx b/sw/source/uibase/uiview/srcview.cxx
new file mode 100644
index 0000000000..563dd0b468
--- /dev/null
+++ b/sw/source/uibase/uiview/srcview.cxx
@@ -0,0 +1,839 @@
+/* -*- 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 <rtl/tencinfo.h>
+#include <osl/diagnose.h>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
+#include <unotools/tempfile.hxx>
+#include <tools/urlobj.hxx>
+#include <vcl/errinf.hxx>
+#include <vcl/weld.hxx>
+#include <vcl/textview.hxx>
+#include <vcl/svapp.hxx>
+#include <svl/intitem.hxx>
+#include <svl/stritem.hxx>
+#include <svl/undo.hxx>
+#include <svl/eitem.hxx>
+#include <svl/whiter.hxx>
+#include <vcl/transfer.hxx>
+#include <svtools/strings.hrc>
+#include <svtools/svtresid.hxx>
+#include <svtools/htmlcfg.hxx>
+#include <sfx2/app.hxx>
+#include <sfx2/objface.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/docfilt.hxx>
+#include <sfx2/fcontnr.hxx>
+#include <sfx2/request.hxx>
+#include <sfx2/docfile.hxx>
+#include <svx/srchdlg.hxx>
+#include <svx/statusitem.hxx>
+#include <svl/srchitem.hxx>
+#include <sfx2/sfxhtml.hxx>
+#include <swtypes.hxx>
+#include <docsh.hxx>
+#include <wdocsh.hxx>
+#include <srcview.hxx>
+#include "viewfunc.hxx"
+#include <doc.hxx>
+#include <IDocumentDeviceAccess.hxx>
+#include <IDocumentState.hxx>
+#include <sfx2/msg.hxx>
+#include <shellio.hxx>
+
+#include <cmdid.h>
+#include <strings.hrc>
+#include <com/sun/star/ui/dialogs/XFilePicker3.hpp>
+#include <sfx2/filedlghelper.hxx>
+#define ShellClass_SwSrcView
+#include <swslots.hxx>
+
+#include <com/sun/star/document/XDocumentProperties.hpp>
+#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::i18n;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::ui::dialogs;
+using namespace ::sfx2;
+
+#define SWSRCVIEWFLAGS SfxViewShellFlags::NO_NEWWINDOW
+
+#define SRC_SEARCHOPTIONS (SearchOptionFlags::ALL & ~SearchOptionFlags(SearchOptionFlags::FORMAT|SearchOptionFlags::FAMILIES|SearchOptionFlags::SEARCHALL))
+
+// Printing margins -> like Basic - Ide
+#define LMARGPRN 1700
+#define RMARGPRN 900
+#define TMARGPRN 2000
+#define BMARGPRN 1000
+#define BORDERPRN 300
+
+SFX_IMPL_NAMED_VIEWFACTORY(SwSrcView, "SourceView")
+{
+ SFX_VIEW_REGISTRATION(SwWebDocShell);
+}
+
+SFX_IMPL_SUPERCLASS_INTERFACE(SwSrcView, SfxViewShell)
+
+void SwSrcView::InitInterface_Impl()
+{
+ GetStaticInterface()->RegisterPopupMenu("source");
+
+ GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_TOOLS,
+ SfxVisibilityFlags::Standard|SfxVisibilityFlags::Server,
+ ToolbarId::Webtools_Toolbox);
+
+ GetStaticInterface()->RegisterChildWindow(SvxSearchDialogWrapper::GetChildWindowId());
+}
+
+
+static void lcl_PrintHeader( vcl::RenderContext &rOutDev, sal_Int32 nPages, sal_Int32 nCurPage, const OUString& rTitle )
+{
+ short nLeftMargin = LMARGPRN;
+ Size aSz = rOutDev.GetOutputSize();
+ short nBorder = BORDERPRN;
+
+ Color aOldFillColor( rOutDev.GetFillColor() );
+ vcl::Font aOldFont( rOutDev.GetFont() );
+
+ rOutDev.SetFillColor( COL_TRANSPARENT );
+
+ vcl::Font aFont( aOldFont );
+ aFont.SetWeight( WEIGHT_BOLD );
+ aFont.SetAlignment( ALIGN_BOTTOM );
+ rOutDev.SetFont( aFont );
+
+ tools::Long nFontHeight = rOutDev.GetTextHeight();
+
+ // 1.Border => Line, 2+3 Border = Space.
+ tools::Long nYTop = TMARGPRN-3*nBorder-nFontHeight;
+
+ tools::Long nXLeft = nLeftMargin-nBorder;
+ tools::Long nXRight = aSz.Width()-RMARGPRN+nBorder;
+
+ rOutDev.DrawRect( tools::Rectangle(
+ Point( nXLeft, nYTop ),
+ Size( nXRight-nXLeft, aSz.Height() - nYTop - BMARGPRN + nBorder ) ) );
+
+ tools::Long nY = TMARGPRN-2*nBorder;
+ Point aPos( nLeftMargin, nY );
+ rOutDev.DrawText( aPos, rTitle );
+ if ( nPages != 1 )
+ {
+ aFont.SetWeight( WEIGHT_NORMAL );
+ rOutDev.SetFont( aFont );
+ OUString aPageStr = " [" + SwResId( STR_PAGE ) + " " + OUString::number( nCurPage ) + "]";
+ aPos.AdjustX(rOutDev.GetTextWidth( rTitle ) );
+ rOutDev.DrawText( aPos, aPageStr );
+ }
+
+ nY = TMARGPRN-nBorder;
+
+ rOutDev.DrawLine( Point( nXLeft, nY ), Point( nXRight, nY ) );
+
+ rOutDev.SetFont( aOldFont );
+ rOutDev.SetFillColor( aOldFillColor );
+}
+
+static rtl_TextEncoding lcl_GetStreamCharSet(rtl_TextEncoding eLoadEncoding)
+{
+ rtl_TextEncoding eRet = eLoadEncoding;
+ if(RTL_TEXTENCODING_DONTKNOW == eRet)
+ {
+ eRet = RTL_TEXTENCODING_UTF8;
+ }
+ return eRet;
+}
+
+static OUString lcl_ConvertTabsToSpaces( const OUString& sLine )
+{
+ if (sLine.isEmpty())
+ return sLine;
+
+ OUString aRet = sLine;
+ const sal_Unicode aPadSpaces[4] = {' ', ' ', ' ', ' '};
+ sal_Int32 nPos = 0;
+ for (;;)
+ {
+ nPos = aRet.indexOf('\t', nPos);
+ if (nPos<0)
+ {
+ break;
+ }
+ // Not 4 blanks, but on 4th TabPos:
+ const sal_Int32 nPadLen = 4 - (nPos % 4);
+ aRet = aRet.replaceAt(nPos, 1, std::u16string_view{aPadSpaces, static_cast<size_t>(nPadLen)});
+ nPos += nPadLen;
+ }
+ return aRet;
+}
+
+SwSrcView::SwSrcView(SfxViewFrame& rViewFrame, SfxViewShell*) :
+ SfxViewShell( rViewFrame, SWSRCVIEWFLAGS ),
+ m_aEditWin( VclPtr<SwSrcEditWindow>::Create( &rViewFrame.GetWindow(), this ) ),
+ m_bSourceSaved(false),
+ m_eLoadEncoding(RTL_TEXTENCODING_DONTKNOW)
+{
+ Init();
+}
+
+SwSrcView::~SwSrcView()
+{
+ SwDocShell* pDocShell = GetDocShell();
+ assert(dynamic_cast<SwWebDocShell*>( pDocShell) && "Why no WebDocShell?" );
+ const TextSelection& rSel = m_aEditWin->GetTextView()->GetSelection();
+ static_cast<SwWebDocShell*>(pDocShell)->SetSourcePara( static_cast< sal_uInt16 >( rSel.GetStart().GetPara() ) );
+
+ uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
+ pDocShell->GetModel(), uno::UNO_QUERY_THROW);
+ uno::Reference<document::XDocumentProperties> xDocProps
+ = xDPS->getDocumentProperties();
+ OUString url = xDocProps->getAutoloadURL();
+ sal_Int32 delay = xDocProps->getAutoloadSecs();
+ pDocShell->SetAutoLoad(INetURLObject(url), delay,
+ (delay != 0) || !url.isEmpty());
+ EndListening(*pDocShell);
+ m_pSearchItem.reset();
+
+ m_aEditWin.disposeAndClear();
+}
+
+void SwSrcView::SaveContentTo(SfxMedium& rMed)
+{
+ SvStream* pOutStream = rMed.GetOutStream();
+ pOutStream->SetStreamCharSet(lcl_GetStreamCharSet(m_eLoadEncoding));
+ m_aEditWin->Write( *pOutStream );
+}
+
+void SwSrcView::Init()
+{
+ SetName("Source");
+ SetWindow( m_aEditWin.get() );
+ SwDocShell* pDocShell = GetDocShell();
+ // If the doc is still loading, then the DocShell must fire up
+ // the Load if the loading is completed.
+ if(!pDocShell->IsLoading())
+ Load(pDocShell);
+ else
+ {
+ m_aEditWin->SetReadonly(true);
+ }
+
+ SetNewWindowAllowed( false );
+ StartListening(*pDocShell, DuplicateHandling::Prevent);
+}
+
+SwDocShell* SwSrcView::GetDocShell()
+{
+ SfxObjectShell* pObjShell = GetViewFrame().GetObjectShell();
+ return dynamic_cast<SwDocShell*>( pObjShell );
+}
+
+void SwSrcView::SaveContent(const OUString& rTmpFile)
+{
+ SfxMedium aMedium( rTmpFile, StreamMode::WRITE);
+ SvStream* pOutStream = aMedium.GetOutStream();
+ pOutStream->SetStreamCharSet( lcl_GetStreamCharSet(m_eLoadEncoding) );
+ m_aEditWin->Write(*pOutStream);
+ aMedium.Commit();
+}
+
+void SwSrcView::Execute(SfxRequest& rReq)
+{
+ TextView* pTextView = m_aEditWin->GetTextView();
+ switch( rReq.GetSlot() )
+ {
+ case SID_SAVEACOPY:
+ case SID_SAVEASDOC:
+ {
+ // filesave dialog with autoextension
+ FileDialogHelper aDlgHelper(
+ TemplateDescription::FILESAVE_AUTOEXTENSION,
+ FileDialogFlags::NONE, m_aEditWin->GetFrameWeld());
+ uno::Reference < XFilePicker3 > xFP = aDlgHelper.GetFilePicker();
+
+ // search for an html filter for export
+ SfxFilterContainer* pFilterCont = GetObjectShell()->GetFactory().GetFilterContainer();
+ std::shared_ptr<const SfxFilter> pFilter =
+ pFilterCont->GetFilter4Extension( "html", SfxFilterFlags::EXPORT );
+ if ( pFilter )
+ {
+ // filter found -> use its uiname and wildcard
+ const OUString& rUIName = pFilter->GetUIName();
+ const WildCard& rCard = pFilter->GetWildcard();
+ xFP->appendFilter( rUIName, rCard.getGlob() );
+ xFP->setCurrentFilter( rUIName ) ;
+ }
+ else
+ {
+ // filter not found
+ OUString sHtml("HTML");
+ xFP->appendFilter( sHtml, "*.html;*.htm" );
+ xFP->setCurrentFilter( sHtml ) ;
+ }
+
+ if( aDlgHelper.Execute() == ERRCODE_NONE)
+ {
+ SfxMedium aMedium( xFP->getSelectedFiles().getConstArray()[0],
+ StreamMode::WRITE | StreamMode::SHARE_DENYNONE );
+ SvStream* pOutStream = aMedium.GetOutStream();
+ pOutStream->SetStreamCharSet(lcl_GetStreamCharSet(m_eLoadEncoding));
+ m_aEditWin->Write( *pOutStream );
+ aMedium.Commit();
+ }
+ }
+ break;
+ case SID_SAVEDOC:
+ {
+ SwDocShell* pDocShell = GetDocShell();
+ assert(pDocShell);
+ SfxMedium* pMed = nullptr;
+ if(pDocShell->HasName())
+ pMed = pDocShell->GetMedium();
+ else
+ {
+ const SfxPoolItemHolder& rResult(pDocShell->ExecuteSlot(rReq, pDocShell->GetInterface()));
+ const SfxBoolItem* pItem(static_cast<const SfxBoolItem*>(rResult.getItem()));
+ if(pItem && pItem->GetValue())
+ pMed = pDocShell->GetMedium();
+ }
+ if(pMed)
+ {
+ SvStream* pOutStream = pMed->GetOutStream();
+ pOutStream->Seek(0);
+ pOutStream->SetStreamSize(0);
+ pOutStream->SetStreamCharSet(lcl_GetStreamCharSet(m_eLoadEncoding));
+ m_aEditWin->Write( *pOutStream );
+ pMed->CloseOutStream();
+ pMed->Commit();
+ pDocShell->GetDoc()->getIDocumentState().ResetModified();
+ m_bSourceSaved = true;
+ m_aEditWin->ClearModifyFlag();
+ }
+ }
+ break;
+ case FID_SEARCH_NOW:
+ {
+ const SfxItemSet* pTmpArgs = rReq.GetArgs();
+
+ const sal_uInt16 nWhich = pTmpArgs->GetWhichByOffset( 0 );
+ OSL_ENSURE( nWhich, "Which for SearchItem ?" );
+ const SfxPoolItem& rItem = pTmpArgs->Get( nWhich );
+ SetSearchItem( static_cast<const SvxSearchItem&>(rItem));
+ StartSearchAndReplace( static_cast<const SvxSearchItem&>(rItem), rReq.IsAPI() );
+ if(m_aEditWin->IsModified())
+ {
+ SwDocShell* pDocShell = GetDocShell();
+ assert(pDocShell);
+ pDocShell->GetDoc()->getIDocumentState().SetModified();
+ }
+ }
+ break;
+ case FN_REPEAT_SEARCH:
+ {
+ SvxSearchItem* pSrchItem = GetSearchItem();
+ if(pSrchItem)
+ {
+ StartSearchAndReplace( *pSrchItem, rReq.IsAPI() );
+ if(m_aEditWin->IsModified())
+ GetDocShell()->GetDoc()->getIDocumentState().SetModified();
+ }
+ }
+ break;
+ case SID_PRINTDOC:
+ case SID_PRINTDOCDIRECT:
+ {
+ SfxViewShell::ExecuteSlot( rReq, SfxViewShell::GetInterface() );
+ }
+ break;
+ case SID_UNDO:
+ pTextView->Undo();
+ GetViewFrame().GetBindings().InvalidateAll(false);
+ break;
+ case SID_REDO:
+ pTextView->Redo();
+ GetViewFrame().GetBindings().InvalidateAll(false);
+ break;
+ case SID_REPEAT:
+ break;
+ case SID_CUT:
+ if(pTextView->HasSelection())
+ pTextView->Cut();
+ break;
+ case SID_COPY:
+ if(pTextView->HasSelection())
+ pTextView->Copy();
+ break;
+ case SID_PASTE:
+ pTextView->Paste();
+ break;
+ case SID_SELECTALL:
+ pTextView->SetSelection( TextSelection( TextPaM( 0, 0 ), TextPaM( TEXT_PARA_ALL, TEXT_INDEX_ALL ) ) );
+ break;
+ }
+ m_aEditWin->Invalidate();
+}
+
+void SwSrcView::GetState(SfxItemSet& rSet)
+{
+ SfxWhichIter aIter(rSet);
+ sal_uInt16 nWhich = aIter.FirstWhich();
+ TextView* pTextView = m_aEditWin->GetTextView();
+
+ while(nWhich)
+ {
+ switch(nWhich)
+ {
+ case SID_SAVEASDOC:
+ rSet.Put(SfxStringItem(nWhich, SwResId(STR_SAVEAS_SRC)));
+ break;
+ case SID_SAVEACOPY:
+ rSet.Put(SfxStringItem(nWhich, SwResId(STR_SAVEACOPY_SRC)));
+ break;
+ case SID_SAVEDOC:
+ {
+ SwDocShell* pDocShell = GetDocShell();
+ assert(pDocShell);
+ if(!pDocShell->IsModified())
+ rSet.DisableItem(nWhich);
+ }
+ break;
+ case SID_PRINTDOC:
+ case SID_PRINTDOCDIRECT:
+ break;
+ case SID_TABLE_CELL:
+ {
+ TextSelection aSel = pTextView->GetSelection();
+ OUString aPos =
+ SwResId(STR_SRCVIEW_ROW)
+ + OUString::number( aSel.GetEnd().GetPara()+1 )
+ + " : "
+ + SwResId(STR_SRCVIEW_COL)
+ + OUString::number( aSel.GetEnd().GetIndex()+1 );
+ SvxStatusItem aItem( SID_TABLE_CELL, aPos, StatusCategory::RowColumn );
+ rSet.Put( aItem );
+ }
+ break;
+ case SID_SEARCH_OPTIONS:
+ {
+ SearchOptionFlags nOpt = SRC_SEARCHOPTIONS;
+ SwDocShell* pDocShell = GetDocShell();
+ assert(pDocShell);
+ if (pDocShell->IsReadOnly())
+ nOpt &= ~SearchOptionFlags(SearchOptionFlags::REPLACE|SearchOptionFlags::REPLACE_ALL);
+
+ rSet.Put( SfxUInt16Item( SID_SEARCH_OPTIONS, static_cast<sal_uInt16>(nOpt) ) );
+ }
+ break;
+ case SID_SEARCH_ITEM:
+ {
+ OUString sSelected;
+ if ( !pTextView->HasSelection() )
+ {
+ const TextSelection& rSel = pTextView->GetSelection();
+ sSelected = m_aEditWin->GetTextEngine()->GetWord( rSel.GetStart());
+ }
+ else
+ {
+ sSelected = pTextView->GetSelected();
+ }
+ SvxSearchItem * pSrchItem = GetSearchItem();
+ pSrchItem->SetSearchString( sSelected );
+ rSet.Put( *pSrchItem );
+ }
+ break;
+ case FN_REPEAT_SEARCH:
+ {
+ if(!GetSearchItem())
+ rSet.DisableItem(nWhich);
+ }
+ break;
+ case SID_UNDO:
+ case SID_REDO:
+ {
+ SfxUndoManager& rMgr = pTextView->GetTextEngine()->GetUndoManager();
+ sal_uInt16 nCount = 0;
+ if(nWhich == SID_UNDO)
+ {
+ nCount = rMgr.GetUndoActionCount();
+ if(nCount)
+ {
+ OUString aStr = SvtResId( STR_UNDO) + rMgr.GetUndoActionComment(--nCount);
+ rSet.Put(SfxStringItem(nWhich, aStr));
+ }
+ else
+ rSet.DisableItem(nWhich);
+ }
+ else
+ {
+ nCount = rMgr.GetRedoActionCount();
+ if(nCount)
+ {
+ OUString aStr = SvtResId( STR_REDO) + rMgr.GetRedoActionComment(--nCount);
+ rSet.Put(SfxStringItem(nWhich,aStr));
+ }
+ else
+ rSet.DisableItem(nWhich);
+ }
+ }
+ break;
+ case SID_MAIL_SENDDOCASPDF:
+ case SID_MAIL_SENDDOC :
+ case SID_EXPORTDOCASPDF:
+ case SID_DIRECTEXPORTDOCASPDF:
+ case SID_EXPORTDOC:
+ case SID_REPEAT:
+ case SID_BROWSER_MODE:
+ case FN_PRINT_LAYOUT:
+ rSet.DisableItem(nWhich);
+ break;
+ case SID_CUT:
+ case SID_COPY:
+ if(!pTextView->HasSelection())
+ rSet.DisableItem(nWhich);
+ break;
+ case SID_PASTE:
+ {
+ TransferableDataHelper aDataHelper(
+ TransferableDataHelper::CreateFromSystemClipboard(
+ m_aEditWin.get()) );
+ bool bDisable = !aDataHelper.GetXTransferable().is() ||
+ 0 == aDataHelper.GetFormatCount();
+ if( bDisable )
+ rSet.DisableItem(nWhich);
+ }
+ break;
+ }
+ nWhich = aIter.NextWhich();
+ }
+}
+
+SvxSearchItem* SwSrcView::GetSearchItem()
+{
+ if(!m_pSearchItem)
+ {
+ m_pSearchItem.reset(new SvxSearchItem(SID_SEARCH_ITEM));
+ }
+ return m_pSearchItem.get();
+}
+
+void SwSrcView::SetSearchItem( const SvxSearchItem& rItem )
+{
+ m_pSearchItem.reset(rItem.Clone());
+}
+
+void SwSrcView::StartSearchAndReplace(const SvxSearchItem& rSearchItem,
+ bool bApi,
+ bool bRecursive)
+{
+ TextView* pTextView = m_aEditWin->GetTextView();
+ TextPaM aPaM;
+
+ bool bForward = !rSearchItem.GetBackward();
+ bool bAtStart = pTextView->GetSelection() == TextSelection( aPaM, aPaM );
+
+ if( !bForward )
+ aPaM = TextPaM( TEXT_PARA_ALL, TEXT_INDEX_ALL );
+
+ i18nutil::SearchOptions2 aSearchOpt( rSearchItem.GetSearchOptions() );
+ aSearchOpt.Locale = GetAppLanguageTag().getLocale();
+
+ sal_uInt16 nFound;
+ bool bAll = false;
+ switch( rSearchItem.GetCommand() )
+ {
+ case SvxSearchCmd::FIND:
+ case SvxSearchCmd::FIND_ALL:
+ nFound = pTextView->Search( aSearchOpt, bForward ) ? 1 : 0;
+ break;
+
+ case SvxSearchCmd::REPLACE_ALL: bAll = true;
+ [[fallthrough]];
+ case SvxSearchCmd::REPLACE:
+ nFound = pTextView->Replace( aSearchOpt, bAll, bForward );
+ break;
+
+ default:
+ nFound = 0;
+ }
+
+ if( nFound )
+ return;
+
+ bool bNotFoundMessage = false;
+ if(!bRecursive)
+ {
+ bNotFoundMessage = bAtStart;
+ }
+ else if(bAtStart)
+ {
+ bNotFoundMessage = true;
+ }
+
+ if(bApi)
+ return;
+
+ if(bNotFoundMessage)
+ {
+ std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(nullptr, "modules/swriter/ui/infonotfounddialog.ui"));
+ std::unique_ptr<weld::MessageDialog> xInfoBox(xBuilder->weld_message_dialog("InfoNotFoundDialog"));
+ xInfoBox->run();
+ }
+ else if(!bRecursive)
+ {
+ int nRet;
+
+ if (!bForward)
+ {
+ std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(nullptr, "modules/swriter/ui/querycontinueenddialog.ui"));
+ std::unique_ptr<weld::MessageDialog> xQueryBox(xBuilder->weld_message_dialog("QueryContinueEndDialog"));
+ nRet = xQueryBox->run();
+ }
+ else
+ {
+ std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(nullptr, "modules/swriter/ui/querycontinuebegindialog.ui"));
+ std::unique_ptr<weld::MessageDialog> xQueryBox(xBuilder->weld_message_dialog("QueryContinueBeginDialog"));
+ nRet = xQueryBox->run();
+ }
+
+ if (nRet == RET_YES)
+ {
+ pTextView->SetSelection( TextSelection( aPaM, aPaM ) );
+ StartSearchAndReplace( rSearchItem, false, true );
+ }
+ }
+}
+
+sal_uInt16 SwSrcView::SetPrinter(SfxPrinter* pNew, SfxPrinterChangeFlags nDiffFlags )
+{
+ SwDocShell* pDocSh = GetDocShell();
+ assert(pDocSh);
+ if ( (SfxPrinterChangeFlags::JOBSETUP | SfxPrinterChangeFlags::PRINTER) & nDiffFlags )
+ {
+ pDocSh->GetDoc()->getIDocumentDeviceAccess().setPrinter( pNew, true, true );
+ if ( nDiffFlags & SfxPrinterChangeFlags::PRINTER )
+ pDocSh->SetModified();
+ }
+ if ( nDiffFlags & SfxPrinterChangeFlags::OPTIONS )
+ ::SetPrinter( &pDocSh->getIDocumentDeviceAccess(), pNew, true );
+
+ const bool bChgOri = bool(nDiffFlags & SfxPrinterChangeFlags::CHG_ORIENTATION);
+ const bool bChgSize = bool(nDiffFlags & SfxPrinterChangeFlags::CHG_SIZE);
+ if ( bChgOri || bChgSize )
+ {
+ pDocSh->SetModified();
+ }
+ return 0;
+}
+
+SfxPrinter* SwSrcView::GetPrinter( bool bCreate )
+{
+ SwDocShell* pDocSh = GetDocShell();
+ assert(pDocSh);
+ return pDocSh->GetDoc()->getIDocumentDeviceAccess().getPrinter(bCreate);
+}
+
+sal_Int32 SwSrcView::PrintSource(
+ OutputDevice *pOutDev,
+ sal_Int32 nPage,
+ bool bCalcNumPagesOnly )
+{
+ if (!pOutDev || nPage <= 0)
+ return 0;
+
+ //! This algorithm for printing the n-th page is very poor since it
+ //! needs to go over the text of all previous pages to get to the correct one.
+ //! But since HTML source code is expected to be just a small number of pages
+ //! even this poor algorithm should be enough...
+
+ pOutDev->Push();
+
+ TextEngine* pTextEngine = m_aEditWin->GetTextEngine();
+ pOutDev->SetMapMode(MapMode(MapUnit::Map100thMM));
+ vcl::Font aFont( m_aEditWin->GetOutWin()->GetFont() );
+ Size aSize( aFont.GetFontSize() );
+ aSize = m_aEditWin->GetOutWin()->PixelToLogic(aSize, MapMode(MapUnit::Map100thMM));
+ aFont.SetFontSize( aSize );
+ aFont.SetColor( COL_BLACK );
+ pOutDev->SetFont( aFont );
+
+ OUString aTitle( GetViewFrame().GetWindow().GetText() );
+
+ const tools::Long nLineHeight = pOutDev->GetTextHeight(); // slightly more
+ const tools::Long nParaSpace = 10;
+
+ Size aPaperSz = pOutDev->GetOutputSize();
+ aPaperSz.AdjustWidth( -(LMARGPRN + RMARGPRN) );
+ aPaperSz.AdjustHeight( -(TMARGPRN + BMARGPRN) );
+
+ // nLinepPage is not true, if lines have to be wrapped...
+ const tools::Long nLinespPage = nLineHeight ? aPaperSz.Height() / nLineHeight : 1;
+ const tools::Long nCharWidth = pOutDev->GetTextWidth("X");
+ const sal_Int32 nCharspLine = nCharWidth ? static_cast<sal_Int32>(aPaperSz.Width() / nCharWidth) : 1;
+ const sal_uInt32 nParas = pTextEngine->GetParagraphCount();
+
+ const sal_Int32 nPages = static_cast<sal_Int32>(nParas / nLinespPage + 1 );
+ sal_Int32 nCurPage = 1;
+
+ // Print header...
+ if (!bCalcNumPagesOnly && nPage == nCurPage)
+ lcl_PrintHeader( *pOutDev, nPages, nCurPage, aTitle );
+ const Point aStartPos( LMARGPRN, TMARGPRN );
+ Point aPos( aStartPos );
+ for ( sal_uInt32 nPara = 0; nPara < nParas; ++nPara )
+ {
+ const OUString aLine( lcl_ConvertTabsToSpaces(pTextEngine->GetText( nPara )) );
+ const sal_Int32 nLineLen = aLine.getLength();
+ const sal_Int32 nLines = (nLineLen+nCharspLine-1) / nCharspLine;
+ for ( sal_Int32 nLine = 0; nLine < nLines; ++nLine )
+ {
+ aPos.AdjustY(nLineHeight );
+ if ( aPos.Y() > ( aPaperSz.Height() + TMARGPRN - nLineHeight/2 ) )
+ {
+ ++nCurPage;
+ if (!bCalcNumPagesOnly && nPage == nCurPage)
+ lcl_PrintHeader( *pOutDev, nPages, nCurPage, aTitle );
+ aPos = aStartPos;
+ }
+ if (!bCalcNumPagesOnly && nPage == nCurPage)
+ {
+ const sal_Int32 nStart = nLine * nCharspLine;
+ const sal_Int32 nLen = std::min(nLineLen-nStart, nCharspLine);
+ pOutDev->DrawText( aPos, aLine.copy(nStart, nLen) );
+ }
+ }
+ aPos.AdjustY(nParaSpace );
+ }
+
+ pOutDev->Pop();
+
+ OSL_ENSURE( bCalcNumPagesOnly || nPage <= nCurPage, "page number out of range" );
+ return nCurPage;
+}
+
+void SwSrcView::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
+{
+ if (rHint.GetId() == SfxHintId::ModeChanged || rHint.GetId() == SfxHintId::TitleChanged)
+ {
+ const SwDocShell* pDocSh = GetDocShell();
+ assert(pDocSh);
+ if (!(rHint.GetId() == SfxHintId::TitleChanged
+ && (pDocSh->IsReadOnly() || !m_aEditWin->IsReadonly())))
+ {
+ // Broadcast only comes once!
+ const bool bReadonly = pDocSh->IsReadOnly();
+ m_aEditWin->SetReadonly(bReadonly);
+ }
+ }
+ SfxViewShell::Notify(rBC, rHint);
+}
+
+void SwSrcView::Load(SwDocShell* pDocShell)
+{
+ rtl_TextEncoding eDestEnc = RTL_TEXTENCODING_UTF8;
+
+ m_aEditWin->SetReadonly(pDocShell->IsReadOnly());
+ m_aEditWin->SetTextEncoding(eDestEnc);
+ SfxMedium* pMedium = pDocShell->GetMedium();
+
+ std::shared_ptr<const SfxFilter> pFilter = pMedium->GetFilter();
+ bool bHtml = pFilter && pFilter->GetUserData() == "HTML";
+ bool bDocModified = pDocShell->IsModified();
+ if(bHtml && !bDocModified && pDocShell->HasName())
+ {
+ SvStream* pStream = pMedium->GetInStream();
+ if(pStream && ERRCODE_NONE == pStream->GetError() )
+ {
+ rtl_TextEncoding eHeaderEnc =
+ SfxHTMLParser::GetEncodingByHttpHeader(
+ pDocShell->GetHeaderAttributes() );
+ if( RTL_TEXTENCODING_DONTKNOW == eHeaderEnc )
+ {
+ const char *pTmpCharSet =
+ rtl_getBestMimeCharsetFromTextEncoding( RTL_TEXTENCODING_ISO_8859_1 );
+ eHeaderEnc = rtl_getTextEncodingFromMimeCharset( pTmpCharSet );
+ }
+ if( RTL_TEXTENCODING_DONTKNOW != eHeaderEnc &&
+ eDestEnc != eHeaderEnc )
+ {
+ eDestEnc = eHeaderEnc;
+ m_aEditWin->SetTextEncoding(eDestEnc);
+ }
+ pStream->SetStreamCharSet( eDestEnc );
+ pStream->Seek(0);
+ TextEngine* pTextEngine = m_aEditWin->GetTextEngine();
+ pTextEngine->EnableUndo(false);
+ m_aEditWin->Read(*pStream);
+ pTextEngine->EnableUndo(true);
+ }
+ else
+ {
+ std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(GetViewFrame().GetFrameWeld(),
+ VclMessageType::Info, VclButtonsType::Ok,
+ SwResId(STR_ERR_SRCSTREAM)));
+ xBox->run();
+ }
+ }
+ else
+ {
+ utl::TempFileNamed aTempFile;
+ aTempFile.EnableKillingFile();
+ const OUString sFileURL( aTempFile.GetURL() );
+
+ {
+ SfxMedium aMedium( sFileURL,StreamMode::READWRITE );
+ SwWriter aWriter( aMedium, *pDocShell->GetDoc() );
+ WriterRef xWriter;
+ ::GetHTMLWriter(std::u16string_view(), aMedium.GetBaseURL( true ), xWriter);
+ const OUString sWriteName = pDocShell->HasName()
+ ? pMedium->GetName()
+ : sFileURL;
+ ErrCodeMsg nRes = aWriter.Write(xWriter, &sWriteName);
+ if(nRes)
+ {
+ ErrorHandler::HandleError(nRes);
+ m_aEditWin->SetReadonly(true);
+ }
+ aMedium.Commit();
+ SvStream* pInStream = aMedium.GetInStream();
+ pInStream->Seek(0);
+ pInStream->SetStreamCharSet( eDestEnc );
+
+ m_aEditWin->Read(*pInStream);
+ }
+ }
+ m_aEditWin->ClearModifyFlag();
+
+ m_eLoadEncoding = eDestEnc;
+
+ if(bDocModified)
+ pDocShell->SetModified();// The flag will be reset in between times.
+ // Disable AutoLoad
+ pDocShell->SetAutoLoad(INetURLObject(), 0, false);
+ assert(dynamic_cast<SwWebDocShell*>( pDocShell) && "Why no WebDocShell?" );
+ sal_uInt16 nLine = static_cast<SwWebDocShell*>(pDocShell)->GetSourcePara();
+ m_aEditWin->SetStartLine(nLine);
+ m_aEditWin->GetTextEngine()->ResetUndo();
+ m_aEditWin->GetOutWin()->GrabFocus();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/swcli.cxx b/sw/source/uibase/uiview/swcli.cxx
new file mode 100644
index 0000000000..ea7093516e
--- /dev/null
+++ b/sw/source/uibase/uiview/swcli.cxx
@@ -0,0 +1,193 @@
+/* -*- 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 <com/sun/star/embed/NoVisualAreaSizeException.hpp>
+#include <com/sun/star/embed/XEmbeddedObject.hpp>
+#include <wrtsh.hxx>
+#include <doc.hxx>
+#include <IDocumentSettingAccess.hxx>
+#include <view.hxx>
+#include <edtwin.hxx>
+#include <swcli.hxx>
+#include <svtools/embedhlp.hxx>
+#include <osl/diagnose.h>
+
+#include <toolkit/helper/vclunohelper.hxx>
+
+#include <ndole.hxx>
+
+using namespace com::sun::star;
+
+SwOleClient::SwOleClient(SwView *pView, SwEditWin *pWin, const svt::EmbeddedObjectRef& xObj)
+ : SfxInPlaceClient( pView, pWin, xObj.GetViewAspect() )
+ , m_IsInDoVerb(false)
+ , m_IsOldCheckForOLEInCaption(pView->GetWrtShell().IsCheckForOLEInCaption())
+{
+ SetObject( xObj.GetObject() );
+}
+
+void SwOleClient::RequestNewObjectArea( tools::Rectangle& aLogRect )
+{
+ // The server wants to change the client size.
+ // We put the desired size in the core. The attributes of the frame
+ // are set to the desired value. This value will be passed on to the
+ // InPlaceClient.
+ // The core accepts or formats the adjusted values not necessarily.
+ // If the Ole-Frame is formatted, then the CalcAndSetScale() of the WrtShell
+ // will be called. There the scaling of the SwOleClient is set if necessary.
+
+ SwWrtShell &rSh = static_cast<SwView*>(GetViewShell())->GetWrtShell();
+
+ rSh.StartAllAction();
+
+ // the aLogRect will get the preliminary size now
+ aLogRect.SetSize( rSh.RequestObjectResize( SwRect( aLogRect ), GetObject() ) );
+
+ // the EndAllAction() call will trigger CalcAndSetScale() call,
+ // so the embedded object must get the correct size before
+ if ( aLogRect.GetSize() != GetScaledObjArea().GetSize() )
+ {
+ // size has changed, so first change visual area of the object before we resize its view
+ // without this the object always would be scaled - now it has the choice
+
+ // TODO/LEAN: getMapUnit can switch object to running state
+ MapMode aObjectMap( VCLUnoHelper::UnoEmbed2VCLMapUnit( GetObject()->getMapUnit( GetAspect() ) ) );
+ MapMode aClientMap( GetEditWin()->GetMapMode().GetMapUnit() );
+
+ Size aNewObjSize( tools::Long( aLogRect.GetWidth() / GetScaleWidth() ),
+ tools::Long( aLogRect.GetHeight() / GetScaleHeight() ) );
+
+ // convert to logical coordinates of the embedded object
+ Size aNewSize = GetEditWin()->LogicToLogic( aNewObjSize, &aClientMap, &aObjectMap );
+ GetObject()->setVisualAreaSize( GetAspect(), awt::Size( aNewSize.Width(), aNewSize.Height() ) );
+ }
+
+ rSh.EndAllAction();
+
+ SwRect aFrame( rSh.GetAnyCurRect( CurRectType::FlyEmbedded, nullptr, GetObject() )),
+ aPrt( rSh.GetAnyCurRect( CurRectType::FlyEmbeddedPrt, nullptr, GetObject() ));
+ aLogRect.SetPos( aPrt.Pos() + aFrame.Pos() );
+ aLogRect.SetSize( aPrt.SSize() );
+}
+
+void SwOleClient::ObjectAreaChanged()
+{
+ SwWrtShell &rSh = static_cast<SwView*>(GetViewShell())->GetWrtShell();
+ SwRect aFrame( rSh.GetAnyCurRect( CurRectType::FlyEmbedded, nullptr, GetObject() ));
+ if ( !aFrame.Overlaps( rSh.VisArea() ) )
+ rSh.MakeVisible( aFrame );
+}
+
+void SwOleClient::ViewChanged()
+{
+ if (m_IsInDoVerb)
+ return;
+
+ if ( GetAspect() == embed::Aspects::MSOLE_ICON )
+ {
+ // the iconified object seems not to need such a scaling handling
+ // since the replacement image and the size a completely controlled by the container
+ // TODO/LATER: when the icon exchange is implemented the scaling handling
+ // might be required again here
+ return;
+ }
+
+ SwWrtShell &rSh = static_cast<SwView*>(GetViewShell())->GetWrtShell();
+
+ // Adjust the size of the object in the core. The Scaling must
+ // be considered. Repercussions on the object are considered by
+ // CalcAndSetScale() of the WrtShell if the size / position of
+ // the frame in the core changes.
+
+ // TODO/LEAN: getMapUnit can switch object to running state
+ awt::Size aSz;
+ try
+ {
+ aSz = GetObject()->getVisualAreaSize( GetAspect() );
+ }
+ catch (const embed::NoVisualAreaSizeException&)
+ {
+ // Nothing will be done
+ }
+ catch (const uno::Exception&)
+ {
+ OSL_FAIL( "Something goes wrong on requesting object size!" );
+ }
+
+ Size aVisSize( aSz.Width, aSz.Height );
+
+ // As long as from the object comes no reasonable size
+ // nothing can be scaled.
+ if( !aVisSize.Width() || !aVisSize.Height() )
+ return;
+
+ // first convert to TWIPS before scaling, because scaling factors are calculated for
+ // the TWIPS mapping and so they will produce the best results if applied to TWIPS based
+ // coordinates
+ const MapMode aMyMap ( MapUnit::MapTwip );
+ const MapMode aObjMap( VCLUnoHelper::UnoEmbed2VCLMapUnit( GetObject()->getMapUnit( GetAspect() ) ) );
+ aVisSize = OutputDevice::LogicToLogic( aVisSize, aObjMap, aMyMap );
+
+ aVisSize.setWidth( tools::Long(aVisSize.Width() * GetScaleWidth()) );
+ aVisSize.setHeight( tools::Long(aVisSize.Height() * GetScaleHeight()) );
+
+ SwRect aRect( Point( LONG_MIN, LONG_MIN ), aVisSize );
+ rSh.LockView( true ); // Prevent scrolling in the EndAction
+ rSh.StartAllAction();
+ rSh.RequestObjectResize( aRect, GetObject() );
+ rSh.EndAllAction();
+ rSh.LockView( false );
+}
+
+void SwOleClient::FormatChanged()
+{
+ const uno::Reference < embed::XEmbeddedObject >& xObj( GetObject() );
+ SwView * pView = dynamic_cast< SwView * >( GetViewShell() );
+ if ( pView && xObj.is() && SotExchange::IsMath( xObj->getClassID() ) )
+ {
+ SwWrtShell & rWrtSh = pView->GetWrtShell();
+ if (rWrtSh.GetDoc()->getIDocumentSettingAccess().get( DocumentSettingId::MATH_BASELINE_ALIGNMENT ))
+ rWrtSh.AlignFormulaToBaseline( xObj );
+ }
+}
+
+bool SwOleClient::IsProtected() const
+{
+ auto pView = dynamic_cast<SwView*>(GetViewShell());
+ if (!pView)
+ {
+ return false;
+ }
+
+ SwWrtShell& rWrtSh = pView->GetWrtShell();
+ if (rWrtSh.IsTableMode())
+ {
+ return false;
+ }
+
+ SwOLENode* pOLENode = rWrtSh.GetCursor()->GetPointNode().GetOLENode();
+ if (!pOLENode)
+ {
+ return false;
+ }
+
+ return pOLENode->GetOLEObj().IsProtected();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/uivwimp.cxx b/sw/source/uibase/uiview/uivwimp.cxx
new file mode 100644
index 0000000000..ed0c3c68fc
--- /dev/null
+++ b/sw/source/uibase/uiview/uivwimp.cxx
@@ -0,0 +1,333 @@
+/* -*- 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 <cmdid.h>
+
+#include <com/sun/star/scanner/XScannerManager2.hpp>
+#include <com/sun/star/datatransfer/clipboard/XClipboard.hpp>
+#include <comphelper/propertysequence.hxx>
+#include <comphelper/servicehelper.hxx>
+#include <vcl/weld.hxx>
+#include <vcl/svapp.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/docfile.hxx>
+
+#include <sfx2/docinsert.hxx>
+#include <sfx2/request.hxx>
+#include <uivwimp.hxx>
+#include <unotxvw.hxx>
+#include <unodispatch.hxx>
+#include <swmodule.hxx>
+#include <swdtflvr.hxx>
+
+#include <strings.hrc>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::scanner;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::datatransfer::clipboard;
+
+SwView_Impl::SwView_Impl(SwView* pShell)
+ : m_pView(pShell)
+ , m_eShellMode(ShellMode::Text)
+ , m_nParam(0)
+ , m_bSelectObject(false)
+ , m_bEditingPositionSet(false)
+{
+ mxXTextView = new SwXTextView(m_pView);
+ m_xDispatchProviderInterceptor = new SwXDispatchProviderInterceptor(*m_pView);
+}
+
+SwView_Impl::~SwView_Impl()
+{
+ if(m_xDispatchProviderInterceptor)
+ m_xDispatchProviderInterceptor->Invalidate();
+ mxXTextView->Invalidate();
+ mxXTextView.clear();
+
+ if( mxScanEvtLstnr.is() )
+ mxScanEvtLstnr->ViewDestroyed();
+ if( mxClipEvtLstnr.is() )
+ {
+ mxClipEvtLstnr->AddRemoveListener( false );
+ mxClipEvtLstnr->ViewDestroyed();
+ }
+ DisconnectTransferableDDE();
+
+#if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
+ m_xConfigItem.reset();
+#endif
+ m_pDocInserter.reset();
+ m_pRequest.reset();
+}
+
+void SwView_Impl::SetShellMode(ShellMode eSet)
+{
+ m_eShellMode = eSet;
+}
+
+view::XSelectionSupplier* SwView_Impl::GetUNOObject()
+{
+ return mxXTextView.get();
+}
+
+SwXTextView* SwView_Impl::GetUNOObject_Impl()
+{
+ return mxXTextView.get();
+}
+
+void SwView_Impl::ExecuteScan( SfxRequest& rReq )
+{
+ switch(rReq.GetSlot())
+ {
+ case SID_TWAIN_SELECT:
+ {
+ bool bDone = false;
+ Reference< XScannerManager2 > xScanMgr = SW_MOD()->GetScannerManager();
+
+ if( xScanMgr.is() )
+ {
+ try
+ {
+ SwScannerEventListener& rListener = GetScannerEventListener();
+ const Sequence< ScannerContext >
+ aContexts( xScanMgr->getAvailableScanners() );
+
+ if( aContexts.hasElements() )
+ {
+ Reference< XEventListener > xLstner = &rListener;
+ ScannerContext aContext( aContexts.getConstArray()[ 0 ] );
+
+ Reference<lang::XInitialization> xInit(xScanMgr, UNO_QUERY);
+ if (xInit.is())
+ {
+ // initialize dialog
+ weld::Window* pWindow = rReq.GetFrameWeld();
+ uno::Sequence<uno::Any> aSeq(comphelper::InitAnyPropertySequence(
+ {
+ {"ParentWindow", pWindow ? uno::Any(pWindow->GetXWindow()) : uno::Any(Reference<awt::XWindow>())}
+ }));
+ xInit->initialize( aSeq );
+ }
+
+ bDone = xScanMgr->configureScannerAndScan( aContext, xLstner );
+ }
+ }
+ catch(...)
+ {
+ }
+
+ }
+ if( bDone )
+ rReq.Done();
+ else
+ {
+ rReq.Ignore();
+ }
+ }
+ break;
+
+ case SID_TWAIN_TRANSFER:
+ {
+ bool bDone = false;
+
+ Reference< XScannerManager2 > xScanMgr = SW_MOD()->GetScannerManager();
+ if( xScanMgr.is() )
+ {
+ SwScannerEventListener& rListener = GetScannerEventListener();
+ try
+ {
+ const Sequence< scanner::ScannerContext >aContexts( xScanMgr->getAvailableScanners() );
+ if( aContexts.hasElements() )
+ {
+ Reference< XEventListener > xLstner = &rListener;
+ xScanMgr->startScan( aContexts.getConstArray()[ 0 ], xLstner );
+ bDone = true;
+ }
+ }
+ catch(...)
+ {
+ }
+ }
+
+ if( !bDone )
+ {
+ std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(rReq.GetFrameWeld(),
+ VclMessageType::Info, VclButtonsType::Ok,
+ SwResId(STR_SCAN_NOSOURCE)));
+ xBox->run();
+ rReq.Ignore();
+ }
+ else
+ {
+ rReq.Done();
+ SfxBindings& rBind = m_pView->GetViewFrame().GetBindings();
+ rBind.Invalidate( SID_TWAIN_SELECT );
+ rBind.Invalidate( SID_TWAIN_TRANSFER );
+ }
+ }
+ break;
+ }
+}
+
+SwScannerEventListener& SwView_Impl::GetScannerEventListener()
+{
+ if(!mxScanEvtLstnr.is())
+ mxScanEvtLstnr = new SwScannerEventListener(*m_pView);
+ return *mxScanEvtLstnr;
+}
+
+void SwView_Impl::AddClipboardListener()
+{
+ if(!mxClipEvtLstnr.is())
+ {
+ mxClipEvtLstnr = new SwClipboardChangeListener( *m_pView );
+ mxClipEvtLstnr->AddRemoveListener( true );
+ }
+}
+
+void SwView_Impl::Invalidate()
+{
+ GetUNOObject_Impl()->Invalidate();
+ for (const auto& xTransferable: mxTransferables)
+ {
+ rtl::Reference<SwTransferable> pTransferable = xTransferable.get();
+ if(pTransferable)
+ pTransferable->Invalidate();
+ }
+}
+
+void SwView_Impl::DisconnectTransferableDDE()
+{
+ for (const auto& xTransferable: mxTransferables)
+ {
+ rtl::Reference<SwTransferable> pTransferable = xTransferable.get();
+ if(pTransferable)
+ pTransferable->DisconnectDDE();
+ }
+}
+
+void SwView_Impl::AddTransferable(SwTransferable& rTransferable)
+{
+ //prevent removing of the non-referenced SwTransferable
+ osl_atomic_increment(&rTransferable.m_refCount);
+ {
+ // Remove previously added, but no longer existing weak references.
+ std::erase_if(mxTransferables,
+ [](const unotools::WeakReference<SwTransferable>& rTunnel) {
+ return !rTunnel.get();
+ });
+
+ mxTransferables.emplace_back(&rTransferable);
+ }
+ osl_atomic_decrement(&rTransferable.m_refCount);
+}
+
+void SwView_Impl::StartDocumentInserter(
+ const OUString& rFactory,
+ const Link<sfx2::FileDialogHelper*,void>& rEndDialogHdl,
+ const sal_uInt16 nSlotId
+)
+{
+ sfx2::DocumentInserter::Mode mode {sfx2::DocumentInserter::Mode::Insert};
+ switch( nSlotId )
+ {
+ case SID_DOCUMENT_MERGE:
+ mode = sfx2::DocumentInserter::Mode::Merge;
+ break;
+ case SID_DOCUMENT_COMPARE:
+ mode = sfx2::DocumentInserter::Mode::Compare;
+ break;
+ default:
+ break;
+ }
+
+ m_pDocInserter.reset(new ::sfx2::DocumentInserter(m_pView->GetFrameWeld(), rFactory, mode));
+ m_pDocInserter->StartExecuteModal( rEndDialogHdl );
+}
+
+std::unique_ptr<SfxMedium> SwView_Impl::CreateMedium()
+{
+ return m_pDocInserter->CreateMedium();
+}
+
+void SwView_Impl::InitRequest( const SfxRequest& rRequest )
+{
+ m_pRequest.reset(new SfxRequest( rRequest ));
+}
+
+SwScannerEventListener::~SwScannerEventListener()
+{
+}
+
+void SAL_CALL SwScannerEventListener::disposing( const EventObject& /*rEventObject*/)
+{
+#if defined(_WIN32) || defined UNX
+ SolarMutexGuard aGuard;
+ if( m_pView )
+ m_pView->ScannerEventHdl();
+#endif
+}
+
+SwClipboardChangeListener::~SwClipboardChangeListener()
+{
+}
+
+void SAL_CALL SwClipboardChangeListener::disposing( const EventObject& /*rEventObject*/ )
+{
+ SolarMutexGuard aGuard;
+ m_pView = nullptr; // so we don't touch the view if changedContents somehow fires afterwards
+}
+
+void SAL_CALL SwClipboardChangeListener::changedContents( const css::datatransfer::clipboard::ClipboardEvent& rEventObject )
+
+{
+ const SolarMutexGuard aGuard;
+ if( !m_pView )
+ return;
+
+ {
+ TransferableDataHelper aDataHelper( rEventObject.Contents );
+ SwWrtShell& rSh = m_pView->GetWrtShell();
+
+ m_pView->m_nLastPasteDestination = SwTransferable::GetSotDestination( rSh );
+ m_pView->m_bPasteState = aDataHelper.GetXTransferable().is() &&
+ SwTransferable::IsPaste( rSh, aDataHelper );
+
+ m_pView->m_bPasteSpecialState = aDataHelper.GetXTransferable().is() &&
+ SwTransferable::IsPasteSpecial( rSh, aDataHelper );
+ }
+
+ SfxBindings& rBind = m_pView->GetViewFrame().GetBindings();
+ rBind.Invalidate( SID_PASTE );
+ rBind.Invalidate( SID_PASTE_SPECIAL );
+ rBind.Invalidate( SID_CLIPBOARD_FORMAT_ITEMS );
+}
+
+void SwClipboardChangeListener::AddRemoveListener( bool bAdd )
+{
+ m_pView->AddRemoveClipboardListener( Reference< XClipboardListener >( this ), bAdd );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/view.cxx b/sw/source/uibase/uiview/view.cxx
new file mode 100644
index 0000000000..2d46cd04f2
--- /dev/null
+++ b/sw/source/uibase/uiview/view.cxx
@@ -0,0 +1,2120 @@
+/* -*- 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 <sal/config.h>
+
+#include <string_view>
+
+#include <config_features.h>
+#include <config_wasm_strip.h>
+
+#include <stdlib.h>
+#include <hintids.hxx>
+#include <comphelper/string.hxx>
+#include <comphelper/lok.hxx>
+#include <o3tl/any.hxx>
+#include <o3tl/string_view.hxx>
+#include <officecfg/Office/Common.hxx>
+#include <vcl/graph.hxx>
+#include <vcl/inputctx.hxx>
+#include <svl/eitem.hxx>
+#include <unotools/configmgr.hxx>
+#include <unotools/lingucfg.hxx>
+#include <unotools/useroptions.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/docfile.hxx>
+#include <sfx2/objface.hxx>
+#include <sfx2/request.hxx>
+#include <svx/ruler.hxx>
+#include <svx/srchdlg.hxx>
+#include <svx/fmshell.hxx>
+#include <svx/extrusionbar.hxx>
+#include <svx/fontworkbar.hxx>
+#include <svx/fmview.hxx>
+#include <unotxvw.hxx>
+#include <cmdid.h>
+#include <svl/hint.hxx>
+#include <swmodule.hxx>
+#include <inputwin.hxx>
+#include <uivwimp.hxx>
+#include <edtwin.hxx>
+#include <textsh.hxx>
+#include <listsh.hxx>
+#include <tabsh.hxx>
+#include <grfsh.hxx>
+#include <mediash.hxx>
+#include <docsh.hxx>
+#include <frmsh.hxx>
+#include <olesh.hxx>
+#include <drawsh.hxx>
+#include <drawbase.hxx>
+#include <drformsh.hxx>
+#include <drwtxtsh.hxx>
+#include <beziersh.hxx>
+#include <navsh.hxx>
+#include <globdoc.hxx>
+#include <scroll.hxx>
+#include <gloshdl.hxx>
+#include <usrpref.hxx>
+#include <srcview.hxx>
+#include <doc.hxx>
+#include <IDocumentUndoRedo.hxx>
+#include <IDocumentSettingAccess.hxx>
+#include <IDocumentDrawModelAccess.hxx>
+#include <DocumentFieldsManager.hxx>
+#include <IDocumentState.hxx>
+#include <IDocumentLayoutAccess.hxx>
+#include <drawdoc.hxx>
+#include <wdocsh.hxx>
+#include <wrtsh.hxx>
+#include <barcfg.hxx>
+#include <pview.hxx>
+#include <swdtflvr.hxx>
+#include <prtopt.hxx>
+#include <unotxdoc.hxx>
+#include <com/sun/star/frame/FrameSearchFlag.hpp>
+#include <com/sun/star/frame/XLayoutManager.hpp>
+#include <com/sun/star/scanner/ScannerContext.hpp>
+#include <com/sun/star/scanner/XScannerManager2.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/sdb/XDatabaseContext.hpp>
+#include <com/sun/star/sdb/DatabaseContext.hpp>
+#include <toolkit/helper/vclunohelper.hxx>
+#include <sal/log.hxx>
+
+#include <formatclipboard.hxx>
+#include <PostItMgr.hxx>
+#include <annotsh.hxx>
+#include <swruler.hxx>
+#include <svx/theme/ThemeColorPaletteManager.hxx>
+#include <com/sun/star/document/XDocumentProperties.hpp>
+#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
+
+#include <comphelper/propertyvalue.hxx>
+#include <comphelper/servicehelper.hxx>
+#include <sfx2/lokhelper.hxx>
+#include <LibreOfficeKit/LibreOfficeKitEnums.h>
+#include <svtools/embedhlp.hxx>
+#include <tools/UnitConversion.hxx>
+
+#include <svx/sdr/overlay/overlayselection.hxx>
+#include <svx/sdr/overlay/overlayobject.hxx>
+#include <svx/sdr/overlay/overlaymanager.hxx>
+#include <svx/sdrpaintwindow.hxx>
+#include <svx/svdview.hxx>
+#include <node2lay.hxx>
+#include <cntfrm.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::scanner;
+using namespace ::com::sun::star::sdb;
+using namespace ::com::sun::star::sdbc;
+
+#define SWVIEWFLAGS SfxViewShellFlags::HAS_PRINTOPTIONS
+
+// Statics. OMG.
+
+bool bDocSzUpdated = true;
+
+SvxSearchItem* SwView::s_pSrchItem = nullptr;
+
+bool SwView::s_bExtra = false;
+bool SwView::s_bFound = false;
+bool SwView::s_bJustOpened = false;
+
+std::unique_ptr<SearchAttrItemList> SwView::s_xSearchList;
+std::unique_ptr<SearchAttrItemList> SwView::s_xReplaceList;
+
+SfxDispatcher &SwView::GetDispatcher()
+{
+ return *GetViewFrame().GetDispatcher();
+}
+
+void SwView::ImpSetVerb( SelectionType nSelType )
+{
+ bool bResetVerbs = m_bVerbsActive;
+ if ( !GetViewFrame().GetFrame().IsInPlace() &&
+ (SelectionType::Ole|SelectionType::Graphic) & nSelType )
+ {
+ FlyProtectFlags eProtectFlags = m_pWrtShell->IsSelObjProtected(FlyProtectFlags::Content);
+ if (eProtectFlags == FlyProtectFlags::NONE || nSelType & SelectionType::Ole)
+ {
+ if ( nSelType & SelectionType::Ole )
+ {
+ SetVerbs( GetWrtShell().GetOLEObject()->getSupportedVerbs() );
+ m_bVerbsActive = true;
+ bResetVerbs = false;
+ }
+ }
+ }
+ if ( bResetVerbs )
+ {
+ SetVerbs( Sequence< embed::VerbDescriptor >() );
+ m_bVerbsActive = false;
+ }
+}
+
+// Called by the SwEditWin when it gets the focus.
+
+void SwView::GotFocus() const
+{
+ // if we got the focus, and the form shell *is* on the top of the dispatcher
+ // stack, then we need to rebuild the stack (the form shell doesn't belong to
+ // the top then)
+ const SfxDispatcher& rDispatcher = const_cast< SwView* >( this )->GetDispatcher();
+ SfxShell* pTopShell = rDispatcher.GetShell( 0 );
+ FmFormShell* pAsFormShell = dynamic_cast<FmFormShell*>( pTopShell );
+ if ( pAsFormShell )
+ {
+ pAsFormShell->ForgetActiveControl();
+ const_cast< SwView* >( this )->AttrChangedNotify(nullptr);
+ }
+ else if ( m_pPostItMgr )
+ {
+ SwAnnotationShell* pAsAnnotationShell = dynamic_cast<SwAnnotationShell*>( pTopShell );
+ if ( pAsAnnotationShell )
+ {
+ m_pPostItMgr->SetActiveSidebarWin(nullptr);
+ const_cast< SwView* >( this )->AttrChangedNotify(nullptr);
+ }
+ }
+ if (SwWrtShell* pWrtShell = GetWrtShellPtr())
+ {
+ SwWrtShell& rWrtShell = GetWrtShell();
+ rWrtShell.GetDoc()->getIDocumentLayoutAccess().SetCurrentViewShell( pWrtShell );
+ rWrtShell.GetDoc()->getIDocumentSettingAccess().set( DocumentSettingId::BROWSE_MODE,
+ rWrtShell.GetViewOptions()->getBrowseMode() );
+ }
+}
+
+// called by the FormShell when a form control is focused. This is
+// a request to put the form shell on the top of the dispatcher stack
+
+IMPL_LINK_NOARG(SwView, FormControlActivated, LinkParamNone*, void)
+{
+ // if a form control has been activated, and the form shell is not on the top
+ // of the dispatcher stack, then we need to activate it
+ const SfxDispatcher& rDispatcher = GetDispatcher();
+ const SfxShell* pTopShell = rDispatcher.GetShell( 0 );
+ const FmFormShell* pAsFormShell = dynamic_cast<const FmFormShell*>( pTopShell );
+ if ( !pAsFormShell )
+ {
+ // if we're editing text currently, cancel this
+ SdrView *pSdrView = m_pWrtShell ? m_pWrtShell->GetDrawView() : nullptr;
+ if ( pSdrView && pSdrView->IsTextEdit() )
+ pSdrView->SdrEndTextEdit( true );
+
+ AttrChangedNotify(nullptr);
+ }
+}
+
+namespace
+{
+uno::Reference<frame::XLayoutManager> getLayoutManager(const SfxViewFrame& rViewFrame)
+{
+ uno::Reference<frame::XLayoutManager> xLayoutManager;
+ uno::Reference<beans::XPropertySet> xPropSet(rViewFrame.GetFrame().GetFrameInterface(),
+ uno::UNO_QUERY);
+ if (xPropSet.is())
+ {
+ try
+ {
+ xLayoutManager.set(xPropSet->getPropertyValue("LayoutManager"), uno::UNO_QUERY);
+ }
+ catch (const Exception& e)
+ {
+ SAL_WARN("sw.ui", "Failure getting layout manager: " + e.Message);
+ }
+ }
+ return xLayoutManager;
+}
+}
+
+void SwView::ShowUIElement(const OUString& sElementURL) const
+{
+ if (auto xLayoutManager = getLayoutManager(GetViewFrame()))
+ {
+ if (!xLayoutManager->getElement(sElementURL).is())
+ {
+ xLayoutManager->createElement(sElementURL);
+ xLayoutManager->showElement(sElementURL);
+ }
+ }
+}
+
+void SwView::SelectShell()
+{
+ // Attention: Maintain the SelectShell for the WebView additionally
+
+ // In case of m_bDying, our SfxShells are already gone, don't try to select a shell at all.
+ if(m_bInDtor || m_bDying)
+ return;
+
+ // Decision if the UpdateTable has to be called
+ bool bUpdateTable = false;
+ const SwFrameFormat* pCurTableFormat = m_pWrtShell->GetTableFormat();
+ if(pCurTableFormat && pCurTableFormat != m_pLastTableFormat)
+ {
+ bUpdateTable = true; // can only be executed later
+ }
+ m_pLastTableFormat = pCurTableFormat;
+
+ //SEL_TBL and SEL_TBL_CELLS can be ORed!
+ SelectionType nNewSelectionType = m_pWrtShell->GetSelectionType()
+ & ~SelectionType::TableCell;
+
+ // Determine if a different fly frame was selected.
+ bool bUpdateFly = false;
+ const SwFrameFormat* pCurFlyFormat = nullptr;
+ if (m_pWrtShell->IsSelFrameMode())
+ {
+ pCurFlyFormat = m_pWrtShell->GetFlyFrameFormat();
+ }
+ if (pCurFlyFormat && m_pLastFlyFormat && pCurFlyFormat != m_pLastFlyFormat)
+ {
+ // Only do an explicit update when switching between flys.
+ bUpdateFly = true;
+ }
+ m_pLastFlyFormat = pCurFlyFormat;
+
+ if ( m_pFormShell && m_pFormShell->IsActiveControl() )
+ nNewSelectionType |= SelectionType::FormControl;
+
+ if ( nNewSelectionType == m_nSelectionType )
+ {
+ GetViewFrame().GetBindings().InvalidateAll( false );
+ if ( m_nSelectionType & SelectionType::Ole ||
+ m_nSelectionType & SelectionType::Graphic )
+ // For graphs and OLE the verb can be modified of course!
+ ImpSetVerb( nNewSelectionType );
+
+ if (bUpdateFly)
+ {
+ SfxViewFrame& rViewFrame = GetViewFrame();
+ uno::Reference<frame::XFrame> xFrame = rViewFrame.GetFrame().GetFrameInterface();
+ if (xFrame.is())
+ {
+ // Invalidate cached dispatch objects.
+ xFrame->contextChanged();
+ }
+ }
+ }
+ else
+ {
+
+ SfxDispatcher &rDispatcher = GetDispatcher();
+ SwToolbarConfigItem *pBarCfg = SW_MOD()->GetToolbarConfig();
+
+ if ( m_pShell )
+ {
+ rDispatcher.Flush(); // Really erase all cached shells
+ //Remember to the old selection which toolbar was visible
+ ToolbarId eId = rDispatcher.GetObjectBarId(SFX_OBJECTBAR_OBJECT);
+ if (eId != ToolbarId::None)
+ pBarCfg->SetTopToolbar(m_nSelectionType, eId);
+
+ for ( sal_uInt16 i = 0; true; ++i )
+ {
+ SfxShell *pSfxShell = rDispatcher.GetShell( i );
+ if ( dynamic_cast< const SwBaseShell *>( pSfxShell ) != nullptr
+ || dynamic_cast< const SwDrawTextShell *>( pSfxShell ) != nullptr
+ || dynamic_cast< const svx::ExtrusionBar*>( pSfxShell ) != nullptr
+ || dynamic_cast< const svx::FontworkBar*>( pSfxShell ) != nullptr
+ || dynamic_cast< const SwAnnotationShell *>( pSfxShell ) != nullptr
+ )
+ {
+ rDispatcher.Pop( *pSfxShell, SfxDispatcherPopFlags::POP_DELETE );
+ }
+ else if ( dynamic_cast< const FmFormShell *>( pSfxShell ) != nullptr )
+ {
+ rDispatcher.Pop( *pSfxShell );
+ }
+ else
+ break;
+ }
+ }
+
+ bool bInitFormShell = false;
+ if (!m_pFormShell)
+ {
+ bInitFormShell = true;
+ m_pFormShell = new FmFormShell( this );
+ m_pFormShell->SetControlActivationHandler( LINK( this, SwView, FormControlActivated ) );
+ StartListening(*m_pFormShell);
+ }
+
+ bool bSetExtInpCntxt = false;
+ m_nSelectionType = nNewSelectionType;
+ ShellMode eShellMode;
+
+ if ( !( m_nSelectionType & SelectionType::FormControl ) )
+ rDispatcher.Push( *m_pFormShell );
+
+ m_pShell = new SwNavigationShell( *this );
+ rDispatcher.Push( *m_pShell );
+
+ if ( m_nSelectionType & SelectionType::Ole )
+ {
+ eShellMode = ShellMode::Object;
+ m_pShell = new SwOleShell( *this );
+ rDispatcher.Push( *m_pShell );
+ }
+ else if ( m_nSelectionType & SelectionType::Frame
+ || m_nSelectionType & SelectionType::Graphic)
+ {
+ eShellMode = ShellMode::Frame;
+ m_pShell = new SwFrameShell( *this );
+ rDispatcher.Push( *m_pShell );
+ if(m_nSelectionType & SelectionType::Graphic )
+ {
+ eShellMode = ShellMode::Graphic;
+ m_pShell = new SwGrfShell( *this );
+ rDispatcher.Push( *m_pShell );
+ }
+ }
+ else if ( m_nSelectionType & SelectionType::DrawObject )
+ {
+ eShellMode = ShellMode::Draw;
+ m_pShell = new SwDrawShell( *this );
+ rDispatcher.Push( *m_pShell );
+
+ if ( m_nSelectionType & SelectionType::Ornament )
+ {
+ eShellMode = ShellMode::Bezier;
+ m_pShell = new SwBezierShell( *this );
+ rDispatcher.Push( *m_pShell );
+ }
+#if HAVE_FEATURE_AVMEDIA
+ else if( m_nSelectionType & SelectionType::Media )
+ {
+ eShellMode = ShellMode::Media;
+ m_pShell = new SwMediaShell( *this );
+ rDispatcher.Push( *m_pShell );
+ }
+#endif
+ if (m_nSelectionType & SelectionType::ExtrudedCustomShape)
+ {
+ eShellMode = ShellMode::ExtrudedCustomShape;
+ m_pShell = new svx::ExtrusionBar(this);
+ rDispatcher.Push( *m_pShell );
+ }
+ if (m_nSelectionType & SelectionType::FontWork)
+ {
+ eShellMode = ShellMode::FontWork;
+ m_pShell = new svx::FontworkBar(this);
+ rDispatcher.Push( *m_pShell );
+ }
+ }
+ else if ( m_nSelectionType & SelectionType::DbForm )
+ {
+ eShellMode = ShellMode::DrawForm;
+ m_pShell = new SwDrawFormShell( *this );
+
+ rDispatcher.Push( *m_pShell );
+ }
+ else if ( m_nSelectionType & SelectionType::DrawObjectEditMode )
+ {
+ bSetExtInpCntxt = true;
+ eShellMode = ShellMode::DrawText;
+ rDispatcher.Push( *(new SwBaseShell( *this )) );
+ m_pShell = new SwDrawTextShell( *this );
+ rDispatcher.Push( *m_pShell );
+ }
+ else if ( m_nSelectionType & SelectionType::PostIt )
+ {
+ eShellMode = ShellMode::PostIt;
+ m_pShell = new SwAnnotationShell( *this );
+ rDispatcher.Push( *m_pShell );
+ }
+ else
+ {
+ bSetExtInpCntxt = true;
+ eShellMode = ShellMode::Text;
+ if ( m_nSelectionType & SelectionType::NumberList )
+ {
+ eShellMode = ShellMode::ListText;
+ m_pShell = new SwListShell( *this );
+ rDispatcher.Push( *m_pShell );
+ }
+ m_pShell = new SwTextShell(*this);
+ rDispatcher.Push( *m_pShell );
+ if ( m_nSelectionType & SelectionType::Table )
+ {
+ eShellMode = eShellMode == ShellMode::ListText ? ShellMode::TableListText
+ : ShellMode::TableText;
+ m_pShell = new SwTableShell( *this );
+ rDispatcher.Push( *m_pShell );
+ }
+ }
+
+ if ( m_nSelectionType & SelectionType::FormControl )
+ rDispatcher.Push( *m_pFormShell );
+
+ m_pViewImpl->SetShellMode(eShellMode);
+ ImpSetVerb( m_nSelectionType );
+
+ if( !GetDocShell()->IsReadOnly() )
+ {
+ if( bSetExtInpCntxt && GetWrtShell().HasReadonlySel() )
+ bSetExtInpCntxt = false;
+
+ InputContext aCntxt( GetEditWin().GetInputContext() );
+ aCntxt.SetOptions( bSetExtInpCntxt
+ ? (aCntxt.GetOptions() |
+ ( InputContextFlags::Text |
+ InputContextFlags::ExtText ))
+ : (aCntxt.GetOptions() & ~
+ InputContextFlags( InputContextFlags::Text |
+ InputContextFlags::ExtText )) );
+ GetEditWin().SetInputContext( aCntxt );
+ }
+
+ // Show Mail Merge toolbar initially for documents with Database fields
+ if (!m_bInitOnceCompleted && GetWrtShell().IsAnyDatabaseFieldInDoc() && !utl::ConfigManager::IsFuzzing())
+ ShowUIElement("private:resource/toolbar/mailmerge");
+
+ // Activate the toolbar to the new selection which also was active last time.
+ // Before a flush () must be, but does not affect the UI according to MBA and
+ // is not a performance problem.
+ // TODO/LATER: maybe now the Flush() command is superfluous?!
+ rDispatcher.Flush();
+
+ Point aPnt = GetEditWin().OutputToScreenPixel(GetEditWin().GetPointerPosPixel());
+ aPnt = GetEditWin().PixelToLogic(aPnt);
+ GetEditWin().UpdatePointer(aPnt);
+
+ SdrView* pDView = GetWrtShell().GetDrawView();
+ if ( bInitFormShell && pDView )
+ m_pFormShell->SetView(dynamic_cast<FmFormView*>( pDView) );
+
+ }
+ // Opportune time for the communication with OLE objects?
+ if ( GetDocShell()->GetDoc()->IsOLEPrtNotifyPending() )
+ GetDocShell()->GetDoc()->PrtOLENotify( false );
+
+ // now the table-update
+ if(bUpdateTable)
+ m_pWrtShell->UpdateTable();
+
+ GetViewImpl()->GetUNOObject_Impl()->NotifySelChanged();
+
+ m_bInitOnceCompleted = true;
+}
+
+// Interaction: AttrChangedNotify() and TimeoutHdl.
+// No Update if actions are still open, since the cursor on the core side
+// can be somewhere in no man's land.
+// But since we can no longer supply status and we want instead lock
+// the dispatcher.
+
+extern "C"
+{
+ static int lcl_CmpIds( const void *pFirst, const void *pSecond)
+ {
+ return *static_cast<sal_uInt16 const *>(pFirst) - *static_cast<sal_uInt16 const *>(pSecond);
+ }
+}
+
+IMPL_LINK_NOARG(SwView, AttrChangedNotify, LinkParamNone*, void)
+{
+ if ( GetEditWin().IsChainMode() )
+ GetEditWin().SetChainMode( false );
+
+ if (!m_pWrtShell || !GetDocShell())
+ {
+ return;
+ }
+
+ //Opt: Not if PaintLocked. During unlock a notify will be once more triggered.
+ if( !m_pWrtShell->IsPaintLocked() && !g_bNoInterrupt &&
+ GetDocShell()->IsReadOnly() )
+ CheckReadonlyState();
+
+ if( !m_pWrtShell->IsPaintLocked() && !g_bNoInterrupt )
+ CheckReadonlySelection();
+
+ if( !m_bAttrChgNotified )
+ {
+ if (m_pWrtShell->ActionPend() || g_bNoInterrupt ||
+ GetDispatcher().IsLocked() || //do not confuse the SFX
+ GetViewFrame().GetBindings().IsInUpdate() )//do not confuse the SFX
+ {
+ m_bAttrChgNotified = true;
+ m_aTimer.Start();
+
+ const SfxBoolItem *pItem =
+ GetObjectShell()->GetMedium()->GetItemSet().
+ GetItemIfSet( SID_HIDDEN, false );
+ if ( !pItem || !pItem->GetValue() )
+ {
+ GetViewFrame().GetBindings().ENTERREGISTRATIONS();
+ m_bAttrChgNotifiedWithRegistrations = true;
+ }
+
+ }
+ else
+ SelectShell();
+
+ }
+
+ // change ui if cursor is at a SwPostItField
+ if (m_pPostItMgr)
+ {
+ // only perform the code that is needed to determine, if at the
+ // actual cursor position is a post-it field
+ m_pPostItMgr->SetShadowState( m_pWrtShell->GetPostItFieldAtCursor() );
+ }
+}
+
+IMPL_LINK_NOARG(SwView, TimeoutHdl, Timer *, void)
+{
+ if (m_pWrtShell->ActionPend() || g_bNoInterrupt)
+ {
+ m_aTimer.Start();
+ return;
+ }
+
+ if ( m_bAttrChgNotifiedWithRegistrations )
+ {
+ GetViewFrame().GetBindings().LEAVEREGISTRATIONS();
+ m_bAttrChgNotifiedWithRegistrations = false;
+ }
+
+ CheckReadonlyState();
+ CheckReadonlySelection();
+
+ bool bOldUndo = m_pWrtShell->DoesUndo();
+ m_pWrtShell->DoUndo( false );
+ SelectShell();
+ m_pWrtShell->DoUndo( bOldUndo );
+ m_bAttrChgNotified = false;
+ GetViewImpl()->GetUNOObject_Impl()->NotifySelChanged();
+}
+
+void SwView::CheckReadonlyState()
+{
+ SfxDispatcher &rDis = GetDispatcher();
+ // To be able to recognize if it is already disabled!
+ SfxItemState eStateRO, eStateProtAll;
+ SfxPoolItemHolder aResult;
+ // Query the status from a slot which is only known to us.
+ // Otherwise the slot is known from other; like the BasicIde
+ eStateRO = rDis.QueryState(FN_INSERT_BOOKMARK, aResult);
+ eStateProtAll = rDis.QueryState(FN_EDIT_REGION, aResult);
+ bool bChgd = false;
+
+ if ( !m_pWrtShell->IsCursorReadonly() )
+ {
+ static sal_uInt16 aROIds[] =
+ {
+ SID_DELETE, FN_BACKSPACE, FN_SHIFT_BACKSPACE,
+ SID_UNDO,
+ SID_REDO, SID_REPEAT, SID_PASTE,
+ SID_PASTE_UNFORMATTED, FN_PASTE_NESTED_TABLE, FN_TABLE_PASTE_ROW_BEFORE,
+ FN_TABLE_PASTE_COL_BEFORE, SID_PASTE_SPECIAL, SID_SBA_BRW_INSERT,
+ SID_BACKGROUND_COLOR, FN_INSERT_BOOKMARK, SID_CHARMAP_CONTROL,
+ SID_CHARMAP, FN_INSERT_SOFT_HYPHEN,
+ FN_INSERT_HARDHYPHEN, FN_INSERT_HARD_SPACE, FN_INSERT_NNBSP,
+ FN_INSERT_BREAK, FN_INSERT_LINEBREAK, FN_INSERT_COLUMN_BREAK,
+ FN_INSERT_BREAK_DLG, FN_INSERT_CONTENT_CONTROL, FN_INSERT_CHECKBOX_CONTENT_CONTROL,
+ FN_INSERT_DROPDOWN_CONTENT_CONTROL, FN_INSERT_PICTURE_CONTENT_CONTROL,
+ FN_INSERT_DATE_CONTENT_CONTROL, FN_INSERT_PLAIN_TEXT_CONTENT_CONTROL,
+ FN_INSERT_COMBO_BOX_CONTENT_CONTROL,
+ FN_DELETE_SENT, FN_DELETE_BACK_SENT, FN_DELETE_WORD,
+ FN_DELETE_BACK_WORD, FN_DELETE_LINE, FN_DELETE_BACK_LINE,
+ FN_DELETE_PARA, FN_DELETE_BACK_PARA, FN_DELETE_WHOLE_LINE,
+ FN_CALCULATE, FN_FORMAT_RESET,
+ FN_POSTIT, FN_JAVAEDIT, SID_ATTR_PARA_ADJUST_LEFT,
+ SID_ATTR_PARA_ADJUST_RIGHT, SID_ATTR_PARA_ADJUST_CENTER,SID_ATTR_PARA_ADJUST_BLOCK,
+ SID_ATTR_PARA_LINESPACE_10, SID_ATTR_PARA_LINESPACE_15, SID_ATTR_PARA_LINESPACE_20,
+ SID_ATTR_CHAR_FONT, SID_ATTR_CHAR_FONTHEIGHT, SID_ATTR_CHAR_COLOR_BACKGROUND,
+ SID_ATTR_CHAR_BACK_COLOR,
+ SID_ATTR_CHAR_COLOR_BACKGROUND_EXT, SID_ATTR_CHAR_COLOR_EXT,
+ SID_ATTR_CHAR_COLOR, SID_ATTR_CHAR_WEIGHT, SID_ATTR_CHAR_POSTURE,
+ SID_ATTR_CHAR_OVERLINE,
+ SID_ATTR_CHAR_UNDERLINE, SID_ATTR_FLASH, SID_ATTR_CHAR_STRIKEOUT,
+ SID_ULINE_VAL_SINGLE, SID_ULINE_VAL_DOUBLE, SID_ULINE_VAL_DOTTED,
+ SID_ATTR_CHAR_CONTOUR, SID_ATTR_CHAR_SHADOWED,
+ SID_ATTR_CHAR_AUTOKERN, SID_ATTR_CHAR_ESCAPEMENT, FN_SET_SUPER_SCRIPT,
+ FN_SET_SUB_SCRIPT, SID_ATTR_CHAR_CASEMAP, SID_ATTR_CHAR_LANGUAGE,
+ SID_ATTR_CHAR_KERNING, SID_CHAR_DLG, SID_ATTR_CHAR_WORDLINEMODE,
+ FN_GROW_FONT_SIZE, FN_SHRINK_FONT_SIZE, FN_TXTATR_INET,
+ FN_FORMAT_DROPCAPS, SID_ATTR_PARA_ADJUST, SID_ATTR_PARA_LINESPACE,
+ SID_ATTR_PARA_SPLIT, SID_ATTR_PARA_KEEP, SID_ATTR_PARA_WIDOWS,
+ SID_ATTR_PARA_ORPHANS,
+ SID_ATTR_PARA_MODEL, SID_PARA_DLG,
+ FN_SELECT_PARA, SID_DEC_INDENT,
+ SID_INC_INDENT
+ };
+ static bool bFirst = true;
+ if ( bFirst )
+ {
+ qsort( static_cast<void*>(aROIds), SAL_N_ELEMENTS(aROIds), sizeof(sal_uInt16), lcl_CmpIds );
+ bFirst = false;
+ }
+ if ( SfxItemState::DISABLED == eStateRO )
+ {
+ rDis.SetSlotFilter( SfxSlotFilterState::ENABLED_READONLY, aROIds );
+ bChgd = true;
+ }
+ }
+ else if( m_pWrtShell->IsAllProtect() )
+ {
+ if ( SfxItemState::DISABLED == eStateProtAll )
+ {
+ static sal_uInt16 aAllProtIds[] = { SID_SAVEDOC, FN_EDIT_REGION };
+ static bool bAllProtFirst = true;
+ if ( bAllProtFirst )
+ {
+ qsort( static_cast<void*>(aAllProtIds), SAL_N_ELEMENTS(aAllProtIds), sizeof(sal_uInt16), lcl_CmpIds );
+ bAllProtFirst = false;
+ }
+ rDis.SetSlotFilter( SfxSlotFilterState::ENABLED_READONLY, aAllProtIds );
+ bChgd = true;
+ }
+ }
+ else if ( SfxItemState::DISABLED != eStateRO ||
+ SfxItemState::DISABLED != eStateProtAll )
+ {
+ bChgd = true;
+ rDis.SetSlotFilter();
+ }
+ if ( bChgd )
+ GetViewFrame().GetBindings().InvalidateAll(true);
+}
+
+void SwView::CheckReadonlySelection()
+{
+ SfxDisableFlags nDisableFlags = SfxDisableFlags::NONE;
+ SfxDispatcher &rDis = GetDispatcher();
+
+ if( m_pWrtShell->HasReadonlySel() &&
+ ( !m_pWrtShell->GetDrawView() ||
+ !m_pWrtShell->GetDrawView()->GetMarkedObjectList().GetMarkCount() ))
+ nDisableFlags |= SfxDisableFlags::SwOnProtectedCursor;
+
+ if( (SfxDisableFlags::SwOnProtectedCursor & nDisableFlags ) !=
+ (SfxDisableFlags::SwOnProtectedCursor & rDis.GetDisableFlags() ) )
+ {
+ // Additionally move at the Window the InputContext, so that
+ // in japanese / chinese versions the external input will be
+ // turned on or off. This but only if the correct shell is on
+ // the stack.
+ switch( m_pViewImpl->GetShellMode() )
+ {
+ case ShellMode::Text:
+ case ShellMode::ListText:
+ case ShellMode::TableText:
+ case ShellMode::TableListText:
+ {
+// Temporary solution!!! Should set the font of the current insertion point
+// at each cursor movement, so outside of this "if". But TH does not
+// evaluates the font at this time and the "purchase" appears to me
+// as too expensive.
+// Moreover, we don't have a font, but only attributes from which the
+// text formatting and the correct font will be build together.
+
+ InputContext aCntxt( GetEditWin().GetInputContext() );
+ aCntxt.SetOptions( SfxDisableFlags::SwOnProtectedCursor & nDisableFlags
+ ? (aCntxt.GetOptions() & ~
+ InputContextFlags( InputContextFlags::Text |
+ InputContextFlags::ExtText ))
+ : (aCntxt.GetOptions() |
+ ( InputContextFlags::Text |
+ InputContextFlags::ExtText )) );
+ GetEditWin().SetInputContext( aCntxt );
+ }
+ break;
+ default:
+ ;
+ }
+
+ }
+
+ if( nDisableFlags != rDis.GetDisableFlags() )
+ {
+ rDis.SetDisableFlags( nDisableFlags );
+ GetViewFrame().GetBindings().InvalidateAll( true );
+ }
+}
+
+SwView::SwView(SfxViewFrame& _rFrame, SfxViewShell* pOldSh)
+ : SfxViewShell(_rFrame, SWVIEWFLAGS),
+ m_aTimer( "sw::SwView m_aTimer" ),
+ m_nNewPage(USHRT_MAX),
+ m_nOldPageNum(0),
+ m_pNumRuleNodeFromDoc(nullptr),
+ m_pEditWin( VclPtr<SwEditWin>::Create( &_rFrame.GetWindow(), *this ) ),
+ m_pShell(nullptr),
+ m_pFormShell(nullptr),
+ m_pHScrollbar(nullptr),
+ m_pVScrollbar(nullptr),
+ m_pVRuler(VclPtr<SvxRuler>::Create(&GetViewFrame().GetWindow(), m_pEditWin,
+ SvxRulerSupportFlags::TABS | SvxRulerSupportFlags::PARAGRAPH_MARGINS_VERTICAL|
+ SvxRulerSupportFlags::BORDERS | SvxRulerSupportFlags::REDUCED_METRIC,
+ GetViewFrame().GetBindings(),
+ WB_VSCROLL | WB_EXTRAFIELD | WB_BORDER )),
+ m_pLastTableFormat(nullptr),
+ m_pLastFlyFormat(nullptr),
+ m_pFormatClipboard(new SwFormatClipboard()),
+ m_nSelectionType( SelectionType::All ),
+ m_nPageCnt(0),
+ m_nDrawSfxId( USHRT_MAX ),
+ m_nFormSfxId( USHRT_MAX ),
+ m_eFormObjKind(SdrObjKind::NONE),
+ m_nLastPasteDestination( static_cast<SotExchangeDest>(0xFFFF) ),
+ m_nLeftBorderDistance( 0 ),
+ m_nRightBorderDistance( 0 ),
+ m_eLastSearchCommand( static_cast<SvxSearchCmd>(0xFFFF) ),
+ m_bWheelScrollInProgress(false),
+ m_bCenterCursor(false),
+ m_bTopCursor(false),
+ m_bTabColFromDoc(false),
+ m_bTabRowFromDoc(false),
+ m_bSetTabColFromDoc(false),
+ m_bSetTabRowFromDoc(false),
+ m_bAttrChgNotified(false),
+ m_bAttrChgNotifiedWithRegistrations(false),
+ m_bVerbsActive(false),
+ m_bDrawRotate(false),
+ m_bDrawSelMode(true),
+ m_bShowAtResize(true),
+ m_bInOuterResizePixel(false),
+ m_bInInnerResizePixel(false),
+ m_bPasteState(false),
+ m_bPasteSpecialState(false),
+ m_bInMailMerge(false),
+ m_bInDtor(false),
+ m_bOldShellWasPagePreview(false),
+ m_bIsPreviewDoubleClick(false),
+ m_bMakeSelectionVisible(false),
+ m_bForceChangesToolbar(true),
+ m_nLOKPageUpDownOffset(0),
+ m_aBringToAttentionBlinkTimer("SwView m_aBringToAttentionBlinkTimer"),
+ m_nBringToAttentionBlinkTimeOutsRemaining(0)
+{
+ static bool bRequestDoubleBuffering = getenv("VCL_DOUBLEBUFFERING_ENABLE");
+ if (bRequestDoubleBuffering)
+ m_pEditWin->RequestDoubleBuffering(true);
+
+ // According to discussion with MBA and further
+ // investigations, no old SfxViewShell will be set as parameter <pOldSh>,
+ // if function "New Window" is performed to open an additional view beside
+ // an already existing one.
+ // If the view is switch from one to another, the 'old' view is given by
+ // parameter <pOldSh>.
+
+ bDocSzUpdated = true;
+
+ static bool bFuzzing = utl::ConfigManager::IsFuzzing();
+
+ if (!bFuzzing)
+ {
+ CreateScrollbar( true );
+ CreateScrollbar( false );
+ }
+
+ m_pViewImpl.reset(new SwView_Impl(this));
+ SetName("View");
+ SetWindow( m_pEditWin );
+
+ m_aTimer.SetTimeout( 120 );
+
+ SwDocShell& rDocSh = dynamic_cast<SwDocShell&>(*_rFrame.GetObjectShell());
+ bool bOldModifyFlag = rDocSh.IsEnableSetModified();
+ if (bOldModifyFlag)
+ rDocSh.EnableSetModified( false );
+ // HACK: SwDocShell has some cached font info, VCL informs about font updates,
+ // but loading of docs with embedded fonts happens after SwDocShell is created
+ // but before SwEditWin (which handles the VCL event) is created. So update
+ // manually.
+ if (rDocSh.GetDoc()->getIDocumentSettingAccess().get( DocumentSettingId::EMBED_FONTS ))
+ rDocSh.UpdateFontList();
+ bool bWebDShell = dynamic_cast<const SwWebDocShell*>(&rDocSh) != nullptr;
+
+ const SwMasterUsrPref *pUsrPref = SW_MOD()->GetUsrPref(bWebDShell);
+ SwViewOption aUsrPref( *pUsrPref);
+
+ //! get lingu options without loading lingu DLL
+ SvtLinguOptions aLinguOpt;
+ SvtLinguConfig().GetOptions( aLinguOpt );
+ aUsrPref.SetOnlineSpell( aLinguOpt.bIsSpellAuto );
+
+ bool bOldShellWasSrcView = false;
+
+ // determine if there is an existing view for
+ // document
+ SfxViewShell* pExistingSh = nullptr;
+ if ( pOldSh )
+ {
+ pExistingSh = pOldSh;
+ // determine type of existing view
+ if (SwPagePreview* pPagePreview = dynamic_cast<SwPagePreview *>(pExistingSh))
+ {
+ m_sSwViewData = pPagePreview->GetPrevSwViewData();
+ m_sNewCursorPos = pPagePreview->GetNewCursorPos();
+ m_nNewPage = pPagePreview->GetNewPage();
+ m_bOldShellWasPagePreview = true;
+ m_bIsPreviewDoubleClick = !m_sNewCursorPos.isEmpty() || m_nNewPage != USHRT_MAX;
+ }
+ else if (dynamic_cast<const SwSrcView *>(pExistingSh) != nullptr)
+ bOldShellWasSrcView = true;
+ }
+
+ SAL_INFO( "sw.ui", "before create WrtShell" );
+ if (SwView *pView = dynamic_cast<SwView*>(pExistingSh))
+ {
+ m_pWrtShell.reset(new SwWrtShell(*pView->m_pWrtShell, m_pEditWin, *this));
+ }
+ else if (SwWrtShell *pWrtShell = dynamic_cast<SwWrtShell*>(rDocSh.GetDoc()->getIDocumentLayoutAccess().GetCurrentViewShell()))
+ {
+ m_pWrtShell.reset(new SwWrtShell(*pWrtShell, m_pEditWin, *this));
+ }
+ else
+ {
+ SwDoc& rDoc = *rDocSh.GetDoc();
+
+ if( !bOldShellWasSrcView && bWebDShell && !m_bOldShellWasPagePreview )
+ aUsrPref.setBrowseMode( true );
+ else
+ aUsrPref.setBrowseMode( rDoc.getIDocumentSettingAccess().get(DocumentSettingId::BROWSE_MODE) );
+
+ //For the BrowseMode we do not assume a factor.
+ if( aUsrPref.getBrowseMode() && aUsrPref.GetZoomType() != SvxZoomType::PERCENT )
+ {
+ aUsrPref.SetZoomType( SvxZoomType::PERCENT );
+ aUsrPref.SetZoom( 100 );
+ }
+ if (rDocSh.IsPreview())
+ {
+ aUsrPref.SetZoomType( SvxZoomType::WHOLEPAGE );
+ aUsrPref.SetViewLayoutBookMode( false );
+ aUsrPref.SetViewLayoutColumns( 1 );
+ }
+ m_pWrtShell.reset(new SwWrtShell(rDoc, m_pEditWin, *this, &aUsrPref));
+ // creating an SwView from a SwPagePreview needs to
+ // add the SwViewShell to the ring of the other SwViewShell(s)
+ if(m_bOldShellWasPagePreview)
+ {
+ SwViewShell& rPreviewViewShell = *static_cast<SwPagePreview*>(pExistingSh)->GetViewShell();
+ m_pWrtShell->MoveTo(&rPreviewViewShell);
+ // to update the field command et.al. if necessary
+ const SwViewOption* pPreviewOpt = rPreviewViewShell.GetViewOptions();
+ if( pPreviewOpt->IsFieldName() != aUsrPref.IsFieldName() ||
+ pPreviewOpt->IsShowHiddenField() != aUsrPref.IsShowHiddenField() ||
+ pPreviewOpt->IsShowHiddenPara() != aUsrPref.IsShowHiddenPara() ||
+ pPreviewOpt->IsShowHiddenChar() != aUsrPref.IsShowHiddenChar() )
+ rPreviewViewShell.ApplyViewOptions(aUsrPref);
+ // reset design mode at draw view for form
+ // shell, if needed.
+ if ( static_cast<SwPagePreview*>(pExistingSh)->ResetFormDesignMode() &&
+ m_pWrtShell->HasDrawView() )
+ {
+ SdrView* pDrawView = m_pWrtShell->GetDrawView();
+ pDrawView->SetDesignMode( static_cast<SwPagePreview*>(pExistingSh)->FormDesignModeToReset() );
+ }
+ }
+ }
+ SAL_INFO( "sw.ui", "after create WrtShell" );
+ m_pHRuler = VclPtr<SwCommentRuler>::Create(m_pWrtShell.get(), &GetViewFrame().GetWindow(), m_pEditWin,
+ SvxRulerSupportFlags::TABS |
+ SvxRulerSupportFlags::PARAGRAPH_MARGINS |
+ SvxRulerSupportFlags::BORDERS |
+ SvxRulerSupportFlags::NEGATIVE_MARGINS|
+ SvxRulerSupportFlags::REDUCED_METRIC,
+ GetViewFrame().GetBindings(),
+ WB_STDRULER | WB_EXTRAFIELD | WB_BORDER);
+
+ // assure that modified state of document
+ // isn't reset, if document is already modified.
+ const bool bIsDocModified = m_pWrtShell->GetDoc()->getIDocumentState().IsModified();
+
+ // Thus among other things, the HRuler is not displayed in the read-only case.
+ aUsrPref.SetReadonly( m_pWrtShell->GetViewOptions()->IsReadonly() );
+
+ // no margin for OLE!
+ Size aBrwsBorder;
+ if( SfxObjectCreateMode::EMBEDDED != rDocSh.GetCreateMode() )
+ aBrwsBorder = GetMargin();
+
+ m_pWrtShell->SetBrowseBorder( aBrwsBorder );
+
+ // In CTOR no shell changes may take place, which must be temporarily stored
+ // with the timer. Otherwise, the SFX removes them from the stack!
+ bool bOld = g_bNoInterrupt;
+ g_bNoInterrupt = true;
+
+ m_pHRuler->SetActive();
+ m_pVRuler->SetActive();
+
+ SfxViewFrame& rViewFrame = GetViewFrame();
+
+ StartListening(rViewFrame, DuplicateHandling::Prevent);
+ StartListening(rDocSh, DuplicateHandling::Prevent);
+
+ // Set Zoom-factor from HRuler
+ Fraction aZoomFract( aUsrPref.GetZoom(), 100 );
+ m_pHRuler->SetZoom( aZoomFract );
+ m_pVRuler->SetZoom( aZoomFract );
+ m_pHRuler->SetDoubleClickHdl(LINK( this, SwView, ExecRulerClick ));
+ FieldUnit eMetric = pUsrPref->GetHScrollMetric();
+ m_pHRuler->SetUnit( eMetric );
+
+ eMetric = pUsrPref->GetVScrollMetric();
+ m_pVRuler->SetUnit( eMetric );
+
+ m_pHRuler->SetCharWidth( 371 ); // default character width
+ m_pVRuler->SetLineHeight( 551 ); // default line height
+
+ // Set DocShell
+ m_xGlueDocShell.reset(new SwViewGlueDocShell(*this, rDocSh));
+ m_pPostItMgr.reset(new SwPostItMgr(this));
+
+ // Check and process the DocSize. Via the handler, the shell could not
+ // be found, because the shell is not known in the SFX management
+ // within the CTOR phase.
+ DocSzChgd( m_pWrtShell->GetDocSize() );
+
+ // Set AttrChangedNotify link
+ m_pWrtShell->SetChgLnk(LINK(this, SwView, AttrChangedNotify));
+
+ if (rDocSh.GetCreateMode() == SfxObjectCreateMode::EMBEDDED &&
+ !rDocSh.GetVisArea(ASPECT_CONTENT).IsEmpty())
+ SetVisArea(rDocSh.GetVisArea(ASPECT_CONTENT),false);
+
+ SAL_WARN_IF(
+ officecfg::Office::Common::Undo::Steps::get() <= 0,
+ "sw.ui", "/org.openoffice.Office.Common/Undo/Steps <= 0");
+ if (!bFuzzing && 0 < officecfg::Office::Common::Undo::Steps::get())
+ {
+ m_pWrtShell->DoUndo();
+ }
+
+ const bool bBrowse = m_pWrtShell->GetViewOptions()->getBrowseMode();
+ // Disable "multiple window"
+ SetNewWindowAllowed(!bBrowse);
+ // End of disabled multiple window
+
+ m_bVScrollbarEnabled = aUsrPref.IsViewVScrollBar();
+ m_bHScrollbarEnabled = aUsrPref.IsViewHScrollBar();
+ if (m_pHScrollbar)
+ m_pHScrollbar->SetAuto(bBrowse);
+ if( aUsrPref.IsViewHRuler() )
+ CreateTab();
+ if( aUsrPref.IsViewVRuler() )
+ CreateVRuler();
+
+ m_pWrtShell->SetUIOptions( aUsrPref );
+ m_pWrtShell->SetReadOnlyAvailable( aUsrPref.IsCursorInProtectedArea() );
+#if !ENABLE_WASM_STRIP_ACCESSIBILITY
+ m_pWrtShell->ApplyAccessibilityOptions();
+#endif
+
+ if( m_pWrtShell->GetDoc()->getIDocumentState().IsUpdateExpField() )
+ {
+ if (m_pWrtShell->GetDoc()->GetDocumentFieldsManager().containsUpdatableFields())
+ {
+ CurrShell aCurr(m_pWrtShell.get());
+ m_pWrtShell->StartAction();
+ m_pWrtShell->CalcLayout();
+ m_pWrtShell->GetDoc()->getIDocumentFieldsAccess().UpdateFields(false);
+ m_pWrtShell->EndAction();
+ }
+ m_pWrtShell->GetDoc()->getIDocumentState().SetUpdateExpFieldStat( false );
+ }
+
+ // Update all tables if necessary:
+ if( m_pWrtShell->GetDoc()->IsUpdateTOX() )
+ {
+ SfxRequest aSfxRequest( FN_UPDATE_TOX, SfxCallMode::SLOT, GetPool() );
+ Execute( aSfxRequest );
+ m_pWrtShell->GetDoc()->SetUpdateTOX( false ); // reset again
+ m_pWrtShell->SttEndDoc(true);
+ }
+
+ // No ResetModified, if there is already a view to this doc.
+ SfxViewFrame& rVFrame = GetViewFrame();
+ SfxViewFrame* pFirst = SfxViewFrame::GetFirst(&rDocSh);
+ // Currently(360) the view is registered firstly after the CTOR,
+ // the following expression is also working if this changes.
+ // If the modification cannot be canceled by undo, then do NOT set
+ // the modify back.
+ // no reset of modified state, if document
+ // was already modified.
+ if (!m_pWrtShell->GetDoc()->GetIDocumentUndoRedo().IsUndoNoResetModified() &&
+ ( !pFirst || pFirst == &rVFrame ) &&
+ !bIsDocModified )
+ {
+ m_pWrtShell->ResetModified();
+ }
+
+ g_bNoInterrupt = bOld;
+
+ // If a new GlobalDoc will be created, the navigator will also be generated.
+ if( dynamic_cast<const SwGlobalDocShell*>(&rDocSh) != nullptr &&
+ !rVFrame.GetChildWindow( SID_NAVIGATOR ))
+ {
+ SfxBoolItem aNavi(SID_NAVIGATOR, true);
+ GetDispatcher().ExecuteList(SID_NAVIGATOR, SfxCallMode::ASYNCHRON, { &aNavi });
+ }
+
+ uno::Reference< frame::XFrame > xFrame = rVFrame.GetFrame().GetFrameInterface();
+
+ uno::Reference< frame::XFrame > xBeamerFrame = xFrame->findFrame(
+ "_beamer", frame::FrameSearchFlag::CHILDREN);
+ if(xBeamerFrame.is())
+ {
+ SwDBData aData = m_pWrtShell->GetDBData();
+ SwModule::ShowDBObj( *this, aData );
+ }
+
+ // has anybody calls the attrchanged handler in the constructor?
+ if( m_bAttrChgNotifiedWithRegistrations )
+ {
+ GetViewFrame().GetBindings().LEAVEREGISTRATIONS();
+ if( m_aTimer.IsActive() )
+ m_aTimer.Stop();
+ }
+
+ m_aTimer.SetInvokeHandler(LINK(this, SwView, TimeoutHdl));
+ m_bAttrChgNotified = m_bAttrChgNotifiedWithRegistrations = false;
+ if (bOldModifyFlag)
+ rDocSh.EnableSetModified();
+ InvalidateBorder();
+
+ if (!bFuzzing)
+ {
+ if (!m_pHScrollbar->IsScrollbarVisible(true))
+ ShowHScrollbar( false );
+ if (!m_pVScrollbar->IsScrollbarVisible(true))
+ ShowVScrollbar( false );
+ }
+
+ if (m_pWrtShell->GetViewOptions()->IsShowOutlineContentVisibilityButton())
+ m_pWrtShell->InvalidateOutlineContentVisibility();
+
+ if (!bFuzzing)
+ GetViewFrame().GetWindow().AddChildEventListener(LINK(this, SwView, WindowChildEventListener));
+
+ m_aBringToAttentionBlinkTimer.SetInvokeHandler(
+ LINK(this, SwView, BringToAttentionBlinkTimerHdl));
+ m_aBringToAttentionBlinkTimer.SetTimeout(350);
+
+ if (comphelper::LibreOfficeKit::isActive())
+ {
+ SwXTextDocument* pModel = comphelper::getFromUnoTunnel<SwXTextDocument>(GetCurrentDocument());
+ SfxLokHelper::notifyViewRenderState(this, pModel);
+ }
+}
+
+SwViewGlueDocShell::SwViewGlueDocShell(SwView& rView, SwDocShell& rDocSh)
+ : m_rView(rView)
+{
+ // Set DocShell
+ rDocSh.SetView(&m_rView);
+ SW_MOD()->SetView(&m_rView);
+}
+
+SwViewGlueDocShell::~SwViewGlueDocShell()
+{
+ SwDocShell* pDocSh = m_rView.GetDocShell();
+ if (pDocSh && pDocSh->GetView() == &m_rView)
+ pDocSh->SetView(nullptr);
+ if (SW_MOD()->GetView() == &m_rView)
+ SW_MOD()->SetView(nullptr);
+}
+
+SwView::~SwView()
+{
+ // Notify other LOK views that we are going away.
+ SfxLokHelper::notifyOtherViews(this, LOK_CALLBACK_VIEW_CURSOR_VISIBLE, "visible", "false"_ostr);
+ SfxLokHelper::notifyOtherViews(this, LOK_CALLBACK_TEXT_VIEW_SELECTION, "selection", ""_ostr);
+ SfxLokHelper::notifyOtherViews(this, LOK_CALLBACK_GRAPHIC_VIEW_SELECTION, "selection", "EMPTY"_ostr);
+
+ // Need to remove activated field's button before disposing EditWin.
+ GetWrtShell().getIDocumentMarkAccess()->ClearFieldActivation();
+
+ GetViewFrame().GetWindow().RemoveChildEventListener( LINK( this, SwView, WindowChildEventListener ) );
+ m_pPostItMgr.reset();
+
+ m_bInDtor = true;
+ m_pEditWin->Hide(); // prevent problems with painting
+
+ // Set pointer in SwDocShell to the view again
+ m_xGlueDocShell.reset();
+
+ if( m_aTimer.IsActive() && m_bAttrChgNotifiedWithRegistrations )
+ GetViewFrame().GetBindings().LEAVEREGISTRATIONS();
+
+ // the last view must end the text edit
+ SdrView *pSdrView = m_pWrtShell->GetDrawView();
+ if( pSdrView && pSdrView->IsTextEdit() )
+ pSdrView->SdrEndTextEdit( true );
+ else if (pSdrView)
+ {
+ pSdrView->DisposeUndoManager();
+ }
+
+ SetWindow( nullptr );
+
+ m_pViewImpl->Invalidate();
+ EndListening(GetViewFrame());
+ EndListening(*GetDocShell());
+
+ // tdf#155410 speedup shutdown, prevent unnecessary broadcasting during teardown of draw model
+ auto pDrawModel = GetWrtShell().getIDocumentDrawModelAccess().GetDrawModel();
+ const bool bWasLocked = pDrawModel->isLocked();
+ pDrawModel->setLock(true);
+ m_pWrtShell.reset(); // reset here so that it is not accessible by the following dtors.
+ pDrawModel->setLock(bWasLocked);
+
+ m_pHScrollbar.disposeAndClear();
+ m_pVScrollbar.disposeAndClear();
+ m_pHRuler.disposeAndClear();
+ m_pVRuler.disposeAndClear();
+ m_pGlosHdl.reset();
+ m_pViewImpl.reset();
+
+ // If this was enabled in the ctor for the frame, then disable it here.
+ static bool bRequestDoubleBuffering = getenv("VCL_DOUBLEBUFFERING_ENABLE");
+ if (bRequestDoubleBuffering)
+ m_pEditWin->RequestDoubleBuffering(false);
+ m_pEditWin.disposeAndClear();
+
+ m_pFormatClipboard.reset();
+}
+
+void SwView::SetDying()
+{
+ m_bDying = true;
+}
+
+void SwView::afterCallbackRegistered()
+{
+ if (!comphelper::LibreOfficeKit::isActive())
+ return;
+
+ // common tasks
+ SfxViewShell::afterCallbackRegistered();
+
+ auto* pDocShell = GetDocShell();
+ if (pDocShell)
+ {
+ svx::ThemeColorPaletteManager aManager(pDocShell->GetThemeColors());
+ libreOfficeKitViewCallback(LOK_CALLBACK_COLOR_PALETTES, aManager.generateJSON());
+ }
+}
+
+SwDocShell* SwView::GetDocShell()
+{
+ SfxObjectShell* pDocShell = GetViewFrame().GetObjectShell();
+ return dynamic_cast<SwDocShell*>( pDocShell );
+}
+
+// Remember CursorPos
+
+void SwView::WriteUserData( OUString &rUserData, bool bBrowse )
+{
+ // The browse flag will be passed from Sfx when documents are browsed
+ // (not to be confused with the BrowseMode).
+ // Then that stored data are not persistent!
+
+ const SwRect& rRect = m_pWrtShell->GetCharRect();
+ const tools::Rectangle& rVis = GetVisArea();
+
+ rUserData = OUString::number( rRect.Left() );
+ rUserData += ";";
+ rUserData += OUString::number( rRect.Top() );
+ rUserData += ";";
+ rUserData += OUString::number( m_pWrtShell->GetViewOptions()->GetZoom() );
+ rUserData += ";";
+ rUserData += OUString::number( rVis.Left() );
+ rUserData += ";";
+ rUserData += OUString::number( rVis.Top() );
+ rUserData += ";";
+ rUserData += OUString::number( bBrowse ? SAL_MIN_INT32 : rVis.Right());
+ rUserData += ";";
+ rUserData += OUString::number( bBrowse ? SAL_MIN_INT32 : rVis.Bottom());
+ rUserData += ";";
+ rUserData += OUString::number(
+ static_cast<sal_uInt16>(m_pWrtShell->GetViewOptions()->GetZoomType()));//eZoom;
+ rUserData += ";";
+ rUserData += FrameTypeFlags::NONE == m_pWrtShell->GetSelFrameType() ? std::u16string_view(u"0") : std::u16string_view(u"1");
+}
+
+// Set CursorPos
+
+static bool lcl_IsOwnDocument( SwView& rView )
+{
+ if (::officecfg::Office::Common::Load::ViewPositionForAnyUser::get())
+ {
+ return true;
+ }
+ uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
+ rView.GetDocShell()->GetModel(), uno::UNO_QUERY_THROW);
+ uno::Reference<document::XDocumentProperties> xDocProps
+ = xDPS->getDocumentProperties();
+ OUString Created = xDocProps->getAuthor();
+ OUString Changed = xDocProps->getModifiedBy();
+ OUString FullName = SW_MOD()->GetUserOptions().GetFullName();
+ return !FullName.isEmpty()
+ && (Changed == FullName || (Changed.isEmpty() && Created == FullName));
+}
+
+void SwView::ReadUserData( const OUString &rUserData, bool bBrowse )
+{
+ if ( !(rUserData.indexOf(';')>=0 && // more than one token
+ // For document without layout only in the onlinelayout or
+ // while forward/backward
+ (!m_pWrtShell->IsNewLayout() || m_pWrtShell->GetViewOptions()->getBrowseMode() || bBrowse)) )
+ return;
+
+ bool bIsOwnDocument = lcl_IsOwnDocument( *this );
+
+ CurrShell aCurr(m_pWrtShell.get());
+
+ sal_Int32 nPos = 0;
+
+ // No it is *not* a good idea to call GetToken within Point constr. immediately,
+ // because which parameter is evaluated first?
+ tools::Long nX = o3tl::toInt32(o3tl::getToken(rUserData, 0, ';', nPos )),
+ nY = o3tl::toInt32(o3tl::getToken(rUserData, 0, ';', nPos ));
+ Point aCursorPos( nX, nY );
+
+ sal_uInt16 nZoomFactor =
+ static_cast< sal_uInt16 >( o3tl::toInt32(o3tl::getToken(rUserData, 0, ';', nPos )) );
+
+ tools::Long nLeft = o3tl::toInt32(o3tl::getToken(rUserData, 0, ';', nPos )),
+ nTop = o3tl::toInt32(o3tl::getToken(rUserData, 0, ';', nPos )),
+ nRight = o3tl::toInt32(o3tl::getToken(rUserData, 0, ';', nPos )),
+ nBottom= o3tl::toInt32(o3tl::getToken(rUserData, 0, ';', nPos ));
+
+ const tools::Long nAdd = m_pWrtShell->GetViewOptions()->getBrowseMode() ? DOCUMENTBORDER : DOCUMENTBORDER*2;
+ if ( nBottom > (m_pWrtShell->GetDocSize().Height()+nAdd) )
+ return;
+
+ m_pWrtShell->EnableSmooth( false );
+
+ const tools::Rectangle aVis( nLeft, nTop, nRight, nBottom );
+
+ sal_Int32 nOff = 0;
+ SvxZoomType eZoom;
+ if( !m_pWrtShell->GetViewOptions()->getBrowseMode() )
+ eZoom = static_cast<SvxZoomType>(o3tl::narrowing<sal_uInt16>(o3tl::toInt32(o3tl::getToken(rUserData, nOff, ';', nPos ))));
+ else
+ {
+ eZoom = SvxZoomType::PERCENT;
+ ++nOff;
+ }
+
+ bool bSelectObj = (0 != o3tl::toInt32(o3tl::getToken(rUserData, nOff, ';', nPos )))
+ && m_pWrtShell->IsObjSelectable( aCursorPos );
+
+ // restore editing position
+ m_pViewImpl->SetRestorePosition(aCursorPos, bSelectObj);
+ // set flag value to avoid macro execution.
+ bool bSavedFlagValue = m_pWrtShell->IsMacroExecAllowed();
+ m_pWrtShell->SetMacroExecAllowed( false );
+// os: changed: The user data has to be read if the view is switched back from page preview
+// go to the last editing position when opening own files
+ if(m_bOldShellWasPagePreview || bIsOwnDocument)
+ {
+ m_pWrtShell->SwCursorShell::SetCursor( aCursorPos, !bSelectObj );
+ if( bSelectObj )
+ {
+ m_pWrtShell->SelectObj( aCursorPos );
+ m_pWrtShell->EnterSelFrameMode( &aCursorPos );
+ }
+ }
+
+ // reset flag value
+ m_pWrtShell->SetMacroExecAllowed( bSavedFlagValue );
+
+ // set visible area before applying
+ // information from print preview. Otherwise, the applied information
+ // is lost.
+// os: changed: The user data has to be read if the view is switched back from page preview
+// go to the last editing position when opening own files
+ if(m_bOldShellWasPagePreview || bIsOwnDocument )
+ {
+ if ( bBrowse )
+ SetVisArea( aVis.TopLeft() );
+ else
+ SetVisArea( aVis );
+ }
+
+ //apply information from print preview - if available
+ if( !m_sNewCursorPos.isEmpty() )
+ {
+ sal_Int32 nIdx{ 0 };
+ const tools::Long nXTmp = o3tl::toInt32(o3tl::getToken(m_sNewCursorPos, 0, ';', nIdx ));
+ const tools::Long nYTmp = o3tl::toInt32(o3tl::getToken(m_sNewCursorPos, 0, ';', nIdx ));
+ Point aCursorPos2( nXTmp, nYTmp );
+ bSelectObj = m_pWrtShell->IsObjSelectable( aCursorPos2 );
+
+ m_pWrtShell->SwCursorShell::SetCursor( aCursorPos2 );
+ if( bSelectObj )
+ {
+ m_pWrtShell->SelectObj( aCursorPos2 );
+ m_pWrtShell->EnterSelFrameMode( &aCursorPos2 );
+ }
+ m_pWrtShell->MakeSelVisible();
+ m_sNewCursorPos.clear();
+ }
+ else if(USHRT_MAX != m_nNewPage)
+ {
+ m_pWrtShell->GotoPage(m_nNewPage, true);
+ m_nNewPage = USHRT_MAX;
+ }
+
+ SelectShell();
+
+ m_pWrtShell->StartAction();
+ const SwViewOption* pVOpt = m_pWrtShell->GetViewOptions();
+ if( pVOpt->GetZoom() != nZoomFactor || pVOpt->GetZoomType() != eZoom )
+ SetZoom( eZoom, nZoomFactor);
+
+ m_pWrtShell->LockView( true );
+ m_pWrtShell->EndAction();
+ m_pWrtShell->LockView( false );
+ m_pWrtShell->EnableSmooth( true );
+}
+
+void SwView::ReadUserDataSequence ( const uno::Sequence < beans::PropertyValue >& rSequence )
+{
+ if(GetDocShell()->IsPreview()||m_bIsPreviewDoubleClick)
+ return;
+ bool bIsOwnDocument = lcl_IsOwnDocument( *this );
+
+ CurrShell aCurr(m_pWrtShell.get());
+ const SwRect& rRect = m_pWrtShell->GetCharRect();
+ const tools::Rectangle &rVis = GetVisArea();
+ const SwViewOption* pVOpt = m_pWrtShell->GetViewOptions();
+
+ sal_Int64 nX = rRect.Left(), nY = rRect.Top(), nLeft = rVis.Left(), nTop = rVis.Top();
+ sal_Int16 nZoomType = static_cast< sal_Int16 >(pVOpt->GetZoomType());
+ sal_Int16 nZoomFactor = static_cast < sal_Int16 > (pVOpt->GetZoom());
+ bool bViewLayoutBookMode = pVOpt->IsViewLayoutBookMode();
+ sal_Int16 nViewLayoutColumns = pVOpt->GetViewLayoutColumns();
+
+ bool bSelectedFrame = ( m_pWrtShell->GetSelFrameType() != FrameTypeFlags::NONE ),
+ bGotVisibleLeft = false,
+ bGotVisibleTop = false,
+ bGotZoomType = false,
+ bGotZoomFactor = false, bGotIsSelectedFrame = false,
+ bGotViewLayoutColumns = false, bGotViewLayoutBookMode = false,
+ bBrowseMode = false, bGotBrowseMode = false;
+ bool bKeepRatio = pVOpt->IsKeepRatio();
+ bool bGotKeepRatio = false;
+
+ for (const beans::PropertyValue& rValue : rSequence)
+ {
+ if ( rValue.Name == "ViewLeft" )
+ {
+ rValue.Value >>= nX;
+ nX = o3tl::toTwips(nX, o3tl::Length::mm100);
+ }
+ else if ( rValue.Name == "ViewTop" )
+ {
+ rValue.Value >>= nY;
+ nY = o3tl::toTwips(nY, o3tl::Length::mm100);
+ }
+ else if ( rValue.Name == "VisibleLeft" )
+ {
+ rValue.Value >>= nLeft;
+ nLeft = o3tl::toTwips(nLeft, o3tl::Length::mm100);
+ bGotVisibleLeft = true;
+ }
+ else if ( rValue.Name == "VisibleTop" )
+ {
+ rValue.Value >>= nTop;
+ nTop = o3tl::toTwips(nTop, o3tl::Length::mm100);
+ bGotVisibleTop = true;
+ }
+ else if ( rValue.Name == "ZoomType" )
+ {
+ rValue.Value >>= nZoomType;
+ bGotZoomType = true;
+ }
+ else if ( rValue.Name == "ZoomFactor" )
+ {
+ rValue.Value >>= nZoomFactor;
+ bGotZoomFactor = true;
+ }
+ else if ( rValue.Name == "ViewLayoutColumns" )
+ {
+ rValue.Value >>= nViewLayoutColumns;
+ bGotViewLayoutColumns = true;
+ }
+ else if ( rValue.Name == "ViewLayoutBookMode" )
+ {
+ bViewLayoutBookMode = *o3tl::doAccess<bool>(rValue.Value);
+ bGotViewLayoutBookMode = true;
+ }
+ else if ( rValue.Name == "IsSelectedFrame" )
+ {
+ rValue.Value >>= bSelectedFrame;
+ bGotIsSelectedFrame = true;
+ }
+ else if (rValue.Name == "ShowOnlineLayout")
+ {
+ rValue.Value >>= bBrowseMode;
+ bGotBrowseMode = true;
+ }
+ else if (rValue.Name == "KeepRatio")
+ {
+ rValue.Value >>= bKeepRatio;
+ bGotKeepRatio = true;
+ }
+ // Fallback to common SdrModel processing
+ else
+ GetDocShell()->GetDoc()->getIDocumentDrawModelAccess().GetDrawModel()->ReadUserDataSequenceValue(&rValue);
+ }
+ if (bGotBrowseMode)
+ {
+ // delegate further
+ GetViewImpl()->GetUNOObject_Impl()->getViewSettings()->setPropertyValue("ShowOnlineLayout", uno::Any(bBrowseMode));
+ }
+
+ SelectShell();
+
+ Point aCursorPos( nX, nY );
+
+ m_pWrtShell->EnableSmooth( false );
+
+ SvxZoomType eZoom;
+ if ( !m_pWrtShell->GetViewOptions()->getBrowseMode() )
+ eZoom = static_cast < SvxZoomType > ( nZoomType );
+ else
+ {
+ eZoom = SvxZoomType::PERCENT;
+ }
+ if (bGotIsSelectedFrame)
+ {
+ bool bSelectObj = bSelectedFrame && m_pWrtShell->IsObjSelectable( aCursorPos );
+
+ // set flag value to avoid macro execution.
+ bool bSavedFlagValue = m_pWrtShell->IsMacroExecAllowed();
+ m_pWrtShell->SetMacroExecAllowed( false );
+// os: changed: The user data has to be read if the view is switched back from page preview
+// go to the last editing position when opening own files
+ m_pViewImpl->SetRestorePosition(aCursorPos, bSelectObj);
+ if(m_bOldShellWasPagePreview|| bIsOwnDocument)
+ {
+ m_pWrtShell->SwCursorShell::SetCursor( aCursorPos, !bSelectObj );
+
+ // Update the shell to toggle Header/Footer edit if needed
+ bool bInHeader = true;
+ if ( m_pWrtShell->IsInHeaderFooter( &bInHeader ) )
+ {
+ if ( !bInHeader )
+ {
+ m_pWrtShell->SetShowHeaderFooterSeparator( FrameControlType::Footer, true );
+ m_pWrtShell->SetShowHeaderFooterSeparator( FrameControlType::Header, false );
+ }
+ else
+ {
+ m_pWrtShell->SetShowHeaderFooterSeparator( FrameControlType::Header, true );
+ m_pWrtShell->SetShowHeaderFooterSeparator( FrameControlType::Footer, false );
+ }
+
+ // Force repaint
+ m_pWrtShell->GetWin()->Invalidate();
+ }
+ if ( m_pWrtShell->IsInHeaderFooter() != m_pWrtShell->IsHeaderFooterEdit() )
+ m_pWrtShell->ToggleHeaderFooterEdit();
+
+ if( bSelectObj )
+ {
+ m_pWrtShell->SelectObj( aCursorPos );
+ m_pWrtShell->EnterSelFrameMode( &aCursorPos );
+ }
+ }
+
+ // reset flag value
+ m_pWrtShell->SetMacroExecAllowed( bSavedFlagValue );
+ }
+
+ if (bGotKeepRatio && bKeepRatio != pVOpt->IsKeepRatio())
+ {
+ // Got a custom value, then it makes sense to trigger notifications.
+ SwViewOption aUsrPref(*pVOpt);
+ aUsrPref.SetKeepRatio(bKeepRatio);
+ SW_MOD()->ApplyUsrPref(aUsrPref, this);
+ }
+
+ // Set ViewLayoutSettings
+ const bool bSetViewLayoutSettings = bGotViewLayoutColumns && bGotViewLayoutBookMode &&
+ ( pVOpt->GetViewLayoutColumns() != nViewLayoutColumns || pVOpt->IsViewLayoutBookMode() != bViewLayoutBookMode );
+
+ const bool bSetViewSettings = bGotZoomType && bGotZoomFactor &&
+ ( pVOpt->GetZoom() != nZoomFactor || pVOpt->GetZoomType() != eZoom );
+
+ // In case we have a 'fixed' view layout of 2 or more columns,
+ // we have to apply the view options *before* starting the action.
+ // Otherwise the SetZoom function cannot work correctly, because
+ // the view layout hasn't been calculated.
+ const bool bZoomNeedsViewLayout = bSetViewLayoutSettings &&
+ 1 < nViewLayoutColumns &&
+ bSetViewSettings &&
+ eZoom != SvxZoomType::PERCENT;
+
+ if ( !bZoomNeedsViewLayout )
+ m_pWrtShell->StartAction();
+
+ if ( bSetViewLayoutSettings )
+ SetViewLayout( nViewLayoutColumns, bViewLayoutBookMode, true );
+
+ if ( bZoomNeedsViewLayout )
+ m_pWrtShell->StartAction();
+
+ if ( bSetViewSettings )
+ SetZoom( eZoom, nZoomFactor, true );
+
+// os: changed: The user data has to be read if the view is switched back from page preview
+// go to the last editing position when opening own files
+ if(m_bOldShellWasPagePreview||bIsOwnDocument)
+ {
+ if ( bGotVisibleLeft && bGotVisibleTop )
+ {
+ Point aTopLeft(nLeft, nTop);
+ // make sure the document is still centered
+ const SwTwips lBorder = IsDocumentBorder() ? DOCUMENTBORDER : 2 * DOCUMENTBORDER;
+ SwTwips nEditWidth = GetEditWin().GetOutDev()->GetOutputSize().Width();
+ if(nEditWidth > (m_aDocSz.Width() + lBorder ))
+ aTopLeft.setX( ( m_aDocSz.Width() + lBorder - nEditWidth ) / 2 );
+ else
+ {
+ //check if the values are possible
+ tools::Long nXMax = m_pHScrollbar->GetRangeMax() - m_pHScrollbar->GetVisibleSize();
+ if( aTopLeft.X() > nXMax )
+ aTopLeft.setX( nXMax < 0 ? 0 : nXMax );
+ }
+ SetVisArea( aTopLeft );
+ }
+ }
+
+ m_pWrtShell->LockView( true );
+ m_pWrtShell->EndAction();
+ m_pWrtShell->LockView( false );
+ m_pWrtShell->EnableSmooth( true );
+
+}
+
+void SwView::WriteUserDataSequence ( uno::Sequence < beans::PropertyValue >& rSequence )
+{
+ const SwRect& rRect = m_pWrtShell->GetCharRect();
+ const tools::Rectangle& rVis = GetVisArea();
+
+ std::vector<beans::PropertyValue> aVector;
+
+ sal_uInt16 nViewID( GetViewFrame().GetCurViewId());
+ aVector.push_back(comphelper::makePropertyValue("ViewId", "view" + OUString::number(nViewID)));
+
+ aVector.push_back(comphelper::makePropertyValue("ViewLeft", convertTwipToMm100 ( rRect.Left() )));
+
+ aVector.push_back(comphelper::makePropertyValue("ViewTop", convertTwipToMm100 ( rRect.Top() )));
+
+ auto visibleLeft = convertTwipToMm100 ( rVis.Left() );
+ aVector.push_back(comphelper::makePropertyValue("VisibleLeft", visibleLeft));
+
+ auto visibleTop = convertTwipToMm100 ( rVis.Top() );
+ aVector.push_back(comphelper::makePropertyValue("VisibleTop", visibleTop));
+
+ // We don't read VisibleRight and VisibleBottom anymore, but write them,
+ // because older versions rely on their presence to restore position
+
+ auto visibleRight = rVis.IsWidthEmpty() ? visibleLeft : convertTwipToMm100 ( rVis.Right() );
+ aVector.push_back(comphelper::makePropertyValue("VisibleRight", visibleRight));
+
+ auto visibleBottom = rVis.IsHeightEmpty() ? visibleTop : convertTwipToMm100 ( rVis.Bottom() );
+ aVector.push_back(comphelper::makePropertyValue("VisibleBottom", visibleBottom));
+
+ const sal_Int16 nZoomType = static_cast< sal_Int16 >(m_pWrtShell->GetViewOptions()->GetZoomType());
+ aVector.push_back(comphelper::makePropertyValue("ZoomType", nZoomType));
+
+ const sal_Int16 nViewLayoutColumns = static_cast< sal_Int16 >(m_pWrtShell->GetViewOptions()->GetViewLayoutColumns());
+ aVector.push_back(comphelper::makePropertyValue("ViewLayoutColumns", nViewLayoutColumns));
+
+ aVector.push_back(comphelper::makePropertyValue("ViewLayoutBookMode", m_pWrtShell->GetViewOptions()->IsViewLayoutBookMode()));
+
+ aVector.push_back(comphelper::makePropertyValue("ZoomFactor", static_cast < sal_Int16 > (m_pWrtShell->GetViewOptions()->GetZoom())));
+
+ aVector.push_back(comphelper::makePropertyValue("IsSelectedFrame", FrameTypeFlags::NONE != m_pWrtShell->GetSelFrameType()));
+
+ aVector.push_back(
+ comphelper::makePropertyValue("KeepRatio", m_pWrtShell->GetViewOptions()->IsKeepRatio()));
+
+ rSequence = comphelper::containerToSequence(aVector);
+
+ // Common SdrModel processing
+ GetDocShell()->GetDoc()->getIDocumentDrawModelAccess().GetDrawModel()->WriteUserDataSequence(rSequence);
+}
+
+void SwView::ShowCursor( bool bOn )
+{
+ //don't scroll the cursor into the visible area
+ bool bUnlockView = !m_pWrtShell->IsViewLocked();
+ m_pWrtShell->LockView( true ); //lock visible section
+
+ if( !bOn )
+ m_pWrtShell->HideCursor();
+ else if( !m_pWrtShell->IsFrameSelected() && !m_pWrtShell->IsObjSelected() )
+ m_pWrtShell->ShowCursor();
+
+ if( bUnlockView )
+ m_pWrtShell->LockView( false );
+}
+
+ErrCode SwView::DoVerb(sal_Int32 nVerb)
+{
+ if ( !GetViewFrame().GetFrame().IsInPlace() )
+ {
+ SwWrtShell &rSh = GetWrtShell();
+ const SelectionType nSel = rSh.GetSelectionType();
+ if ( nSel & SelectionType::Ole )
+ rSh.LaunchOLEObj( nVerb );
+ }
+ return ERRCODE_NONE;
+}
+
+// only return true for a text selection
+
+bool SwView::HasSelection( bool bText ) const
+{
+ return bText ? GetWrtShell().SwCursorShell::HasSelection()
+ : GetWrtShell().HasSelection();
+}
+
+OUString SwView::GetSelectionText( bool bCompleteWrds, bool /*bOnlyASample*/ )
+{
+ return GetSelectionTextParam( bCompleteWrds, true );
+}
+
+OUString SwView::GetSelectionTextParam( bool bCompleteWrds, bool bEraseTrail )
+{
+ OUString sReturn;
+ if( bCompleteWrds && !GetWrtShell().HasSelection() )
+ GetWrtShell().SelWrd();
+
+ GetWrtShell().GetSelectedText( sReturn );
+ if( bEraseTrail )
+ sReturn = comphelper::string::stripEnd(sReturn, ' ');
+ return sReturn;
+}
+
+SwGlossaryHdl* SwView::GetGlosHdl()
+{
+ if(!m_pGlosHdl)
+ m_pGlosHdl.reset(new SwGlossaryHdl(GetViewFrame(), m_pWrtShell.get()));
+ return m_pGlosHdl.get();
+}
+
+void SwView::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
+{
+ bool bCallBase = true;
+ if(auto pChangedHint = dynamic_cast<const FmDesignModeChangedHint*>(&rHint))
+ {
+ bool bDesignMode = pChangedHint->GetDesignMode();
+ if (!bDesignMode && GetDrawFuncPtr())
+ {
+ GetDrawFuncPtr()->Deactivate();
+ SetDrawFuncPtr(nullptr);
+ LeaveDrawCreate();
+ AttrChangedNotify(nullptr);
+ }
+ }
+ else
+ {
+ SfxHintId nId = rHint.GetId();
+
+ switch ( nId )
+ {
+ // sub shells will be destroyed by the
+ // dispatcher, if the view frame is dying. Thus, reset member <pShell>.
+ case SfxHintId::Dying:
+ {
+ if ( &rBC == &GetViewFrame() )
+ {
+ ResetSubShell();
+ }
+ }
+ break;
+ case SfxHintId::ModeChanged:
+ {
+ // Modal mode change-over?
+ bool bModal = GetDocShell()->IsInModalMode();
+ m_pHRuler->SetActive( !bModal );
+ m_pVRuler->SetActive( !bModal );
+ }
+
+ [[fallthrough]];
+
+ case SfxHintId::TitleChanged:
+ if ( GetDocShell()->IsReadOnly() != GetWrtShell().GetViewOptions()->IsReadonly() )
+ {
+ SwWrtShell &rSh = GetWrtShell();
+ rSh.SetReadonlyOption( GetDocShell()->IsReadOnly() );
+
+ if ( rSh.GetViewOptions()->IsViewVRuler() )
+ CreateVRuler();
+ else
+ KillVRuler();
+ if ( rSh.GetViewOptions()->IsViewHRuler() )
+ CreateTab();
+ else
+ KillTab();
+ bool bReadonly = GetDocShell()->IsReadOnly();
+ // if document is to be opened in alive-mode then this has to be
+ // regarded while switching from readonly-mode to edit-mode
+ if( !bReadonly )
+ {
+ SwDrawModel * pDrawDoc = GetDocShell()->GetDoc()->getIDocumentDrawModelAccess().GetDrawModel();
+ if (pDrawDoc)
+ {
+ if( !pDrawDoc->GetOpenInDesignMode() )
+ break;// don't touch the design mode
+ }
+ }
+ SfxBoolItem aItem( SID_FM_DESIGN_MODE, !bReadonly);
+ GetDispatcher().ExecuteList(SID_FM_DESIGN_MODE,
+ SfxCallMode::ASYNCHRON, { &aItem });
+ }
+ break;
+
+ case SfxHintId::SwDrawViewsCreated:
+ {
+ bCallBase = false;
+ if ( GetFormShell() )
+ {
+ GetFormShell()->SetView(dynamic_cast<FmFormView*>(GetWrtShell().GetDrawView()));
+ SfxBoolItem aItem( SID_FM_DESIGN_MODE, !GetDocShell()->IsReadOnly());
+ GetDispatcher().ExecuteList(SID_FM_DESIGN_MODE,
+ SfxCallMode::SYNCHRON, { &aItem });
+ }
+ }
+ break;
+ case SfxHintId::RedlineChanged:
+ {
+ static sal_uInt16 const aSlotRedLine[] = {
+ FN_REDLINE_ACCEPT_DIRECT,
+ FN_REDLINE_REJECT_DIRECT,
+ FN_REDLINE_NEXT_CHANGE,
+ FN_REDLINE_PREV_CHANGE,
+ FN_REDLINE_ACCEPT_ALL,
+ FN_REDLINE_REJECT_ALL,
+ 0
+ };
+ GetViewFrame().GetBindings().Invalidate(aSlotRedLine);
+ }
+ break;
+ default: break;
+ }
+ }
+
+ if ( bCallBase )
+ SfxViewShell::Notify(rBC, rHint);
+}
+
+#if defined(_WIN32) || defined UNX
+
+void SwView::ScannerEventHdl()
+{
+ uno::Reference< XScannerManager2 > xScanMgr = SW_MOD()->GetScannerManager();
+ if( xScanMgr.is() )
+ {
+ const ScannerContext aContext( xScanMgr->getAvailableScanners().getConstArray()[ 0 ] );
+ const ScanError eError = xScanMgr->getError( aContext );
+
+ if( ScanError_ScanErrorNone == eError )
+ {
+ const uno::Reference< awt::XBitmap > xBitmap( xScanMgr->getBitmap( aContext ) );
+
+ if( xBitmap.is() )
+ {
+ const BitmapEx aScanBmp( VCLUnoHelper::GetBitmap( xBitmap ) );
+
+ if( !aScanBmp.IsEmpty() )
+ {
+ Graphic aGrf(aScanBmp);
+ m_pWrtShell->InsertGraphic( OUString(), OUString(), aGrf );
+ }
+ }
+ }
+ }
+ SfxBindings& rBind = GetViewFrame().GetBindings();
+ rBind.Invalidate( SID_TWAIN_SELECT );
+ rBind.Invalidate( SID_TWAIN_TRANSFER );
+}
+#endif
+
+void SwView::StopShellTimer()
+{
+ if(m_aTimer.IsActive())
+ {
+ m_aTimer.Stop();
+ if ( m_bAttrChgNotifiedWithRegistrations )
+ {
+ GetViewFrame().GetBindings().LEAVEREGISTRATIONS();
+ m_bAttrChgNotifiedWithRegistrations = false;
+ }
+ SelectShell();
+ m_bAttrChgNotified = false;
+ }
+}
+
+bool SwView::PrepareClose( bool bUI )
+{
+ SfxViewFrame& rVFrame = GetViewFrame();
+ rVFrame.SetChildWindow( SwInputChild::GetChildWindowId(), false );
+ if( rVFrame.GetDispatcher()->IsLocked() )
+ rVFrame.GetDispatcher()->Lock(false);
+
+ if ( m_pFormShell && !m_pFormShell->PrepareClose( bUI ) )
+ {
+ return false;
+ }
+ return SfxViewShell::PrepareClose( bUI );
+}
+
+// status methods for clipboard.
+// Status changes now notified from the clipboard.
+bool SwView::IsPasteAllowed()
+{
+ SotExchangeDest nPasteDestination = SwTransferable::GetSotDestination( *m_pWrtShell );
+ if( m_nLastPasteDestination != nPasteDestination )
+ {
+ TransferableDataHelper aDataHelper(
+ TransferableDataHelper::CreateFromSystemClipboard(
+ &GetEditWin()) );
+ if( aDataHelper.GetXTransferable().is() )
+ {
+ m_bPasteState = SwTransferable::IsPaste( *m_pWrtShell, aDataHelper );
+ m_bPasteSpecialState = SwTransferable::IsPasteSpecial(
+ *m_pWrtShell, aDataHelper );
+ }
+ else
+ m_bPasteState = m_bPasteSpecialState = false;
+
+ if( static_cast<SotExchangeDest>(0xFFFF) == m_nLastPasteDestination ) // the init value
+ m_pViewImpl->AddClipboardListener();
+ m_nLastPasteDestination = nPasteDestination;
+ }
+ return m_bPasteState;
+}
+
+bool SwView::IsPasteSpecialAllowed()
+{
+ if ( m_pFormShell && m_pFormShell->IsActiveControl() )
+ return false;
+
+ SotExchangeDest nPasteDestination = SwTransferable::GetSotDestination( *m_pWrtShell );
+ if( m_nLastPasteDestination != nPasteDestination )
+ {
+ TransferableDataHelper aDataHelper(
+ TransferableDataHelper::CreateFromSystemClipboard(
+ &GetEditWin()) );
+ if( aDataHelper.GetXTransferable().is() )
+ {
+ m_bPasteState = SwTransferable::IsPaste( *m_pWrtShell, aDataHelper );
+ m_bPasteSpecialState = SwTransferable::IsPasteSpecial(
+ *m_pWrtShell, aDataHelper );
+ }
+ else
+ m_bPasteState = m_bPasteSpecialState = false;
+
+ if( static_cast<SotExchangeDest>(0xFFFF) == m_nLastPasteDestination ) // the init value
+ m_pViewImpl->AddClipboardListener();
+ }
+ return m_bPasteSpecialState;
+}
+
+bool SwView::IsPasteSpreadsheet(bool bHasOwnTableCopied)
+{
+ TransferableDataHelper aDataHelper(
+ TransferableDataHelper::CreateFromSystemClipboard(
+ &GetEditWin()) );
+ if( aDataHelper.GetXTransferable().is() )
+ {
+ if (bHasOwnTableCopied && SwTransferable::IsPasteOwnFormat( aDataHelper ))
+ return true;
+ return aDataHelper.HasFormat( SotClipboardFormatId::SYLK ) || aDataHelper.HasFormat( SotClipboardFormatId::SYLK_BIGCAPS );
+ }
+ return false;
+}
+
+void SwView::NotifyDBChanged()
+{
+ GetViewImpl()->GetUNOObject_Impl()->NotifyDBChanged();
+}
+
+// Printing
+
+SfxObjectShellLock SwView::CreateTmpSelectionDoc()
+{
+ SwXTextView *const pTempImpl = GetViewImpl()->GetUNOObject_Impl();
+ return pTempImpl->BuildTmpSelectionDoc();
+}
+
+void SwView::AddTransferable(SwTransferable& rTransferable)
+{
+ GetViewImpl()->AddTransferable(rTransferable);
+}
+
+tools::Rectangle SwView::getLOKVisibleArea() const
+{
+ if (SwViewShell* pVwSh = GetWrtShellPtr())
+ return pVwSh->getLOKVisibleArea();
+ else
+ return tools::Rectangle();
+}
+
+void SwView::flushPendingLOKInvalidateTiles()
+{
+ if (SwWrtShell* pSh = GetWrtShellPtr())
+ pSh->FlushPendingLOKInvalidateTiles();
+}
+
+std::optional<OString> SwView::getLOKPayload(int nType, int nViewId) const
+{
+ if (SwWrtShell* pSh = GetWrtShellPtr())
+ return pSh->getLOKPayload(nType, nViewId);
+ else
+ return std::nullopt;
+}
+
+OUString SwView::GetDataSourceName() const
+{
+ uno::Reference<lang::XMultiServiceFactory> xFactory(GetDocShell()->GetModel(), uno::UNO_QUERY);
+ uno::Reference<beans::XPropertySet> xSettings(
+ xFactory->createInstance("com.sun.star.document.Settings"), uno::UNO_QUERY);
+ OUString sDataSourceName = "";
+ xSettings->getPropertyValue("CurrentDatabaseDataSource") >>= sDataSourceName;
+
+ return sDataSourceName;
+}
+
+bool SwView::IsDataSourceAvailable(const OUString sDataSourceName)
+{
+ uno::Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
+ Reference< XDatabaseContext> xDatabaseContext = DatabaseContext::create(xContext);
+
+ return xDatabaseContext->hasByName(sDataSourceName);
+}
+
+void SwView::BringToAttention(std::vector<basegfx::B2DRange>&& aRanges)
+{
+ m_nBringToAttentionBlinkTimeOutsRemaining = 0;
+ m_aBringToAttentionBlinkTimer.Stop();
+ if (aRanges.empty())
+ m_xBringToAttentionOverlayObject.reset();
+ else
+ {
+ m_xBringToAttentionOverlayObject.reset(
+ new sdr::overlay::OverlaySelection(sdr::overlay::OverlayType::Invert,
+ Color(), std::move(aRanges),
+ true /*unused for Invert type*/));
+ m_nBringToAttentionBlinkTimeOutsRemaining = 4;
+ m_aBringToAttentionBlinkTimer.Start();
+ }
+}
+
+void SwView::BringToAttention(const tools::Rectangle& rRect)
+{
+ std::vector<basegfx::B2DRange> aRanges{ basegfx::B2DRange(rRect.Left(), rRect.Top(),
+ rRect.Right(), rRect.Bottom()) };
+ BringToAttention(std::move(aRanges));
+}
+
+void SwView::BringToAttention(const SwNode* pNode)
+{
+ if (!pNode)
+ return;
+
+ std::vector<basegfx::B2DRange> aRanges;
+ const SwFrame* pFrame;
+ if (pNode->IsContentNode())
+ {
+ pFrame = pNode->GetContentNode()->getLayoutFrame(GetWrtShell().GetLayout());
+ }
+ else
+ {
+ // section and table nodes
+ SwNode2Layout aTmp(*pNode, pNode->GetIndex() - 1);
+ pFrame = aTmp.NextFrame();
+ }
+ while (pFrame)
+ {
+ const SwRect& rFrameRect = pFrame->getFrameArea();
+ if (!rFrameRect.IsEmpty())
+ aRanges.emplace_back(rFrameRect.Left(), rFrameRect.Top() + pFrame->GetTopMargin(),
+ rFrameRect.Right(), rFrameRect.Bottom());
+ if (!pFrame->IsFlowFrame())
+ break;
+ const SwFlowFrame* pFollow = SwFlowFrame::CastFlowFrame(pFrame)->GetFollow();
+ if (!pFollow)
+ break;
+ pFrame = &pFollow->GetFrame();
+ }
+ BringToAttention(std::move(aRanges));
+}
+
+IMPL_LINK_NOARG(SwView, BringToAttentionBlinkTimerHdl, Timer*, void)
+{
+ if (GetDrawView() && m_xBringToAttentionOverlayObject)
+ {
+ if (SdrView* pView = GetDrawView())
+ {
+ if (SdrPaintWindow* pPaintWindow = pView->GetPaintWindow(0))
+ {
+ const rtl::Reference<sdr::overlay::OverlayManager>& xOverlayManager
+ = pPaintWindow->GetOverlayManager();
+ if (m_nBringToAttentionBlinkTimeOutsRemaining % 2 == 0)
+ xOverlayManager->add(*m_xBringToAttentionOverlayObject);
+ else
+ xOverlayManager->remove(*m_xBringToAttentionOverlayObject);
+ --m_nBringToAttentionBlinkTimeOutsRemaining;
+ }
+ else
+ m_nBringToAttentionBlinkTimeOutsRemaining = 0;
+ }
+ else
+ m_nBringToAttentionBlinkTimeOutsRemaining = 0;
+ }
+ else
+ m_nBringToAttentionBlinkTimeOutsRemaining = 0;
+ if (m_nBringToAttentionBlinkTimeOutsRemaining == 0)
+ {
+ m_xBringToAttentionOverlayObject.reset();
+ m_aBringToAttentionBlinkTimer.Stop();
+ }
+}
+
+namespace sw {
+
+void InitPrintOptionsFromApplication(SwPrintData & o_rData, bool const bWeb)
+{
+ o_rData = *SW_MOD()->GetPrtOptions(bWeb);
+}
+
+} // namespace sw
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/view0.cxx b/sw/source/uibase/uiview/view0.cxx
new file mode 100644
index 0000000000..66d8c66597
--- /dev/null
+++ b/sw/source/uibase/uiview/view0.cxx
@@ -0,0 +1,770 @@
+/* -*- 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_wasm_strip.h>
+
+#include <SwSpellDialogChildWindow.hxx>
+#include <svl/eitem.hxx>
+#include <unotools/configmgr.hxx>
+#include <unotools/linguprops.hxx>
+#include <unotools/lingucfg.hxx>
+#include <officecfg/Office/Common.hxx>
+#include <viewopt.hxx>
+#include <globals.h>
+#include <sfx2/infobar.hxx>
+#include <sfx2/request.hxx>
+#include <svl/whiter.hxx>
+#include <svx/srchdlg.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/sidebar/SidebarChildWindow.hxx>
+#include <uivwimp.hxx>
+#include <avmedia/mediaplayer.hxx>
+#include <swmodule.hxx>
+#include <com/sun/star/linguistic2/XLinguProperties.hpp>
+#include <osl/diagnose.h>
+
+#include <sfx2/objface.hxx>
+#include <wrtsh.hxx>
+#include <edtwin.hxx>
+#include <view.hxx>
+#include <docsh.hxx>
+#include <doc.hxx>
+#include <globals.hrc>
+#include <cmdid.h>
+#include <globdoc.hxx>
+#include <wview.hxx>
+#include <OnlineAccessibilityCheck.hxx>
+
+#define ShellClass_SwView
+#define ShellClass_Text
+#define ShellClass_TextDrawText
+
+#include <sfx2/msg.hxx>
+#include <swslots.hxx>
+#include <PostItMgr.hxx>
+
+#include <unotools/moduleoptions.hxx>
+#include <sfx2/viewfac.hxx>
+
+#include <memory>
+#include <swabstdlg.hxx>
+
+using namespace ::com::sun::star;
+
+SFX_IMPL_NAMED_VIEWFACTORY(SwView, "Default")
+{
+ if (utl::ConfigManager::IsFuzzing() || SvtModuleOptions().IsWriter())
+ {
+ SFX_VIEW_REGISTRATION(SwDocShell);
+ SFX_VIEW_REGISTRATION(SwGlobalDocShell);
+ }
+}
+
+SFX_IMPL_INTERFACE(SwView, SfxViewShell)
+
+void SwView::InitInterface_Impl()
+{
+ GetStaticInterface()->RegisterChildWindow(SID_NAVIGATOR, true);
+
+ GetStaticInterface()->RegisterChildWindow(::sfx2::sidebar::SidebarChildWindow::GetChildWindowId());
+
+ GetStaticInterface()->RegisterChildWindow(SfxInfoBarContainerChild::GetChildWindowId());
+ GetStaticInterface()->RegisterChildWindow(SvxSearchDialogWrapper::GetChildWindowId());
+ GetStaticInterface()->RegisterChildWindow(SwSpellDialogChildWindow::GetChildWindowId());
+ GetStaticInterface()->RegisterChildWindow(FN_REDLINE_ACCEPT);
+ GetStaticInterface()->RegisterChildWindow(SID_HYPERLINK_DIALOG);
+ GetStaticInterface()->RegisterChildWindow(FN_WORDCOUNT_DIALOG);
+#if HAVE_FEATURE_AVMEDIA
+ GetStaticInterface()->RegisterChildWindow(::avmedia::MediaPlayer::GetChildWindowId());
+#endif
+ GetStaticInterface()->RegisterChildWindow(FN_INSERT_FIELD_DATA_ONLY);
+
+ GetStaticInterface()->RegisterChildWindow(FN_SYNC_LABELS, false, SfxShellFeature::SwChildWindowLabel);
+
+ GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_TOOLS, SfxVisibilityFlags::Standard|SfxVisibilityFlags::Server,
+ ToolbarId::Tools_Toolbox);
+}
+
+
+ShellMode SwView::GetShellMode() const
+{
+ return m_pViewImpl->GetShellMode();
+}
+
+view::XSelectionSupplier* SwView::GetUNOObject()
+{
+ return m_pViewImpl->GetUNOObject();
+}
+
+void SwView::ApplyAccessibilityOptions()
+{
+#if ENABLE_WASM_STRIP_ACCESSIBILITY
+#else
+ m_pWrtShell->ApplyAccessibilityOptions();
+ //to enable the right state of the selection cursor in readonly documents
+ if(GetDocShell()->IsReadOnly())
+ m_pWrtShell->ShowCursor();
+#endif
+}
+
+void SwView::SetMailMergeConfigItem(std::shared_ptr<SwMailMergeConfigItem> const & rConfigItem)
+{
+ m_pViewImpl->SetMailMergeConfigItem(rConfigItem);
+ UIFeatureChanged();
+}
+
+std::shared_ptr<SwMailMergeConfigItem> const & SwView::GetMailMergeConfigItem() const
+{
+ return m_pViewImpl->GetMailMergeConfigItem();
+}
+
+static bool lcl_IsViewMarks( const SwViewOption& rVOpt )
+{
+ return rVOpt.IsHardBlank() &&
+ rVOpt.IsSoftHyph() &&
+ rVOpt.IsFieldShadings();
+}
+static void lcl_SetViewMarks(SwViewOption& rVOpt, bool bOn )
+{
+ rVOpt.SetHardBlank(bOn);
+ rVOpt.SetSoftHyph(bOn);
+ rVOpt.SetAppearanceFlag(
+ ViewOptFlags::FieldShadings, bOn, true);
+}
+
+static void lcl_SetViewMetaChars( SwViewOption& rVOpt, bool bOn)
+{
+ rVOpt.SetViewMetaChars( bOn );
+ if(bOn && !(rVOpt.IsParagraph() ||
+ rVOpt.IsTab() ||
+ rVOpt.IsLineBreak() ||
+ rVOpt.IsShowHiddenChar() ||
+ rVOpt.IsShowBookmarks() ||
+ rVOpt.IsBlank()))
+ {
+ rVOpt.SetParagraph(bOn);
+ rVOpt.SetTab(bOn);
+ rVOpt.SetLineBreak(bOn);
+ rVOpt.SetBlank(bOn);
+ rVOpt.SetShowHiddenChar(bOn);
+ rVOpt.SetShowBookmarks(bOn);
+ }
+}
+
+void SwView::RecheckBrowseMode()
+{
+ // OS: pay attention to numerical order!
+ static sal_uInt16 const aInva[] =
+ {
+ //SID_NEWWINDOW,/*5620*/
+ SID_BROWSER_MODE, /*6313*/
+ SID_RULER_BORDERS, SID_RULER_PAGE_POS,
+ //SID_ATTR_LONG_LRSPACE,
+ SID_HTML_MODE,
+ SID_RULER_PROTECT, /* 10915 */
+ //SID_AUTOSPELL_CHECK,
+ //SID_AUTOSPELL_MARKOFF,
+ SID_TOGGLE_RESOLVED_NOTES, /* 11672*/
+ FN_RULER, /*20211*/
+ FN_VIEW_GRAPHIC, /*20213*/
+ FN_VIEW_BOUNDS, /**/
+ FN_VIEW_FIELDS, /*20215*/
+ FN_VLINEAL, /*20216*/
+ FN_VSCROLLBAR, /*20217*/
+ FN_HSCROLLBAR, /*20218*/
+ FN_VIEW_SECTION_BOUNDARIES, /*20219*/
+ FN_VIEW_META_CHARS, /**/
+ FN_VIEW_MARKS, /**/
+ //FN_VIEW_FIELDNAME, /**/
+ FN_VIEW_TABLEGRID, /*20227*/
+ FN_PRINT_LAYOUT, /*20237*/
+ FN_QRY_MERGE, /*20364*/
+ FN_SHADOWCURSOR, /**/
+ 0
+ };
+ // the view must not exist!
+ GetViewFrame().GetBindings().Invalidate(aInva);
+ CheckVisArea();
+
+ SvxZoomType eType;
+ if( GetWrtShell().GetViewOptions()->getBrowseMode() && SvxZoomType::PERCENT != (eType =
+ GetWrtShell().GetViewOptions()->GetZoomType()) )
+ SetZoom( eType );
+ InvalidateBorder();
+}
+
+// State of view options
+
+void SwView::StateViewOptions(SfxItemSet &rSet)
+{
+ SfxWhichIter aIter(rSet);
+ sal_uInt16 nWhich = aIter.FirstWhich();
+ SfxBoolItem aBool;
+ const SwViewOption* pOpt = GetWrtShell().GetViewOptions();
+
+ while(nWhich)
+ {
+ bool bReadonly = GetDocShell()->IsReadOnly();
+ if (bReadonly && nWhich != FN_VIEW_GRAPHIC && nWhich != FN_HIGHLIGHT_CHAR_DF)
+ {
+ rSet.DisableItem(nWhich);
+ nWhich = 0;
+ }
+ switch(nWhich)
+ {
+ case FN_RULER:
+ {
+ if(!pOpt->IsViewHRuler(true) && !pOpt->IsViewVRuler(true))
+ {
+ rSet.DisableItem(nWhich);
+ nWhich = 0;
+ }
+ else
+ aBool.SetValue( pOpt->IsViewAnyRuler());
+ }
+ break;
+ case SID_BROWSER_MODE:
+ case FN_PRINT_LAYOUT:
+ {
+ bool bState = pOpt->getBrowseMode();
+ if(FN_PRINT_LAYOUT == nWhich)
+ bState = !bState;
+ aBool.SetValue( bState );
+ }
+ break;
+ case FN_VIEW_BOUNDS:
+ aBool.SetValue( pOpt->IsDocBoundaries()); break;
+ case FN_VIEW_SECTION_BOUNDARIES:
+ aBool.SetValue(pOpt->IsSectionBoundaries()); break;
+ case FN_VIEW_GRAPHIC:
+ aBool.SetValue( pOpt->IsGraphic() ); break;
+ case FN_VIEW_FIELDS:
+ aBool.SetValue( pOpt->IsFieldShadings() ); break;
+ case FN_VIEW_FIELDNAME:
+ aBool.SetValue( pOpt->IsFieldName() ); break;
+ case FN_VIEW_MARKS:
+ aBool.SetValue( lcl_IsViewMarks(*pOpt) ); break;
+ case FN_VIEW_META_CHARS:
+ aBool.SetValue( pOpt->IsViewMetaChars() ); break;
+ case FN_VIEW_TABLEGRID:
+ aBool.SetValue( pOpt->IsTableBoundaries() ); break;
+ case SID_TOGGLE_NOTES:
+ {
+ if (!GetPostItMgr()->HasNotes())
+ {
+ rSet.DisableItem(nWhich);
+ nWhich = 0;
+ }
+ else
+ aBool.SetValue( pOpt->IsPostIts());
+ break;
+ }
+ case SID_TOGGLE_RESOLVED_NOTES:
+ {
+ if (!GetPostItMgr()->HasNotes())
+ {
+ rSet.DisableItem(nWhich);
+ nWhich = 0;
+ }
+ else
+ aBool.SetValue( pOpt->IsResolvedPostIts());
+ break;
+ }
+ case FN_VIEW_HIDDEN_PARA:
+ aBool.SetValue( pOpt->IsShowHiddenPara()); break;
+ case FN_VIEW_HIDE_WHITESPACE:
+ {
+ if (pOpt->getBrowseMode() || !pOpt->CanHideWhitespace())
+ {
+ rSet.DisableItem(nWhich);
+ nWhich = 0;
+ }
+ else
+ aBool.SetValue(pOpt->IsHideWhitespaceMode());
+ break;
+ }
+ case FN_VIEW_SHOW_WHITESPACE:
+ {
+ aBool.SetValue(!pOpt->IsHideWhitespaceMode());
+ break;
+ }
+ case SID_GRID_VISIBLE:
+ aBool.SetValue( pOpt->IsGridVisible() ); break;
+ case SID_GRID_USE:
+ aBool.SetValue( pOpt->IsSnap() ); break;
+ case SID_HELPLINES_MOVE:
+ aBool.SetValue( pOpt->IsCrossHair() ); break;
+ case FN_VIEW_SMOOTH_SCROLL:
+ aBool.SetValue( pOpt->IsSmoothScroll()); break;
+ case FN_VLINEAL:
+ aBool.SetValue( StatVRuler() ); break;
+ case FN_HSCROLLBAR:
+ if( pOpt->getBrowseMode() )
+ {
+ rSet.DisableItem(nWhich);
+ nWhich = 0;
+ }
+ else
+ aBool.SetValue( IsHScrollbarVisible() );
+ break;
+ case FN_VSCROLLBAR:
+ aBool.SetValue( IsVScrollbarVisible() ); break;
+ case SID_AUTOSPELL_CHECK:
+ aBool.SetValue( pOpt->IsOnlineSpell() );
+ break;
+ case SID_ACCESSIBILITY_CHECK_ONLINE:
+ {
+ bool bOnlineAccessibilityCheck = officecfg::Office::Common::Accessibility::OnlineAccessibilityCheck::get();
+ aBool.SetValue(bOnlineAccessibilityCheck);
+ }
+ break;
+ case FN_SHADOWCURSOR:
+ if ( pOpt->getBrowseMode() )
+ {
+ rSet.DisableItem( nWhich );
+ nWhich = 0;
+ }
+ else
+ aBool.SetValue( pOpt->IsShadowCursor() );
+ break;
+ case FN_SHOW_INLINETOOLTIPS:
+ aBool.SetValue( pOpt->IsShowInlineTooltips() );
+ break;
+ case FN_USE_HEADERFOOTERMENU:
+ aBool.SetValue( pOpt->IsUseHeaderFooterMenu() );
+ break;
+ case FN_SHOW_OUTLINECONTENTVISIBILITYBUTTON:
+ aBool.SetValue( pOpt->IsShowOutlineContentVisibilityButton() );
+ break;
+ case FN_SHOW_CHANGES_IN_MARGIN:
+ aBool.SetValue( pOpt->IsShowChangesInMargin() );
+ break;
+ case FN_HIGHLIGHT_CHAR_DF:
+ aBool.SetValue(m_bIsHighlightCharDF);
+ break;
+ case SID_SPOTLIGHT_PARASTYLES:
+ aBool.SetValue(m_bIsSpotlightParaStyles);
+ break;
+ case SID_SPOTLIGHT_CHARSTYLES:
+ aBool.SetValue(m_bIsSpotlightCharStyles);
+ break;
+ }
+
+ if( nWhich )
+ {
+ aBool.SetWhich( nWhich );
+ rSet.Put( aBool );
+ }
+ nWhich = aIter.NextWhich();
+ }
+}
+
+// execute view options
+
+void SwView::ExecViewOptions(SfxRequest &rReq)
+{
+ std::optional<SwViewOption> pOpt( *GetWrtShell().GetViewOptions() );
+ bool bModified = GetWrtShell().IsModified();
+
+ int eState = STATE_TOGGLE;
+ bool bSet = false;
+ bool bBrowseModeChanged = false;
+
+ const SfxItemSet *pArgs = rReq.GetArgs();
+ sal_uInt16 nSlot = rReq.GetSlot();
+ const SfxPoolItem* pAttr=nullptr;
+
+ if( pArgs && SfxItemState::SET == pArgs->GetItemState( nSlot , false, &pAttr ))
+ {
+ bSet = static_cast<const SfxBoolItem*>(pAttr)->GetValue();
+ eState = bSet ? STATE_ON : STATE_OFF;
+ }
+
+ bool bFlag = STATE_ON == eState;
+ uno::Reference< linguistic2::XLinguProperties > xLngProp( ::GetLinguPropertySet() );
+
+ switch ( nSlot )
+ {
+ case FN_VIEW_GRAPHIC:
+ if( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsGraphic();
+ pOpt->SetGraphic( bFlag );
+ break;
+
+ case FN_VIEW_FIELDS:
+ if( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsFieldShadings() ;
+ pOpt->SetAppearanceFlag(ViewOptFlags::FieldShadings, bFlag, true );
+ break;
+
+ case FN_VIEW_BOUNDS:
+ if( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsDocBoundaries();
+ pOpt->SetAppearanceFlag(ViewOptFlags::DocBoundaries, bFlag, true );
+ break;
+
+ case FN_VIEW_SECTION_BOUNDARIES:
+ if( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsSectionBoundaries();
+ pOpt->SetAppearanceFlag(ViewOptFlags::SectionBoundaries, bFlag, true );
+ break;
+
+ case SID_GRID_VISIBLE:
+ if( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsGridVisible();
+
+ pOpt->SetGridVisible( bFlag );
+ break;
+
+ case SID_GRID_USE:
+ if( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsSnap();
+
+ pOpt->SetSnap( bFlag );
+ break;
+
+ case SID_HELPLINES_MOVE:
+ if( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsCrossHair();
+
+ pOpt->SetCrossHair( bFlag );
+ break;
+
+ case SID_BROWSER_MODE:
+ bBrowseModeChanged = !pOpt->getBrowseMode();
+ pOpt->setBrowseMode(true );
+ break;
+
+ case FN_PRINT_LAYOUT:
+ bBrowseModeChanged = pOpt->getBrowseMode();
+ pOpt->setBrowseMode( false );
+ break;
+
+ case SID_TOGGLE_NOTES:
+ if ( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsPostIts();
+
+ GetPostItMgr()->SetLayout();
+ pOpt->SetPostIts( bFlag );
+ if (pOpt->IsPostIts())
+ GetPostItMgr()->CheckMetaText();
+ break;
+
+ case SID_TOGGLE_RESOLVED_NOTES:
+ if ( STATE_TOGGLE == eState )
+ bFlag = pOpt->IsResolvedPostIts();
+
+ GetPostItMgr()->ShowHideResolvedNotes(!bFlag);
+
+ GetPostItMgr()->SetLayout();
+ pOpt->SetResolvedPostIts( !bFlag );
+
+ break;
+
+ case FN_VIEW_HIDDEN_PARA:
+ if ( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsShowHiddenPara();
+
+ pOpt->SetShowHiddenPara( bFlag );
+ break;
+
+ case FN_VIEW_HIDE_WHITESPACE:
+ if ( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsHideWhitespaceMode();
+
+ pOpt->SetHideWhitespaceMode(bFlag);
+ break;
+
+ case FN_VIEW_SHOW_WHITESPACE:
+ if ( STATE_TOGGLE == eState )
+ bFlag = pOpt->IsHideWhitespaceMode();
+
+ pOpt->SetHideWhitespaceMode(!bFlag);
+ break;
+
+ case FN_VIEW_SMOOTH_SCROLL:
+
+ if ( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsSmoothScroll();
+
+ pOpt->SetSmoothScroll( bFlag );
+ break;
+
+ case FN_VLINEAL:
+ if( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsViewVRuler();
+
+ pOpt->SetViewVRuler( bFlag );
+ break;
+
+ case FN_VSCROLLBAR:
+ if( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsViewVScrollBar();
+
+ pOpt->SetViewVScrollBar( bFlag );
+ break;
+
+ case FN_HSCROLLBAR:
+ if( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsViewHScrollBar();
+
+ pOpt->SetViewHScrollBar( bFlag );
+ break;
+
+ case FN_RULER:
+ if( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsViewAnyRuler();
+
+ pOpt->SetViewAnyRuler( bFlag );
+ break;
+
+ case FN_VIEW_TABLEGRID:
+ if( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsTableBoundaries();
+ pOpt->SetAppearanceFlag(ViewOptFlags::TableBoundaries, bFlag, true );
+ break;
+
+ case FN_VIEW_FIELDNAME:
+ if( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsFieldName() ;
+
+ pOpt->SetFieldName( bFlag );
+ break;
+
+ case FN_VIEW_MARKS:
+ if( STATE_TOGGLE == eState )
+ bFlag = !lcl_IsViewMarks(*pOpt) ;
+
+ lcl_SetViewMarks( *pOpt, bFlag );
+ break;
+
+ case FN_HIGHLIGHT_CHAR_DF:
+ if (STATE_TOGGLE == eState)
+ bFlag = !m_bIsHighlightCharDF;
+ m_bIsHighlightCharDF = bFlag;
+ break;
+
+ case SID_SPOTLIGHT_PARASTYLES:
+ if (!pArgs || (pArgs && !pArgs->HasItem(FN_PARAM_1)))
+ {
+ const SfxStringItem sDeckName(SID_SIDEBAR_DECK, "StyleListDeck");
+ GetDispatcher().ExecuteList(SID_SIDEBAR_DECK, SfxCallMode::SYNCHRON, { &sDeckName });
+ }
+ if (STATE_TOGGLE == eState)
+ bFlag = !m_bIsSpotlightParaStyles;
+ m_bIsSpotlightParaStyles = bFlag;
+ break;
+
+ case SID_SPOTLIGHT_CHARSTYLES:
+ if (!pArgs || (pArgs && !pArgs->HasItem(FN_PARAM_1)))
+ {
+ const SfxStringItem sDeckName(SID_SIDEBAR_DECK, "StyleListDeck");
+ GetDispatcher().ExecuteList(SID_SIDEBAR_DECK, SfxCallMode::SYNCHRON, { &sDeckName });
+ }
+ if (STATE_TOGGLE == eState)
+ bFlag = !m_bIsSpotlightCharStyles;
+ m_bIsSpotlightCharStyles = bFlag;
+ break;
+
+ case FN_VIEW_META_CHARS:
+ if( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsViewMetaChars();
+
+ lcl_SetViewMetaChars( *pOpt, bFlag );
+ break;
+
+ case SID_AUTOSPELL_CHECK:
+ const SfxPoolItem* pItem;
+
+ if (pArgs && pArgs->HasItem(FN_PARAM_1, &pItem))
+ bSet = static_cast<const SfxBoolItem*>(pItem)->GetValue();
+ else if( STATE_TOGGLE == eState )
+ {
+ bFlag = !pOpt->IsOnlineSpell();
+ bSet = bFlag;
+ }
+
+ pOpt->SetOnlineSpell(bSet);
+ {
+ SvtLinguConfig aCfg;
+ aCfg.SetProperty( UPN_IS_SPELL_AUTO, uno::Any( bSet ) );
+
+ if (xLngProp.is())
+ xLngProp->setIsSpellAuto( bSet );
+
+ // for the time being we do not have a specific option for grammarchecking.
+ // thus we'll use the one for spell checking...
+ if (bSet)
+ {
+ SwDocShell *pDocSh = GetDocShell();
+ SwDoc *pDoc = pDocSh? pDocSh->GetDoc() : nullptr;
+
+ // right now we don't have view options for automatic grammar checking. Thus...
+ bool bIsAutoGrammar = false;
+ aCfg.GetProperty( UPN_IS_GRAMMAR_AUTO ) >>= bIsAutoGrammar;
+
+ if (pDoc && bIsAutoGrammar)
+ pDoc->StartGrammarChecking();
+ }
+ }
+ break;
+
+ case SID_ACCESSIBILITY_CHECK_ONLINE:
+ {
+ if (pArgs && pArgs->HasItem(FN_PARAM_1, &pItem))
+ {
+ bSet = static_cast<const SfxBoolItem*>(pItem)->GetValue();
+ }
+ else if (STATE_TOGGLE == eState)
+ {
+ bool bOnlineCheck = officecfg::Office::Common::Accessibility::OnlineAccessibilityCheck::get();
+ bSet = !bOnlineCheck;
+ }
+ std::shared_ptr<comphelper::ConfigurationChanges> batch(comphelper::ConfigurationChanges::create());
+ officecfg::Office::Common::Accessibility::OnlineAccessibilityCheck::set(bSet, batch);
+ batch->commit();
+
+ SwDocShell *pDocSh = GetDocShell();
+ SwDoc* pDocument = pDocSh? pDocSh->GetDoc() : nullptr;
+ if (pDocument)
+ pDocument->getOnlineAccessibilityCheck()->updateCheckerActivity();
+ }
+ break;
+
+ case FN_SHADOWCURSOR:
+ if( STATE_TOGGLE == eState )
+ {
+ bFlag = !pOpt->IsShadowCursor();
+ bSet = bFlag;
+ }
+
+ pOpt->SetShadowCursor(bSet);
+ break;
+
+ case FN_SHOW_INLINETOOLTIPS:
+ if( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsShowInlineTooltips();
+
+ pOpt->SetShowInlineTooltips( bFlag );
+ break;
+
+ case FN_USE_HEADERFOOTERMENU:
+ if( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsUseHeaderFooterMenu();
+
+ pOpt->SetUseHeaderFooterMenu( bFlag );
+ break;
+
+ case FN_SHOW_OUTLINECONTENTVISIBILITYBUTTON:
+ {
+ if( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsShowOutlineContentVisibilityButton();
+
+ SwWrtShell &rSh = GetWrtShell();
+
+ if (!bFlag) // Outline folding is being turned ON!
+ rSh.MakeAllFoldedOutlineContentVisible();
+
+ pOpt->SetShowOutlineContentVisibilityButton(bFlag);
+
+ // Apply option change here so if toggling the outline folding feature ON
+ // the invalidate function will see this.
+ rSh.StartAction();
+ rSh.ApplyViewOptions(*pOpt);
+ rSh.EndAction();
+
+ if (bFlag) // Outline folding is being turned OFF!
+ rSh.MakeAllFoldedOutlineContentVisible(false);
+
+ break;
+ }
+
+ case FN_SHOW_CHANGES_IN_MARGIN:
+ if( STATE_TOGGLE == eState )
+ bFlag = !pOpt->IsShowChangesInMargin();
+
+ pOpt->SetShowChangesInMargin( bFlag );
+ break;
+
+ default:
+ OSL_FAIL("wrong request method");
+ return;
+ }
+
+ // Set UserPrefs, mark request as modified
+ bool bWebView = dynamic_cast<const SwWebView*>(this) != nullptr;
+ SwWrtShell &rSh = GetWrtShell();
+ rSh.StartAction();
+ SwModule* pModule = SW_MOD();
+ if( *rSh.GetViewOptions() != *pOpt )
+ {
+ rSh.ApplyViewOptions( *pOpt );
+ if( bBrowseModeChanged )
+ {
+ GetDocShell()->ToggleLayoutMode(this);
+ }
+
+ // The UsrPref must be marked as modified.
+ // call for initialization
+ pModule->GetUsrPref(bWebView);
+ SwModule::CheckSpellChanges( pOpt->IsOnlineSpell(), false, false, false );
+ }
+ //OS: Set back modified again, because view/fields sets the Doc modified.
+ if( !bModified )
+ rSh.ResetModified();
+
+ pModule->ApplyUsrPref( *pOpt, this, bWebView ? SvViewOpt::DestWeb : SvViewOpt::DestText );
+
+ // #i6193# let postits know about new spellcheck setting
+ if ( nSlot == SID_AUTOSPELL_CHECK )
+ GetPostItMgr()->SetSpellChecking();
+
+ const bool bLockedView = rSh.IsViewLocked();
+ rSh.LockView( true ); //lock visible section
+ GetWrtShell().EndAction();
+ if( bBrowseModeChanged && !bFlag )
+ CalcVisArea( GetEditWin().GetOutputSizePixel() );
+ rSh.LockView( bLockedView );
+
+ pOpt.reset();
+ Invalidate(rReq.GetSlot());
+ if(!pArgs)
+ rReq.AppendItem(SfxBoolItem(nSlot, bFlag));
+ rReq.Done();
+}
+
+void SwView::ExecFormatFootnote()
+{
+ SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
+ ScopedVclPtr<VclAbstractDialog> pDlg(pFact->CreateSwFootNoteOptionDlg(GetFrameWeld(), GetWrtShell()));
+ pDlg->Execute();
+}
+
+void SwView::ExecNumberingOutline(SfxItemPool & rPool)
+{
+ SfxItemSetFixed<FN_PARAM_1, FN_PARAM_1> aTmp(rPool);
+ SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
+ ScopedVclPtr<SfxAbstractTabDialog> pDlg(pFact->CreateOutlineTabDialog(GetFrameWeld(), &aTmp, GetWrtShell()));
+ pDlg->Execute();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/view1.cxx b/sw/source/uibase/uiview/view1.cxx
new file mode 100644
index 0000000000..ca51ceba98
--- /dev/null
+++ b/sw/source/uibase/uiview/view1.cxx
@@ -0,0 +1,213 @@
+/* -*- 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 <svl/eitem.hxx>
+#include <svx/ruler.hxx>
+#include <idxmrk.hxx>
+#include <view.hxx>
+#include <basesh.hxx>
+#include <wrtsh.hxx>
+#include <swmodule.hxx>
+#include <docsh.hxx>
+#include <fldwrap.hxx>
+#include <redlndlg.hxx>
+#include <edtwin.hxx>
+#include <formatclipboard.hxx>
+#include <cmdid.h>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/request.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <wordcountdialog.hxx>
+
+void SwView::Activate(bool bMDIActivate)
+{
+ // fdo#40438 Update the layout to make sure everything is correct before showing the content
+ m_pWrtShell->StartAction();
+ m_pWrtShell->EndAction( true );
+
+ // Register the current View at the DocShell.
+ // The view remains active at the DocShell until it will
+ // be destroyed or by Activate a new one will be set.
+ SwDocShell* pDocSh = GetDocShell();
+ if(pDocSh)
+ pDocSh->SetView(this);
+ SwModule* pSwMod = SW_MOD();
+ pSwMod->SetView(this);
+
+ // Document size has changed.
+ if(!bDocSzUpdated)
+ DocSzChgd(m_aDocSz);
+
+ // make selection visible
+ if(m_bMakeSelectionVisible)
+ {
+ m_pWrtShell->MakeSelVisible();
+ m_bMakeSelectionVisible = false;
+ }
+ m_pHRuler->SetActive();
+ m_pVRuler->SetActive();
+
+ if ( bMDIActivate )
+ {
+ if ( m_pShell )
+ {
+ SfxDispatcher &rDispatcher = GetDispatcher();
+ SfxShell *pTopShell = rDispatcher.GetShell( 0 );
+
+ // this SwView is the top-most shell on the stack
+ if ( pTopShell == this )
+ {
+ for ( sal_uInt16 i = 1; true; ++i )
+ {
+ SfxShell *pSfxShell = rDispatcher.GetShell( i );
+ // does the stack contain any shells spawned by this SwView already?
+ if ( ( dynamic_cast< const SwBaseShell *>( pSfxShell ) != nullptr
+ || dynamic_cast< const FmFormShell *>( pSfxShell ) != nullptr )
+ && ( pSfxShell->GetViewShell() == this ) )
+ {
+ // it shouldn't b/c we haven't been activated yet
+ // so assert that 'cause it'll crash during dispose at the latest
+ assert( pSfxShell && "Corrupted shell stack: dependent shell positioned below its view");
+ }
+ else
+ break;
+ }
+ }
+ }
+
+ m_pWrtShell->ShellGetFocus(); // Selections visible
+
+ if( !m_sSwViewData.isEmpty() )
+ {
+ ReadUserData(m_sSwViewData);
+ m_sSwViewData.clear();
+ }
+
+ AttrChangedNotify(nullptr);
+
+ // Initialize Fielddlg newly if necessary (e.g. for TYP_SETVAR)
+ sal_uInt16 nId = SwFieldDlgWrapper::GetChildWindowId();
+ SfxViewFrame& rVFrame = GetViewFrame();
+ SwFieldDlgWrapper *pWrp = static_cast<SwFieldDlgWrapper*>(rVFrame.GetChildWindow(nId));
+ if (pWrp)
+ pWrp->ReInitDlg(GetDocShell());
+
+ // Initialize RedlineDlg newly if necessary
+ nId = SwRedlineAcceptChild::GetChildWindowId();
+ SwRedlineAcceptChild *pRed = static_cast<SwRedlineAcceptChild*>(rVFrame.GetChildWindow(nId));
+ if (pRed)
+ pRed->ReInitDlg(GetDocShell());
+
+ // reinit IdxMarkDlg
+ nId = SwInsertIdxMarkWrapper::GetChildWindowId();
+ SwInsertIdxMarkWrapper *pIdxMrk = static_cast<SwInsertIdxMarkWrapper*>(rVFrame.GetChildWindow(nId));
+ if (pIdxMrk)
+ pIdxMrk->ReInitDlg(*m_pWrtShell);
+
+ // reinit AuthMarkDlg
+ nId = SwInsertAuthMarkWrapper::GetChildWindowId();
+ SwInsertAuthMarkWrapper *pAuthMrk = static_cast<SwInsertAuthMarkWrapper*>(rVFrame.
+ GetChildWindow(nId));
+ if (pAuthMrk)
+ pAuthMrk->ReInitDlg(*m_pWrtShell);
+ }
+ else
+ // At least call the Notify (as a precaution because of the SlotFilter).
+ AttrChangedNotify(nullptr);
+
+ SfxViewShell::Activate(bMDIActivate);
+}
+
+void SwView::Deactivate(bool bMDIActivate)
+{
+ GetEditWin().FlushInBuffer(); // Flush characters still in the input buffer.
+
+ if( bMDIActivate )
+ {
+ m_pWrtShell->ShellLoseFocus(); // Selections invisible
+
+ m_pHRuler->SetActive( false );
+ m_pVRuler->SetActive( false );
+ }
+ SfxViewShell::Deactivate(bMDIActivate);
+}
+
+void SwView::MarginChanged()
+{
+ GetWrtShell().SetBrowseBorder( GetMargin() );
+}
+
+void SwView::ExecFormatPaintbrush(SfxRequest const & rReq)
+{
+ if(!m_pFormatClipboard)
+ return;
+
+ if( m_pFormatClipboard->HasContent() )
+ {
+ m_pFormatClipboard->Erase();
+
+ SwApplyTemplate aTemplate;
+ GetEditWin().SetApplyTemplate(aTemplate);
+ }
+ else
+ {
+ bool bPersistentCopy = false;
+ const SfxItemSet *pArgs = rReq.GetArgs();
+ if( pArgs && pArgs->Count() >= 1 )
+ {
+ bPersistentCopy = pArgs->Get(SID_FORMATPAINTBRUSH).GetValue();
+ }
+
+ m_pFormatClipboard->Copy( GetWrtShell(), GetPool(), bPersistentCopy );
+
+ SwApplyTemplate aTemplate;
+ aTemplate.m_pFormatClipboard = m_pFormatClipboard.get();
+ GetEditWin().SetApplyTemplate(aTemplate);
+ }
+ GetViewFrame().GetBindings().Invalidate(SID_FORMATPAINTBRUSH);
+}
+
+void SwView::StateFormatPaintbrush(SfxItemSet &rSet)
+{
+ if(!m_pFormatClipboard)
+ return;
+
+ const bool bHasContent = m_pFormatClipboard->HasContent();
+ if( !bHasContent &&
+ !SwFormatClipboard::CanCopyThisType( GetWrtShell().GetSelectionType())
+ )
+ {
+ rSet.DisableItem( SID_FORMATPAINTBRUSH );
+ }
+ else
+ rSet.Put(SfxBoolItem(SID_FORMATPAINTBRUSH, bHasContent));
+}
+
+void SwView::UpdateWordCount(SfxShell* pShell, sal_uInt16 nSlot)
+{
+ SfxViewFrame& rVFrame = GetViewFrame();
+ rVFrame.ToggleChildWindow(FN_WORDCOUNT_DIALOG);
+ pShell->Invalidate(nSlot);
+
+ SwWordCountWrapper *pWrdCnt = static_cast<SwWordCountWrapper*>(rVFrame.GetChildWindow(SwWordCountWrapper::GetChildWindowId()));
+ if (pWrdCnt)
+ pWrdCnt->UpdateCounts();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/view2.cxx b/sw/source/uibase/uiview/view2.cxx
new file mode 100644
index 0000000000..cc6faf78a3
--- /dev/null
+++ b/sw/source/uibase/uiview/view2.cxx
@@ -0,0 +1,3197 @@
+/* -*- 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 <com/sun/star/util/SearchAlgorithms2.hpp>
+#include <o3tl/any.hxx>
+#include <vcl/graphicfilter.hxx>
+#include <com/sun/star/sdb/DatabaseContext.hpp>
+#include <com/sun/star/ui/dialogs/XFilePicker3.hpp>
+#include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp>
+#include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>
+#include <com/sun/star/ui/dialogs/ListboxControlActions.hpp>
+#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
+#include <com/sun/star/linguistic2/XProofreadingIterator.hpp>
+#include <com/sun/star/linguistic2/XDictionary.hpp>
+#include <comphelper/propertyvalue.hxx>
+#include <officecfg/Office/Common.hxx>
+#include <SwCapObjType.hxx>
+#include <SwStyleNameMapper.hxx>
+#include <docary.hxx>
+#include <hintids.hxx>
+#include <SwRewriter.hxx>
+#include <numrule.hxx>
+#include <swundo.hxx>
+#include <svl/PasswordHelper.hxx>
+#include <svl/urihelper.hxx>
+#include <sfx2/passwd.hxx>
+#include <sfx2/sfxdlg.hxx>
+#include <sfx2/filedlghelper.hxx>
+#include <editeng/langitem.hxx>
+#include <svx/linkwarn.hxx>
+#include <svx/statusitem.hxx>
+#include <svx/viewlayoutitem.hxx>
+#include <svx/zoomslideritem.hxx>
+#include <sfx2/htmlmode.hxx>
+#include <vcl/svapp.hxx>
+#include <sfx2/app.hxx>
+#include <sfx2/request.hxx>
+#include <sfx2/bindings.hxx>
+#include <editeng/lrspitem.hxx>
+#include <unotools/localedatawrapper.hxx>
+#include <unotools/syslocale.hxx>
+#include <editeng/unolingu.hxx>
+#include <vcl/weld.hxx>
+#include <editeng/tstpitem.hxx>
+#include <sfx2/event.hxx>
+#include <sfx2/docfile.hxx>
+#include <sfx2/docfilt.hxx>
+#include <sfx2/fcontnr.hxx>
+#include <editeng/sizeitem.hxx>
+#include <sfx2/dispatch.hxx>
+#include <svl/whiter.hxx>
+#include <svl/ptitem.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <vcl/errinf.hxx>
+#include <tools/urlobj.hxx>
+#include <svx/svdview.hxx>
+#include <swtypes.hxx>
+#include <swwait.hxx>
+#include <redlndlg.hxx>
+#include <gotodlg.hxx>
+#include <view.hxx>
+#include <uivwimp.hxx>
+#include <docsh.hxx>
+#include <doc.hxx>
+#include <printdata.hxx>
+#include <IDocumentDeviceAccess.hxx>
+#include <IDocumentRedlineAccess.hxx>
+#include <DocumentRedlineManager.hxx>
+#include <IDocumentUndoRedo.hxx>
+#include <IDocumentSettingAccess.hxx>
+#include <IDocumentDrawModelAccess.hxx>
+#include <IDocumentStatistics.hxx>
+#include <IDocumentOutlineNodes.hxx>
+#include <wrtsh.hxx>
+#include <viewopt.hxx>
+#include <basesh.hxx>
+#include <swmodule.hxx>
+#include <uitool.hxx>
+#include <shellio.hxx>
+#include <fmtinfmt.hxx>
+#include <mdiexp.hxx>
+#include <drawbase.hxx>
+#include <frmatr.hxx>
+#include <frmmgr.hxx>
+#include <pagedesc.hxx>
+#include <section.hxx>
+#include <tox.hxx>
+#include <edtwin.hxx>
+#include <wview.hxx>
+#include <cmdid.h>
+#include <sfx2/strings.hrc>
+#include <sfx2/sfxresid.hxx>
+#include <strings.hrc>
+#include <swerror.h>
+#include <globals.hrc>
+#include <fmtclds.hxx>
+#include <sfx2/templatedlg.hxx>
+#include <dbconfig.hxx>
+#include <dbmgr.hxx>
+#include <reffld.hxx>
+#include <comphelper/lok.hxx>
+#include <comphelper/string.hxx>
+#include <comphelper/docpasswordhelper.hxx>
+#include <svtools/strings.hrc>
+#include <svtools/svtresid.hxx>
+
+#include <PostItMgr.hxx>
+
+#include <comphelper/processfactory.hxx>
+#include <LibreOfficeKit/LibreOfficeKitEnums.h>
+
+#include <svx/svxdlg.hxx>
+#include <swabstdlg.hxx>
+#include <fmthdft.hxx>
+#include <unotextrange.hxx>
+#include <docstat.hxx>
+#include <wordcountdialog.hxx>
+#include <OnlineAccessibilityCheck.hxx>
+#include <sfx2/sidebar/Sidebar.hxx>
+
+#include <vcl/GraphicNativeTransform.hxx>
+#include <vcl/GraphicNativeMetadata.hxx>
+#include <vcl/settings.hxx>
+#include <i18nutil/searchopt.hxx>
+#include <osl/diagnose.h>
+#include <paratr.hxx>
+#include <rootfrm.hxx>
+#include <frameformats.hxx>
+
+#include <viewimp.hxx>
+#include <pagefrm.hxx>
+
+#include <memory>
+#include <string_view>
+#include <svl/slstitm.hxx>
+
+#include <basegfx/utils/zoomtools.hxx>
+
+#include <ndtxt.hxx>
+
+#include <svx/srchdlg.hxx>
+#include <o3tl/string_view.hxx>
+
+const char sStatusDelim[] = " : ";
+
+using namespace sfx2;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::i18n;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::scanner;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::sdb;
+using namespace ::com::sun::star::ui::dialogs;
+
+namespace {
+
+class SwNumberInputDlg : public SfxDialogController
+{
+private:
+ std::unique_ptr<weld::Label> m_xLabel1;
+ std::unique_ptr<weld::SpinButton> m_xSpinButton;
+ std::unique_ptr<weld::Label> m_xLabel2;
+ std::unique_ptr<weld::Button> m_xOKButton;
+
+ DECL_LINK(InputModifiedHdl, weld::Entry&, void);
+public:
+ SwNumberInputDlg(weld::Window* pParent, const OUString& rTitle,
+ const OUString& rLabel1, const sal_Int64 nValue, const sal_Int64 min, const sal_Int64 max,
+ OUString rLabel2 = OUString())
+ : SfxDialogController(pParent, "modules/swriter/ui/numberinput.ui", "NumberInputDialog")
+ , m_xLabel1(m_xBuilder->weld_label("label1"))
+ , m_xSpinButton(m_xBuilder->weld_spin_button("spinbutton"))
+ , m_xLabel2(m_xBuilder->weld_label("label2"))
+ , m_xOKButton(m_xBuilder->weld_button("ok"))
+ {
+ m_xDialog->set_title(rTitle);
+ m_xLabel1->set_label(rLabel1);
+ m_xSpinButton->set_value(nValue);
+ m_xSpinButton->set_range(min, max);
+ m_xSpinButton->set_position(-1);
+ m_xSpinButton->select_region(0, -1);
+ m_xSpinButton->connect_changed(LINK(this, SwNumberInputDlg, InputModifiedHdl));
+ if (!rLabel2.isEmpty())
+ {
+ m_xLabel2->set_label(rLabel2);
+ m_xLabel2->show();
+ }
+ }
+
+ auto GetNumber()
+ {
+ return m_xSpinButton->get_text().toInt32();
+ }
+};
+
+IMPL_LINK_NOARG(SwNumberInputDlg, InputModifiedHdl, weld::Entry&, void)
+{
+ m_xOKButton->set_sensitive(!m_xSpinButton->get_text().isEmpty());
+ if (!m_xOKButton->get_sensitive())
+ return;
+
+ auto nValue = m_xSpinButton->get_text().toInt32();
+ if (nValue <= m_xSpinButton->get_min())
+ m_xSpinButton->set_value(m_xSpinButton->get_min());
+ else if (nValue > m_xSpinButton->get_max())
+ m_xSpinButton->set_value(m_xSpinButton->get_max());
+ else
+ m_xSpinButton->set_value(nValue);
+
+ m_xSpinButton->set_position(-1);
+}
+
+}
+
+static void lcl_SetAllTextToDefaultLanguage( SwWrtShell &rWrtSh, TypedWhichId<SvxLanguageItem> nWhichId )
+{
+ if (!(nWhichId == RES_CHRATR_LANGUAGE ||
+ nWhichId == RES_CHRATR_CJK_LANGUAGE ||
+ nWhichId == RES_CHRATR_CTL_LANGUAGE))
+ return;
+
+ rWrtSh.StartAction();
+ rWrtSh.LockView( true );
+ rWrtSh.Push();
+
+ // prepare to apply new language to all text in document
+ rWrtSh.SelAll();
+ rWrtSh.ExtendedSelectAll();
+
+ // set language attribute to default for all text
+ rWrtSh.ResetAttr({ nWhichId });
+
+ rWrtSh.Pop(SwCursorShell::PopMode::DeleteCurrent);
+ rWrtSh.LockView( false );
+ rWrtSh.EndAction();
+
+}
+
+/**
+ * Create string for showing the page number in the statusbar
+ *
+ * @param nPhyNum The physical page number
+ * @param nVirtNum The logical page number (user-assigned)
+ * @param rPgStr User-defined page name (will be shown if different from logical page number)
+ *
+ * @return OUString Formatted string: Page 1 of 10 (Page 1 of 8 to print OR Page nVirtNumv/rPgStr)
+ **/
+OUString SwView::GetPageStr(sal_uInt16 nPhyNum, sal_uInt16 nVirtNum, const OUString& rPgStr)
+{
+ // Show user-defined page number in brackets if any.
+ OUString extra;
+ if (!rPgStr.isEmpty() && std::u16string_view(OUString::number(nPhyNum)) != rPgStr)
+ extra = rPgStr;
+ else if (nPhyNum != nVirtNum)
+ extra = OUString::number(nVirtNum);
+
+ sal_uInt16 nPageCount = GetWrtShell().GetPageCnt();
+ sal_uInt16 nPrintedPhyNum = nPhyNum;
+ sal_uInt16 nPrintedPageCount = nPageCount;
+ if (!GetWrtShell().getIDocumentDeviceAccess().getPrintData().IsPrintEmptyPages())
+ SwDoc::CalculateNonBlankPages(*m_pWrtShell->GetLayout(), nPrintedPageCount, nPrintedPhyNum);
+ // Show printed page numbers only, when they are different
+ OUString aStr( nPageCount != nPrintedPageCount
+ ? SwResId(STR_PAGE_COUNT_PRINTED)
+ : (extra.isEmpty() ? SwResId(STR_PAGE_COUNT) : SwResId(STR_PAGE_COUNT_CUSTOM)));
+ aStr = aStr.replaceFirst("%1", OUString::number(nPhyNum));
+ aStr = aStr.replaceFirst("%2", OUString::number(nPageCount));
+ if (nPageCount != nPrintedPageCount)
+ {
+ aStr = aStr.replaceFirst("%3", OUString::number(nPrintedPhyNum));
+ aStr = aStr.replaceFirst("%4", OUString::number(nPrintedPageCount));
+ }
+ else
+ aStr = aStr.replaceFirst("%3", extra);
+
+ return aStr;
+}
+
+ErrCode SwView::InsertGraphic( const OUString &rPath, const OUString &rFilter,
+ bool bLink, GraphicFilter *pFilter )
+{
+ SwWait aWait( *GetDocShell(), true );
+
+ Graphic aGraphic;
+ ErrCode aResult = ERRCODE_NONE;
+ if( !pFilter )
+ {
+ pFilter = &GraphicFilter::GetGraphicFilter();
+ }
+ aResult = GraphicFilter::LoadGraphic( rPath, rFilter, aGraphic, pFilter );
+
+ if( ERRCODE_NONE == aResult )
+ {
+ GraphicNativeMetadata aMetadata;
+ if ( aMetadata.read(aGraphic) )
+ {
+ const Degree10 aRotation = aMetadata.getRotation();
+ if (aRotation)
+ {
+ GraphicNativeTransform aTransform( aGraphic );
+ aTransform.rotate( aRotation );
+ }
+ }
+
+ SwFlyFrameAttrMgr aFrameManager( true, GetWrtShellPtr(), Frmmgr_Type::GRF, nullptr );
+ SwWrtShell& rShell = GetWrtShell();
+
+ // #i123922# determine if we really want to insert or replace the graphic at a selected object
+ const bool bReplaceMode(rShell.HasSelection() && SelectionType::Frame == rShell.GetSelectionType());
+
+ if(bReplaceMode)
+ {
+ // #i123922# Do same as in D&D, ReRead graphic and all is done
+ rShell.ReRead(
+ bLink ? rPath : OUString(),
+ bLink ? rFilter : OUString(),
+ &aGraphic);
+ }
+ else
+ {
+ rShell.StartAction();
+ if( bLink )
+ {
+ SwDocShell* pDocSh = GetDocShell();
+ INetURLObject aTemp(
+ pDocSh->HasName() ?
+ pDocSh->GetMedium()->GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ) :
+ OUString());
+
+ OUString sURL = URIHelper::SmartRel2Abs(
+ aTemp, rPath, URIHelper::GetMaybeFileHdl() );
+ aGraphic.setOriginURL(sURL);
+ rShell.InsertGraphic( sURL, rFilter, aGraphic, &aFrameManager );
+ }
+ else
+ {
+ rShell.InsertGraphic( OUString(), OUString(), aGraphic, &aFrameManager );
+ }
+
+ // it is too late after "EndAction" because the Shell can already be destroyed.
+ rShell.EndAction();
+ }
+ }
+ return aResult;
+}
+
+bool SwView::InsertGraphicDlg( SfxRequest& rReq )
+{
+ bool bReturn = false;
+ SwDocShell* pDocShell = GetDocShell();
+ SwDoc* pDoc = pDocShell->GetDoc();
+
+ OUString sGraphicFormat = SwResId(STR_POOLFRM_GRAPHIC);
+
+// No file pickers in a non-desktop (mobile app) build.
+
+#if HAVE_FEATURE_DESKTOP
+ // when in HTML mode insert only as a link
+ const sal_uInt16 nHtmlMode = ::GetHtmlMode(pDocShell);
+ std::unique_ptr<FileDialogHelper> pFileDlg(new FileDialogHelper(
+ ui::dialogs::TemplateDescription::FILEOPEN_LINK_PREVIEW_IMAGE_TEMPLATE,
+ FileDialogFlags::Graphic, GetFrameWeld()));
+ pFileDlg->SetTitle(SwResId(STR_INSERT_GRAPHIC ));
+ pFileDlg->SetContext( FileDialogHelper::WriterInsertImage );
+
+ uno::Reference < XFilePicker3 > xFP = pFileDlg->GetFilePicker();
+ uno::Reference < XFilePickerControlAccess > xCtrlAcc(xFP, UNO_QUERY);
+ if(nHtmlMode & HTMLMODE_ON)
+ {
+ xCtrlAcc->setValue( ExtendedFilePickerElementIds::CHECKBOX_LINK, 0, Any(true));
+ xCtrlAcc->enableControl( ExtendedFilePickerElementIds::CHECKBOX_LINK, false);
+ }
+
+ std::vector<OUString> aFormats;
+ const size_t nArrLen = pDoc->GetFrameFormats()->size();
+ for( size_t i = 0; i < nArrLen; ++i )
+ {
+ const SwFrameFormat* pFormat = (*pDoc->GetFrameFormats())[ i ];
+ if(pFormat->IsDefault() || pFormat->IsAuto())
+ continue;
+ aFormats.push_back(pFormat->GetName());
+ }
+
+ // pool formats
+
+ const std::vector<OUString>& rFramePoolArr(
+ SwStyleNameMapper::GetFrameFormatUINameArray());
+ for(const auto & i : rFramePoolArr)
+ {
+ aFormats.push_back(i);
+ }
+
+ std::sort(aFormats.begin(), aFormats.end());
+ aFormats.erase(std::unique(aFormats.begin(), aFormats.end()), aFormats.end());
+
+ Sequence<OUString> aListBoxEntries(aFormats.size());
+ OUString* pEntries = aListBoxEntries.getArray();
+ sal_Int16 nSelect = 0;
+ for( size_t i = 0; i < aFormats.size(); ++i )
+ {
+ pEntries[i] = aFormats[i];
+ if(pEntries[i] == sGraphicFormat)
+ nSelect = i;
+ }
+ try
+ {
+ Any aTemplates(&aListBoxEntries, cppu::UnoType<decltype(aListBoxEntries)>::get());
+
+ xCtrlAcc->setValue( ExtendedFilePickerElementIds::LISTBOX_IMAGE_TEMPLATE,
+ ListboxControlActions::ADD_ITEMS , aTemplates );
+
+ Any aSelectPos(&nSelect, cppu::UnoType<decltype(nSelect)>::get());
+ xCtrlAcc->setValue( ExtendedFilePickerElementIds::LISTBOX_IMAGE_TEMPLATE,
+ ListboxControlActions::SET_SELECT_ITEM, aSelectPos );
+ }
+ catch (const Exception&)
+ {
+ OSL_FAIL("control access failed");
+ }
+#endif
+
+ const SfxStringItem* pName = rReq.GetArg<SfxStringItem>(SID_INSERT_GRAPHIC);
+ bool bShowError = !pName;
+
+ bool bHaveName = pName != nullptr;
+#if HAVE_FEATURE_DESKTOP
+ if (!bHaveName && !Application::IsHeadlessModeEnabled())
+ {
+ // execute file dialog, without capturing mouse (tdf#156033)
+ vcl::Window* pWin = GetWindow();
+ const bool bMouseCaptured = pWin && pWin->IsMouseCaptured();
+ if (bMouseCaptured)
+ pWin->ReleaseMouse();
+ bHaveName = ERRCODE_NONE == pFileDlg->Execute();
+ if (bMouseCaptured)
+ pWin->CaptureMouse();
+ }
+#endif
+ if (bHaveName)
+ {
+
+ OUString aFileName, aFilterName;
+ if ( pName )
+ {
+ aFileName = pName->GetValue();
+ const SfxStringItem* pFilter = rReq.GetArg<SfxStringItem>(FN_PARAM_FILTER);
+ if ( pFilter )
+ aFilterName = pFilter->GetValue();
+ }
+#if HAVE_FEATURE_DESKTOP
+ else
+ {
+ aFileName = pFileDlg->GetPath();
+ aFilterName = pFileDlg->GetCurrentFilter();
+ rReq.AppendItem( SfxStringItem( SID_INSERT_GRAPHIC, aFileName ) );
+ rReq.AppendItem( SfxStringItem( FN_PARAM_FILTER, aFilterName ) );
+
+ bool bAsLink = false;
+ if(nHtmlMode & HTMLMODE_ON)
+ bAsLink = true;
+ else
+ {
+ try
+ {
+ Any aVal = xCtrlAcc->getValue( ExtendedFilePickerElementIds::CHECKBOX_LINK, 0);
+ OSL_ENSURE(aVal.hasValue(), "Value CBX_INSERT_AS_LINK not found");
+ bAsLink = !aVal.hasValue() || *o3tl::doAccess<bool>(aVal);
+ Any aTemplateValue = xCtrlAcc->getValue(
+ ExtendedFilePickerElementIds::LISTBOX_IMAGE_TEMPLATE,
+ ListboxControlActions::GET_SELECTED_ITEM );
+ OUString sTmpl;
+ aTemplateValue >>= sTmpl;
+ rReq.AppendItem( SfxStringItem( FN_PARAM_2, sTmpl) );
+ }
+ catch (const Exception&)
+ {
+ OSL_FAIL("control access failed");
+ }
+ }
+ rReq.AppendItem( SfxBoolItem( FN_PARAM_1, bAsLink ) );
+ }
+ const SfxBoolItem* pAsLink = rReq.GetArg<SfxBoolItem>(FN_PARAM_1);
+ const SfxStringItem* pStyle = rReq.GetArg<SfxStringItem>(FN_PARAM_2);
+#endif
+
+ bool bAsLink = false;
+
+#if HAVE_FEATURE_DESKTOP
+ if( nHtmlMode & HTMLMODE_ON )
+ bAsLink = true;
+ else
+ {
+ if ( rReq.GetArgs() )
+ {
+ if ( pAsLink )
+ bAsLink = pAsLink->GetValue();
+ if ( pStyle && !pStyle->GetValue().isEmpty() )
+ sGraphicFormat = pStyle->GetValue();
+ }
+ else
+ {
+ Any aVal = xCtrlAcc->getValue( ExtendedFilePickerElementIds::CHECKBOX_LINK, 0);
+ OSL_ENSURE(aVal.hasValue(), "Value CBX_INSERT_AS_LINK not found");
+ bAsLink = !aVal.hasValue() || *o3tl::doAccess<bool>(aVal);
+ Any aTemplateValue = xCtrlAcc->getValue(
+ ExtendedFilePickerElementIds::LISTBOX_IMAGE_TEMPLATE,
+ ListboxControlActions::GET_SELECTED_ITEM );
+ OUString sTmpl;
+ aTemplateValue >>= sTmpl;
+ if( !sTmpl.isEmpty() )
+ sGraphicFormat = sTmpl;
+ rReq.AppendItem( SfxStringItem( FN_PARAM_2, sGraphicFormat ) );
+ rReq.AppendItem( SfxBoolItem( FN_PARAM_1, bAsLink ) );
+ }
+
+ // really store as link only?
+ if( bAsLink && officecfg::Office::Common::Misc::ShowLinkWarningDialog::get() )
+ {
+ SvxLinkWarningDialog aWarnDlg(GetFrameWeld(), pFileDlg->GetPath());
+ if (aWarnDlg.run() != RET_OK)
+ bAsLink=false; // don't store as link
+ }
+ }
+#endif
+
+ SwWrtShell& rSh = GetWrtShell();
+ rSh.LockPaint(LockPaintReason::InsertGraphic);
+ rSh.StartAction();
+
+ SwRewriter aRewriter;
+ aRewriter.AddRule(UndoArg1, SwResId(STR_GRAPHIC_DEFNAME));
+
+ // #i123922# determine if we really want to insert or replace the graphic at a selected object
+ const bool bReplaceMode(rSh.HasSelection() && SelectionType::Frame == rSh.GetSelectionType());
+
+ rSh.StartUndo(SwUndoId::INSERT, &aRewriter);
+
+ ErrCode nError = InsertGraphic( aFileName, aFilterName, bAsLink, &GraphicFilter::GetGraphicFilter() );
+
+ // format not equal to current filter (with autodetection)
+ if( nError == ERRCODE_GRFILTER_FORMATERROR )
+ nError = InsertGraphic( aFileName, OUString(), bAsLink, &GraphicFilter::GetGraphicFilter() );
+
+ // #i123922# no new FrameFormat for replace mode, only when new object was created,
+ // else this would reset the current setting for the frame holding the graphic
+ if ( !bReplaceMode && rSh.IsFrameSelected() )
+ {
+ SwFrameFormat* pFormat = pDoc->FindFrameFormatByName( sGraphicFormat );
+ if(!pFormat)
+ pFormat = pDoc->MakeFrameFormat(sGraphicFormat,
+ pDocShell->GetDoc()->GetDfltFrameFormat(),
+ true, false);
+ rSh.SetFrameFormat( pFormat );
+ }
+
+ TranslateId pResId;
+ if( nError == ERRCODE_GRFILTER_OPENERROR )
+ pResId = STR_GRFILTER_OPENERROR;
+ else if( nError == ERRCODE_GRFILTER_IOERROR )
+ pResId = STR_GRFILTER_IOERROR;
+ else if( nError ==ERRCODE_GRFILTER_FORMATERROR )
+ pResId = STR_GRFILTER_FORMATERROR;
+ else if( nError ==ERRCODE_GRFILTER_VERSIONERROR )
+ pResId = STR_GRFILTER_VERSIONERROR;
+ else if( nError ==ERRCODE_GRFILTER_FILTERERROR )
+ pResId = STR_GRFILTER_FILTERERROR;
+ else if( nError ==ERRCODE_GRFILTER_TOOBIG )
+ pResId = STR_GRFILTER_TOOBIG;
+
+ rSh.EndAction();
+ rSh.UnlockPaint();
+ if (pResId)
+ {
+ if( bShowError )
+ {
+ std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetFrameWeld(),
+ VclMessageType::Info, VclButtonsType::Ok,
+ SwResId(pResId)));
+ xInfoBox->run();
+ }
+ rReq.Ignore();
+ }
+ else
+ {
+ // set the specific graphic attributes to the graphic
+ bReturn = true;
+ AutoCaption( GRAPHIC_CAP );
+ rReq.Done();
+ }
+
+ rSh.EndUndo(); // due to possible change of Shell
+ }
+
+ return bReturn;
+}
+
+void SwView::Execute(SfxRequest &rReq)
+{
+ const sal_uInt16 nSlot = rReq.GetSlot();
+ const SfxItemSet* pArgs = rReq.GetArgs();
+ const SfxPoolItem* pItem;
+ bool bIgnore = false;
+ switch( nSlot )
+ {
+ case SID_CREATE_SW_DRAWVIEW:
+ m_pWrtShell->getIDocumentDrawModelAccess().GetOrCreateDrawModel();
+ break;
+
+ case FN_LINE_NUMBERING_DLG:
+ {
+ SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
+ ScopedVclPtr<VclAbstractDialog> pDlg(pFact->CreateVclSwViewDialog(*this));
+ VclAbstractDialog::AsyncContext aContext;
+ aContext.maEndDialogFn = [](sal_Int32){};
+ pDlg->StartExecuteAsync(aContext);
+ break;
+ }
+ case FN_EDIT_LINK_DLG:
+ EditLinkDlg();
+ break;
+ case SID_REFRESH_VIEW:
+ GetEditWin().Invalidate();
+ m_pWrtShell->Reformat();
+ break;
+ case FN_PAGEUP:
+ case FN_PAGEUP_SEL:
+ case FN_PAGEDOWN:
+ case FN_PAGEDOWN_SEL:
+ {
+ tools::Rectangle aVis( GetVisArea() );
+ SwEditWin& rTmpWin = GetEditWin();
+ if ( FN_PAGEUP == nSlot || FN_PAGEUP_SEL == nSlot )
+ PageUpCursor(FN_PAGEUP_SEL == nSlot);
+ else
+ PageDownCursor(FN_PAGEDOWN_SEL == nSlot);
+
+ rReq.SetReturnValue(SfxBoolItem(nSlot,
+ aVis != GetVisArea()));
+ //#i42732# - notify the edit window that from now on we do not use the input language
+ rTmpWin.SetUseInputLanguage( false );
+ }
+ break;
+ case SID_ZOOM_IN:
+ case SID_ZOOM_OUT:
+ {
+ sal_uInt16 nFact = m_pWrtShell->GetViewOptions()->GetZoom();
+ if (SID_ZOOM_IN == nSlot)
+ nFact = basegfx::zoomtools::zoomIn(nFact);
+ else
+ nFact = basegfx::zoomtools::zoomOut(nFact);
+ SetZoom(SvxZoomType::PERCENT, nFact);
+ }
+ break;
+ case FN_TO_PREV_PAGE:
+ case FN_TO_NEXT_PAGE:
+ {
+ sal_uInt16 nPage = 0;
+ if (m_pWrtShell->IsCursorVisible())
+ nPage = m_pWrtShell->GetCursor()->GetPageNum();
+ else
+ {
+ SwFrame* pPageFrame = m_pWrtShell->Imp()->GetFirstVisPage(m_pWrtShell->GetOut());
+ if (pPageFrame)
+ nPage = pPageFrame->GetPhyPageNum();
+ }
+ if (nPage != 0)
+ {
+ sal_uInt16 nOldPage(nPage);
+ if (FN_TO_PREV_PAGE == nSlot && nPage > 1)
+ nPage--;
+ else if (FN_TO_NEXT_PAGE == nSlot && nPage < m_pWrtShell->GetPageCount())
+ nPage++;
+ if (nPage != nOldPage)
+ {
+ m_pWrtShell->LockPaint(LockPaintReason::GotoPage);
+ if (IsDrawMode())
+ LeaveDrawCreate();
+ m_pWrtShell->EnterStdMode();
+ m_pWrtShell->GotoPage(nPage, true);
+ // set visible area (borrowed from SwView::PhyPageUp/Down)
+ const Point aPt(m_aVisArea.Left(), m_pWrtShell->GetPagePos(nPage).Y());
+ Point aAlPt(AlignToPixel(aPt));
+ if(aPt.Y() != aAlPt.Y())
+ aAlPt.AdjustY(3 * GetEditWin().PixelToLogic(Size(0, 1)).Height());
+ SetVisArea(aAlPt);
+ m_pWrtShell->UnlockPaint();
+ }
+ }
+ }
+ break;
+ case FN_SELECTION_CYCLE:
+ {
+ if (m_pWrtShell->IsSelFrameMode())
+ break;
+ if (!m_pWrtShell->IsStdMode())
+ m_pWrtShell->EnterStdMode();
+ SwShellCursor *pCursor = m_pWrtShell->SwCursorShell::GetCursor_();
+ Point CurrMarkPt = pCursor->GetMkPos();
+ Point CurrPointPt = pCursor->GetPtPos();
+ sal_uInt16 nStep = m_aSelectCycle.nStep;
+ if (nStep && (CurrMarkPt != m_aSelectCycle.m_MarkPt || CurrPointPt != m_aSelectCycle.m_PointPt))
+ nStep = 0;
+ switch(nStep)
+ {
+ case 0:
+ m_aSelectCycle.m_pInitialCursor = CurrPointPt;
+ m_pWrtShell->SwCursorShell::ClearMark();
+ m_pWrtShell->SelWrd(&CurrPointPt);
+ break;
+ case 1:
+ m_pWrtShell->SelSentence(&CurrPointPt);
+ break;
+ case 2:
+ m_pWrtShell->SelPara(&CurrPointPt);
+ break;
+ case 3:
+ m_pWrtShell->SwCursorShell::ClearMark();
+ m_pWrtShell->SwCursorShell::SetCursor(m_aSelectCycle.m_pInitialCursor);
+ break;
+ }
+ nStep++;
+ nStep %= 4;
+ pCursor = m_pWrtShell->SwCursorShell::GetCursor_();
+ m_aSelectCycle.m_MarkPt = pCursor->GetMkPos();
+ m_aSelectCycle.m_PointPt = pCursor->GetPtPos();
+ m_aSelectCycle.nStep = nStep;
+ }
+ break;
+ case FN_REDLINE_ON:
+ {
+ if( pArgs &&
+ SfxItemState::SET == pArgs->GetItemState(nSlot, false, &pItem ))
+ {
+ IDocumentRedlineAccess& rIDRA = m_pWrtShell->getIDocumentRedlineAccess();
+ Sequence <sal_Int8> aPasswd = rIDRA.GetRedlinePassword();
+ if( aPasswd.hasElements() )
+ {
+ OSL_ENSURE( !static_cast<const SfxBoolItem*>(pItem)->GetValue(), "SwView::Execute(): password set and redlining off doesn't match!" );
+
+ // xmlsec05: new password dialog
+ SfxPasswordDialog aPasswdDlg(GetFrameWeld());
+ aPasswdDlg.SetMinLen(1);
+ //#i69751# the result of Execute() can be ignored
+ (void)aPasswdDlg.run();
+ OUString sNewPasswd(aPasswdDlg.GetPassword());
+
+ // password verification
+ bool bPasswordOk = false;
+ if (aPasswd.getLength() == 1 && aPasswd[0] == 1)
+ {
+ // dummy RedlinePassword from OOXML import: get real password info
+ // from the grab-bag to verify the password
+ const css::uno::Sequence< css::beans::PropertyValue > aDocumentProtection =
+ static_cast<SfxObjectShell*>(GetDocShell())->
+ GetDocumentProtectionFromGrabBag();
+
+ bPasswordOk =
+ // password is ok, if there is no DocumentProtection in the GrabBag,
+ // i.e. the dummy RedlinePassword imported from an OpenDocument file
+ !aDocumentProtection.hasElements() ||
+ // verify password with the password info imported from OOXML
+ ::comphelper::DocPasswordHelper::IsModifyPasswordCorrect(sNewPasswd,
+ ::comphelper::DocPasswordHelper::ConvertPasswordInfo ( aDocumentProtection ) );
+ }
+ else
+ {
+ // the simplified RedlinePassword
+ Sequence <sal_Int8> aNewPasswd = rIDRA.GetRedlinePassword();
+ SvPasswordHelper::GetHashPassword( aNewPasswd, sNewPasswd );
+ bPasswordOk = SvPasswordHelper::CompareHashPassword(aPasswd, sNewPasswd);
+ }
+
+ if (bPasswordOk)
+ rIDRA.SetRedlinePassword(Sequence <sal_Int8> ());
+ else
+ { // xmlsec05: message box for wrong password
+ std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(nullptr,
+ VclMessageType::Info, VclButtonsType::Ok,
+ SfxResId(RID_SVXSTR_INCORRECT_PASSWORD)));
+ xInfoBox->run();
+ break;
+ }
+ }
+
+ SwDocShell* pDocShell = GetDocShell();
+ pDocShell->SetChangeRecording( static_cast<const SfxBoolItem*>(pItem)->GetValue(), /*bLockAllViews=*/true );
+
+ // Notify all view shells of this document, as the track changes mode is document-global.
+ for (SfxViewFrame* pViewFrame = SfxViewFrame::GetFirst(pDocShell); pViewFrame; pViewFrame = SfxViewFrame::GetNext(*pViewFrame, pDocShell))
+ {
+ pViewFrame->GetBindings().Invalidate(FN_REDLINE_ON);
+ pViewFrame->GetBindings().Update(FN_REDLINE_ON);
+ }
+ }
+ }
+ break;
+ case FN_REDLINE_PROTECT :
+ {
+ IDocumentRedlineAccess& rIDRA = m_pWrtShell->getIDocumentRedlineAccess();
+ Sequence <sal_Int8> aPasswd = rIDRA.GetRedlinePassword();
+ if( pArgs && SfxItemState::SET == pArgs->GetItemState(nSlot, false, &pItem )
+ && static_cast<const SfxBoolItem*>(pItem)->GetValue() == aPasswd.hasElements() )
+ break;
+
+ // xmlsec05: new password dialog
+ // message box for wrong password
+ SfxPasswordDialog aPasswdDlg(GetFrameWeld());
+ aPasswdDlg.SetMinLen(1);
+ if (!aPasswd.hasElements())
+ aPasswdDlg.ShowExtras(SfxShowExtras::CONFIRM);
+ if (aPasswdDlg.run())
+ {
+ RedlineFlags nOn = RedlineFlags::On;
+ OUString sNewPasswd(aPasswdDlg.GetPassword());
+ Sequence <sal_Int8> aNewPasswd =
+ rIDRA.GetRedlinePassword();
+ SvPasswordHelper::GetHashPassword( aNewPasswd, sNewPasswd );
+ if(!aPasswd.hasElements())
+ {
+ rIDRA.SetRedlinePassword(aNewPasswd);
+ }
+ else if(SvPasswordHelper::CompareHashPassword(aPasswd, sNewPasswd))
+ {
+ rIDRA.SetRedlinePassword(Sequence <sal_Int8> ());
+ nOn = RedlineFlags::NONE;
+ }
+ const RedlineFlags nMode = rIDRA.GetRedlineFlags();
+ m_pWrtShell->SetRedlineFlagsAndCheckInsMode( (nMode & ~RedlineFlags::On) | nOn);
+ rReq.AppendItem( SfxBoolItem( FN_REDLINE_PROTECT, !(nMode&RedlineFlags::On) ) );
+ }
+ else
+ bIgnore = true;
+ }
+ break;
+ case FN_REDLINE_SHOW:
+
+ if( pArgs &&
+ SfxItemState::SET == pArgs->GetItemState(nSlot, false, &pItem))
+ {
+ // tdf#125754 avoid recursive layout
+ // because all views share the layout, have to use AllAction
+ const bool bShow = static_cast<const SfxBoolItem*>(pItem)->GetValue();
+ m_pWrtShell->StartAllAction();
+ // always show redline insertions in Hide Changes mode
+ if ( m_pWrtShell->GetViewOptions()->IsShowChangesInMargin() &&
+ m_pWrtShell->GetViewOptions()->IsShowChangesInMargin2() )
+ {
+ GetDocShell()->GetDoc()->GetDocumentRedlineManager().HideAll(/*bDeletion=*/!bShow);
+ }
+ m_pWrtShell->GetLayout()->SetHideRedlines( !bShow );
+ m_pWrtShell->EndAllAction();
+ if (m_pWrtShell->IsRedlineOn())
+ m_pWrtShell->SetInsMode();
+ }
+ break;
+ case FN_MAILMERGE_SENDMAIL_CHILDWINDOW:
+ case FN_REDLINE_ACCEPT:
+ GetViewFrame().ToggleChildWindow(nSlot);
+ break;
+ case FN_REDLINE_ACCEPT_DIRECT:
+ case FN_REDLINE_REJECT_DIRECT:
+ case FN_REDLINE_ACCEPT_TONEXT:
+ case FN_REDLINE_REJECT_TONEXT:
+ {
+ SwDoc *pDoc = m_pWrtShell->GetDoc();
+ SwPaM *pCursor = m_pWrtShell->GetCursor();
+ const SwRedlineTable& rRedlineTable = pDoc->getIDocumentRedlineAccess().GetRedlineTable();
+ SwRedlineTable::size_type nRedline = SwRedlineTable::npos;
+ if (pArgs && pArgs->GetItemState(nSlot, false, &pItem) == SfxItemState::SET)
+ {
+ const sal_Int64 nChangeId = static_cast<const SfxUInt32Item*>(pItem)->GetValue();
+ for (SwRedlineTable::size_type i = 0; i < rRedlineTable.size(); ++i)
+ {
+ if (nChangeId == rRedlineTable[i]->GetId())
+ nRedline = i;
+ }
+ }
+
+ if( pCursor->HasMark() && nRedline == SwRedlineTable::npos)
+ {
+ bool bAccept = FN_REDLINE_ACCEPT_DIRECT == nSlot || FN_REDLINE_ACCEPT_TONEXT == nSlot;
+ SwUndoId eUndoId = bAccept ? SwUndoId::ACCEPT_REDLINE : SwUndoId::REJECT_REDLINE;
+ SwWrtShell& rSh = GetWrtShell();
+ SwRewriter aRewriter;
+ bool bTableSelection = rSh.IsTableMode();
+ if ( bTableSelection )
+ {
+ aRewriter.AddRule(UndoArg1, SwResId( STR_REDLINE_TABLECHG ));
+ rSh.StartUndo( eUndoId, &aRewriter);
+ }
+ if ( bAccept )
+ m_pWrtShell->AcceptRedlinesInSelection();
+ else
+ m_pWrtShell->RejectRedlinesInSelection();
+ if ( bTableSelection )
+ rSh.EndUndo( eUndoId, &aRewriter);
+ }
+ else
+ {
+ // We check for a redline at the start of the selection/cursor, not the point.
+ // This ensures we work properly with FN_REDLINE_NEXT_CHANGE, which leaves the
+ // point at the *end* of the redline and the mark at the start (so GetRedline
+ // would return NULL if called on the point)
+ const SwRangeRedline* pRedline = nullptr;
+ if (nRedline != SwRedlineTable::npos)
+ {
+ // A redline was explicitly requested by specifying an
+ // index, don't guess based on the cursor position.
+
+ if (nRedline < rRedlineTable.size())
+ pRedline = rRedlineTable[nRedline];
+ }
+ else
+ pRedline = pDoc->getIDocumentRedlineAccess().GetRedline(*pCursor->Start(), &nRedline);
+
+ // accept or reject table row deletion or insertion
+ bool bTableChange = false;
+ if ( !pRedline && m_pWrtShell->IsCursorInTable() )
+ {
+ nRedline = 0;
+ auto pTabBox = pCursor->Start()->GetNode().GetTableBox();
+ auto pTabLine = pTabBox->GetUpper();
+ const SwTableNode* pTableNd = pCursor->Start()->GetNode().FindTableNode();
+
+ if ( RedlineType::None != pTabLine->GetRedlineType() )
+ {
+ nRedline = pTabLine->UpdateTextChangesOnly(nRedline);
+
+ if ( nRedline != SwRedlineTable::npos )
+ {
+ bTableChange = true;
+
+ SwWrtShell& rSh = GetWrtShell();
+ SwRewriter aRewriter;
+
+ aRewriter.AddRule(UndoArg1, SwResId(
+ rRedlineTable[nRedline]->GetType() == RedlineType::Delete
+ ? STR_REDLINE_TABLE_ROW_DELETE
+ : STR_REDLINE_TABLE_ROW_INSERT ));
+
+ SwUndoId eUndoId =
+ (FN_REDLINE_ACCEPT_DIRECT == nSlot || FN_REDLINE_ACCEPT_TONEXT == nSlot)
+ ? SwUndoId::ACCEPT_REDLINE
+ : SwUndoId::REJECT_REDLINE;
+
+ rSh.StartUndo( eUndoId, &aRewriter);
+ while ( nRedline != SwRedlineTable::npos && nRedline < rRedlineTable.size() )
+ {
+ pRedline = rRedlineTable[nRedline];
+
+ // until next redline is not in the same row
+ SwTableBox* pTableBox = pRedline->Start()->GetNode().GetTableBox();
+ if ( !pTableBox || pTableBox->GetUpper() != pTabLine )
+ break;
+
+ if (FN_REDLINE_ACCEPT_DIRECT == nSlot || FN_REDLINE_ACCEPT_TONEXT == nSlot)
+ m_pWrtShell->AcceptRedline(nRedline);
+ else
+ m_pWrtShell->RejectRedline(nRedline);
+ }
+ rSh.EndUndo( eUndoId, &aRewriter);
+ }
+ }
+ else if ( RedlineType::None != pTabBox->GetRedlineType() )
+ {
+ nRedline = pTabBox->GetRedline();
+
+ if ( nRedline != SwRedlineTable::npos )
+ {
+ bTableChange = true;
+
+ SwWrtShell& rSh = GetWrtShell();
+ SwRewriter aRewriter;
+
+ aRewriter.AddRule(UndoArg1, SwResId(
+ rRedlineTable[nRedline]->GetType() == RedlineType::Delete
+ ? STR_REDLINE_TABLE_COLUMN_DELETE
+ : STR_REDLINE_TABLE_COLUMN_INSERT ));
+
+ SwUndoId eUndoId =
+ (FN_REDLINE_ACCEPT_DIRECT == nSlot || FN_REDLINE_ACCEPT_TONEXT == nSlot)
+ ? SwUndoId::ACCEPT_REDLINE
+ : SwUndoId::REJECT_REDLINE;
+
+ // change only the cells with the same data
+ SwRedlineData aData(rRedlineTable[nRedline]->GetRedlineData(0));
+
+ // start from the first redline of the table to handle all the
+ // cells of the changed column(s)
+ while ( nRedline )
+ {
+ pRedline = rRedlineTable[nRedline-1];
+ SwTableBox* pTableBox = pRedline->Start()->GetNode().GetTableBox();
+ SwTableNode* pTableNode = pRedline->Start()->GetNode().FindTableNode();
+
+ // previous redline is not in the same table
+ if ( !pTableBox || pTableNode != pTableNd )
+ break;
+
+ --nRedline;
+ }
+
+ rSh.StartUndo( eUndoId, &aRewriter);
+ while ( nRedline != SwRedlineTable::npos && nRedline < rRedlineTable.size() )
+ {
+ pRedline = rRedlineTable[nRedline];
+
+ // until next redline is not in the same table
+ SwTableBox* pTableBox = pRedline->Start()->GetNode().GetTableBox();
+ SwTableNode* pTableNode = pRedline->Start()->GetNode().FindTableNode();
+ if ( !pTableBox || pTableNode != pTableNd )
+ break;
+
+ // skip cells which are not from the same author, same type change
+ // or timestamp, i.e. keep only the cells of the same tracked
+ // column insertion or deletion
+ if ( !pRedline->GetRedlineData(0).CanCombine(aData) ||
+ // not a tracked cell change
+ RedlineType::None == pTableBox->GetRedlineType() )
+ {
+ ++nRedline;
+ continue;
+ }
+
+ if (FN_REDLINE_ACCEPT_DIRECT == nSlot || FN_REDLINE_ACCEPT_TONEXT == nSlot)
+ m_pWrtShell->AcceptRedline(nRedline);
+ else
+ m_pWrtShell->RejectRedline(nRedline);
+ }
+ rSh.EndUndo( eUndoId, &aRewriter);
+ }
+ }
+ }
+ else
+ {
+ assert(pRedline != nullptr);
+ }
+
+ if (pRedline && !bTableChange)
+ {
+ if (FN_REDLINE_ACCEPT_DIRECT == nSlot || FN_REDLINE_ACCEPT_TONEXT == nSlot)
+ m_pWrtShell->AcceptRedline(nRedline);
+ else
+ m_pWrtShell->RejectRedline(nRedline);
+ }
+ }
+ if (FN_REDLINE_ACCEPT_TONEXT == nSlot || FN_REDLINE_REJECT_TONEXT == nSlot)
+ {
+ // Go to next change after accepting or rejecting one (tdf#101977)
+ GetViewFrame().GetDispatcher()->Execute(FN_REDLINE_NEXT_CHANGE, SfxCallMode::ASYNCHRON);
+ }
+ }
+ break;
+
+ case FN_REDLINE_NEXT_CHANGE:
+ {
+ // If a parameter is provided, try going to the nth change, not to
+ // the next one.
+ SwDoc* pDoc = m_pWrtShell->GetDoc();
+ const SwRedlineTable& rRedlineTable = pDoc->getIDocumentRedlineAccess().GetRedlineTable();
+ SwRedlineTable::size_type nRedline = SwRedlineTable::npos;
+ if (pArgs && pArgs->GetItemState(nSlot, false, &pItem) == SfxItemState::SET)
+ {
+ const sal_uInt32 nChangeId = static_cast<const SfxUInt32Item*>(pItem)->GetValue();
+ for (SwRedlineTable::size_type i = 0; i < rRedlineTable.size(); ++i)
+ {
+ if (nChangeId == rRedlineTable[i]->GetId())
+ nRedline = i;
+ }
+ }
+
+ const SwRangeRedline *pNext = nullptr;
+ if (nRedline < rRedlineTable.size())
+ pNext = m_pWrtShell->GotoRedline(nRedline, true);
+ else
+ pNext = m_pWrtShell->SelNextRedline();
+
+ if (pNext)
+ {
+ if (comphelper::LibreOfficeKit::isActive())
+ {
+ sal_uInt32 nRedlineId = pNext->GetId();
+ OString aPayload(".uno:CurrentTrackedChangeId=" + OString::number(nRedlineId));
+ libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED, aPayload);
+ }
+
+ m_pWrtShell->SetInSelect();
+ }
+
+ }
+ break;
+
+ case FN_REDLINE_PREV_CHANGE:
+ {
+ const SwRangeRedline *pPrev = m_pWrtShell->SelPrevRedline();
+
+ if (pPrev)
+ {
+ if (comphelper::LibreOfficeKit::isActive())
+ {
+ sal_uInt32 nRedlineId = pPrev->GetId();
+ OString aPayload(".uno:CurrentTrackedChangeId=" + OString::number(nRedlineId));
+ libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED, aPayload);
+ }
+
+ m_pWrtShell->SetInSelect();
+ }
+ }
+ break;
+
+ case SID_DOCUMENT_COMPARE:
+ case SID_DOCUMENT_MERGE:
+ {
+ OUString sFileName, sFilterName;
+ sal_Int16 nVersion = 0;
+ bool bHasFileName = false;
+ m_pViewImpl->SetParam( 0 );
+ bool bNoAcceptDialog = false;
+
+ if( pArgs )
+ {
+ if( const SfxStringItem* pFileItem = pArgs->GetItemIfSet( SID_FILE_NAME, false ))
+ sFileName = pFileItem->GetValue();
+ bHasFileName = !sFileName.isEmpty();
+
+ if( const SfxStringItem* pFilterNameItem = pArgs->GetItemIfSet( SID_FILTER_NAME, false ))
+ sFilterName = pFilterNameItem->GetValue();
+
+ if( const SfxInt16Item* pVersionItem = pArgs->GetItemIfSet( SID_VERSION, false ))
+ {
+ nVersion = pVersionItem->GetValue();
+ m_pViewImpl->SetParam( nVersion );
+ }
+ if( const SfxBoolItem* pDialogItem = pArgs->GetItemIfSet( SID_NO_ACCEPT_DIALOG, false ))
+ {
+ bNoAcceptDialog = pDialogItem->GetValue();
+ }
+ }
+
+ m_pViewImpl->InitRequest( rReq );
+ tools::Long nFound = InsertDoc( nSlot, sFileName, sFilterName, nVersion );
+
+ if ( bHasFileName )
+ {
+ rReq.SetReturnValue( SfxInt32Item( nSlot, nFound ));
+
+ if (nFound > 0 && !bNoAcceptDialog) // show Redline browser
+ {
+ SfxViewFrame& rVFrame = GetViewFrame();
+ rVFrame.ShowChildWindow(FN_REDLINE_ACCEPT);
+
+ // re-initialize the Redline dialog
+ const sal_uInt16 nId = SwRedlineAcceptChild::GetChildWindowId();
+ SwRedlineAcceptChild *pRed = static_cast<SwRedlineAcceptChild*>(
+ rVFrame.GetChildWindow(nId));
+ if (pRed)
+ pRed->ReInitDlg(GetDocShell());
+ }
+ }
+ else
+ bIgnore = true;
+ }
+ break;
+ case FN_SYNC_LABELS:
+ GetViewFrame().ShowChildWindow(nSlot);
+ break;
+ case FN_ESCAPE:
+ {
+ if ( m_pWrtShell->HasDrawViewDrag() )
+ {
+ m_pWrtShell->BreakDrag();
+ m_pWrtShell->EnterSelFrameMode();
+ }
+ else if ( m_pWrtShell->IsDrawCreate() )
+ {
+ GetDrawFuncPtr()->BreakCreate();
+ AttrChangedNotify(nullptr); // shell change if needed
+ }
+ else if ( m_pWrtShell->HasSelection() || IsDrawMode() )
+ {
+ SdrView *pSdrView = m_pWrtShell->HasDrawView() ? m_pWrtShell->GetDrawView() : nullptr;
+ if(pSdrView && pSdrView->AreObjectsMarked() &&
+ pSdrView->GetHdlList().GetFocusHdl())
+ {
+ const_cast<SdrHdlList&>(pSdrView->GetHdlList()).ResetFocusHdl();
+ }
+ else
+ {
+ if(pSdrView)
+ {
+ LeaveDrawCreate();
+ Point aPt(LONG_MIN, LONG_MIN);
+ //go out of the frame
+ m_pWrtShell->SelectObj(aPt, SW_LEAVE_FRAME);
+ SfxBindings& rBind = GetViewFrame().GetBindings();
+ rBind.Invalidate( SID_ATTR_SIZE );
+ }
+ m_pWrtShell->EnterStdMode();
+ AttrChangedNotify(nullptr); // shell change if necessary
+ }
+ }
+ else if ( GetEditWin().GetApplyTemplate() )
+ {
+ GetEditWin().SetApplyTemplate(SwApplyTemplate());
+ }
+ else if( static_cast<SfxObjectShell*>(GetDocShell())->IsInPlaceActive() )
+ {
+ Escape();
+ }
+ else if ( GetEditWin().IsChainMode() )
+ {
+ GetEditWin().SetChainMode( false );
+ }
+ else if( m_pWrtShell->GetFlyFrameFormat() )
+ {
+ const SwFrameFormat* pFormat = m_pWrtShell->GetFlyFrameFormat();
+ if(m_pWrtShell->GotoFly( pFormat->GetName(), FLYCNTTYPE_FRM ))
+ {
+ m_pWrtShell->HideCursor();
+ m_pWrtShell->EnterSelFrameMode();
+ }
+ }
+ else
+ {
+ SfxBoolItem aItem( SID_WIN_FULLSCREEN, false );
+ GetViewFrame().GetDispatcher()->ExecuteList(SID_WIN_FULLSCREEN,
+ SfxCallMode::RECORD, { &aItem });
+ bIgnore = true;
+ }
+ }
+ break;
+ case SID_ATTR_BORDER_INNER:
+ case SID_ATTR_BORDER_OUTER:
+ case SID_ATTR_BORDER_SHADOW:
+ if(pArgs)
+ m_pWrtShell->SetAttrSet(*pArgs);
+ break;
+
+ case SID_ATTR_PAGE:
+ case SID_ATTR_PAGE_SIZE:
+ case SID_ATTR_PAGE_MAXSIZE:
+ case SID_ATTR_PAGE_PAPERBIN:
+ case SID_ATTR_PAGE_EXT1:
+ case FN_PARAM_FTN_INFO:
+ {
+ if(pArgs)
+ {
+ const size_t nCurIdx = m_pWrtShell->GetCurPageDesc();
+ SwPageDesc aPageDesc( m_pWrtShell->GetPageDesc( nCurIdx ) );
+ ::ItemSetToPageDesc( *pArgs, aPageDesc );
+ // change the descriptor of the core
+ m_pWrtShell->ChgPageDesc( nCurIdx, aPageDesc );
+ }
+ }
+ break;
+ case FN_GOTO_PAGE:
+ {
+ SwGotoPageDlg aDlg(GetViewFrame().GetFrameWeld(), GetViewFrame().GetBindings());
+ if (aDlg.run() == RET_OK)
+ GetWrtShell().GotoPage(aDlg.GetPageSelection(), true);
+ }
+ break;
+ case FN_EDIT_CURRENT_TOX:
+ {
+ GetViewFrame().GetDispatcher()->Execute(
+ FN_INSERT_MULTI_TOX, SfxCallMode::ASYNCHRON);
+ }
+ break;
+ case FN_UPDATE_CUR_TOX:
+ {
+ const SwTOXBase* pBase = m_pWrtShell->GetCurTOX();
+ if(pBase)
+ {
+ // tdf#106374: don't jump view on the update
+ const bool bWasLocked = m_pWrtShell->IsViewLocked();
+ m_pWrtShell->LockView(true);
+ m_pWrtShell->StartAction();
+ if(TOX_INDEX == pBase->GetType())
+ m_pWrtShell->ApplyAutoMark();
+ m_pWrtShell->UpdateTableOf( *pBase );
+ m_pWrtShell->EndAction();
+ if (!bWasLocked)
+ m_pWrtShell->LockView(false);
+ }
+ }
+ break;
+ case FN_UPDATE_TOX:
+ {
+ m_pWrtShell->StartAction();
+ m_pWrtShell->EnterStdMode();
+ bool bOldCursorInReadOnly = m_pWrtShell->IsReadOnlyAvailable();
+ m_pWrtShell->SetReadOnlyAvailable( true );
+
+ for( int i = 0; i < 2; ++i )
+ {
+ if( m_pWrtShell->GetTOXCount() == 1 )
+ ++i;
+
+ while( m_pWrtShell->GotoPrevTOXBase() )
+ ; // jump to the first "table of ..."
+
+ // if we are not in one, jump to next
+ const SwTOXBase* pBase = m_pWrtShell->GetCurTOX();
+ if( !pBase )
+ {
+ if (m_pWrtShell->GotoNextTOXBase())
+ pBase = m_pWrtShell->GetCurTOX();
+ }
+
+ bool bAutoMarkApplied = false;
+ while( pBase )
+ {
+ if(TOX_INDEX == pBase->GetType() && !bAutoMarkApplied)
+ {
+ m_pWrtShell->ApplyAutoMark();
+ bAutoMarkApplied = true;
+ }
+ // pBase is needed only for the interface. Should be changed in future! (JP 1996)
+ m_pWrtShell->UpdateTableOf( *pBase );
+
+ if( m_pWrtShell->GotoNextTOXBase() )
+ pBase = m_pWrtShell->GetCurTOX();
+ else
+ pBase = nullptr;
+ }
+ }
+ m_pWrtShell->SetReadOnlyAvailable( bOldCursorInReadOnly );
+ m_pWrtShell->EndAction();
+ }
+ break;
+ case SID_ATTR_BRUSH:
+ {
+ if(pArgs && SfxItemState::SET == pArgs->GetItemState(RES_BACKGROUND, false, &pItem))
+ {
+ const size_t nCurIdx = m_pWrtShell->GetCurPageDesc();
+ SwPageDesc aDesc( m_pWrtShell->GetPageDesc( nCurIdx ));
+ SwFrameFormat& rMaster = aDesc.GetMaster();
+ rMaster.SetFormatAttr(*pItem);
+ m_pWrtShell->ChgPageDesc( nCurIdx, aDesc);
+ }
+ }
+ break;
+ case SID_CLEARHISTORY:
+ {
+ m_pWrtShell->DelAllUndoObj();
+ }
+ break;
+ case SID_UNDO:
+ {
+ m_pShell->ExecuteSlot(rReq);
+ }
+ break;
+#if defined(_WIN32) || defined UNX
+ case SID_TWAIN_SELECT:
+ case SID_TWAIN_TRANSFER:
+ GetViewImpl()->ExecuteScan( rReq );
+ break;
+#endif
+
+ case SID_ATTR_DEFTABSTOP:
+ {
+ const SfxUInt16Item* pTabStopItem = nullptr;
+ if(pArgs && (pTabStopItem = pArgs->GetItemIfSet(SID_ATTR_DEFTABSTOP, false)))
+ {
+ SvxTabStopItem aDefTabs( 0, 0, SvxTabAdjust::Default, RES_PARATR_TABSTOP );
+ const sal_uInt16 nTab = pTabStopItem->GetValue();
+ MakeDefTabs( nTab, aDefTabs );
+ m_pWrtShell->SetDefault( aDefTabs );
+ }
+ }
+ break;
+ case SID_ATTR_LANGUAGE :
+ {
+ const SvxLanguageItem* pLangItem;
+ if(pArgs && (pLangItem = pArgs->GetItemIfSet(SID_ATTR_LANGUAGE, false)))
+ {
+ SvxLanguageItem aLang(pLangItem->GetLanguage(), RES_CHRATR_LANGUAGE);
+ m_pWrtShell->SetDefault( aLang );
+ lcl_SetAllTextToDefaultLanguage( *m_pWrtShell, RES_CHRATR_LANGUAGE );
+ }
+ }
+ break;
+ case SID_ATTR_CHAR_CTL_LANGUAGE:
+ if(pArgs && SfxItemState::SET == pArgs->GetItemState(RES_CHRATR_CTL_LANGUAGE, false, &pItem))
+ {
+ m_pWrtShell->SetDefault( *pItem );
+ lcl_SetAllTextToDefaultLanguage( *m_pWrtShell, RES_CHRATR_CTL_LANGUAGE );
+ }
+ break;
+ case SID_ATTR_CHAR_CJK_LANGUAGE:
+ if(pArgs && SfxItemState::SET == pArgs->GetItemState(RES_CHRATR_CJK_LANGUAGE, false, &pItem))
+ {
+ m_pWrtShell->SetDefault( *pItem );
+ lcl_SetAllTextToDefaultLanguage( *m_pWrtShell, RES_CHRATR_CJK_LANGUAGE );
+ }
+ break;
+ case FN_OUTLINE_LEVELS_SHOWN:
+ {
+ SwWrtShell& rSh = GetWrtShell();
+ int nOutlineLevel = -1;
+ auto nOutlinePos = rSh.GetOutlinePos();
+ if (nOutlinePos != SwOutlineNodes::npos)
+ nOutlineLevel = rSh.getIDocumentOutlineNodesAccess()->getOutlineLevel(nOutlinePos);
+ SwNumberInputDlg aDlg(GetViewFrame().GetFrameWeld(),
+ SwResId(STR_OUTLINE_LEVELS_SHOWN_TITLE),
+ SwResId(STR_OUTLINE_LEVELS_SHOWN_SPIN_LABEL),
+ nOutlineLevel + 1, 1, 10,
+ SwResId(STR_OUTLINE_LEVELS_SHOWN_HELP_LABEL));
+ if (aDlg.run() == RET_OK)
+ rSh.MakeOutlineLevelsVisible(aDlg.GetNumber());
+ }
+ break;
+ case FN_TOGGLE_OUTLINE_CONTENT_VISIBILITY:
+ {
+ size_t nPos(m_pWrtShell->GetOutlinePos());
+ if (nPos != SwOutlineNodes::npos)
+ GetEditWin().ToggleOutlineContentVisibility(nPos, false);
+ }
+ break;
+ case FN_NAV_ELEMENT:
+ {
+ pArgs->GetItemState(GetPool().GetWhich(FN_NAV_ELEMENT), false, &pItem);
+ if(pItem)
+ {
+ SvxSearchDialogWrapper::SetSearchLabel(SearchLabel::Empty);
+ sal_uInt32 nMoveType(static_cast<const SfxUInt32Item*>(pItem)->GetValue());
+ SwView::SetMoveType(nMoveType);
+ }
+ }
+ break;
+ case FN_SCROLL_PREV:
+ case FN_SCROLL_NEXT:
+ {
+ bool *pbNext = new bool(true);
+ if (nSlot == FN_SCROLL_PREV)
+ *pbNext = false;
+ MoveNavigationHdl(pbNext);
+ }
+ break;
+ case SID_JUMPTOMARK:
+ if( pArgs && SfxItemState::SET == pArgs->GetItemState(SID_JUMPTOMARK, false, &pItem))
+ JumpToSwMark( static_cast<const SfxStringItem*>(pItem)->GetValue() );
+ break;
+ case SID_GALLERY :
+ // First make sure that the sidebar is visible
+ GetViewFrame().ShowChildWindow(SID_SIDEBAR);
+
+ ::sfx2::sidebar::Sidebar::ShowPanel(
+ u"GalleryPanel",
+ GetViewFrame().GetFrame().GetFrameInterface());
+ break;
+ case SID_AVMEDIA_PLAYER :
+ GetViewFrame().ChildWindowExecute(rReq);
+ break;
+ case SID_VIEW_DATA_SOURCE_BROWSER:
+ {
+ SfxViewFrame& rVFrame = GetViewFrame();
+ rVFrame.ChildWindowExecute(rReq);
+ if(rVFrame.HasChildWindow(SID_BROWSER))
+ {
+ const SwDBData& rData = GetWrtShell().GetDBData();
+ SwModule::ShowDBObj(*this, rData);
+ }
+ }
+ break;
+ case FN_INSERT_FIELD_DATA_ONLY:
+ {
+ bool bShow = false;
+ if( pArgs &&
+ SfxItemState::SET == pArgs->GetItemState(nSlot, false, &pItem ))
+ bShow = static_cast<const SfxBoolItem*>(pItem)->GetValue();
+ if((bShow && m_bInMailMerge) != GetViewFrame().HasChildWindow(nSlot))
+ GetViewFrame().ToggleChildWindow(nSlot);
+ //if fields have been successfully inserted call the "real"
+ //mail merge dialog
+#if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
+ SwWrtShell &rSh = GetWrtShell();
+ if(m_bInMailMerge && rSh.IsAnyDatabaseFieldInDoc())
+ {
+ SwDBManager* pDBManager = rSh.GetDBManager();
+ if (pDBManager)
+ {
+ SwDBData aData = rSh.GetDBData();
+ rSh.EnterStdMode(); // force change in text shell; necessary for mixing DB fields
+ AttrChangedNotify(nullptr);
+
+ Sequence<PropertyValue> aProperties
+ {
+ comphelper::makePropertyValue("DataSourceName", aData.sDataSource),
+ comphelper::makePropertyValue("Command", aData.sCommand),
+ comphelper::makePropertyValue("CommandType", aData.nCommandType)
+ };
+ pDBManager->ExecuteFormLetter(rSh, aProperties);
+ }
+ }
+#endif
+ m_bInMailMerge &= bShow;
+ GetViewFrame().GetBindings().Invalidate(FN_INSERT_FIELD);
+ }
+ break;
+ case FN_QRY_MERGE:
+ {
+ bool bUseCurrentDocument = true;
+ bool bQuery = !pArgs || SfxItemState::SET != pArgs->GetItemState(nSlot);
+ if(bQuery)
+ {
+ SfxViewFrame& rTmpFrame = GetViewFrame();
+ SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
+ ScopedVclPtr<AbstractMailMergeCreateFromDlg> pDlg(pFact->CreateMailMergeCreateFromDlg(rTmpFrame.GetFrameWeld()));
+ if (RET_OK == pDlg->Execute())
+ bUseCurrentDocument = pDlg->IsThisDocument();
+ else
+ break;
+ }
+ GenerateFormLetter(bUseCurrentDocument);
+ }
+ break;
+ case SID_RECHECK_DOCUMENT:
+ {
+ SwDocShell* pDocShell = GetDocShell();
+ SwDoc* pDoc = pDocShell->GetDoc();
+ uno::Reference< linguistic2::XProofreadingIterator > xGCIterator( pDoc->GetGCIterator() );
+ if( xGCIterator.is() )
+ {
+ xGCIterator->resetIgnoreRules();
+ }
+ // reset ignore lists
+ pDoc->SpellItAgainSam( true, false, false );
+ // clear ignore dictionary
+ uno::Reference< linguistic2::XDictionary > xDictionary = LinguMgr::GetIgnoreAllList();
+ if( xDictionary.is() )
+ xDictionary->clear();
+ // put cursor to the start of the document
+ m_pWrtShell->StartOfSection();
+ [[fallthrough]]; // call spell/grammar dialog
+ }
+ case FN_SPELL_GRAMMAR_DIALOG:
+ {
+ SfxViewFrame& rViewFrame = GetViewFrame();
+ if (rReq.GetArgs() != nullptr)
+ rViewFrame.SetChildWindow (FN_SPELL_GRAMMAR_DIALOG,
+ static_cast<const SfxBoolItem&>( (rReq.GetArgs()->
+ Get(FN_SPELL_GRAMMAR_DIALOG))).GetValue());
+ else
+ rViewFrame.ToggleChildWindow(FN_SPELL_GRAMMAR_DIALOG);
+
+ rViewFrame.GetBindings().Invalidate(FN_SPELL_GRAMMAR_DIALOG);
+ rReq.Ignore ();
+ }
+ break;
+ case SID_ALIGN_ANY_LEFT :
+ case SID_ALIGN_ANY_HCENTER :
+ case SID_ALIGN_ANY_RIGHT :
+ case SID_ALIGN_ANY_JUSTIFIED:
+ case SID_ALIGN_ANY_TOP :
+ case SID_ALIGN_ANY_VCENTER :
+ case SID_ALIGN_ANY_BOTTOM :
+ case SID_ALIGN_ANY_HDEFAULT :
+ case SID_ALIGN_ANY_VDEFAULT :
+ {
+ sal_uInt16 nAlias = 0;
+ if( m_nSelectionType & (SelectionType::DrawObjectEditMode|SelectionType::Text) )
+ {
+ switch( nSlot )
+ {
+ case SID_ALIGN_ANY_LEFT : nAlias = SID_ATTR_PARA_ADJUST_LEFT; break;
+ case SID_ALIGN_ANY_HCENTER : nAlias = SID_ATTR_PARA_ADJUST_CENTER; break;
+ case SID_ALIGN_ANY_RIGHT : nAlias = SID_ATTR_PARA_ADJUST_RIGHT; break;
+ case SID_ALIGN_ANY_JUSTIFIED: nAlias = SID_ATTR_PARA_ADJUST_BLOCK; break;
+ case SID_ALIGN_ANY_TOP : nAlias = SID_TABLE_VERT_NONE; break;
+ case SID_ALIGN_ANY_VCENTER : nAlias = SID_TABLE_VERT_CENTER; break;
+ case SID_ALIGN_ANY_BOTTOM : nAlias = SID_TABLE_VERT_BOTTOM; break;
+ }
+ }
+ else
+ {
+ switch( nSlot )
+ {
+ case SID_ALIGN_ANY_LEFT : nAlias = SID_OBJECT_ALIGN_LEFT ; break;
+ case SID_ALIGN_ANY_HCENTER : nAlias = SID_OBJECT_ALIGN_CENTER ; break;
+ case SID_ALIGN_ANY_RIGHT : nAlias = SID_OBJECT_ALIGN_RIGHT ; break;
+ case SID_ALIGN_ANY_TOP : nAlias = SID_OBJECT_ALIGN_UP ; break;
+ case SID_ALIGN_ANY_VCENTER : nAlias = SID_OBJECT_ALIGN_MIDDLE ; break;
+ case SID_ALIGN_ANY_BOTTOM : nAlias = SID_OBJECT_ALIGN_DOWN ; break;
+ }
+ }
+ //these slots are either re-mapped to text or object alignment
+ if (nAlias)
+ GetViewFrame().GetDispatcher()->Execute(
+ nAlias, SfxCallMode::ASYNCHRON);
+ }
+ break;
+ case SID_RESTORE_EDITING_VIEW:
+ {
+ //#i33307# restore editing position
+ Point aCursorPos;
+ bool bSelectObj;
+ if(m_pViewImpl->GetRestorePosition(aCursorPos, bSelectObj))
+ {
+ m_pWrtShell->SwCursorShell::SetCursor( aCursorPos, !bSelectObj );
+ if( bSelectObj )
+ {
+ m_pWrtShell->SelectObj( aCursorPos );
+ m_pWrtShell->EnterSelFrameMode( &aCursorPos );
+ }
+ }
+ }
+ break;
+ case SID_INSERT_GRAPHIC:
+ {
+ rReq.SetReturnValue(SfxBoolItem(nSlot, InsertGraphicDlg( rReq )));
+ }
+ break;
+ case SID_MOVE_SHAPE_HANDLE:
+ {
+ if (pArgs && pArgs->Count() >= 3)
+ {
+ SdrView *pSdrView = m_pWrtShell->HasDrawView() ? m_pWrtShell->GetDrawView() : nullptr;
+ if (pSdrView == nullptr)
+ break;
+ const SfxUInt32Item* handleNumItem = rReq.GetArg<SfxUInt32Item>(FN_PARAM_1);
+ const SfxUInt32Item* newPosXTwips = rReq.GetArg<SfxUInt32Item>(FN_PARAM_2);
+ const SfxUInt32Item* newPosYTwips = rReq.GetArg<SfxUInt32Item>(FN_PARAM_3);
+ const SfxInt32Item* OrdNum = rReq.GetArg<SfxInt32Item>(FN_PARAM_4);
+
+ const sal_uLong handleNum = handleNumItem->GetValue();
+ const sal_uLong newPosX = newPosXTwips->GetValue();
+ const sal_uLong newPosY = newPosYTwips->GetValue();
+ const Point mPoint(newPosX, newPosY);
+ const SdrHdl* handle = pSdrView->GetHdlList().GetHdl(handleNum);
+ if (!handle)
+ {
+ break;
+ }
+
+ if (handle->GetKind() == SdrHdlKind::Anchor || handle->GetKind() == SdrHdlKind::Anchor_TR)
+ m_pWrtShell->FindAnchorPos(mPoint, /*bMoveIt=*/true);
+ else
+ pSdrView->MoveShapeHandle(handleNum, mPoint, OrdNum ? OrdNum->GetValue() : -1);
+ }
+ break;
+ }
+
+ default:
+ OSL_ENSURE(false, "wrong dispatcher");
+ return;
+ }
+ if(!bIgnore)
+ rReq.Done();
+}
+
+bool SwView::IsConditionalFastCall( const SfxRequest &rReq )
+{
+ sal_uInt16 nId = rReq.GetSlot();
+ bool bRet = false;
+
+ if (nId == FN_REDLINE_ACCEPT_DIRECT || nId == FN_REDLINE_REJECT_DIRECT)
+ {
+ if (comphelper::LibreOfficeKit::isActive())
+ bRet = true;
+ }
+ return bRet || SfxShell::IsConditionalFastCall(rReq);
+
+}
+
+/// invalidate page numbering field
+void SwView::UpdatePageNums()
+{
+ SfxBindings &rBnd = GetViewFrame().GetBindings();
+ rBnd.Invalidate(FN_STAT_PAGE);
+}
+
+void SwView::UpdateDocStats()
+{
+ SfxBindings &rBnd = GetViewFrame().GetBindings();
+ rBnd.Invalidate( FN_STAT_WORDCOUNT );
+ rBnd.Update( FN_STAT_WORDCOUNT );
+}
+
+/// get status of the status line
+void SwView::StateStatusLine(SfxItemSet &rSet)
+{
+ SwWrtShell& rShell = GetWrtShell();
+
+ SfxWhichIter aIter( rSet );
+ sal_uInt16 nWhich = aIter.FirstWhich();
+ OSL_ENSURE( nWhich, "empty set");
+
+ //get section change event
+ const SwSection* CurrSect = rShell.GetCurrSection();
+ if( CurrSect )
+ {
+ const OUString& sCurrentSectionName = CurrSect->GetSectionName();
+ if(sCurrentSectionName != m_sOldSectionName)
+ {
+ SwCursorShell::FireSectionChangeEvent(2, 1);
+ }
+ m_sOldSectionName = sCurrentSectionName;
+ }
+ else if (!m_sOldSectionName.isEmpty())
+ {
+ SwCursorShell::FireSectionChangeEvent(2, 1);
+ m_sOldSectionName= OUString();
+ }
+ //get column change event
+ if(rShell.bColumnChange())
+ {
+ SwCursorShell::FireColumnChangeEvent(2, 1);
+ }
+
+ while( nWhich )
+ {
+ switch( nWhich )
+ {
+ case FN_STAT_PAGE:
+ {
+ OUString aTooltip;
+ OUString aPageStr;
+
+ SwVisiblePageNumbers aVisiblePageNumbers;
+ m_pWrtShell->GetFirstLastVisPageNumbers(aVisiblePageNumbers);
+
+ // convert to strings and define references
+ OUString sFirstPhy = OUString::number(aVisiblePageNumbers.nFirstPhy);
+ OUString sLastPhy = OUString::number(aVisiblePageNumbers.nLastPhy);
+ OUString sFirstVirt = OUString::number(aVisiblePageNumbers.nFirstVirt);
+ OUString sLastVirt = OUString::number(aVisiblePageNumbers.nLastVirt);
+ OUString& sFirstCustomPhy = aVisiblePageNumbers.sFirstCustomPhy;
+ OUString& sLastCustomPhy = aVisiblePageNumbers.sLastCustomPhy;
+ OUString& sFirstCustomVirt = aVisiblePageNumbers.sFirstCustomVirt;
+ OUString& sLastCustomVirt = aVisiblePageNumbers.sLastCustomVirt;
+ OUString sPageCount = OUString::number(m_pWrtShell->GetPageCount());
+
+ if (aVisiblePageNumbers.nFirstPhy == aVisiblePageNumbers.nFirstVirt)
+ {
+ aTooltip = SwResId(STR_BOOKCTRL_HINT);
+ if (aVisiblePageNumbers.nFirstPhy != aVisiblePageNumbers.nLastPhy)
+ {
+ if (sFirstPhy == sFirstCustomPhy && sLastPhy == sLastCustomPhy)
+ {
+ aPageStr = SwResId(STR_PAGES_COUNT);
+ aPageStr = aPageStr.replaceFirst("%1", sFirstPhy);
+ aPageStr = aPageStr.replaceFirst("%2", sLastPhy);
+ aPageStr = aPageStr.replaceFirst("%3", sPageCount);
+ }
+ else
+ {
+ aPageStr = SwResId(STR_PAGES_COUNT_CUSTOM);
+ aPageStr = aPageStr.replaceFirst("%1", sFirstPhy);
+ aPageStr = aPageStr.replaceFirst("%2", sLastPhy);
+ aPageStr = aPageStr.replaceFirst("%3", sFirstCustomPhy);
+ aPageStr = aPageStr.replaceFirst("%4", sLastCustomPhy);
+ aPageStr = aPageStr.replaceFirst("%5", sPageCount);
+ }
+ }
+ else
+ {
+ if (sFirstPhy == sFirstCustomPhy && sLastPhy == sLastCustomPhy)
+ {
+ aPageStr = SwResId(STR_PAGE_COUNT);
+ aPageStr = aPageStr.replaceFirst("%1", sFirstPhy);
+ aPageStr = aPageStr.replaceFirst("%2", sPageCount);
+ }
+ else
+ {
+ aPageStr = SwResId(STR_PAGE_COUNT_CUSTOM);
+ aPageStr = aPageStr.replaceFirst("%1", sFirstPhy);
+ aPageStr = aPageStr.replaceFirst("%2", sFirstCustomPhy);
+ aPageStr = aPageStr.replaceFirst("%3", sPageCount);
+ }
+ }
+ }
+ else
+ {
+ aTooltip = SwResId(STR_BOOKCTRL_HINT_EXTENDED);
+ if (aVisiblePageNumbers.nFirstPhy != aVisiblePageNumbers.nLastPhy)
+ {
+ if (sFirstPhy == sFirstCustomPhy && sLastPhy == sLastCustomPhy)
+ {
+ aPageStr = SwResId(STR_PAGES_COUNT_EXTENDED);
+ aPageStr = aPageStr.replaceFirst("%1", sFirstPhy);
+ aPageStr = aPageStr.replaceFirst("%2", sLastPhy);
+ aPageStr = aPageStr.replaceFirst("%3", sPageCount);
+ aPageStr = aPageStr.replaceFirst("%4", sFirstVirt);
+ aPageStr = aPageStr.replaceFirst("%5", sLastVirt);
+ }
+ else
+ {
+ aPageStr = SwResId(STR_PAGES_COUNT_CUSTOM_EXTENDED);
+ aPageStr = aPageStr.replaceFirst("%1", sFirstPhy);
+ aPageStr = aPageStr.replaceFirst("%2", sLastPhy);
+ aPageStr = aPageStr.replaceFirst("%3", sFirstCustomPhy);
+ aPageStr = aPageStr.replaceFirst("%4", sLastCustomPhy);
+ aPageStr = aPageStr.replaceFirst("%5", sPageCount);
+ aPageStr = aPageStr.replaceFirst("%6", sFirstVirt);
+ aPageStr = aPageStr.replaceFirst("%7", sLastVirt);
+ aPageStr = aPageStr.replaceFirst("%8", sFirstCustomVirt);
+ aPageStr = aPageStr.replaceFirst("%9", sLastCustomVirt);
+ }
+ }
+ else
+ {
+ if (sFirstPhy == sFirstCustomPhy && sLastPhy == sLastCustomPhy)
+ {
+ aPageStr = SwResId(STR_PAGE_COUNT_EXTENDED);
+ aPageStr = aPageStr.replaceFirst("%1", sFirstPhy);
+ aPageStr = aPageStr.replaceFirst("%2", sPageCount);
+ aPageStr = aPageStr.replaceFirst("%3", sFirstVirt);
+ }
+ else
+ {
+ aPageStr = SwResId(STR_PAGE_COUNT_CUSTOM_EXTENDED);
+ aPageStr = aPageStr.replaceFirst("%1", sFirstPhy);
+ aPageStr = aPageStr.replaceFirst("%2", sFirstCustomPhy);
+ aPageStr = aPageStr.replaceFirst("%3", sPageCount);
+ aPageStr = aPageStr.replaceFirst("%4", sFirstVirt);
+ aPageStr = aPageStr.replaceFirst("%5", sFirstCustomVirt);
+ }
+ }
+ }
+
+ // replace range indicator with two pages conjunction if applicable
+ if ((aVisiblePageNumbers.nLastPhy - aVisiblePageNumbers.nFirstPhy) == 1)
+ aPageStr = aPageStr.replaceAll("-", SwResId(STR_PAGES_TWO_CONJUNCTION));
+
+ // status bar bookmark control string and tooltip
+ std::vector<OUString> aStringList
+ {
+ aPageStr,
+ aTooltip
+ };
+ rSet.Put(SfxStringListItem(FN_STAT_PAGE, &aStringList));
+
+ //if existing page number is not equal to old page number, send out this event.
+ if (m_nOldPageNum != aVisiblePageNumbers.nFirstPhy)
+ {
+ if (m_nOldPageNum != 0)
+ SwCursorShell::FirePageChangeEvent(m_nOldPageNum, aVisiblePageNumbers.nFirstPhy);
+ m_nOldPageNum = aVisiblePageNumbers.nFirstPhy;
+ }
+ const sal_uInt16 nCnt = GetWrtShell().GetPageCnt();
+ if (m_nPageCnt != nCnt) // notify Basic
+ {
+ m_nPageCnt = nCnt;
+ SfxGetpApp()->NotifyEvent(SfxEventHint(SfxEventHintId::SwEventPageCount, SwDocShell::GetEventName(STR_SW_EVENT_PAGE_COUNT), GetViewFrame().GetObjectShell()), false);
+ }
+ }
+ break;
+
+ case FN_STAT_WORDCOUNT:
+ {
+ SwDocStat selectionStats;
+ SwDocStat documentStats;
+ rShell.CountWords(selectionStats);
+ documentStats = rShell.GetDoc()->getIDocumentStatistics().GetUpdatedDocStat( true /* complete-async */, false /* don't update fields */ );
+
+ sal_uLong nWord = selectionStats.nWord ? selectionStats.nWord : documentStats.nWord;
+ sal_uLong nChar = selectionStats.nChar ? selectionStats.nChar : documentStats.nChar;
+ TranslateId pResId = selectionStats.nWord ? STR_WORDCOUNT : STR_WORDCOUNT_NO_SELECTION;
+ TranslateNId pWordResId = selectionStats.nWord ? STR_WORDCOUNT_WORDARG : STR_WORDCOUNT_WORDARG_NO_SELECTION;
+ TranslateNId pCharResId = selectionStats.nWord ? STR_WORDCOUNT_CHARARG : STR_WORDCOUNT_CHARARG_NO_SELECTION;
+
+ const LocaleDataWrapper& rLocaleData = Application::GetSettings().GetUILocaleDataWrapper();
+ OUString aWordArg = SwResId(pWordResId, nWord).replaceAll("$1", rLocaleData.getNum(nWord, 0));
+ OUString aCharArg = SwResId(pCharResId, nChar).replaceAll("$1", rLocaleData.getNum(nChar, 0));
+ OUString aWordCount(SwResId(pResId));
+ aWordCount = aWordCount.replaceAll("$1", aWordArg);
+ aWordCount = aWordCount.replaceAll("$2", aCharArg);
+ rSet.Put( SfxStringItem( FN_STAT_WORDCOUNT, aWordCount ) );
+
+ SwPostItMgr* pPostItMgr = rShell.GetPostItMgr();
+ if (pPostItMgr)
+ selectionStats.nComments = pPostItMgr->end() - pPostItMgr->begin();
+
+ SwWordCountWrapper *pWrdCnt = static_cast<SwWordCountWrapper*>(GetViewFrame().GetChildWindow(SwWordCountWrapper::GetChildWindowId()));
+ if (pWrdCnt)
+ pWrdCnt->SetCounts(selectionStats, documentStats);
+ }
+ break;
+ case FN_STAT_ACCESSIBILITY_CHECK:
+ {
+ std::unique_ptr<sw::OnlineAccessibilityCheck> const& rOnlineAccessibilityCheck = rShell.GetDoc()->getOnlineAccessibilityCheck();
+ if (rOnlineAccessibilityCheck)
+ {
+ sal_Int32 nIssues = rOnlineAccessibilityCheck->getNumberOfAccessibilityIssues()
+ + rOnlineAccessibilityCheck->getNumberOfDocumentLevelAccessibilityIssues();
+ rSet.Put(SfxInt32Item(FN_STAT_ACCESSIBILITY_CHECK, nIssues));
+ }
+ }
+ break;
+
+ case FN_STAT_TEMPLATE:
+ {
+ rSet.Put(SfxStringItem( FN_STAT_TEMPLATE,
+ rShell.GetCurPageStyle()));
+
+ }
+ break;
+ case SID_ATTR_ZOOM:
+ {
+ if ( ( GetDocShell()->GetCreateMode() != SfxObjectCreateMode::EMBEDDED ) || !GetDocShell()->IsInPlaceActive() )
+ {
+ const SwViewOption* pVOpt = rShell.GetViewOptions();
+ SvxZoomType eZoom = pVOpt->GetZoomType();
+ SvxZoomItem aZoom(eZoom,
+ pVOpt->GetZoom());
+ if( pVOpt->getBrowseMode() )
+ {
+ aZoom.SetValueSet(
+ SvxZoomEnableFlags::N50|
+ SvxZoomEnableFlags::N75|
+ SvxZoomEnableFlags::N100|
+ SvxZoomEnableFlags::N150|
+ SvxZoomEnableFlags::N200);
+ }
+ rSet.Put( aZoom );
+ }
+ else
+ rSet.DisableItem( SID_ATTR_ZOOM );
+ }
+ break;
+ case SID_ATTR_VIEWLAYOUT:
+ {
+ if ( ( GetDocShell()->GetCreateMode() != SfxObjectCreateMode::EMBEDDED ) || !GetDocShell()->IsInPlaceActive() )
+ {
+ const SwViewOption* pVOpt = rShell.GetViewOptions();
+ const sal_uInt16 nColumns = pVOpt->GetViewLayoutColumns();
+ const bool bBookMode = pVOpt->IsViewLayoutBookMode();
+ SvxViewLayoutItem aViewLayout(nColumns, bBookMode);
+ rSet.Put( aViewLayout );
+ }
+ else
+ rSet.DisableItem( SID_ATTR_VIEWLAYOUT );
+ }
+ break;
+ case SID_ATTR_ZOOMSLIDER:
+ {
+ if ( ( GetDocShell()->GetCreateMode() != SfxObjectCreateMode::EMBEDDED ) || !GetDocShell()->IsInPlaceActive() )
+ {
+ const SwViewOption* pVOpt = rShell.GetViewOptions();
+ const sal_uInt16 nCurrentZoom = pVOpt->GetZoom();
+ SvxZoomSliderItem aZoomSliderItem( nCurrentZoom, MINZOOM, MAXZOOM );
+ aZoomSliderItem.AddSnappingPoint( 100 );
+
+ if ( !m_pWrtShell->getIDocumentSettingAccess().get(DocumentSettingId::BROWSE_MODE) )
+ {
+ const sal_uInt16 nColumns = pVOpt->GetViewLayoutColumns();
+ const bool bAutomaticViewLayout = 0 == nColumns;
+ const SwPostItMgr* pMgr = GetPostItMgr();
+
+ // snapping points:
+ // automatic mode: 1 Page, 2 Pages, 100%
+ // n Columns mode: n Pages, 100%
+ // n Columns book mode: nPages without gaps, 100%
+ const SwRect aPageRect( m_pWrtShell->GetAnyCurRect( CurRectType::PageCalc ) );
+ const SwRect aRootRect( m_pWrtShell->GetAnyCurRect( CurRectType::PagesArea ) ); // width of columns
+ Size aPageSize( aPageRect.SSize() );
+ aPageSize.AdjustWidth(pMgr->HasNotes() && pMgr->ShowNotes() ?
+ pMgr->GetSidebarWidth() + pMgr->GetSidebarBorderWidth() :
+ 0 );
+
+ Size aRootSize( aRootRect.SSize() );
+
+ const MapMode aTmpMap( MapUnit::MapTwip );
+ const Size& rEditSize = GetEditWin().GetOutputSizePixel();
+ const Size aWindowSize( GetEditWin().PixelToLogic( rEditSize, aTmpMap ) );
+
+ const tools::Long nOf = pVOpt->GetDocumentBorder() * 2;
+ tools::Long nTmpWidth = bAutomaticViewLayout ? aPageSize.Width() : aRootSize.Width();
+ nTmpWidth += nOf;
+ aPageSize.AdjustHeight(nOf );
+ tools::Long nFac = aWindowSize.Width() * 100 / nTmpWidth;
+
+ tools::Long nVisPercent = aWindowSize.Height() * 100 / aPageSize.Height();
+ nFac = std::min( nFac, nVisPercent );
+
+ if (nFac >= MINZOOM)
+ {
+ aZoomSliderItem.AddSnappingPoint( nFac );
+ }
+
+ if ( bAutomaticViewLayout )
+ {
+ nTmpWidth += aPageSize.Width() + pVOpt->GetGapBetweenPages();
+ nFac = aWindowSize.Width() * 100 / nTmpWidth;
+ nFac = std::min( nFac, nVisPercent );
+ if (nFac >= MINZOOM)
+ {
+ aZoomSliderItem.AddSnappingPoint( nFac );
+ }
+ }
+ }
+
+ rSet.Put( aZoomSliderItem );
+ }
+ else
+ rSet.DisableItem( SID_ATTR_ZOOMSLIDER );
+ }
+ break;
+ case SID_ATTR_POSITION:
+ case SID_ATTR_SIZE:
+ {
+ if( !rShell.IsFrameSelected() && !rShell.IsObjSelected() )
+ SwBaseShell::SetFrameMode_( FLY_DRAG_END );
+ else
+ {
+ FlyMode eFrameMode = SwBaseShell::GetFrameMode();
+ if ( eFrameMode == FLY_DRAG_START || eFrameMode == FLY_DRAG )
+ {
+ if ( nWhich == SID_ATTR_POSITION )
+ rSet.Put( SfxPointItem( SID_ATTR_POSITION,
+ rShell.GetAnchorObjDiff()));
+ else
+ rSet.Put( SvxSizeItem( SID_ATTR_SIZE,
+ rShell.GetObjSize()));
+ }
+ }
+ }
+ break;
+ case SID_TABLE_CELL:
+
+ if( rShell.IsFrameSelected() || rShell.IsObjSelected() )
+ {
+ // #i39171# Don't put a SvxSizeItem into a slot which is defined as SfxStringItem.
+ // SvxPosSizeStatusBarControl no longer resets to empty display if only one slot
+ // has no item, so SID_TABLE_CELL can remain empty (the SvxSizeItem is supplied
+ // in SID_ATTR_SIZE).
+ }
+ else
+ {
+ StatusCategory eCategory(StatusCategory::NONE);
+ OUString sStr;
+ if( rShell.IsCursorInTable() )
+ {
+ // table name + cell coordinate
+ sStr = rShell.GetTableFormat()->GetName() + ":" + rShell.GetBoxNms();
+ eCategory = StatusCategory::TableCell;
+ }
+ else
+ {
+ const SwSection* pCurrSect = rShell.GetCurrSection();
+ if( pCurrSect )
+ {
+ switch( pCurrSect->GetType() )
+ {
+ case SectionType::ToxHeader:
+ case SectionType::ToxContent:
+ {
+ const SwTOXBase* pTOX = m_pWrtShell->GetCurTOX();
+ if( pTOX )
+ {
+ sStr = pTOX->GetTOXName();
+ eCategory = StatusCategory::TableOfContents;
+ }
+ else
+ {
+ OSL_ENSURE( false,
+ "Unknown kind of section" );
+ sStr = pCurrSect->GetSectionName();
+ eCategory = StatusCategory::Section;
+ }
+ }
+ break;
+ default:
+ sStr = pCurrSect->GetSectionName();
+ eCategory = StatusCategory::Section;
+ break;
+ }
+ }
+ }
+
+ const SwNumRule* pNumRule = rShell.GetNumRuleAtCurrCursorPos();
+ const bool bOutlineNum = pNumRule && pNumRule->IsOutlineRule();
+
+ if (pNumRule && !bOutlineNum ) // cursor in numbering
+ {
+ sal_uInt8 nNumLevel = rShell.GetNumLevel();
+ if ( nNumLevel < MAXLEVEL )
+ {
+ if(!pNumRule->IsAutoRule())
+ {
+ SfxItemSetFixed<RES_PARATR_NUMRULE, RES_PARATR_NUMRULE> aSet(GetPool());
+ rShell.GetCurAttr(aSet);
+ if(SfxItemState::DEFAULT <=
+ aSet.GetItemState(RES_PARATR_NUMRULE))
+ {
+ const OUString& rNumStyle =
+ aSet.Get(RES_PARATR_NUMRULE).GetValue();
+ if(!rNumStyle.isEmpty())
+ {
+ if(!sStr.isEmpty())
+ sStr += sStatusDelim;
+ if (eCategory == StatusCategory::NONE)
+ eCategory = StatusCategory::ListStyle;
+ sStr += rNumStyle;
+ }
+ }
+ }
+ if (!sStr.isEmpty())
+ sStr += sStatusDelim;
+ sStr += SwResId(STR_NUM_LEVEL) + OUString::number( nNumLevel + 1 );
+ if (eCategory == StatusCategory::NONE)
+ eCategory = StatusCategory::Numbering;
+ }
+ }
+ const int nOutlineLevel = rShell.GetCurrentParaOutlineLevel();
+ if( nOutlineLevel != 0 )
+ {
+ if (!sStr.isEmpty())
+ sStr += " , ";
+ if( bOutlineNum )
+ {
+ sStr += SwResId(STR_OUTLINE_NUMBERING) +
+ sStatusDelim + SwResId(STR_NUM_LEVEL);
+ }
+ else
+ sStr += SwResId(STR_NUM_OUTLINE);
+ sStr += OUString::number( nOutlineLevel);
+ if (eCategory == StatusCategory::NONE)
+ eCategory = StatusCategory::Numbering;
+ }
+
+ if( rShell.HasReadonlySel() )
+ {
+ if (!sStr.isEmpty())
+ sStr = sStatusDelim + sStr;
+ sStr = SwResId(SW_STR_READONLY) + sStr;
+ }
+ if (!sStr.isEmpty())
+ rSet.Put( SvxStatusItem( SID_TABLE_CELL, sStr, eCategory ));
+ }
+ break;
+ case FN_STAT_SELMODE:
+ {
+ if(rShell.IsStdMode())
+ rSet.Put(SfxUInt16Item(FN_STAT_SELMODE, 0));
+ else if(rShell.IsAddMode())
+ rSet.Put(SfxUInt16Item(FN_STAT_SELMODE, 2));
+ else if(rShell.IsBlockMode())
+ rSet.Put(SfxUInt16Item(FN_STAT_SELMODE, 3));
+ else
+ rSet.Put(SfxUInt16Item(FN_STAT_SELMODE, 1));
+ break;
+ }
+ case SID_ATTR_INSERT:
+ if( rShell.IsRedlineOn() )
+ rSet.DisableItem( nWhich );
+ else
+ {
+ rSet.Put(SfxBoolItem(SID_ATTR_INSERT,rShell.IsInsMode()));
+ }
+ break;
+ }
+ nWhich = aIter.NextWhich();
+ }
+}
+
+/** execute method for the status line
+ *
+ * @param rReq ???
+ */
+void SwView::ExecuteStatusLine(SfxRequest &rReq)
+{
+ SwWrtShell &rSh = GetWrtShell();
+ const SfxItemSet* pArgs = rReq.GetArgs();
+ const SfxPoolItem* pItem=nullptr;
+ bool bUp = false;
+ sal_uInt16 nWhich = rReq.GetSlot();
+ switch( nWhich )
+ {
+ case FN_STAT_PAGE:
+ {
+ GetViewFrame().GetDispatcher()->Execute( FN_GOTO_PAGE,
+ SfxCallMode::SYNCHRON|SfxCallMode::RECORD );
+ }
+ break;
+
+ case FN_STAT_WORDCOUNT:
+ {
+ GetViewFrame().GetDispatcher()->Execute(FN_WORDCOUNT_DIALOG,
+ SfxCallMode::SYNCHRON|SfxCallMode::RECORD );
+ }
+ break;
+
+ case FN_STAT_ACCESSIBILITY_CHECK:
+ {
+ const SfxStringItem sDeckName(SID_SIDEBAR_DECK, "A11yCheckDeck");
+ GetViewFrame().GetDispatcher()->ExecuteList(SID_SIDEBAR_DECK, SfxCallMode::RECORD,
+ { &sDeckName });
+ }
+ break;
+
+ case FN_STAT_BOOKMARK:
+ if ( pArgs )
+ {
+ if (SfxItemState::SET == pArgs->GetItemState( nWhich, true, &pItem))
+ {
+ const IDocumentMarkAccess* pMarkAccess = rSh.getIDocumentMarkAccess();
+ const sal_Int32 nIdx = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
+ if(nIdx < pMarkAccess->getBookmarksCount())
+ {
+ const IDocumentMarkAccess::const_iterator_t ppBookmark = rSh.getIDocumentMarkAccess()->getBookmarksBegin() + nIdx;
+ rSh.EnterStdMode();
+ rSh.GotoMark( *ppBookmark );
+ }
+ else
+ OSL_FAIL("SwView::ExecuteStatusLine(..)"
+ " - Ignoring out of range bookmark index");
+ }
+ }
+ break;
+
+ case FN_STAT_TEMPLATE:
+ {
+ weld::Window* pDialogParent = GetViewFrame().GetFrameWeld();
+ css::uno::Any aAny(pDialogParent->GetXWindow());
+ SfxUnoAnyItem aDialogParent(SID_DIALOG_PARENT, aAny);
+ const SfxPoolItem* pInternalItems[ 2 ];
+ pInternalItems[ 0 ] = &aDialogParent;
+ pInternalItems[ 1 ] = nullptr;
+ GetViewFrame().GetDispatcher()->Execute(FN_FORMAT_PAGE_DLG,
+ SfxCallMode::SYNCHRON|SfxCallMode::RECORD,
+ nullptr, 0, pInternalItems);
+ }
+ break;
+ case SID_ATTR_ZOOM:
+ {
+ if ( ( GetDocShell()->GetCreateMode() != SfxObjectCreateMode::EMBEDDED ) || !GetDocShell()->IsInPlaceActive() )
+ {
+ const SfxItemSet *pSet = nullptr;
+ ScopedVclPtr<AbstractSvxZoomDialog> pDlg;
+ if ( pArgs )
+ pSet = pArgs;
+ else
+ {
+ const SwViewOption& rViewOptions = *rSh.GetViewOptions();
+ SfxItemSetFixed<SID_ATTR_ZOOM, SID_ATTR_ZOOM, SID_ATTR_VIEWLAYOUT, SID_ATTR_VIEWLAYOUT> aCoreSet(m_pShell->GetPool());
+ SvxZoomItem aZoom( rViewOptions.GetZoomType(), rViewOptions.GetZoom() );
+
+ const bool bBrowseMode = rSh.GetViewOptions()->getBrowseMode();
+ if( bBrowseMode )
+ {
+ aZoom.SetValueSet(
+ SvxZoomEnableFlags::N50|
+ SvxZoomEnableFlags::N75|
+ SvxZoomEnableFlags::N100|
+ SvxZoomEnableFlags::N150|
+ SvxZoomEnableFlags::N200);
+ }
+ aCoreSet.Put( aZoom );
+
+ if ( !bBrowseMode )
+ {
+ const SvxViewLayoutItem aViewLayout( rViewOptions.GetViewLayoutColumns(), rViewOptions.IsViewLayoutBookMode() );
+ aCoreSet.Put( aViewLayout );
+ }
+
+ SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
+ pDlg.disposeAndReset(pFact->CreateSvxZoomDialog(GetViewFrame().GetFrameWeld(), aCoreSet));
+ pDlg->SetLimits( MINZOOM, MAXZOOM );
+ if( pDlg->Execute() != RET_CANCEL )
+ pSet = pDlg->GetOutputItemSet();
+ }
+
+ const SvxViewLayoutItem* pViewLayoutItem = nullptr;
+ if ( pSet && (pViewLayoutItem = pSet->GetItemIfSet(SID_ATTR_VIEWLAYOUT)))
+ {
+ const sal_uInt16 nColumns = pViewLayoutItem->GetValue();
+ const bool bBookMode = pViewLayoutItem->IsBookMode();
+ SetViewLayout( nColumns, bBookMode );
+ }
+
+ const SvxZoomItem* pZoomItem = nullptr;
+ if ( pSet && (pZoomItem = pSet->GetItemIfSet(SID_ATTR_ZOOM)))
+ {
+ SvxZoomType eType = pZoomItem->GetType();
+ SetZoom( eType, pZoomItem->GetValue() );
+ }
+ bUp = true;
+ if ( pZoomItem )
+ rReq.AppendItem( *pZoomItem );
+ rReq.Done();
+ }
+ }
+ break;
+
+ case SID_ATTR_VIEWLAYOUT:
+ {
+ if ( pArgs && !rSh.getIDocumentSettingAccess().get(DocumentSettingId::BROWSE_MODE) &&
+ ( ( GetDocShell()->GetCreateMode() != SfxObjectCreateMode::EMBEDDED ) || !GetDocShell()->IsInPlaceActive() ) )
+ {
+ if ( const SvxViewLayoutItem* pLayoutItem = pArgs->GetItemIfSet(SID_ATTR_VIEWLAYOUT ))
+ {
+ const sal_uInt16 nColumns = pLayoutItem->GetValue();
+ const bool bBookMode = (0 != nColumns && 0 == (nColumns % 2)) && pLayoutItem->IsBookMode();
+
+ SetViewLayout( nColumns, bBookMode );
+ }
+
+ bUp = true;
+ rReq.Done();
+
+ InvalidateRulerPos();
+ }
+ }
+ break;
+
+ case SID_ATTR_ZOOMSLIDER:
+ {
+ if ( pArgs && ( ( GetDocShell()->GetCreateMode() != SfxObjectCreateMode::EMBEDDED ) || !GetDocShell()->IsInPlaceActive() ) )
+ {
+ if ( const SvxZoomSliderItem* pZoomItem = pArgs->GetItemIfSet(SID_ATTR_ZOOMSLIDER) )
+ {
+ const sal_uInt16 nCurrentZoom = pZoomItem->GetValue();
+ SetZoom( SvxZoomType::PERCENT, nCurrentZoom );
+ }
+
+ bUp = true;
+ rReq.Done();
+ }
+ }
+ break;
+
+ case SID_ATTR_SIZE:
+ {
+ sal_uInt16 nId = 0;
+ if( rSh.IsCursorInTable() )
+ nId = FN_FORMAT_TABLE_DLG;
+ else if( rSh.GetCurTOX() )
+ nId = FN_INSERT_MULTI_TOX;
+ else if( rSh.GetCurrSection() )
+ nId = FN_EDIT_REGION;
+ else
+ {
+ const SwNumRule* pNumRule = rSh.GetNumRuleAtCurrCursorPos();
+ if( pNumRule ) // cursor in numbering
+ {
+ if( pNumRule->IsAutoRule() )
+ nId = FN_NUMBER_BULLETS;
+ else
+ {
+ // start dialog of the painter
+ nId = 0;
+ }
+ }
+ else if( rSh.IsFrameSelected() )
+ nId = FN_FORMAT_FRAME_DLG;
+ else if( rSh.IsObjSelected() )
+ nId = SID_ATTR_TRANSFORM;
+ }
+ if( nId )
+ GetViewFrame().GetDispatcher()->Execute(nId,
+ SfxCallMode::SYNCHRON | SfxCallMode::RECORD );
+ }
+ break;
+
+ case FN_STAT_SELMODE:
+ {
+ if ( pArgs )
+ {
+ if (SfxItemState::SET == pArgs->GetItemState( nWhich, true, &pItem))
+ {
+ switch ( static_cast<const SfxUInt16Item *>(pItem)->GetValue() )
+ {
+ case 0: rSh.EnterStdMode(); break;
+ case 1: rSh.EnterExtMode(); break;
+ case 2: rSh.EnterAddMode(); break;
+ case 3: rSh.EnterBlockMode(); break;
+ }
+ }
+ }
+ bUp = true;
+ break;
+ }
+ case FN_SET_ADD_MODE:
+ rSh.ToggleAddMode();
+ nWhich = FN_STAT_SELMODE;
+ bUp = true;
+ break;
+ case FN_SET_BLOCK_MODE:
+ rSh.ToggleBlockMode();
+ nWhich = FN_STAT_SELMODE;
+ bUp = true;
+ break;
+ case FN_SET_EXT_MODE:
+ rSh.ToggleExtMode();
+ nWhich = FN_STAT_SELMODE;
+ bUp = true;
+ break;
+ case SID_ATTR_INSERT:
+ SwPostItMgr* pMgr = GetPostItMgr();
+ if ( pMgr && pMgr->HasActiveSidebarWin() )
+ {
+ pMgr->ToggleInsModeOnActiveSidebarWin();
+ }
+ else
+ rSh.ToggleInsMode();
+ bUp = true;
+ break;
+
+ }
+ if ( bUp )
+ {
+ SfxBindings &rBnd = GetViewFrame().GetBindings();
+ rBnd.Invalidate(nWhich);
+ rBnd.Update(nWhich);
+ }
+}
+
+void SwView::InsFrameMode(sal_uInt16 nCols)
+{
+ if ( m_pWrtShell->HasWholeTabSelection() )
+ {
+ SwFlyFrameAttrMgr aMgr( true, m_pWrtShell.get(), Frmmgr_Type::TEXT, nullptr );
+
+ const SwFrameFormat &rPageFormat =
+ m_pWrtShell->GetPageDesc(m_pWrtShell->GetCurPageDesc()).GetMaster();
+ SwTwips lWidth = rPageFormat.GetFrameSize().GetWidth();
+ const SvxLRSpaceItem &rLR = rPageFormat.GetLRSpace();
+ lWidth -= rLR.GetLeft() + rLR.GetRight();
+ aMgr.SetSize(Size(lWidth, aMgr.GetSize().Height()));
+ if(nCols > 1)
+ {
+ SwFormatCol aCol;
+ aCol.Init( nCols, aCol.GetGutterWidth(), aCol.GetWishWidth() );
+ aMgr.SetCol( aCol );
+ }
+ aMgr.InsertFlyFrame();
+ }
+ else
+ GetEditWin().InsFrame(nCols);
+}
+
+/// show "edit link" dialog
+void SwView::EditLinkDlg()
+{
+ if (officecfg::Office::Common::Security::Scripting::DisableActiveContent::get())
+ {
+ std::unique_ptr<weld::MessageDialog> xError(
+ Application::CreateMessageDialog(nullptr, VclMessageType::Warning, VclButtonsType::Ok,
+ SvtResId(STR_WARNING_EXTERNAL_LINK_EDIT_DISABLED)));
+ xError->run();
+ return;
+ }
+
+ bool bWeb = dynamic_cast<SwWebView*>( this ) != nullptr;
+ SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
+ ScopedVclPtr<SfxAbstractLinksDialog> pDlg(pFact->CreateLinksDialog(GetViewFrame().GetFrameWeld(), &GetWrtShell().GetLinkManager(), bWeb));
+ pDlg->Execute();
+}
+
+namespace sw {
+
+auto PrepareJumpToTOXMark(SwDoc const& rDoc, std::u16string_view aName)
+ -> std::optional<std::pair<SwTOXMark, sal_Int32>>
+{
+ size_t const first(aName.find(toxMarkSeparator));
+ if (first == std::u16string_view::npos)
+ {
+ SAL_WARN("sw.ui", "JumpToTOXMark: missing separator");
+ return std::optional<std::pair<SwTOXMark, sal_Int32>>();
+ }
+ sal_Int32 const counter(o3tl::toInt32(aName.substr(0, first)));
+ if (counter <= 0)
+ {
+ SAL_WARN("sw.ui", "JumpToTOXMark: invalid counter");
+ return std::optional<std::pair<SwTOXMark, sal_Int32>>();
+ }
+ size_t const second(aName.find(toxMarkSeparator, first + 1));
+ if (second == std::u16string_view::npos)
+ {
+ SAL_WARN("sw.ui", "JumpToTOXMark: missing separator");
+ return std::optional<std::pair<SwTOXMark, sal_Int32>>();
+ }
+ std::u16string_view const entry(aName.substr(first + 1, second - (first + 1)));
+ if (aName.size() < second + 2)
+ {
+ SAL_WARN("sw.ui", "JumpToTOXMark: invalid tox");
+ return std::optional<std::pair<SwTOXMark, sal_Int32>>();
+ }
+ sal_uInt16 const indexType(aName[second + 1]);
+ std::u16string_view const indexName(aName.substr(second + 2));
+ SwTOXType const* pType(nullptr);
+ switch (indexType)
+ {
+ case 'A':
+ pType = rDoc.GetTOXType(TOX_INDEX, 0);
+ assert(pType);
+ break;
+ case 'C':
+ pType = rDoc.GetTOXType(TOX_CONTENT, 0);
+ assert(pType);
+ break;
+ case 'U':
+ for (auto i = rDoc.GetTOXTypeCount(TOX_USER); 0 < i; )
+ {
+ --i;
+ auto const pTmp(rDoc.GetTOXType(TOX_USER, i));
+ if (pTmp->GetTypeName() == indexName)
+ {
+ pType = pTmp;
+ break;
+ }
+ }
+ break;
+ }
+ if (!pType)
+ {
+ SAL_WARN("sw.ui", "JumpToTOXMark: tox doesn't exist");
+ return std::optional<std::pair<SwTOXMark, sal_Int32>>();
+ }
+ // type and alt text are the search keys
+ SwTOXMark tmp(pType);
+ tmp.SetAlternativeText(OUString(entry));
+ return std::optional<std::pair<SwTOXMark, sal_Int32>>(std::pair<SwTOXMark, sal_Int32>(tmp, counter));
+}
+
+} // namespace sw
+
+static auto JumpToTOXMark(SwWrtShell & rSh, std::u16string_view aName) -> bool
+{
+ std::optional<std::pair<SwTOXMark, sal_Int32>> const tmp(
+ sw::PrepareJumpToTOXMark(*rSh.GetDoc(), aName));
+ if (!tmp)
+ {
+ return false;
+ }
+ SwTOXMark const* pMark(&tmp->first);
+ // hack: check first if one exists
+ // need simple ptr control, else UnitTest CppunitTest_sw_uiwriter3 fails
+ if (!areSfxPoolItemPtrsEqual(&tmp->first, &rSh.GetDoc()->GotoTOXMark(tmp->first, TOX_SAME_NXT, rSh.IsReadOnlyAvailable())))
+ {
+ for (sal_Int32 i = 0; i < tmp->second; ++i)
+ {
+ pMark = &rSh.GotoTOXMark(*pMark, TOX_SAME_NXT);
+ }
+ return true;
+ }
+ else
+ {
+ SAL_WARN("sw.ui", "JumpToTOXMark: tox mark doesn't exist");
+ return false;
+ }
+}
+
+bool SwView::JumpToSwMark( std::u16string_view rMark )
+{
+ bool bRet = false;
+ if( !rMark.empty() )
+ {
+ // place bookmark at top-center
+ bool bSaveCC = m_bCenterCursor;
+ bool bSaveCT = m_bTopCursor;
+ SetCursorAtTop( true );
+
+ // For scrolling the FrameSet, the corresponding shell needs to have the focus.
+ bool bHasShFocus = m_pWrtShell->HasShellFocus();
+ if( !bHasShFocus )
+ m_pWrtShell->ShellGetFocus();
+
+ const SwFormatINetFormat* pINet;
+ OUString sCmp;
+ OUString sMark( INetURLObject::decode( rMark,
+ INetURLObject::DecodeMechanism::WithCharset ));
+
+ sal_Int32 nLastPos, nPos = sMark.indexOf( cMarkSeparator );
+ if( -1 != nPos )
+ while( -1 != ( nLastPos = sMark.indexOf( cMarkSeparator, nPos + 1 )) )
+ nPos = nLastPos;
+
+ IDocumentMarkAccess::const_iterator_t ppMark;
+ IDocumentMarkAccess* const pMarkAccess = m_pWrtShell->getIDocumentMarkAccess();
+ if( -1 != nPos )
+ sCmp = sMark.copy(nPos + 1).replaceAll(" ", "");
+
+ if( !sCmp.isEmpty() )
+ {
+ OUString sName( sMark.copy( 0, nPos ) );
+ sCmp = sCmp.toAsciiLowerCase();
+ FlyCntType eFlyType = FLYCNTTYPE_ALL;
+
+ if (sCmp == "drawingobject")
+ bRet = m_pWrtShell->GotoDrawingObject(sName);
+ else if( sCmp == "region" )
+ {
+ m_pWrtShell->EnterStdMode();
+ bRet = m_pWrtShell->GotoRegion( sName );
+ }
+ else if( sCmp == "outline" )
+ {
+ m_pWrtShell->EnterStdMode();
+ bRet = m_pWrtShell->GotoOutline( sName );
+ }
+ else if( sCmp == "frame" )
+ eFlyType = FLYCNTTYPE_FRM;
+ else if( sCmp == "graphic" )
+ eFlyType = FLYCNTTYPE_GRF;
+ else if( sCmp == "ole" )
+ eFlyType = FLYCNTTYPE_OLE;
+ else if( sCmp == "table" )
+ {
+ m_pWrtShell->EnterStdMode();
+ bRet = m_pWrtShell->GotoTable( sName );
+ }
+ else if( sCmp == "sequence" )
+ {
+ m_pWrtShell->EnterStdMode();
+ sal_Int32 nNoPos = sName.indexOf( cSequenceMarkSeparator );
+ if ( nNoPos != -1 )
+ {
+ sal_uInt16 nSeqNo = o3tl::toInt32(sName.subView( nNoPos + 1 ));
+ sName = sName.copy( 0, nNoPos );
+ bRet = m_pWrtShell->GotoRefMark(sName, REF_SEQUENCEFLD, nSeqNo);
+ }
+ }
+ else if (sCmp == "toxmark")
+ {
+ bRet = JumpToTOXMark(*m_pWrtShell, sName);
+ }
+ else if( sCmp == "text" )
+ {
+ // normal text search
+ m_pWrtShell->EnterStdMode();
+
+ i18nutil::SearchOptions2 aSearchOpt(
+ 0,
+ sName, OUString(),
+ SvtSysLocale().GetLanguageTag().getLocale(),
+ 0,0,0,
+ TransliterationFlags::IGNORE_CASE,
+ SearchAlgorithms2::ABSOLUTE,
+ '\\' );
+
+ //todo/mba: assuming that notes shouldn't be searched
+ if( m_pWrtShell->SearchPattern( aSearchOpt, false/*bSearchInNotes*/, SwDocPositions::Start, SwDocPositions::End ))
+ {
+ m_pWrtShell->EnterStdMode(); // remove the selection
+ bRet = true;
+ }
+ }
+ else if( pMarkAccess->getAllMarksEnd() != (ppMark = pMarkAccess->findMark(sMark)) )
+ {
+ bRet = m_pWrtShell->GotoMark( *ppMark, false );
+ }
+ else if( nullptr != ( pINet = m_pWrtShell->FindINetAttr( sMark ) )) {
+ m_pWrtShell->addCurrentPosition();
+ bRet = m_pWrtShell->GotoINetAttr( *pINet->GetTextINetFormat() );
+ }
+
+ // for all types of Flys
+ if( FLYCNTTYPE_ALL != eFlyType && m_pWrtShell->GotoFly( sName, eFlyType ))
+ {
+ bRet = true;
+ if( FLYCNTTYPE_FRM == eFlyType )
+ {
+ // TextFrames: set Cursor in the frame
+ m_pWrtShell->UnSelectFrame();
+ m_pWrtShell->LeaveSelFrameMode();
+ }
+ else
+ {
+ m_pWrtShell->HideCursor();
+ m_pWrtShell->EnterSelFrameMode();
+ }
+ }
+ }
+ else if( pMarkAccess->getAllMarksEnd() != (ppMark = pMarkAccess->findMark(sMark)))
+ {
+ bRet = m_pWrtShell->GotoMark( *ppMark, false );
+ }
+ else if( nullptr != ( pINet = m_pWrtShell->FindINetAttr( sMark ) ))
+ bRet = m_pWrtShell->GotoINetAttr( *pINet->GetTextINetFormat() );
+
+ // make selection visible later
+ if ( m_aVisArea.IsEmpty() )
+ m_bMakeSelectionVisible = true;
+
+ // reset ViewStatus
+ SetCursorAtTop( bSaveCT, bSaveCC );
+
+ if(!m_pWrtShell->IsFrameSelected() && !m_pWrtShell->IsObjSelected())
+ m_pWrtShell->ShowCursor();
+
+ if( !bHasShFocus )
+ m_pWrtShell->ShellLoseFocus();
+ }
+ return bRet;
+}
+
+// #i67305# Undo after insert from file:
+// Undo "Insert form file" crashes with documents imported from binary filter (.sdw) => disabled
+// Undo "Insert form file" crashes with (.odt) documents crashes if these documents contains
+// page styles with active header/footer => disabled for those documents
+static size_t lcl_PageDescWithHeader( const SwDoc& rDoc )
+{
+ size_t nRet = 0;
+ size_t nCnt = rDoc.GetPageDescCnt();
+ for( size_t i = 0; i < nCnt; ++i )
+ {
+ const SwPageDesc& rPageDesc = rDoc.GetPageDesc( i );
+ const SwFrameFormat& rMaster = rPageDesc.GetMaster();
+ const SwFormatHeader* pHeaderItem = rMaster.GetAttrSet().GetItemIfSet( RES_HEADER, false );
+ const SwFormatFooter* pFooterItem = rMaster.GetAttrSet().GetItemIfSet( RES_FOOTER, false );
+ if( (pHeaderItem && pHeaderItem->IsActive()) ||
+ (pFooterItem && pFooterItem->IsActive()) )
+ ++nRet;
+ }
+ return nRet; // number of page styles with active header/footer
+}
+
+void SwView::ExecuteInsertDoc( SfxRequest& rRequest, const SfxPoolItem* pItem )
+{
+ m_pViewImpl->InitRequest( rRequest );
+ m_pViewImpl->SetParam( pItem ? 1 : 0 );
+ const sal_uInt16 nSlot = rRequest.GetSlot();
+
+ if ( !pItem )
+ {
+ InsertDoc( nSlot, "", "" );
+ }
+ else
+ {
+ OUString sFile, sFilter;
+ sFile = static_cast<const SfxStringItem *>( pItem )->GetValue();
+ if ( SfxItemState::SET == rRequest.GetArgs()->GetItemState( FN_PARAM_1, true, &pItem ) )
+ sFilter = static_cast<const SfxStringItem *>(pItem )->GetValue();
+
+ bool bHasFileName = !sFile.isEmpty();
+ tools::Long nFound = InsertDoc( nSlot, sFile, sFilter );
+
+ if ( bHasFileName )
+ {
+ rRequest.SetReturnValue( SfxBoolItem( nSlot, nFound != -1 ) );
+ rRequest.Done();
+ }
+ }
+}
+
+tools::Long SwView::InsertDoc( sal_uInt16 nSlotId, const OUString& rFileName, const OUString& rFilterName, sal_Int16 nVersion )
+{
+ std::unique_ptr<SfxMedium> pMed;
+ SwDocShell* pDocSh = GetDocShell();
+
+ if( !rFileName.isEmpty() )
+ {
+ SfxObjectFactory& rFact = pDocSh->GetFactory();
+ std::shared_ptr<const SfxFilter> pFilter = rFact.GetFilterContainer()->GetFilter4FilterName( rFilterName );
+ if ( !pFilter )
+ {
+ pMed.reset(new SfxMedium(rFileName, StreamMode::READ, nullptr, nullptr ));
+ SfxFilterMatcher aMatcher( rFact.GetFilterContainer()->GetName() );
+ pMed->UseInteractionHandler( true );
+ ErrCode nErr = aMatcher.GuessFilter(*pMed, pFilter, SfxFilterFlags::NONE);
+ if ( nErr )
+ pMed.reset();
+ else
+ pMed->SetFilter( pFilter );
+ }
+ else
+ pMed.reset(new SfxMedium(rFileName, StreamMode::READ, pFilter, nullptr));
+ }
+ else
+ {
+ m_pViewImpl->StartDocumentInserter(
+ // tdf#118578 allow inserting any Writer document except GlobalDoc
+ SwDocShell::Factory().GetFactoryName(),
+ LINK( this, SwView, DialogClosedHdl ),
+ nSlotId
+ );
+ return -1;
+ }
+
+ if( !pMed )
+ return -1;
+
+ return InsertMedium( nSlotId, std::move(pMed), nVersion );
+}
+
+tools::Long SwView::InsertMedium( sal_uInt16 nSlotId, std::unique_ptr<SfxMedium> pMedium, sal_Int16 nVersion )
+{
+ bool bInsert = false, bCompare = false;
+ tools::Long nFound = 0;
+ SwDocShell* pDocSh = GetDocShell();
+
+ switch( nSlotId )
+ {
+ case SID_DOCUMENT_MERGE: break;
+ case SID_DOCUMENT_COMPARE: bCompare = true; break;
+ case SID_INSERTDOC: bInsert = true; break;
+
+ default:
+ OSL_ENSURE( false, "unknown SlotId!" );
+ bInsert = true;
+ break;
+ }
+
+ if( bInsert )
+ {
+ uno::Reference< frame::XDispatchRecorder > xRecorder =
+ GetViewFrame().GetBindings().GetRecorder();
+ if ( xRecorder.is() )
+ {
+ SfxRequest aRequest(GetViewFrame(), SID_INSERTDOC);
+ aRequest.AppendItem(SfxStringItem(SID_INSERTDOC, pMedium->GetOrigURL()));
+ if(pMedium->GetFilter())
+ aRequest.AppendItem(SfxStringItem(FN_PARAM_1, pMedium->GetFilter()->GetName()));
+ aRequest.Done();
+ }
+
+ SfxObjectShellRef aRef( pDocSh );
+
+ ErrCode nError = SfxObjectShell::HandleFilter( pMedium.get(), pDocSh );
+ // #i16722# aborted?
+ if(nError != ERRCODE_NONE)
+ {
+ return -1;
+ }
+
+ pMedium->Download(); // start download if needed
+ if( aRef.is() && 1 < aRef->GetRefCount() ) // still a valid ref?
+ {
+ SwReaderPtr pRdr;
+ Reader *pRead = pDocSh->StartConvertFrom(*pMedium, pRdr, m_pWrtShell.get());
+ if( pRead ||
+ (pMedium->GetFilter()->GetFilterFlags() & SfxFilterFlags::STARONEFILTER) )
+ {
+ size_t nUndoCheck = 0;
+ SwDoc *pDoc = pDocSh->GetDoc();
+ if( pRead && pDocSh->GetDoc() )
+ nUndoCheck = lcl_PageDescWithHeader( *pDoc );
+ ErrCodeMsg nErrno;
+ { //Scope for SwWait-Object, to be able to execute slots
+ //outside this scope.
+ SwWait aWait( *GetDocShell(), true );
+ m_pWrtShell->StartAllAction();
+ if ( m_pWrtShell->HasSelection() )
+ m_pWrtShell->DelRight(); // delete selections
+ if( pRead )
+ {
+ nErrno = pRdr->Read( *pRead ); // and insert document
+ pRdr.reset();
+ }
+ else
+ {
+ ::sw::UndoGuard const ug(pDoc->GetIDocumentUndoRedo());
+ rtl::Reference<SwXTextRange> const xInsertPosition(
+ SwXTextRange::CreateXTextRange(*pDoc,
+ *m_pWrtShell->GetCursor()->GetPoint(), nullptr));
+ nErrno = pDocSh->ImportFrom(*pMedium, xInsertPosition)
+ ? ERRCODE_NONE : ERR_SWG_READ_ERROR;
+ }
+
+ }
+
+ // update all "table of ..." sections if needed
+ if( m_pWrtShell->IsUpdateTOX() )
+ {
+ SfxRequest aReq( FN_UPDATE_TOX, SfxCallMode::SLOT, GetPool() );
+ Execute( aReq );
+ m_pWrtShell->SetUpdateTOX( false ); // reset
+ }
+
+ if( pDoc )
+ { // Disable Undo for .sdw or
+ // if the number of page styles with header/footer has changed
+ if( !pRead || nUndoCheck != lcl_PageDescWithHeader( *pDoc ) )
+ {
+ pDoc->GetIDocumentUndoRedo().DelAllUndoObj();
+ }
+ }
+
+ m_pWrtShell->EndAllAction();
+ if( nErrno )
+ {
+ ErrorHandler::HandleError( nErrno );
+ nFound = nErrno.IsError() ? -1 : 0;
+ }
+ else
+ nFound = 0;
+ }
+ }
+ }
+ else
+ {
+ SfxObjectShellRef xDocSh;
+ SfxObjectShellLock xLockRef;
+
+ const int nRet = SwFindDocShell( xDocSh, xLockRef, pMedium->GetName(), OUString(),
+ OUString(), nVersion, pDocSh );
+ if( nRet )
+ {
+ SwWait aWait( *GetDocShell(), true );
+ m_pWrtShell->StartAllAction();
+
+ m_pWrtShell->EnterStdMode(); // delete selections
+
+ if( bCompare )
+ nFound = m_pWrtShell->CompareDoc( *static_cast<SwDocShell*>( xDocSh.get() )->GetDoc() );
+ else
+ nFound = m_pWrtShell->MergeDoc( *static_cast<SwDocShell*>( xDocSh.get() )->GetDoc() );
+
+ m_pWrtShell->EndAllAction();
+
+ if (!bCompare && !nFound)
+ {
+ std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetEditWin().GetFrameWeld(),
+ VclMessageType::Info, VclButtonsType::Ok,
+ SwResId(STR_NO_MERGE_ENTRY)));
+ xInfoBox->run();
+ }
+ if( nRet==2 && xDocSh.is() )
+ xDocSh->DoClose();
+ }
+ }
+
+ return nFound;
+}
+
+void SwView::EnableMailMerge()
+{
+ m_bInMailMerge = true;
+ SfxBindings& rBind = GetViewFrame().GetBindings();
+ rBind.Invalidate(FN_INSERT_FIELD_DATA_ONLY);
+ rBind.Update(FN_INSERT_FIELD_DATA_ONLY);
+}
+
+#if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS
+
+namespace
+{
+ bool lcl_NeedAdditionalDataSource( const uno::Reference< XDatabaseContext >& _rDatasourceContext )
+ {
+ Sequence < OUString > aNames = _rDatasourceContext->getElementNames();
+
+ return ( !aNames.hasElements()
+ || ( ( 1 == aNames.getLength() )
+ && aNames.getConstArray()[0] == SW_MOD()->GetDBConfig()->GetBibliographySource().sDataSource
+ )
+ );
+ }
+}
+
+#endif
+
+void SwView::GenerateFormLetter(bool bUseCurrentDocument)
+{
+#if !HAVE_FEATURE_DBCONNECTIVITY || ENABLE_FUZZERS
+ (void) bUseCurrentDocument;
+#else
+ if(bUseCurrentDocument)
+ {
+ if(!GetWrtShell().IsAnyDatabaseFieldInDoc())
+ {
+ //check availability of data sources (except biblio source)
+ uno::Reference<XComponentContext> xContext( ::comphelper::getProcessComponentContext() );
+ uno::Reference<XDatabaseContext> xDBContext = DatabaseContext::create(xContext);
+ bool bCallAddressPilot = false;
+ if ( lcl_NeedAdditionalDataSource( xDBContext ) )
+ {
+ // no data sources are available - create a new one
+ std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "modules/swriter/ui/datasourcesunavailabledialog.ui"));
+ std::unique_ptr<weld::MessageDialog> xQuery(xBuilder->weld_message_dialog("DataSourcesUnavailableDialog"));
+ // no cancel allowed
+ if (RET_OK != xQuery->run())
+ return;
+ bCallAddressPilot = true;
+ }
+ else
+ {
+ //take an existing data source or create a new one?
+ SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
+ ScopedVclPtr<AbstractMailMergeFieldConnectionsDlg> pConnectionsDlg(pFact->CreateMailMergeFieldConnectionsDlg(GetFrameWeld()));
+ if(RET_OK == pConnectionsDlg->Execute())
+ bCallAddressPilot = !pConnectionsDlg->IsUseExistingConnections();
+ else
+ return;
+
+ }
+ if(bCallAddressPilot)
+ {
+ GetViewFrame().GetDispatcher()->Execute(
+ SID_ADDRESS_DATA_SOURCE, SfxCallMode::SYNCHRON);
+ if ( lcl_NeedAdditionalDataSource( xDBContext ) )
+ // no additional data source has been created
+ // -> assume that the user has cancelled the pilot
+ return;
+ }
+
+ //call insert fields with database field page available, only
+ SfxViewFrame& rVFrame = GetViewFrame();
+ //at first hide the default field dialog if currently visible
+ rVFrame.SetChildWindow(FN_INSERT_FIELD, false);
+ //enable the status of the db field dialog - it is disabled in the status method
+ //to prevent creation of the dialog without mail merge active
+ EnableMailMerge();
+ //then show the "Data base only" field dialog
+ SfxBoolItem aOn(FN_INSERT_FIELD_DATA_ONLY, true);
+ rVFrame.GetDispatcher()->ExecuteList(FN_INSERT_FIELD_DATA_ONLY,
+ SfxCallMode::SYNCHRON, { &aOn });
+ return;
+ }
+ else
+ {
+ OUString sSource;
+ if(!GetWrtShell().IsFieldDataSourceAvailable(sSource))
+ {
+ std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "modules/swriter/ui/warndatasourcedialog.ui"));
+ std::unique_ptr<weld::MessageDialog> xWarning(xBuilder->weld_message_dialog("WarnDataSourceDialog"));
+ OUString sTmp(xWarning->get_primary_text());
+ xWarning->set_primary_text(sTmp.replaceFirst("%1", sSource));
+ if (RET_OK == xWarning->run())
+ {
+ SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();
+ ScopedVclPtr<VclAbstractDialog> pDlg(pFact->CreateVclDialog( nullptr, SID_OPTIONS_DATABASES ));
+ pDlg->Execute();
+ }
+ return ;
+ }
+ }
+ SwDBManager* pDBManager = GetWrtShell().GetDBManager();
+
+ SwDBData aData;
+ SwWrtShell &rSh = GetWrtShell();
+
+ std::vector<OUString> aDBNameList;
+ std::vector<OUString> aAllDBNames;
+ rSh.GetAllUsedDB( aDBNameList, &aAllDBNames );
+ if(!aDBNameList.empty())
+ {
+ OUString sDBName(aDBNameList[0]);
+ sal_Int32 nIdx {0};
+ aData.sDataSource = sDBName.getToken(0, DB_DELIM, nIdx);
+ aData.sCommand = sDBName.getToken(0, DB_DELIM, nIdx);
+ aData.nCommandType = o3tl::toInt32(o3tl::getToken(sDBName, 0, DB_DELIM, nIdx));
+ }
+ rSh.EnterStdMode(); // force change in text shell; necessary for mixing DB fields
+ AttrChangedNotify(nullptr);
+
+ if (pDBManager)
+ {
+ Sequence<PropertyValue> aProperties
+ {
+ comphelper::makePropertyValue("DataSourceName", aData.sDataSource),
+ comphelper::makePropertyValue("Command", aData.sCommand),
+ comphelper::makePropertyValue("CommandType", aData.nCommandType),
+ };
+ pDBManager->ExecuteFormLetter(GetWrtShell(), aProperties);
+ }
+ }
+ else
+ {
+ // call documents and template dialog
+ SfxApplication* pSfxApp = SfxGetpApp();
+ weld::Window* pTopWin = pSfxApp->GetTopWindow();
+
+ SfxTemplateManagerDlg aDocTemplDlg(GetFrameWeld());
+ int nRet = aDocTemplDlg.run();
+ bool bNewWin = false;
+ if ( nRet == RET_OK )
+ {
+ if ( pTopWin != pSfxApp->GetTopWindow() )
+ {
+ // the dialogue opens a document -> a new TopWindow appears
+ pTopWin = pSfxApp->GetTopWindow();
+ bNewWin = true;
+ }
+ }
+
+ if (bNewWin)
+ {
+ // after the destruction of the dialogue its parent comes to top,
+ // but we want that the new document is on top
+ pTopWin->present();
+ }
+ }
+#endif
+}
+
+IMPL_LINK( SwView, DialogClosedHdl, sfx2::FileDialogHelper*, _pFileDlg, void )
+{
+ if ( ERRCODE_NONE != _pFileDlg->GetError() )
+ return;
+
+ std::unique_ptr<SfxMedium> pMed = m_pViewImpl->CreateMedium();
+ if ( !pMed )
+ {
+ std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetEditWin().GetFrameWeld(),
+ VclMessageType::Info, VclButtonsType::Ok,
+ SwResId(RID_SVXSTR_TXTFILTER_FILTERERROR)));
+ xInfoBox->run();
+ return;
+ }
+
+ const sal_uInt16 nSlot = m_pViewImpl->GetRequest()->GetSlot();
+ tools::Long nFound = InsertMedium( nSlot, std::move(pMed), m_pViewImpl->GetParam() );
+
+ if ( SID_INSERTDOC == nSlot )
+ {
+ if ( m_pViewImpl->GetParam() == 0 )
+ {
+ m_pViewImpl->GetRequest()->SetReturnValue( SfxBoolItem( nSlot, nFound != -1 ) );
+ m_pViewImpl->GetRequest()->Ignore();
+ }
+ else
+ {
+ m_pViewImpl->GetRequest()->SetReturnValue( SfxBoolItem( nSlot, nFound != -1 ) );
+ m_pViewImpl->GetRequest()->Done();
+ }
+ }
+ else if ( SID_DOCUMENT_COMPARE == nSlot || SID_DOCUMENT_MERGE == nSlot )
+ {
+ m_pViewImpl->GetRequest()->SetReturnValue( SfxInt32Item( nSlot, nFound ) );
+
+ if ( nFound > 0 ) // show Redline browser
+ {
+ SfxViewFrame& rVFrame = GetViewFrame();
+ rVFrame.ShowChildWindow(FN_REDLINE_ACCEPT);
+
+ // re-initialize Redline dialog
+ sal_uInt16 nId = SwRedlineAcceptChild::GetChildWindowId();
+ SwRedlineAcceptChild* pRed = static_cast<SwRedlineAcceptChild*>(rVFrame.GetChildWindow( nId ));
+ if ( pRed )
+ pRed->ReInitDlg( GetDocShell() );
+ }
+ }
+}
+
+void SwView::ExecuteScan( SfxRequest& rReq )
+{
+ if (m_pViewImpl)
+ m_pViewImpl->ExecuteScan(rReq) ;
+}
+
+const OUString& SwView::GetOldGrfCat()
+{
+ return GetCachedString(OldGrfCat);
+}
+
+void SwView::SetOldGrfCat(const OUString& sStr)
+{
+ SetCachedString(OldGrfCat, sStr);
+}
+
+const OUString& SwView::GetOldTabCat()
+{
+ return GetCachedString(OldTabCat);
+}
+
+void SwView::SetOldTabCat(const OUString& sStr)
+{
+ SetCachedString(OldTabCat, sStr);
+}
+
+const OUString& SwView::GetOldFrameCat()
+{
+ return GetCachedString(OldFrameCat);
+}
+
+void SwView::SetOldFrameCat(const OUString& sStr)
+{
+ SetCachedString(OldFrameCat, sStr);
+}
+
+const OUString& SwView::GetOldDrwCat()
+{
+ return GetCachedString(OldDrwCat);
+}
+
+void SwView::SetOldDrwCat(const OUString& sStr)
+{
+ SwView::SetCachedString(OldDrwCat, sStr);
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/viewcoll.cxx b/sw/source/uibase/uiview/viewcoll.cxx
new file mode 100644
index 0000000000..9ee42e1e21
--- /dev/null
+++ b/sw/source/uibase/uiview/viewcoll.cxx
@@ -0,0 +1,78 @@
+/* -*- 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 <cmdid.h>
+#include <uiitems.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/request.hxx>
+#include <svl/stritem.hxx>
+#include <svl/style.hxx>
+#include <osl/diagnose.h>
+
+#include <view.hxx>
+#include <wrtsh.hxx>
+
+void SwView::ExecColl(SfxRequest const &rReq)
+{
+ const SfxItemSet* pArgs = rReq.GetArgs();
+ const SfxPoolItem* pItem = nullptr;
+ sal_uInt16 nWhich = rReq.GetSlot();
+ switch( nWhich )
+ {
+ case FN_SET_PAGE:
+ {
+ OSL_ENSURE(false, "Not implemented");
+ }
+ break;
+ case FN_SET_PAGE_STYLE:
+ {
+ if( pArgs )
+ {
+ if (SfxItemState::SET == pArgs->GetItemState( nWhich , true, &pItem ))
+ {
+ if( static_cast<const SfxStringItem*>(pItem)->GetValue() !=
+ GetWrtShell().GetCurPageStyle() )
+ {
+ SfxStringItem aName(SID_STYLE_APPLY,
+ static_cast<const SfxStringItem*>(pItem)->GetValue());
+ SfxUInt16Item aFamItem( SID_STYLE_FAMILY,
+ sal_uInt16(SfxStyleFamily::Page));
+ SwPtrItem aShell(FN_PARAM_WRTSHELL, GetWrtShellPtr());
+ SfxRequest aReq(SID_STYLE_APPLY, SfxCallMode::SLOT, GetPool());
+ aReq.AppendItem(aName);
+ aReq.AppendItem(aFamItem);
+ aReq.AppendItem(aShell);
+ GetCurShell()->ExecuteSlot(aReq);
+ }
+ }
+ }
+ else
+ {
+ SfxRequest aReq(FN_FORMAT_PAGE_DLG, SfxCallMode::SLOT, GetPool());
+ GetCurShell()->ExecuteSlot(aReq);
+ }
+ }
+ break;
+ default:
+ OSL_FAIL("wrong CommandProcessor for Dispatch");
+ return;
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/viewdlg.cxx b/sw/source/uibase/uiview/viewdlg.cxx
new file mode 100644
index 0000000000..041b13bf48
--- /dev/null
+++ b/sw/source/uibase/uiview/viewdlg.cxx
@@ -0,0 +1,66 @@
+/* -*- 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 <sfx2/request.hxx>
+#include <osl/diagnose.h>
+
+#include <view.hxx>
+#include <wrtsh.hxx>
+#include <cmdid.h>
+
+void SwView::ExecDlg(SfxRequest const &rReq)
+{
+ // Thus, from the basic no dialogues for background views are called:
+ const SfxPoolItem* pItem = nullptr;
+ const SfxItemSet* pArgs = rReq.GetArgs();
+
+ sal_uInt16 nSlot = rReq.GetSlot();
+ if(pArgs)
+ pArgs->GetItemState( GetPool().GetWhich(nSlot), false, &pItem );
+
+ switch ( nSlot )
+ {
+ case FN_CHANGE_PAGENUM:
+ {
+ if ( pItem )
+ {
+ sal_uInt16 nValue = static_cast<const SfxUInt16Item *>(pItem)->GetValue();
+ sal_uInt16 nOldValue = m_pWrtShell->GetPageOffset();
+ sal_uInt16 nPage, nLogPage;
+ m_pWrtShell->GetPageNum( nPage, nLogPage,
+ m_pWrtShell->IsCursorVisible(), false);
+
+ if(nValue != nOldValue || nValue != nLogPage)
+ {
+ if(!nOldValue)
+ m_pWrtShell->SetNewPageOffset( nValue );
+ else
+ m_pWrtShell->SetPageOffset( nValue );
+ }
+ }
+ }
+ break;
+
+ default:
+ OSL_ENSURE(false, "wrong dispatcher");
+ return;
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/viewdlg2.cxx b/sw/source/uibase/uiview/viewdlg2.cxx
new file mode 100644
index 0000000000..597731645e
--- /dev/null
+++ b/sw/source/uibase/uiview/viewdlg2.cxx
@@ -0,0 +1,305 @@
+/* -*- 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 <sfx2/request.hxx>
+#include <sfx2/objface.hxx>
+#include <svx/svdograf.hxx>
+#include <svx/svdview.hxx>
+#include <osl/diagnose.h>
+#include <fldmgr.hxx>
+#include <expfld.hxx>
+#include <modcfg.hxx>
+
+#include <swmodule.hxx>
+#include <view.hxx>
+#include <wview.hxx>
+#include <wrtsh.hxx>
+#include <cmdid.h>
+#include <caption.hxx>
+#include <poolfmt.hxx>
+#include <edtwin.hxx>
+#include <SwStyleNameMapper.hxx>
+
+#include <swabstdlg.hxx>
+
+#include <strings.hrc>
+
+#include <memory>
+
+#include <svl/stritem.hxx>
+
+using namespace css;
+
+void SwView::ExecDlgExt(SfxRequest const& rReq)
+{
+ switch (rReq.GetSlot())
+ {
+ case FN_INSERT_CAPTION:
+ {
+ SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
+ VclPtr<VclAbstractDialog> pDialog(
+ pFact->CreateSwCaptionDialog(GetFrameWeld(), *this));
+ pDialog->StartExecuteAsync([pDialog](sal_Int32) {
+ pDialog->disposeOnce();
+ });
+ break;
+ }
+ case SID_INSERT_SIGNATURELINE:
+ case SID_EDIT_SIGNATURELINE:
+ {
+ VclAbstractDialogFactory* pFact = VclAbstractDialogFactory::Create();
+ const uno::Reference<frame::XModel> xModel(GetCurrentDocument());
+ ScopedVclPtr<AbstractSignatureLineDialog> pDialog(pFact->CreateSignatureLineDialog(
+ GetFrameWeld(), xModel, rReq.GetSlot() == SID_EDIT_SIGNATURELINE));
+ pDialog->Execute();
+ break;
+ }
+ case SID_INSERT_QRCODE:
+ case SID_EDIT_QRCODE:
+ {
+ VclAbstractDialogFactory* pFact = VclAbstractDialogFactory::Create();
+ const uno::Reference<frame::XModel> xModel(GetCurrentDocument());
+ VclPtr<AbstractQrCodeGenDialog> pDialog(pFact->CreateQrCodeGenDialog(
+ GetFrameWeld(), xModel, rReq.GetSlot() == SID_EDIT_QRCODE));
+ pDialog->StartExecuteAsync([pDialog](sal_Int32) {
+ pDialog->disposeOnce();
+ });
+ break;
+ }
+ case SID_ADDITIONS_DIALOG:
+ {
+ OUString sAdditionsTag = "";
+
+ const SfxStringItem* pStringArg = rReq.GetArg<SfxStringItem>(FN_PARAM_ADDITIONS_TAG);
+ if (pStringArg)
+ sAdditionsTag = pStringArg->GetValue();
+
+ VclAbstractDialogFactory* pFact = VclAbstractDialogFactory::Create();
+ ScopedVclPtr<AbstractAdditionsDialog> pDialog(
+ pFact->CreateAdditionsDialog(GetFrameWeld(), sAdditionsTag));
+ pDialog->Execute();
+ break;
+ }
+ case SID_SIGN_SIGNATURELINE:
+ {
+ VclAbstractDialogFactory* pFact = VclAbstractDialogFactory::Create();
+ const uno::Reference<frame::XModel> xModel(GetCurrentDocument());
+ ScopedVclPtr<AbstractSignSignatureLineDialog> pDialog(
+ pFact->CreateSignSignatureLineDialog(GetFrameWeld(), xModel));
+ pDialog->Execute();
+ break;
+ }
+ case FN_EDIT_FOOTNOTE:
+ {
+ SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
+ ScopedVclPtr<AbstractInsFootNoteDlg> pDlg(pFact->CreateInsFootNoteDlg(
+ GetFrameWeld(), *m_pWrtShell, true));
+
+ pDlg->SetHelpId(GetStaticInterface()->GetSlot(FN_EDIT_FOOTNOTE)->GetCommand());
+ pDlg->SetText( SwResId(STR_EDIT_FOOTNOTE) );
+ pDlg->Execute();
+ break;
+ }
+ }
+}
+
+bool SwView::isSignatureLineSelected() const
+{
+ SwWrtShell& rSh = GetWrtShell();
+ SdrView* pSdrView = rSh.GetDrawView();
+ if (!pSdrView)
+ return false;
+
+ if (pSdrView->GetMarkedObjectCount() != 1)
+ return false;
+
+ SdrObject* pPickObj = pSdrView->GetMarkedObjectByIndex(0);
+ if (!pPickObj)
+ return false;
+
+ SdrGrafObj* pGraphic = dynamic_cast<SdrGrafObj*>(pPickObj);
+ if (!pGraphic)
+ return false;
+
+ return pGraphic->isSignatureLine();
+}
+
+bool SwView::isSignatureLineSigned() const
+{
+ SwWrtShell& rSh = GetWrtShell();
+ SdrView* pSdrView = rSh.GetDrawView();
+ if (!pSdrView)
+ return false;
+
+ if (pSdrView->GetMarkedObjectCount() != 1)
+ return false;
+
+ SdrObject* pPickObj = pSdrView->GetMarkedObjectByIndex(0);
+ if (!pPickObj)
+ return false;
+
+ SdrGrafObj* pGraphic = dynamic_cast<SdrGrafObj*>(pPickObj);
+ if (!pGraphic)
+ return false;
+
+ return pGraphic->isSignatureLineSigned();
+}
+
+bool SwView::isQRCodeSelected() const
+{
+ SwWrtShell& rSh = GetWrtShell();
+ SdrView* pSdrView = rSh.GetDrawView();
+ if (!pSdrView)
+ return false;
+
+ if (pSdrView->GetMarkedObjectCount() != 1)
+ return false;
+
+ SdrObject* pPickObj = pSdrView->GetMarkedObjectByIndex(0);
+ if (!pPickObj)
+ return false;
+
+ SdrGrafObj* pGraphic = dynamic_cast<SdrGrafObj*>(pPickObj);
+ if (!pGraphic)
+ return false;
+
+ return pGraphic->getQrCode() != nullptr;
+}
+
+void SwView::AutoCaption(const sal_uInt16 nType, const SvGlobalName *pOleId)
+{
+ SwModuleOptions* pModOpt = SW_MOD()->GetModuleConfig();
+
+ bool bWeb = dynamic_cast<SwWebView*>( this ) != nullptr;
+ if (pModOpt->IsInsWithCaption(bWeb))
+ {
+ const InsCaptionOpt *pOpt = pModOpt->GetCapOption(bWeb, static_cast<SwCapObjType>(nType), pOleId);
+ if (pOpt && pOpt->UseCaption())
+ InsertCaption(pOpt);
+ }
+}
+
+void SwView::InsertCaption(const InsCaptionOpt *pOpt)
+{
+ if (!pOpt)
+ return;
+
+ const OUString &rName = pOpt->GetCategory();
+
+ // Is there a pool template with the same name?
+ SwWrtShell &rSh = GetWrtShell();
+ if(!rName.isEmpty())
+ {
+ sal_uInt16 nPoolId = SwStyleNameMapper::GetPoolIdFromUIName(rName, SwGetPoolIdFromName::TxtColl);
+ if( USHRT_MAX != nPoolId )
+ rSh.GetTextCollFromPool(nPoolId);
+ // Pool template does not exist: Does it exist on the document?
+ else if( !rSh.GetParaStyle(rName) )
+ {
+ // It also does not exist in the document: generate
+ SwTextFormatColl* pDerivedFrom = rSh.GetTextCollFromPool(RES_POOLCOLL_LABEL);
+ rSh.MakeTextFormatColl(rName, pDerivedFrom);
+ }
+ }
+
+ SelectionType eType = rSh.GetSelectionType();
+ if (eType & SelectionType::Ole)
+ eType = SelectionType::Graphic;
+
+ const SwLabelType eT = (eType & SelectionType::Table) ? SwLabelType::Table :
+ (eType & SelectionType::Frame) ? SwLabelType::Fly :
+ (eType == SelectionType::Text) ? SwLabelType::Fly :
+ (eType & SelectionType::DrawObject) ? SwLabelType::Draw :
+ SwLabelType::Object;
+
+ SwFieldMgr aMgr(&rSh);
+ SwSetExpFieldType* pFieldType =
+ static_cast<SwSetExpFieldType*>(aMgr.GetFieldType(SwFieldIds::SetExp, rName));
+ if (!pFieldType && !rName.isEmpty() )
+ {
+ // Create new field types
+ SwSetExpFieldType aSwSetExpFieldType(rSh.GetDoc(), rName, nsSwGetSetExpType::GSE_SEQ);
+ aMgr.InsertFieldType(aSwSetExpFieldType);
+ pFieldType = static_cast<SwSetExpFieldType*>(aMgr.GetFieldType(SwFieldIds::SetExp, rName));
+ }
+
+ if (!pOpt->IgnoreSeqOpts())
+ {
+ if (pFieldType)
+ {
+ pFieldType->SetDelimiter(pOpt->GetSeparator());
+ pFieldType->SetOutlineLvl( static_cast< sal_uInt8 >(pOpt->GetLevel()) );
+ }
+ }
+
+ sal_uInt16 nID = USHRT_MAX;
+ SwFieldType* pType = nullptr;
+ const size_t nCount = aMgr.GetFieldTypeCount();
+ if( !rName.isEmpty() )
+ {
+ for (size_t i = 0; i < nCount; ++i)
+ {
+ pType = aMgr.GetFieldType(SwFieldIds::Unknown, i);
+ OUString aTmpName( pType->GetName() );
+ if (aTmpName == rName && pType->Which() == SwFieldIds::SetExp)
+ {
+ nID = i;
+ OSL_ENSURE(nID==i, "Downcasting to sal_uInt16 lost information!");
+ break;
+ }
+ }
+ }
+ rSh.StartAllAction();
+
+ GetWrtShell().InsertLabel( eT,
+ pOpt->GetCaption(),
+ !pOpt->IgnoreSeqOpts() ? OUString() : pOpt->GetSeparator(),
+ pOpt->GetNumSeparator(),
+ !pOpt->GetPos(),
+ nID,
+ pOpt->GetCharacterStyle(),
+ pOpt->CopyAttributes() );
+ // Set Number Format
+ if(pType)
+ static_cast<SwSetExpFieldType*>(pType)->SetSeqFormat(pOpt->GetNumType());
+
+ rSh.UpdateExpFields( true );
+
+ rSh.EndAllAction();
+
+ if ( rSh.IsFrameSelected() )
+ {
+ GetEditWin().StopInsFrame();
+ rSh.EnterSelFrameMode();
+ }
+
+ // remember category
+ if (eType & SelectionType::Graphic)
+ SetOldGrfCat(rName);
+ else if( eType & SelectionType::Table)
+ SetOldTabCat(rName);
+ else if( eType & SelectionType::Frame)
+ SetOldFrameCat(rName);
+ else if( eType == SelectionType::Text)
+ SetOldFrameCat(rName);
+ else if( eType & SelectionType::DrawObject)
+ SetOldDrwCat(rName);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/viewdraw.cxx b/sw/source/uibase/uiview/viewdraw.cxx
new file mode 100644
index 0000000000..956d05f1df
--- /dev/null
+++ b/sw/source/uibase/uiview/viewdraw.cxx
@@ -0,0 +1,755 @@
+/* -*- 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 <hintids.hxx>
+#include <svl/itempool.hxx>
+#include <svl/stritem.hxx>
+#include <svx/svdobj.hxx>
+#include <svx/svdview.hxx>
+#include <svx/svdpage.hxx>
+#include <editeng/outliner.hxx>
+#include <svx/fmview.hxx>
+#include <svx/dataaccessdescriptor.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <doc.hxx>
+#include <IDocumentDeviceAccess.hxx>
+#include <textboxhelper.hxx>
+#include <editeng/langitem.hxx>
+#include <svx/fontworkbar.hxx>
+#include <svx/fontworkgallery.hxx>
+#include <editeng/eeitem.hxx>
+#include <svx/svdogrp.hxx>
+#include <svx/svdetc.hxx>
+#include <editeng/editstat.hxx>
+#include <sfx2/request.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/dispatch.hxx>
+#include <svx/svdoutl.hxx>
+#include <vcl/ptrstyle.hxx>
+#include <osl/diagnose.h>
+
+#include <view.hxx>
+#include <wrtsh.hxx>
+#include <viewopt.hxx>
+#include <cmdid.h>
+#include <drwbassh.hxx>
+#include <beziersh.hxx>
+#include <conrect.hxx>
+#include <conpoly.hxx>
+#include <conarc.hxx>
+#include <conform.hxx>
+#include <concustomshape.hxx>
+#include <dselect.hxx>
+#include <edtwin.hxx>
+
+#include <dcontact.hxx>
+
+#include <svx/svdpagv.hxx>
+#include <svx/extrusionbar.hxx>
+#include <comphelper/lok.hxx>
+#include <sfx2/lokhelper.hxx>
+#include <LibreOfficeKit/LibreOfficeKitEnums.h>
+
+using namespace ::com::sun::star;
+
+// Execute Drawing-Ids
+
+void SwView::ExecDraw(const SfxRequest& rReq)
+{
+ const SfxItemSet *pArgs = rReq.GetArgs();
+ const SfxPoolItem* pItem;
+ const SfxStringItem* pStringItem = nullptr;
+ SdrView *pSdrView = m_pWrtShell->GetDrawView();
+ bool bDeselect = false;
+
+ sal_uInt16 nSlotId = rReq.GetSlot();
+ if(pArgs && SfxItemState::SET == pArgs->GetItemState(GetPool().GetWhich(nSlotId), false, &pItem))
+ pStringItem = dynamic_cast< const SfxStringItem*>(pItem);
+
+ SdrObjKind eNewFormObjKind = SdrObjKind::NONE;
+ if (nSlotId == SID_FM_CREATE_CONTROL)
+ {
+ const SfxUInt16Item* pIdentifierItem = rReq.GetArg<SfxUInt16Item>(SID_FM_CONTROL_IDENTIFIER);
+ if (pIdentifierItem)
+ eNewFormObjKind = static_cast<SdrObjKind>(pIdentifierItem->GetValue());
+ }
+
+ if (nSlotId == SID_OBJECT_SELECT && m_nFormSfxId == nSlotId)
+ {
+ bDeselect = true;
+ }
+ else if (nSlotId == SID_FM_CREATE_CONTROL)
+ {
+ if (eNewFormObjKind == m_eFormObjKind || eNewFormObjKind == SdrObjKind::NONE)
+ {
+ bDeselect = true;
+ GetViewFrame().GetDispatcher()->Execute(SID_FM_LEAVE_CREATE); // Button should popping out
+ }
+ }
+ else if (nSlotId == SID_FM_CREATE_FIELDCONTROL)
+ {
+ FmFormView* pFormView = dynamic_cast<FmFormView*>(pSdrView);
+ if (pFormView)
+ {
+ const SfxUnoAnyItem* pDescriptorItem = rReq.GetArg<SfxUnoAnyItem>(SID_FM_DATACCESS_DESCRIPTOR);
+ OSL_ENSURE( pDescriptorItem, "SwView::ExecDraw(SID_FM_CREATE_FIELDCONTROL): invalid request args!" );
+ if( pDescriptorItem )
+ {
+ svx::ODataAccessDescriptor aDescriptor( pDescriptorItem->GetValue() );
+ rtl::Reference<SdrObject> pObj = pFormView->CreateFieldControl( aDescriptor );
+
+ if ( pObj )
+ {
+ Size aDocSize(m_pWrtShell->GetDocSize());
+ const SwRect& rVisArea = m_pWrtShell->VisArea();
+ Point aStartPos = rVisArea.Center();
+ if(rVisArea.Width() > aDocSize.Width())
+ aStartPos.setX( aDocSize.Width() / 2 + rVisArea.Left() );
+ if(rVisArea.Height() > aDocSize.Height())
+ aStartPos.setY( aDocSize.Height() / 2 + rVisArea.Top() );
+
+ //determine the size of the object
+ if(pObj->IsGroupObject())
+ {
+ const tools::Rectangle& rBoundRect = static_cast<SdrObjGroup*>(pObj.get())->GetCurrentBoundRect();
+ aStartPos.AdjustX( -(rBoundRect.GetWidth()/2) );
+ aStartPos.AdjustY( -(rBoundRect.GetHeight()/2) );
+ }
+
+ // TODO: unmark all other
+ m_pWrtShell->EnterStdMode();
+ m_pWrtShell->SwFEShell::InsertDrawObj( *pObj, aStartPos );
+ }
+ }
+ }
+ }
+ else if ( nSlotId == SID_FONTWORK_GALLERY_FLOATER )
+ {
+ vcl::Window& rWin = m_pWrtShell->GetView().GetViewFrame().GetWindow();
+
+ rWin.EnterWait();
+
+ if( !m_pWrtShell->HasDrawView() )
+ m_pWrtShell->MakeDrawView();
+
+ pSdrView = m_pWrtShell->GetDrawView();
+ if (pSdrView)
+ {
+ std::shared_ptr<svx::FontWorkGalleryDialog> pDlg = std::make_shared<svx::FontWorkGalleryDialog>(rWin.GetFrameWeld(), *pSdrView);
+ pDlg->SetSdrObjectRef(&pSdrView->GetModel());
+ weld::DialogController::runAsync(pDlg, [this, pDlg](int) {
+ vcl::Window& rWin2 = m_pWrtShell->GetView().GetViewFrame().GetWindow();
+
+ SdrObject* pObj = pDlg->GetSdrObjectRef();
+ if ( pObj )
+ {
+ Size aDocSize( m_pWrtShell->GetDocSize() );
+ const SwRect& rVisArea = comphelper::LibreOfficeKit::isActive() ?
+ SwRect(m_pWrtShell->getLOKVisibleArea()) : m_pWrtShell->VisArea();
+ Point aPos( rVisArea.Center() );
+ tools::Rectangle aObjRect( pObj->GetLogicRect() );
+
+ if ( rVisArea.Width() > aDocSize.Width())
+ aPos.setX( aDocSize.Width() / 2 + rVisArea.Left() );
+ else if (aPos.getX() > aObjRect.GetWidth() / 2)
+ aPos.AdjustX( -(aObjRect.GetWidth() / 2) );
+
+ if (rVisArea.Height() > aDocSize.Height())
+ aPos.setY( aDocSize.Height() / 2 + rVisArea.Top() );
+ else if (aPos.getY() > aObjRect.GetHeight() / 2)
+ aPos.AdjustY( -(aObjRect.GetHeight() / 2) );
+
+ m_pWrtShell->EnterStdMode();
+ m_pWrtShell->SwFEShell::InsertDrawObj( *pObj, aPos );
+ }
+
+ rWin2.LeaveWait();
+ });
+ }
+ else
+ rWin.LeaveWait();
+ }
+ else if ( m_nFormSfxId != USHRT_MAX )
+ GetViewFrame().GetDispatcher()->Execute( SID_FM_LEAVE_CREATE );
+
+ if( nSlotId == SID_DRAW_CS_ID )
+ {
+ //deselect if same custom shape is selected again
+ SwDrawBase* pFuncPtr = GetDrawFuncPtr();
+ if( pFuncPtr && pFuncPtr->GetSlotId() == SID_DRAW_CS_ID )
+ {
+ ConstCustomShape* pConstCustomShape = static_cast<ConstCustomShape*>(pFuncPtr);
+ OUString aNew = ConstCustomShape::GetShapeTypeFromRequest( rReq );
+ const OUString& aOld = pConstCustomShape->GetShapeType();
+ if( aNew == aOld )
+ {
+ bDeselect = true;
+ }
+ }
+ }
+
+ //deselect if same shape is selected again (but different custom shapes do have same slot id)
+ if ( bDeselect || (nSlotId == m_nDrawSfxId &&
+ (!pStringItem || (pStringItem->GetValue() == m_sDrawCustom))
+ && (nSlotId != SID_DRAW_CS_ID) ) )
+ {
+ if (GetDrawFuncPtr())
+ {
+ GetDrawFuncPtr()->Deactivate();
+ SetDrawFuncPtr(nullptr);
+ }
+
+ if (m_pWrtShell->IsObjSelected() && !m_pWrtShell->IsSelFrameMode())
+ m_pWrtShell->EnterSelFrameMode();
+ LeaveDrawCreate();
+
+ AttrChangedNotify(nullptr);
+ return;
+ }
+
+ LeaveDrawCreate();
+
+ if (m_pWrtShell->IsFrameSelected())
+ m_pWrtShell->EnterStdMode(); // because bug #45639
+
+ std::unique_ptr<SwDrawBase> pFuncPtr;
+
+ // for LibreOfficeKit - choosing a shape should construct it directly
+ bool bCreateDirectly = false;
+
+ switch (nSlotId)
+ {
+ case SID_OBJECT_SELECT:
+ case SID_DRAW_SELECT:
+ pFuncPtr.reset( new DrawSelection(m_pWrtShell.get(), m_pEditWin, this) );
+ m_nDrawSfxId = m_nFormSfxId = SID_OBJECT_SELECT;
+ m_sDrawCustom.clear();
+ break;
+
+ case SID_LINE_ARROW_END:
+ case SID_LINE_ARROW_CIRCLE:
+ case SID_LINE_ARROW_SQUARE:
+ case SID_LINE_ARROW_START:
+ case SID_LINE_CIRCLE_ARROW:
+ case SID_LINE_SQUARE_ARROW:
+ case SID_LINE_ARROWS:
+ case SID_DRAW_LINE:
+ case SID_DRAW_XLINE:
+ case SID_DRAW_MEASURELINE:
+ case SID_DRAW_RECT:
+ case SID_DRAW_ELLIPSE:
+ case SID_DRAW_TEXT:
+ case SID_DRAW_TEXT_VERTICAL:
+ case SID_DRAW_TEXT_MARQUEE:
+ case SID_DRAW_CAPTION:
+ case SID_DRAW_CAPTION_VERTICAL:
+ pFuncPtr.reset( new ConstRectangle(m_pWrtShell.get(), m_pEditWin, this) );
+ bCreateDirectly = comphelper::LibreOfficeKit::isActive();
+ m_nDrawSfxId = nSlotId;
+ m_sDrawCustom.clear();
+ break;
+
+ case SID_DRAW_XPOLYGON_NOFILL:
+ case SID_DRAW_XPOLYGON:
+ case SID_DRAW_POLYGON_NOFILL:
+ case SID_DRAW_POLYGON:
+ case SID_DRAW_BEZIER_NOFILL:
+ case SID_DRAW_BEZIER_FILL:
+ case SID_DRAW_FREELINE_NOFILL:
+ case SID_DRAW_FREELINE:
+ pFuncPtr.reset( new ConstPolygon(m_pWrtShell.get(), m_pEditWin, this) );
+ m_nDrawSfxId = nSlotId;
+ m_sDrawCustom.clear();
+ break;
+
+ case SID_DRAW_ARC:
+ case SID_DRAW_PIE:
+ case SID_DRAW_CIRCLECUT:
+ pFuncPtr.reset( new ConstArc(m_pWrtShell.get(), m_pEditWin, this) );
+ m_nDrawSfxId = nSlotId;
+ m_sDrawCustom.clear();
+ break;
+
+ case SID_FM_CREATE_CONTROL:
+ {
+ pFuncPtr.reset(new ConstFormControl(m_pWrtShell.get(), m_pEditWin, this, eNewFormObjKind));
+ m_nFormSfxId = nSlotId;
+ m_eFormObjKind = eNewFormObjKind;
+ }
+ break;
+
+ case SID_DRAWTBX_CS_BASIC :
+ case SID_DRAWTBX_CS_SYMBOL :
+ case SID_DRAWTBX_CS_ARROW :
+ case SID_DRAWTBX_CS_FLOWCHART :
+ case SID_DRAWTBX_CS_CALLOUT :
+ case SID_DRAWTBX_CS_STAR :
+ case SID_DRAW_CS_ID :
+ {
+ pFuncPtr.reset( new ConstCustomShape(m_pWrtShell.get(), m_pEditWin, this, rReq ) );
+
+ bCreateDirectly = comphelper::LibreOfficeKit::isActive();
+
+ m_nDrawSfxId = nSlotId;
+ if ( nSlotId != SID_DRAW_CS_ID )
+ {
+ if ( pStringItem )
+ {
+ m_sDrawCustom = pStringItem->GetValue();
+ SfxBindings& rBind = GetViewFrame().GetBindings();
+ rBind.Invalidate( nSlotId );
+ rBind.Update( nSlotId );
+ }
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ GetViewFrame().GetBindings().Invalidate(SID_ATTRIBUTES_AREA);
+
+ bool bEndTextEdit = true;
+ if (pFuncPtr)
+ {
+ if (GetDrawFuncPtr())
+ {
+ GetDrawFuncPtr()->Deactivate();
+ }
+
+ auto pTempFuncPtr = pFuncPtr.get();
+ SetDrawFuncPtr(std::move(pFuncPtr));
+ AttrChangedNotify(nullptr);
+
+ pTempFuncPtr->Activate(nSlotId);
+ NoRotate();
+ if(rReq.GetModifier() == KEY_MOD1 || bCreateDirectly)
+ {
+ if (bCreateDirectly)
+ GetViewFrame().GetDispatcher()->Execute(SID_OBJECT_SELECT, SfxCallMode::ASYNCHRON);
+ if(SID_OBJECT_SELECT == m_nDrawSfxId )
+ {
+ m_pWrtShell->GotoObj(true);
+ }
+ else if (dynamic_cast<ConstCustomShape*>(pTempFuncPtr))
+ {
+ pTempFuncPtr->CreateDefaultObject();
+ }
+ else
+ {
+ pTempFuncPtr->CreateDefaultObject();
+ pTempFuncPtr->Deactivate();
+ SetDrawFuncPtr(nullptr);
+ LeaveDrawCreate();
+ m_pWrtShell->EnterStdMode();
+ SdrView *pTmpSdrView = m_pWrtShell->GetDrawView();
+ const SdrMarkList& rMarkList = pTmpSdrView->GetMarkedObjectList();
+ if(rMarkList.GetMarkCount() == 1 &&
+ (SID_DRAW_TEXT == nSlotId || SID_DRAW_TEXT_VERTICAL == nSlotId ||
+ SID_DRAW_TEXT_MARQUEE == nSlotId ))
+ {
+ SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
+ BeginTextEdit(pObj);
+ bEndTextEdit = false;
+ }
+ }
+ }
+ }
+ else
+ {
+ if (m_pWrtShell->IsObjSelected() && !m_pWrtShell->IsSelFrameMode())
+ m_pWrtShell->EnterSelFrameMode();
+ }
+
+ if(bEndTextEdit && pSdrView && pSdrView->IsTextEdit())
+ pSdrView->SdrEndTextEdit( true );
+
+ AttrChangedNotify(nullptr);
+}
+
+// End drawing
+
+void SwView::ExitDraw()
+{
+ NoRotate();
+
+ if(!m_pShell)
+ return;
+
+ // the shell may be invalid at close/reload/SwitchToViewShell
+ SfxDispatcher* pDispatch = GetViewFrame().GetDispatcher();
+ sal_uInt16 nIdx = 0;
+ SfxShell* pTest = nullptr;
+ do
+ {
+ pTest = pDispatch->GetShell(nIdx++);
+ }
+ while( pTest && pTest != this && pTest != m_pShell);
+ if(!(pTest == m_pShell &&
+ // don't call LeaveSelFrameMode() etc. for the below,
+ // because objects may still be selected:
+ dynamic_cast< const SwDrawBaseShell *>( m_pShell ) == nullptr &&
+ dynamic_cast< const SwBezierShell *>( m_pShell ) == nullptr &&
+ dynamic_cast< const svx::ExtrusionBar *>( m_pShell ) == nullptr &&
+ dynamic_cast< const svx::FontworkBar *>( m_pShell ) == nullptr))
+ return;
+
+ SdrView *pSdrView = m_pWrtShell->GetDrawView();
+
+ if (pSdrView && pSdrView->IsGroupEntered())
+ {
+ pSdrView->LeaveOneGroup();
+ pSdrView->UnmarkAll();
+ GetViewFrame().GetBindings().Invalidate(SID_ENTER_GROUP);
+ }
+
+ if (GetDrawFuncPtr())
+ {
+ if (m_pWrtShell->IsSelFrameMode())
+ m_pWrtShell->LeaveSelFrameMode();
+ GetDrawFuncPtr()->Deactivate();
+
+ SetDrawFuncPtr(nullptr);
+ LeaveDrawCreate();
+
+ GetViewFrame().GetBindings().Invalidate(SID_INSERT_DRAW);
+ }
+ GetEditWin().SetPointer(PointerStyle::Text);
+}
+
+// Disable rotate mode
+
+void SwView::NoRotate()
+{
+ if (IsDrawRotate())
+ {
+ m_pWrtShell->SetDragMode(SdrDragMode::Move);
+ FlipDrawRotate();
+
+ const SfxBoolItem aTmp( SID_OBJECT_ROTATE, false );
+ GetViewFrame().GetBindings().SetState( aTmp );
+ }
+}
+
+// Enable DrawTextEditMode
+
+static bool lcl_isTextBox(SdrObject const * pObject)
+{
+ if (SwDrawContact* pDrawContact = static_cast<SwDrawContact*>(pObject->GetUserCall()))
+ {
+ if (SwFrameFormat* pFormat = pDrawContact->GetFormat())
+ return SwTextBoxHelper::isTextBox(pFormat, RES_DRAWFRMFMT);
+ }
+ return false;
+}
+
+bool SwView::EnterDrawTextMode(const Point& aDocPos)
+{
+ SwWrtShell *pSh = &GetWrtShell();
+ SdrView *pSdrView = pSh->GetDrawView();
+ OSL_ENSURE( pSdrView, "EnterDrawTextMode without DrawView?" );
+
+ bool bReturn = false;
+
+ sal_uInt16 nOld = pSdrView->GetHitTolerancePixel();
+ pSdrView->SetHitTolerancePixel( 2 );
+
+ SdrObject* pObj = nullptr;
+ SdrPageView* pPV = nullptr;
+ if (pSdrView->IsMarkedHit(aDocPos) && !pSdrView->PickHandle(aDocPos) && IsTextTool())
+ pObj = pSdrView->PickObj(aDocPos, pSdrView->getHitTolLog(), pPV, SdrSearchOptions::PICKTEXTEDIT);
+
+ if (pObj)
+ {
+ // To allow SwDrawVirtObj text objects to be activated, allow their type, too.
+ auto pVirtObj = dynamic_cast<SwDrawVirtObj*>( pObj );
+ if ( (pVirtObj && DynCastSdrTextObj(&pVirtObj->GetReferencedObj() ) != nullptr &&
+ m_pWrtShell->IsSelObjProtected(FlyProtectFlags::Content) == FlyProtectFlags::NONE) ||
+ DynCastSdrTextObj( pObj ) != nullptr )
+ {
+ // Refuse to edit editeng text of the shape if it has textbox attached.
+ if (!lcl_isTextBox(pObj))
+ bReturn = BeginTextEdit( pObj, pPV, m_pEditWin );
+ }
+ }
+
+ pSdrView->SetHitTolerancePixel( nOld );
+
+ return bReturn;
+}
+
+bool SwView::EnterShapeDrawTextMode(SdrObject* pObject)
+{
+ SdrView* pSdrView = GetWrtShell().GetDrawView();
+ SdrPageView* pPageView = pSdrView->GetSdrPageView();
+ return BeginTextEdit(pObject, pPageView, m_pEditWin);
+}
+
+// Enable DrawTextEditMode
+
+bool SwView::BeginTextEdit(SdrObject* pObj, SdrPageView* pPV, vcl::Window* pWin,
+ bool bIsNewObj, bool bSetSelectionToStart)
+{
+ SwWrtShell *pSh = &GetWrtShell();
+ SdrView *pSdrView = pSh->GetDrawView();
+ std::unique_ptr<SdrOutliner> pOutliner = ::SdrMakeOutliner(OutlinerMode::TextObject, pSdrView->GetModel());
+ uno::Reference< linguistic2::XSpellChecker1 > xSpell( ::GetSpellChecker() );
+ if (pOutliner)
+ {
+ pOutliner->SetRefDevice(pSh->getIDocumentDeviceAccess().getReferenceDevice(false));
+ pOutliner->SetSpeller(xSpell);
+ uno::Reference<linguistic2::XHyphenator> xHyphenator( ::GetHyphenator() );
+ pOutliner->SetHyphenator( xHyphenator );
+ pSh->SetCalcFieldValueHdl(pOutliner.get());
+
+ EEControlBits nCntrl = pOutliner->GetControlWord();
+ nCntrl |= EEControlBits::ALLOWBIGOBJS;
+
+ const SwViewOption *pOpt = pSh->GetViewOptions();
+
+ if (pOpt->IsFieldShadings())
+ nCntrl |= EEControlBits::MARKFIELDS;
+ else
+ nCntrl &= ~EEControlBits::MARKFIELDS;
+
+ if (pOpt->IsOnlineSpell())
+ nCntrl |= EEControlBits::ONLINESPELLING;
+ else
+ nCntrl &= ~EEControlBits::ONLINESPELLING;
+
+ pOutliner->SetControlWord(nCntrl);
+ const SvxLanguageItem& rItem = pSh->GetDoc()->GetDefault(RES_CHRATR_LANGUAGE);
+ pOutliner->SetDefaultLanguage(rItem.GetLanguage());
+
+ if( bIsNewObj )
+ pOutliner->SetVertical( SID_DRAW_TEXT_VERTICAL == m_nDrawSfxId ||
+ SID_DRAW_CAPTION_VERTICAL == m_nDrawSfxId );
+
+ // set default horizontal text direction at outliner
+ EEHorizontalTextDirection aDefHoriTextDir =
+ pSh->IsShapeDefaultHoriTextDirR2L() ? EEHorizontalTextDirection::R2L : EEHorizontalTextDirection::L2R;
+ pOutliner->SetDefaultHorizontalTextDirection( aDefHoriTextDir );
+ }
+
+ // To allow editing the referenced object from a SwDrawVirtObj here
+ // the original needs to be fetched eventually. This ATM activates the
+ // text edit mode for the original object.
+ SdrObject* pToBeActivated = pObj;
+
+ // Always the original object is edited. To allow the TextEdit to happen
+ // where the VirtObj is positioned, on demand an occurring offset is set at
+ // the TextEdit object. That offset is used for creating and managing the
+ // OutlinerView.
+ Point aNewTextEditOffset(0, 0);
+
+ if (SwDrawVirtObj* pVirtObj = dynamic_cast<SwDrawVirtObj *>(pObj))
+ {
+ pToBeActivated = &const_cast<SdrObject&>(pVirtObj->GetReferencedObj());
+ aNewTextEditOffset = pVirtObj->GetOffset();
+ }
+
+ // set in each case, thus it will be correct for all objects
+ static_cast<SdrTextObj*>(pToBeActivated)->SetTextEditOffset(aNewTextEditOffset);
+
+ bool bRet(pSdrView->SdrBeginTextEdit( pToBeActivated, pPV, pWin, true, pOutliner.release(), nullptr, false, false, false ));
+
+ // #i7672#
+ // Since SdrBeginTextEdit actually creates the OutlinerView and thus also
+ // sets the background color, an own background color needs to be set
+ // after TextEditing was started. This is now done here.
+ if(bRet)
+ {
+ OutlinerView* pView = pSdrView->GetTextEditOutlinerView();
+
+ if(pView)
+ {
+ Color aBackground(pSh->GetShapeBackground());
+ pView->SetBackgroundColor(aBackground);
+ }
+
+ // editing should start at the end of text, spell checking at the beginning ...
+ ESelection aNewSelection(EE_PARA_NOT_FOUND, EE_INDEX_NOT_FOUND, EE_PARA_NOT_FOUND, EE_INDEX_NOT_FOUND);
+ if (bSetSelectionToStart)
+ aNewSelection = ESelection();
+ if (pView)
+ {
+ pView->SetSelection(aNewSelection);
+
+ if (comphelper::LibreOfficeKit::isActive())
+ {
+ OString sRect = pView->GetOutputArea().toString();
+ SfxLokHelper::notifyOtherViews(this, LOK_CALLBACK_VIEW_LOCK, "rectangle", sRect);
+ }
+ }
+ }
+
+ return bRet;
+}
+
+// Is a DrawTextObject selected?
+bool SwView::IsTextTool() const
+{
+ SdrObjKind nId;
+ SdrInventor nInvent;
+ SdrView *pSdrView = GetWrtShell().GetDrawView();
+ OSL_ENSURE( pSdrView, "IsTextTool without DrawView?" );
+
+ if (pSdrView->IsCreateMode())
+ pSdrView->SetCreateMode(false);
+
+ pSdrView->TakeCurrentObj(nId,nInvent);
+ return nInvent == SdrInventor::Default;
+}
+
+SdrView* SwView::GetDrawView() const
+{
+ return GetWrtShell().GetDrawView();
+}
+
+bool SwView::IsBezierEditMode() const
+{
+ return (!IsDrawSelMode() && GetWrtShell().GetDrawView()->HasMarkablePoints());
+}
+
+bool SwView::IsFormMode() const
+{
+ if (GetDrawFuncPtr() && GetDrawFuncPtr()->IsCreateObj())
+ {
+ return GetDrawFuncPtr()->IsInsertForm();
+ }
+
+ return AreOnlyFormsSelected();
+}
+
+void SwView::SetDrawFuncPtr(std::unique_ptr<SwDrawBase> pFuncPtr)
+{
+ m_pDrawActual = std::move(pFuncPtr);
+}
+
+void SwView::SetSelDrawSlot()
+{
+ m_nDrawSfxId = SID_OBJECT_SELECT;
+ m_sDrawCustom.clear();
+}
+
+bool SwView::AreOnlyFormsSelected() const
+{
+ if ( GetWrtShell().IsFrameSelected() )
+ return false;
+
+ bool bForm = true;
+
+ SdrView* pSdrView = GetWrtShell().GetDrawView();
+
+ const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
+ const size_t nCount = rMarkList.GetMarkCount();
+
+ if (nCount)
+ {
+ for (size_t i = 0; i < nCount; ++i)
+ {
+ // Except controls, are still normal draw objects selected?
+ SdrObject *pSdrObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
+ if (!pSdrObj)
+ continue;
+
+ if (!HasOnlyObj(pSdrObj, SdrInventor::FmForm))
+ {
+ bForm = false;
+ break;
+ }
+ }
+ }
+ else
+ bForm = false;
+
+ return bForm;
+}
+
+bool SwView::HasOnlyObj(SdrObject const *pSdrObj, SdrInventor eObjInventor) const
+{
+ bool bRet = false;
+
+ if (pSdrObj->IsGroupObject())
+ {
+ SdrObjList* pList = pSdrObj->GetSubList();
+ for (const rtl::Reference<SdrObject>& pObj : *pList)
+ {
+ bRet = HasOnlyObj(pObj.get(), eObjInventor);
+ if (!bRet)
+ break;
+ }
+ }
+ else if (eObjInventor == pSdrObj->GetObjInventor())
+ return true;
+
+ return bRet;
+}
+
+//#i87414# mod
+IMPL_LINK(SwView, OnlineSpellCallback, SpellCallbackInfo&, rInfo, void)
+{
+ if (rInfo.nCommand == SpellCallbackCommand::STARTSPELLDLG)
+ GetViewFrame().GetDispatcher()->Execute( FN_SPELL_GRAMMAR_DIALOG, SfxCallMode::ASYNCHRON);
+ else if (rInfo.nCommand == SpellCallbackCommand::AUTOCORRECT_OPTIONS)
+ GetViewFrame().GetDispatcher()->Execute( SID_AUTO_CORRECT_DLG, SfxCallMode::ASYNCHRON );
+}
+
+bool SwView::ExecDrwTextSpellPopup(const Point& rPt)
+{
+ bool bRet = false;
+ SdrView *pSdrView = m_pWrtShell->GetDrawView();
+ OutlinerView* pOLV = pSdrView->GetTextEditOutlinerView();
+ Point aPos( GetEditWin().LogicToPixel( rPt ) );
+
+ if (pOLV->IsWrongSpelledWordAtPos( aPos ))
+ {
+ bRet = true;
+ Link<SpellCallbackInfo&,void> aLink = LINK(this, SwView, OnlineSpellCallback);
+ pOLV->ExecuteSpellPopup(aPos, aLink);
+ }
+ return bRet;
+}
+
+bool SwView::IsDrawTextHyphenate()
+{
+ SdrView *pSdrView = m_pWrtShell->GetDrawView();
+ bool bHyphenate = false;
+
+ SfxItemSetFixed<EE_PARA_HYPHENATE, EE_PARA_HYPHENATE> aNewAttr( pSdrView->GetModel().GetItemPool() );
+ pSdrView->GetAttributes( aNewAttr );
+ if( aNewAttr.GetItemState( EE_PARA_HYPHENATE ) >= SfxItemState::DEFAULT )
+ bHyphenate = aNewAttr.Get( EE_PARA_HYPHENATE ).GetValue();
+
+ return bHyphenate;
+}
+
+void SwView::HyphenateDrawText()
+{
+ SdrView *pSdrView = m_pWrtShell->GetDrawView();
+ bool bHyphenate = IsDrawTextHyphenate();
+
+ SfxItemSetFixed<EE_PARA_HYPHENATE, EE_PARA_HYPHENATE> aSet( GetPool() );
+ aSet.Put( SfxBoolItem( EE_PARA_HYPHENATE, !bHyphenate ) );
+ pSdrView->SetAttributes( aSet );
+ GetViewFrame().GetBindings().Invalidate(FN_HYPHENATE_OPT_DLG);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/viewfunc.hxx b/sw/source/uibase/uiview/viewfunc.hxx
new file mode 100644
index 0000000000..38320f6f39
--- /dev/null
+++ b/sw/source/uibase/uiview/viewfunc.hxx
@@ -0,0 +1,54 @@
+/* -*- 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 .
+ */
+#ifndef INCLUDED_SW_SOURCE_UIBASE_UIVIEW_VIEWFUNC_HXX
+#define INCLUDED_SW_SOURCE_UIBASE_UIVIEW_VIEWFUNC_HXX
+
+#include <vcl/outdev.hxx>
+
+#include <IDocumentDeviceAccess.hxx>
+
+class ImageButton;
+class Point;
+class SfxItemSet;
+class SfxPrinter;
+class SfxTabPage;
+class Size;
+class SvxRuler;
+class SwScrollbar;
+class SwViewShell;
+namespace vcl { class Window; }
+
+// The following functions are available in viewprt.cxx
+void SetPrinter( IDocumentDeviceAccess*, SfxPrinter const *, bool bWeb );
+void SetAppPrintOptions( SwViewShell* pSh, bool bWeb );
+
+// The following functions are available in viewport.cxx
+void ViewResizePixel( const vcl::RenderContext &rRef,
+ const Point &rOfst,
+ const Size &rSize,
+ const Size &rEditSz,
+ SwScrollbar& rVScrollbar,
+ SwScrollbar& rHScrollbar,
+ SvxRuler* pVRuler = nullptr,
+ SvxRuler* pHRuler = nullptr,
+ bool bVRulerRight = false );
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/viewling.cxx b/sw/source/uibase/uiview/viewling.cxx
new file mode 100644
index 0000000000..a9f64d7bf7
--- /dev/null
+++ b/sw/source/uibase/uiview/viewling.cxx
@@ -0,0 +1,856 @@
+/* -*- 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 <hintids.hxx>
+
+#include <com/sun/star/lang/Locale.hpp>
+#include <com/sun/star/linguistic2/XThesaurus.hpp>
+#include <com/sun/star/linguistic2/ProofreadingResult.hpp>
+#include <com/sun/star/linguistic2/XLinguProperties.hpp>
+#include <com/sun/star/i18n/TextConversionOption.hpp>
+#include <comphelper/lok.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/propertyvalue.hxx>
+#include <comphelper/propertysequence.hxx>
+#include <comphelper/scopeguard.hxx>
+#include <toolkit/helper/vclunohelper.hxx>
+#include <vcl/weld.hxx>
+#include <svtools/ehdl.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/request.hxx>
+#include <svx/dialmgr.hxx>
+#include <svx/svxerr.hxx>
+#include <svx/svxdlg.hxx>
+#include <osl/diagnose.h>
+#include <swwait.hxx>
+#include <uitool.hxx>
+#include <view.hxx>
+#include <wrtsh.hxx>
+#include <viewopt.hxx>
+#include <swundo.hxx>
+#include <hyp.hxx>
+#include <olmenu.hxx>
+#include <pam.hxx>
+#include <edtwin.hxx>
+#include <ndtxt.hxx>
+#include <txtfrm.hxx>
+#include <cmdid.h>
+#include <strings.hrc>
+#include <hhcwrp.hxx>
+
+#include <boost/property_tree/json_parser.hpp>
+
+#include <com/sun/star/ui/dialogs/XExecutableDialog.hpp>
+#include <com/sun/star/ui/ContextMenuExecuteEvent.hpp>
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/frame/XDispatch.hpp>
+#include <com/sun/star/frame/XDispatchProvider.hpp>
+#include <com/sun/star/frame/XFrame.hpp>
+#include <com/sun/star/frame/XPopupMenuController.hpp>
+#include <com/sun/star/awt/PopupMenuDirection.hpp>
+#include <com/sun/star/awt/XVclWindowPeer.hpp>
+#include <com/sun/star/util/URL.hpp>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/util/URLTransformer.hpp>
+#include <com/sun/star/util/XURLTransformer.hpp>
+
+#include <vcl/svapp.hxx>
+#include <rtl/ustring.hxx>
+
+#include <cppuhelper/bootstrap.hxx>
+#include <svtools/langtab.hxx>
+
+#include <editeng/editerr.hxx>
+#include <LibreOfficeKit/LibreOfficeKitEnums.h>
+
+#include <memory>
+
+using namespace sw::mark;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::linguistic2;
+
+// Lingu-Dispatcher
+
+void SwView::ExecLingu(SfxRequest &rReq)
+{
+ switch(rReq.GetSlot())
+ {
+ case SID_THESAURUS:
+ StartThesaurus();
+ rReq.Ignore();
+ break;
+ case SID_HANGUL_HANJA_CONVERSION:
+ StartTextConversion( LANGUAGE_KOREAN, LANGUAGE_KOREAN, nullptr,
+ i18n::TextConversionOption::CHARACTER_BY_CHARACTER, true );
+ break;
+ case SID_CHINESE_CONVERSION:
+ {
+ //open ChineseTranslationDialog
+ Reference< XComponentContext > xContext(
+ ::cppu::defaultBootstrap_InitialComponentContext() ); //@todo get context from calc if that has one
+ if(xContext.is())
+ {
+ Reference< lang::XMultiComponentFactory > xMCF( xContext->getServiceManager() );
+ if(xMCF.is())
+ {
+ Reference< ui::dialogs::XExecutableDialog > xDialog(
+ xMCF->createInstanceWithContext(
+ "com.sun.star.linguistic2.ChineseTranslationDialog", xContext),
+ UNO_QUERY);
+ Reference< lang::XInitialization > xInit( xDialog, UNO_QUERY );
+ if( xInit.is() )
+ {
+ Reference<awt::XWindow> xParentWindow;
+ if (weld::Window* pParentWindow = rReq.GetFrameWeld())
+ xParentWindow = pParentWindow->GetXWindow();
+ // initialize dialog
+ uno::Sequence<uno::Any> aSeq(comphelper::InitAnyPropertySequence(
+ {
+ {"ParentWindow", uno::Any(xParentWindow)}
+ }));
+ xInit->initialize( aSeq );
+
+ //execute dialog
+ sal_Int16 nDialogRet = xDialog->execute();
+ if( RET_OK == nDialogRet )
+ {
+ //get some parameters from the dialog
+ bool bToSimplified = true;
+ bool bUseVariants = true;
+ bool bCommonTerms = true;
+ Reference< beans::XPropertySet > xProp( xDialog, UNO_QUERY );
+ if( xProp.is() )
+ {
+ try
+ {
+ xProp->getPropertyValue( "IsDirectionToSimplified" ) >>= bToSimplified;
+ xProp->getPropertyValue( "IsUseCharacterVariants" ) >>= bUseVariants;
+ xProp->getPropertyValue( "IsTranslateCommonTerms" ) >>= bCommonTerms;
+ }
+ catch (const Exception&)
+ {
+ }
+ }
+
+ //execute translation
+ LanguageType nSourceLang = bToSimplified ? LANGUAGE_CHINESE_TRADITIONAL : LANGUAGE_CHINESE_SIMPLIFIED;
+ LanguageType nTargetLang = bToSimplified ? LANGUAGE_CHINESE_SIMPLIFIED : LANGUAGE_CHINESE_TRADITIONAL;
+ sal_Int32 nOptions = bUseVariants ? i18n::TextConversionOption::USE_CHARACTER_VARIANTS : 0;
+ if( !bCommonTerms )
+ nOptions = nOptions | i18n::TextConversionOption::CHARACTER_BY_CHARACTER;
+
+ vcl::Font aTargetFont = OutputDevice::GetDefaultFont( DefaultFontType::CJK_TEXT,
+ nTargetLang, GetDefaultFontFlags::OnlyOne );
+
+ // disallow formatting, updating the view, ... while
+ // converting the document. (saves time)
+ // Also remember the current view and cursor position for later
+ m_pWrtShell->StartAction();
+
+ // remember cursor position data for later restoration of the cursor
+ const SwPosition *pPoint = m_pWrtShell->GetCursor()->GetPoint();
+ bool bRestoreCursor = pPoint->GetNode().IsTextNode();
+ const SwNodeIndex aPointNodeIndex( pPoint->GetNode() );
+ sal_Int32 nPointIndex = pPoint->GetContentIndex();
+
+ // since this conversion is not interactive the whole converted
+ // document should be undone in a single undo step.
+ m_pWrtShell->StartUndo( SwUndoId::OVERWRITE );
+
+ StartTextConversion( nSourceLang, nTargetLang, &aTargetFont, nOptions, false );
+
+ m_pWrtShell->EndUndo( SwUndoId::OVERWRITE );
+
+ if (bRestoreCursor)
+ {
+ SwTextNode *pTextNode = aPointNodeIndex.GetNode().GetTextNode();
+ // check for unexpected error case
+ OSL_ENSURE(pTextNode && pTextNode->GetText().getLength() >= nPointIndex,
+ "text missing: corrupted node?" );
+ // restore cursor to its original position
+ if (!pTextNode || pTextNode->GetText().getLength() < nPointIndex)
+ m_pWrtShell->GetCursor()->GetPoint()->Assign( aPointNodeIndex );
+ else
+ m_pWrtShell->GetCursor()->GetPoint()->Assign( *pTextNode, nPointIndex );
+ }
+
+ // enable all, restore view and cursor position
+ m_pWrtShell->EndAction();
+ }
+ }
+ Reference< lang::XComponent > xComponent( xDialog, UNO_QUERY );
+ if( xComponent.is() )
+ xComponent->dispose();
+ }
+ }
+ break;
+ }
+ case FN_HYPHENATE_OPT_DLG:
+ HyphenateDocument();
+ break;
+ default:
+ OSL_ENSURE(false, "wrong Dispatcher");
+ return;
+ }
+}
+
+// start language specific text conversion
+
+void SwView::StartTextConversion(
+ LanguageType nSourceLang,
+ LanguageType nTargetLang,
+ const vcl::Font *pTargetFont,
+ sal_Int32 nOptions,
+ bool bIsInteractive )
+{
+ // do not do text conversion if it is active elsewhere
+ if (SwEditShell::HasConvIter())
+ {
+ return;
+ }
+
+ SpellContext();
+
+ const SwViewOption* pVOpt = m_pWrtShell->GetViewOptions();
+ const bool bOldIdle = pVOpt->IsIdle();
+ pVOpt->SetIdle( false );
+
+ bool bOldIns = m_pWrtShell->IsInsMode();
+ m_pWrtShell->SetInsMode();
+
+ const bool bSelection = static_cast<SwCursorShell*>(m_pWrtShell.get())->HasSelection() ||
+ m_pWrtShell->GetCursor() != m_pWrtShell->GetCursor()->GetNext();
+
+ const bool bStart = bSelection || m_pWrtShell->IsStartOfDoc();
+ const bool bOther = !bSelection && !(m_pWrtShell->GetFrameType(nullptr,true) & FrameTypeFlags::BODY);
+
+ {
+ const uno::Reference< uno::XComponentContext > xContext(
+ comphelper::getProcessComponentContext() );
+ SwHHCWrapper aWrap( this, xContext, nSourceLang, nTargetLang, pTargetFont,
+ nOptions, bIsInteractive,
+ bStart, bOther, bSelection );
+ aWrap.Convert();
+ }
+
+ m_pWrtShell->SetInsMode( bOldIns );
+ pVOpt->SetIdle( bOldIdle );
+ SpellContext(false);
+}
+
+// spellcheck and text conversion related stuff
+
+void SwView::SpellStart( SvxSpellArea eWhich,
+ bool bStartDone, bool bEndDone,
+ SwConversionArgs *pConvArgs )
+{
+ Reference< XLinguProperties > xProp = ::GetLinguPropertySet();
+ bool bIsWrapReverse = !pConvArgs && xProp.is() && xProp->getIsWrapReverse();
+
+ SwDocPositions eStart = SwDocPositions::Start;
+ SwDocPositions eEnd = SwDocPositions::End;
+ SwDocPositions eCurr = SwDocPositions::Curr;
+ switch ( eWhich )
+ {
+ case SvxSpellArea::Body:
+ if( bIsWrapReverse )
+ eCurr = SwDocPositions::End;
+ else
+ eCurr = SwDocPositions::Start;
+ break;
+ case SvxSpellArea::BodyEnd:
+ if( bIsWrapReverse )
+ {
+ if( bStartDone )
+ eStart = SwDocPositions::Curr;
+ eCurr = SwDocPositions::End;
+ }
+ else if( bStartDone )
+ eCurr = SwDocPositions::Start;
+ break;
+ case SvxSpellArea::BodyStart:
+ if( !bIsWrapReverse )
+ {
+ if( bEndDone )
+ eEnd = SwDocPositions::Curr;
+ eCurr = SwDocPositions::Start;
+ }
+ else if( bEndDone )
+ eCurr = SwDocPositions::End;
+ break;
+ case SvxSpellArea::Other:
+ if( bIsWrapReverse )
+ {
+ eStart = SwDocPositions::OtherStart;
+ eEnd = SwDocPositions::OtherEnd;
+ eCurr = SwDocPositions::OtherEnd;
+ }
+ else
+ {
+ eStart = SwDocPositions::OtherStart;
+ eEnd = SwDocPositions::OtherEnd;
+ eCurr = SwDocPositions::OtherStart;
+ }
+ break;
+ default:
+ OSL_ENSURE( false, "SpellStart with unknown Area" );
+ }
+ m_pWrtShell->SpellStart( eStart, eEnd, eCurr, pConvArgs );
+}
+
+// Error message while Spelling
+
+// The passed pointer nlang is itself the value
+void SwView::SpellError(LanguageType eLang)
+{
+ int nPend = 0;
+
+ if ( m_pWrtShell->ActionPend() )
+ {
+ m_pWrtShell->Push();
+ m_pWrtShell->ClearMark();
+ do
+ {
+ m_pWrtShell->EndAction();
+ ++nPend;
+ }
+ while( m_pWrtShell->ActionPend() );
+ }
+ OUString aErr(SvtLanguageTable::GetLanguageString( eLang ) );
+
+ SwEditWin &rEditWin = GetEditWin();
+ int nWaitCnt = 0;
+ while( rEditWin.IsWait() )
+ {
+ rEditWin.LeaveWait();
+ ++nWaitCnt;
+ }
+ if ( LANGUAGE_NONE == eLang )
+ ErrorHandler::HandleError( ERRCODE_SVX_LINGU_NOLANGUAGE );
+ else
+ ErrorHandler::HandleError( ErrCodeMsg( ERRCODE_SVX_LINGU_LANGUAGENOTEXISTS, aErr ) );
+
+ while( nWaitCnt )
+ {
+ rEditWin.EnterWait();
+ --nWaitCnt;
+ }
+
+ if ( nPend )
+ {
+ while( nPend-- )
+ m_pWrtShell->StartAction();
+ m_pWrtShell->Combine();
+ }
+}
+
+// Finish spelling and restore cursor
+
+void SwView::SpellEnd( SwConversionArgs const *pConvArgs )
+{
+ m_pWrtShell->SpellEnd( pConvArgs );
+ if( m_pWrtShell->IsExtMode() )
+ m_pWrtShell->SetMark();
+}
+
+void SwView::HyphStart( SvxSpellArea eWhich )
+{
+ switch ( eWhich )
+ {
+ case SvxSpellArea::Body:
+ m_pWrtShell->HyphStart( SwDocPositions::Start, SwDocPositions::End );
+ break;
+ case SvxSpellArea::BodyEnd:
+ m_pWrtShell->HyphStart( SwDocPositions::Curr, SwDocPositions::End );
+ break;
+ case SvxSpellArea::BodyStart:
+ m_pWrtShell->HyphStart( SwDocPositions::Start, SwDocPositions::Curr );
+ break;
+ case SvxSpellArea::Other:
+ m_pWrtShell->HyphStart( SwDocPositions::OtherStart, SwDocPositions::OtherEnd );
+ break;
+ default:
+ OSL_ENSURE( false, "HyphStart with unknown Area" );
+ }
+}
+
+// Interactive separation
+
+void SwView::HyphenateDocument()
+{
+ // do not hyphenate if interactive hyphenation is active elsewhere
+ if (SwEditShell::HasHyphIter())
+ {
+ std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(GetEditWin().GetFrameWeld(),
+ VclMessageType::Warning, VclButtonsType::Ok, SwResId(STR_MULT_INTERACT_HYPH_WARN)));
+ xBox->set_title(SwResId(STR_HYPH_TITLE));
+ xBox->run();
+ return;
+ }
+
+ SfxErrorContext aContext( ERRCTX_SVX_LINGU_HYPHENATION, OUString(), m_pEditWin->GetFrameWeld(),
+ RID_SVXERRCTX, SvxResLocale() );
+
+ Reference< XHyphenator > xHyph( ::GetHyphenator() );
+ if (!xHyph.is())
+ {
+ ErrorHandler::HandleError( ERRCODE_SVX_LINGU_LINGUNOTEXISTS );
+ return;
+ }
+
+ if (m_pWrtShell->GetSelectionType() & (SelectionType::DrawObjectEditMode|SelectionType::DrawObject))
+ {
+ // Hyphenation in a Draw object
+ HyphenateDrawText();
+ }
+ else
+ {
+ SwViewOption* pVOpt = const_cast<SwViewOption*>(m_pWrtShell->GetViewOptions());
+ bool bOldIdle = pVOpt->IsIdle();
+ pVOpt->SetIdle( false );
+
+ Reference< XLinguProperties > xProp( ::GetLinguPropertySet() );
+
+ m_pWrtShell->StartUndo(SwUndoId::INSATTR); // valid later
+
+ bool bHyphSpecial = xProp.is() && xProp->getIsHyphSpecial();
+ bool bSelection = static_cast<SwCursorShell*>(m_pWrtShell.get())->HasSelection() ||
+ m_pWrtShell->GetCursor() != m_pWrtShell->GetCursor()->GetNext();
+ bool bOther = m_pWrtShell->HasOtherCnt() && bHyphSpecial && !bSelection;
+ bool bStart = bSelection || ( !bOther && m_pWrtShell->IsStartOfDoc() );
+ bool bStop = false;
+ if( !bOther && !(m_pWrtShell->GetFrameType(nullptr,true) & FrameTypeFlags::BODY) && !bSelection )
+ // turned on no special area
+ {
+ // I want also in special areas hyphenation
+ std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(GetEditWin().GetFrameWeld(),
+ VclMessageType::Question, VclButtonsType::YesNo,
+ SwResId(STR_QUERY_SPECIAL_FORCED)));
+ if (xBox->run() == RET_YES)
+ {
+ bOther = true;
+ if (xProp.is())
+ {
+ xProp->setIsHyphSpecial( true );
+ }
+ }
+ else
+ bStop = true; // No hyphenation
+ }
+
+ if( !bStop )
+ {
+ SwHyphWrapper aWrap( this, xHyph, bStart, bOther, bSelection );
+ aWrap.SpellDocument();
+ m_pWrtShell->EndUndo(SwUndoId::INSATTR);
+ }
+ pVOpt->SetIdle( bOldIdle );
+ }
+}
+
+bool SwView::IsValidSelectionForThesaurus() const
+{
+ // must not be a multi-selection, and if it is a selection it needs
+ // to be within a single paragraph
+
+ const bool bMultiSel = m_pWrtShell->GetCursor()->IsMultiSelection();
+ const bool bSelection = static_cast<SwCursorShell*>(m_pWrtShell.get())->HasSelection();
+ return !bMultiSel && (!bSelection || m_pWrtShell->IsSelOnePara() );
+}
+
+OUString SwView::GetThesaurusLookUpText( bool bSelection ) const
+{
+ return bSelection ? m_pWrtShell->GetSelText() : m_pWrtShell->GetCurWord();
+}
+
+void SwView::InsertThesaurusSynonym( const OUString &rSynonmText, const OUString &rLookUpText, bool bSelection )
+{
+ bool bOldIns = m_pWrtShell->IsInsMode();
+ m_pWrtShell->SetInsMode();
+
+ m_pWrtShell->StartAllAction();
+ m_pWrtShell->StartUndo(SwUndoId::DELETE);
+
+ if( !bSelection )
+ {
+ if(m_pWrtShell->IsEndWrd())
+ m_pWrtShell->Left(SwCursorSkipMode::Cells, false, 1, false );
+
+ m_pWrtShell->SelWrd();
+
+ // make sure the selection build later from the data below does not
+ // include "in word" character to the left and right in order to
+ // preserve those. Therefore count those "in words" in order to modify
+ // the selection accordingly.
+ const sal_Unicode* pChar = rLookUpText.getStr();
+ sal_Int32 nLeft = 0;
+ while (*pChar++ == CH_TXTATR_INWORD)
+ ++nLeft;
+ pChar = rLookUpText.getLength() ? rLookUpText.getStr() + rLookUpText.getLength() - 1 : nullptr;
+ sal_Int32 nRight = 0;
+ while (pChar && *pChar-- == CH_TXTATR_INWORD)
+ ++nRight;
+
+ // adjust existing selection
+ SwPaM *pCursor = m_pWrtShell->GetCursor();
+ pCursor->GetPoint()->AdjustContent(-nRight);
+ pCursor->GetMark()->AdjustContent(nLeft);
+ }
+
+ m_pWrtShell->Insert( rSynonmText );
+
+ m_pWrtShell->EndUndo(SwUndoId::DELETE);
+ m_pWrtShell->EndAllAction();
+
+ m_pWrtShell->SetInsMode( bOldIns );
+}
+
+// Start thesaurus
+
+void SwView::StartThesaurus()
+{
+ if (!IsValidSelectionForThesaurus())
+ return;
+
+ SfxErrorContext aContext( ERRCTX_SVX_LINGU_THESAURUS, OUString(), m_pEditWin->GetFrameWeld(),
+ RID_SVXERRCTX, SvxResLocale() );
+
+ // Determine language
+ LanguageType eLang = m_pWrtShell->GetCurLang();
+ if( LANGUAGE_SYSTEM == eLang )
+ eLang = GetAppLanguage();
+
+ if( eLang == LANGUAGE_DONTKNOW || eLang == LANGUAGE_NONE )
+ {
+ SpellError( LANGUAGE_NONE );
+ return;
+ }
+
+ SwViewOption* pVOpt = const_cast<SwViewOption*>(m_pWrtShell->GetViewOptions());
+ const bool bOldIdle = pVOpt->IsIdle();
+ pVOpt->SetIdle( false );
+ comphelper::ScopeGuard guard([&]() { pVOpt->SetIdle(bOldIdle); }); // restore when leaving scope
+
+ // get initial LookUp text
+ const bool bSelection = static_cast<SwCursorShell*>(m_pWrtShell.get())->HasSelection();
+ OUString aTmp = GetThesaurusLookUpText( bSelection );
+
+ Reference< XThesaurus > xThes( ::GetThesaurus() );
+
+ if ( !xThes.is() || !xThes->hasLocale( LanguageTag::convertToLocale( eLang ) ) )
+ SpellError( eLang );
+ else
+ {
+ VclPtr<AbstractThesaurusDialog> pDlg;
+ // create dialog
+ { //Scope for SwWait-Object
+ SwWait aWait( *GetDocShell(), true );
+ // load library with dialog only on demand ...
+ SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
+ pDlg.reset(pFact->CreateThesaurusDialog(GetEditWin().GetFrameWeld(), xThes, aTmp, eLang));
+ }
+
+ if (pDlg)
+ {
+ guard.dismiss(); // ignore, we'll call SetIdle() explicitly after the dialog ends
+
+ pDlg->StartExecuteAsync([aTmp, bSelection, bOldIdle, pDlg, pVOpt, this](sal_Int32 nResult){
+ if (nResult == RET_OK )
+ InsertThesaurusSynonym(pDlg->GetWord(), aTmp, bSelection);
+
+ pVOpt->SetIdle(bOldIdle);
+ pDlg->disposeOnce();
+ });
+ }
+ }
+}
+
+// Offer online suggestions
+
+namespace {
+
+//!! Start of extra code for context menu modifying extensions
+struct ExecuteInfo
+{
+ uno::Reference< frame::XDispatch > xDispatch;
+ util::URL aTargetURL;
+ uno::Sequence< PropertyValue > aArgs;
+};
+
+class AsyncExecute
+{
+public:
+ DECL_STATIC_LINK( AsyncExecute, ExecuteHdl_Impl, void*, void );
+};
+
+}
+
+IMPL_STATIC_LINK( AsyncExecute, ExecuteHdl_Impl, void*, p, void )
+{
+ ExecuteInfo* pExecuteInfo = static_cast<ExecuteInfo*>(p);
+ SolarMutexReleaser aReleaser;
+ try
+ {
+ // Asynchronous execution as this can lead to our own destruction!
+ // Framework can recycle our current frame and the layout manager disposes all user interface
+ // elements if a component gets detached from its frame!
+ pExecuteInfo->xDispatch->dispatch( pExecuteInfo->aTargetURL, pExecuteInfo->aArgs );
+ }
+ catch (const Exception&)
+ {
+ }
+
+ delete pExecuteInfo;
+}
+//!! End of extra code for context menu modifying extensions
+
+bool SwView::ExecSpellPopup(const Point& rPt)
+{
+ bool bRet = false;
+ const SwViewOption* pVOpt = m_pWrtShell->GetViewOptions();
+ if( pVOpt->IsOnlineSpell() &&
+ !m_pWrtShell->IsSelection())
+ {
+ if (m_pWrtShell->GetSelectionType() & SelectionType::DrawObjectEditMode)
+ bRet = ExecDrwTextSpellPopup(rPt);
+ else if (!m_pWrtShell->IsSelFrameMode())
+ {
+ const bool bOldViewLock = m_pWrtShell->IsViewLocked();
+ m_pWrtShell->LockView( true );
+ if (!comphelper::LibreOfficeKit::isActive())
+ m_pWrtShell->Push();
+ SwRect aToFill;
+
+ SwCursorShell *pCursorShell = m_pWrtShell.get();
+ SwPaM *pCursor = pCursorShell->GetCursor();
+ SwPosition aPoint(*pCursor->GetPoint());
+ const SwTextNode *pNode = aPoint.GetNode().GetTextNode();
+
+ // Spell-check in case the idle jobs haven't had a chance to kick in.
+ // This makes it possible to suggest spelling corrections for
+ // wrong words independent of the spell-checking idle job.
+ if (pNode && pNode->IsWrongDirty() &&
+ !pCursorShell->IsTableMode() &&
+ !pCursor->HasMark() && !pCursor->IsMultiSelection())
+ {
+ std::pair<Point, bool> const tmp(rPt, false);
+ SwContentFrame *const pContentFrame = pCursor->GetPointContentNode()->getLayoutFrame(
+ pCursorShell->GetLayout(),
+ &aPoint, &tmp);
+ if (pContentFrame)
+ {
+ SwRect aRepaint(static_cast<SwTextFrame*>(pContentFrame)->AutoSpell_(
+ *pCursor->GetPointContentNode()->GetTextNode(), 0));
+ if (aRepaint.HasArea())
+ m_pWrtShell->InvalidateWindows(aRepaint);
+ }
+ }
+
+ // decide which variant of the context menu to use...
+ // if neither spell checking nor grammar checking provides suggestions use the
+ // default context menu.
+ bool bUseGrammarContext = false;
+ Reference< XSpellAlternatives > xAlt( m_pWrtShell->GetCorrection(&rPt, aToFill) );
+ ProofreadingResult aGrammarCheckRes;
+ sal_Int32 nErrorInResult = -1;
+ uno::Sequence< OUString > aSuggestions;
+ bool bCorrectionRes = false;
+ if (!xAlt.is() || !xAlt->getAlternatives().hasElements())
+ {
+ sal_Int32 nErrorPosInText = -1;
+ bCorrectionRes = m_pWrtShell->GetGrammarCorrection( aGrammarCheckRes, nErrorPosInText, nErrorInResult, aSuggestions, &rPt, aToFill );
+ OUString aMessageText;
+ if (nErrorInResult >= 0)
+ aMessageText = aGrammarCheckRes.aErrors[ nErrorInResult ].aShortComment;
+ // we like to use the grammar checking context menu if we either get
+ // some suggestions or at least a comment about the error found...
+ bUseGrammarContext = bCorrectionRes &&
+ (aSuggestions.hasElements() || !aMessageText.isEmpty());
+ }
+
+ // open respective context menu for spell check or grammar errors with correction suggestions...
+ if ((!bUseGrammarContext && xAlt.is()) ||
+ (bUseGrammarContext && bCorrectionRes && aGrammarCheckRes.aErrors.hasElements()))
+ {
+ // get paragraph text
+ OUString aParaText;
+ if (pNode)
+ {
+ pCursorShell->Push();
+ if (!pCursorShell->IsSttPara())
+ {
+ pCursorShell->MovePara(GoCurrPara, fnParaStart);
+ }
+ pCursorShell->SetMark();
+ if (!pCursorShell->IsEndPara())
+ {
+ pCursorShell->MovePara(GoCurrPara, fnParaEnd);
+ }
+ aParaText = pCursorShell->GetSelText();
+ pCursorShell->Pop(SwCursorShell::PopMode::DeleteCurrent);
+ }
+ else
+ {
+ OSL_FAIL("text node expected but not found" );
+ }
+
+ bRet = true;
+ m_pWrtShell->SttSelect();
+ std::unique_ptr<SwSpellPopup> xPopup(bUseGrammarContext ?
+ new SwSpellPopup(m_pWrtShell.get(), aGrammarCheckRes, nErrorInResult, aSuggestions, aParaText) :
+ new SwSpellPopup(m_pWrtShell.get(), xAlt, aParaText));
+ ui::ContextMenuExecuteEvent aEvent;
+ const Point aPixPos = GetEditWin().LogicToPixel( rPt );
+
+ aEvent.SourceWindow = VCLUnoHelper::GetInterface( m_pEditWin );
+ aEvent.ExecutePosition.X = aPixPos.X();
+ aEvent.ExecutePosition.Y = aPixPos.Y();
+ rtl::Reference<VCLXPopupMenu> xMenu;
+
+ OUString sMenuName = bUseGrammarContext ?
+ OUString("private:resource/GrammarContextMenu") : OUString("private:resource/SpellContextMenu");
+ rtl::Reference<VCLXPopupMenu> xMenuInterface = xPopup->CreateMenuInterface();
+ if (TryContextMenuInterception(xMenuInterface, sMenuName, xMenu, aEvent))
+ {
+ //! happy hacking for context menu modifying extensions of this
+ //! 'custom made' menu... *sigh* (code copied from sfx2 and framework)
+ if (xMenu.is())
+ {
+ css::uno::Reference<css::awt::XWindowPeer> xParent(aEvent.SourceWindow, css::uno::UNO_QUERY);
+ const sal_uInt16 nId = xMenu->execute(xParent, css::awt::Rectangle(aPixPos.X(), aPixPos.Y(), 1, 1),
+ css::awt::PopupMenuDirection::EXECUTE_DOWN);
+ OUString aCommand = xMenu->getCommand(nId);
+ if (aCommand.isEmpty() )
+ {
+ if (!ExecuteMenuCommand(xMenu, GetViewFrame(), nId))
+ xPopup->Execute(nId);
+ }
+ else
+ {
+ SfxViewFrame& rSfxViewFrame = GetViewFrame();
+ uno::Reference<frame::XFrame> xFrame = rSfxViewFrame.GetFrame().GetFrameInterface();
+ css::util::URL aURL;
+ uno::Reference< frame::XDispatchProvider > xDispatchProvider( xFrame, UNO_QUERY );
+
+ try
+ {
+ uno::Reference< frame::XDispatch > xDispatch;
+ uno::Reference< util::XURLTransformer > xURLTransformer = util::URLTransformer::create(comphelper::getProcessComponentContext());
+
+ aURL.Complete = aCommand;
+ xURLTransformer->parseStrict(aURL);
+ uno::Sequence< beans::PropertyValue > aArgs;
+ xDispatch = xDispatchProvider->queryDispatch( aURL, OUString(), 0 );
+
+ if (xDispatch.is())
+ {
+ // Execute dispatch asynchronously
+ ExecuteInfo* pExecuteInfo = new ExecuteInfo;
+ pExecuteInfo->xDispatch = xDispatch;
+ pExecuteInfo->aTargetURL = aURL;
+ pExecuteInfo->aArgs = aArgs;
+ Application::PostUserEvent( LINK(nullptr, AsyncExecute , ExecuteHdl_Impl), pExecuteInfo );
+ }
+ }
+ catch (const Exception&)
+ {
+ }
+ }
+ }
+ else
+ {
+ if (comphelper::LibreOfficeKit::isActive())
+ {
+ if (SfxViewShell* pViewShell = SfxViewShell::Current())
+ {
+ boost::property_tree::ptree aMenu = SfxDispatcher::fillPopupMenu(xMenuInterface);
+ boost::property_tree::ptree aRoot;
+ aRoot.add_child("menu", aMenu);
+
+ std::stringstream aStream;
+ boost::property_tree::write_json(aStream, aRoot, true);
+ pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_CONTEXT_MENU, OString(aStream.str()));
+ }
+ }
+ else
+ {
+ xPopup->Execute(aToFill.SVRect(), m_pEditWin);
+ }
+ }
+ }
+ }
+
+ if (!comphelper::LibreOfficeKit::isActive())
+ m_pWrtShell->Pop(SwCursorShell::PopMode::DeleteCurrent);
+ m_pWrtShell->LockView( bOldViewLock );
+ }
+ }
+ return bRet;
+}
+
+/** Function: ExecSmartTagPopup
+
+ This function shows the popup menu for smarttag
+ actions.
+*/
+void SwView::ExecSmartTagPopup( const Point& rPt )
+{
+ const bool bOldViewLock = m_pWrtShell->IsViewLocked();
+ m_pWrtShell->LockView( true );
+ m_pWrtShell->Push();
+
+ css::uno::Sequence< css::uno::Any > aArgs{
+ css::uno::Any(comphelper::makePropertyValue( "Frame", GetDispatcher().GetFrame()->GetFrame().GetFrameInterface() )),
+ css::uno::Any(comphelper::makePropertyValue( "CommandURL", OUString( ".uno:OpenSmartTagMenuOnCursor" ) ))
+ };
+
+ css::uno::Reference< css::uno::XComponentContext > xContext = comphelper::getProcessComponentContext();
+ css::uno::Reference< css::frame::XPopupMenuController > xPopupController(
+ xContext->getServiceManager()->createInstanceWithArgumentsAndContext(
+ "com.sun.star.comp.svx.SmartTagMenuController", aArgs, xContext ), css::uno::UNO_QUERY );
+
+ css::uno::Reference< css::awt::XPopupMenu > xPopupMenu( xContext->getServiceManager()->createInstanceWithContext(
+ "com.sun.star.awt.PopupMenu", xContext ), css::uno::UNO_QUERY );
+
+ if ( xPopupController.is() && xPopupMenu.is() )
+ {
+ xPopupController->setPopupMenu( xPopupMenu );
+
+ SwRect aToFill;
+ m_pWrtShell->GetSmartTagRect( rPt, aToFill );
+ m_pWrtShell->SttSelect();
+
+ if ( aToFill.HasArea() )
+ xPopupMenu->execute( m_pEditWin->GetComponentInterface(),
+ VCLUnoHelper::ConvertToAWTRect( m_pEditWin->LogicToPixel( aToFill.SVRect() ) ), css::awt::PopupMenuDirection::EXECUTE_DOWN );
+
+ css::uno::Reference< css::lang::XComponent > xComponent( xPopupController, css::uno::UNO_QUERY );
+ if ( xComponent.is() )
+ xComponent->dispose();
+ }
+
+ m_pWrtShell->Pop(SwCursorShell::PopMode::DeleteCurrent);
+ m_pWrtShell->LockView( bOldViewLock );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/viewmdi.cxx b/sw/source/uibase/uiview/viewmdi.cxx
new file mode 100644
index 0000000000..f07c25e2df
--- /dev/null
+++ b/sw/source/uibase/uiview/viewmdi.cxx
@@ -0,0 +1,791 @@
+/* -*- 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 <sfx2/dispatch.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <svx/ruler.hxx>
+#include <editeng/lrspitem.hxx>
+#include <o3tl/safeint.hxx>
+#include <svl/srchitem.hxx>
+#include <svl/stritem.hxx>
+#include <sfx2/request.hxx>
+#include <swmodule.hxx>
+#include <view.hxx>
+#include <wrtsh.hxx>
+#include <viewopt.hxx>
+#include <frmatr.hxx>
+#include <edtwin.hxx>
+#include <pagedesc.hxx>
+#include <IMark.hxx>
+#include <fldbas.hxx>
+#include <workctrl.hxx>
+#include <usrpref.hxx>
+#include <scroll.hxx>
+#include <wview.hxx>
+
+#include <cmdid.h>
+
+#include <PostItMgr.hxx>
+#include <AnnotationWin.hxx>
+
+#include <svx/srchdlg.hxx>
+#include <svx/svdview.hxx>
+
+#include <vcl/uitest/logger.hxx>
+#include <vcl/uitest/eventdescription.hxx>
+
+sal_uInt16 SwView::s_nMoveType = NID_PGE;
+sal_Int32 SwView::s_nActMark = 0;
+
+using namespace ::com::sun::star::uno;
+
+namespace {
+
+void collectUIInformation(const OUString& aFactor)
+{
+ EventDescription aDescription;
+ aDescription.aID = "writer_edit";
+ aDescription.aParameters = {{"ZOOM", aFactor}};
+ aDescription.aAction = "SET";
+ aDescription.aKeyWord = "SwEditWinUIObject";
+ aDescription.aParent = "MainWindow";
+ UITestLogger::getInstance().logEvent(aDescription);
+}
+
+}
+
+void SwView::SetZoom( SvxZoomType eZoomType, short nFactor, bool bViewOnly )
+{
+ bool const bCursorIsVisible(m_pWrtShell->IsCursorVisible());
+ SetZoom_( GetEditWin().GetOutputSizePixel(), eZoomType, nFactor, bViewOnly );
+ // fdo#40465 force the cursor to stay in view whilst zooming
+ if (bCursorIsVisible)
+ m_pWrtShell->ShowCursor();
+
+ Invalidate(SID_ZOOM_IN);
+ Invalidate(SID_ZOOM_OUT);
+
+ collectUIInformation(OUString::number(nFactor));
+}
+
+void SwView::SetZoom_( const Size &rEditSize, SvxZoomType eZoomType,
+ short nFactor, bool bViewOnly )
+{
+ bool bUnLockView = !m_pWrtShell->IsViewLocked();
+ m_pWrtShell->LockView( true );
+ m_pWrtShell->LockPaint(LockPaintReason::SetZoom);
+
+ { // start of SwActContext scope
+ SwActContext aActContext(m_pWrtShell.get());
+
+ tools::Long nFac = nFactor;
+
+ const bool bWeb = dynamic_cast< const SwWebView *>( this ) != nullptr;
+ SwMasterUsrPref *pUsrPref = const_cast<SwMasterUsrPref*>(SW_MOD()->GetUsrPref(bWeb));
+
+ const SwPageDesc &rDesc = m_pWrtShell->GetPageDesc( m_pWrtShell->GetCurPageDesc() );
+ const SvxLRSpaceItem &rLRSpace = rDesc.GetMaster().GetLRSpace();
+ const SwViewOption *pOpt = m_pWrtShell->GetViewOptions();
+ tools::Long lLeftMargin = 0;
+
+ if( eZoomType != SvxZoomType::PERCENT )
+ {
+ const bool bAutomaticViewLayout = 0 == pOpt->GetViewLayoutColumns();
+
+ const SwRect aPageRect( m_pWrtShell->GetAnyCurRect( CurRectType::PageCalc ) );
+ const SwRect aRootRect( m_pWrtShell->GetAnyCurRect( CurRectType::PagesArea ) );
+ Size aPageSize( aPageRect.SSize() );
+ Size aRootSize( aRootRect.SSize() );
+
+ //mod #i6193# added sidebar width
+ SwPostItMgr* pPostItMgr = GetPostItMgr();
+ if (pPostItMgr->HasNotes() && pPostItMgr->ShowNotes())
+ aPageSize.AdjustWidth(pPostItMgr->GetSidebarWidth() + pPostItMgr->GetSidebarBorderWidth() );
+
+ const MapMode aTmpMap( MapUnit::MapTwip );
+ const Size aWindowSize( GetEditWin().PixelToLogic( rEditSize, aTmpMap ) );
+
+ if( SvxZoomType::OPTIMAL == eZoomType )
+ {
+ // unclear if this is useful for OPTIMAL, or completely useless?
+ if( UseOnPage::Mirror == rDesc.GetUseOn() ) // mirrored pages
+ {
+ const SvxLRSpaceItem &rLeftLRSpace = rDesc.GetLeft().GetLRSpace();
+ aPageSize.AdjustWidth(std::abs( rLeftLRSpace.GetLeft() - rLRSpace.GetLeft() ) );
+ }
+
+ if (!pPostItMgr->HasNotes() || !pPostItMgr->ShowNotes())
+ aPageSize.AdjustWidth( -( rLRSpace.GetLeft() + rLRSpace.GetRight() + nLeftOfst * 2 ) );
+ lLeftMargin = rLRSpace.GetLeft() + DOCUMENTBORDER + nLeftOfst;
+ nFac = aWindowSize.Width() * 100 / aPageSize.Width();
+ }
+ else if(SvxZoomType::WHOLEPAGE == eZoomType || SvxZoomType::PAGEWIDTH == eZoomType )
+ {
+ const tools::Long nOf = DOCUMENTBORDER * 2;
+ tools::Long nTmpWidth = bAutomaticViewLayout ? aPageSize.Width() : aRootSize.Width();
+ nTmpWidth += nOf;
+ aPageSize.AdjustHeight(nOf );
+ nFac = aWindowSize.Width() * 100 / nTmpWidth;
+
+ if ( SvxZoomType::WHOLEPAGE == eZoomType )
+ {
+ tools::Long nVisPercent = aWindowSize.Height() * 100 / aPageSize.Height();
+ nFac = std::min( nFac, nVisPercent );
+ }
+ }
+ else
+ {
+ const tools::Long nTmpWidth = bAutomaticViewLayout ? aPageSize.Width() : aRootSize.Width();
+ nFac = aWindowSize.Width() * 100 / nTmpWidth;
+ }
+ }
+
+ nFac = std::max( tools::Long( MINZOOM ), nFac );
+ const sal_uInt16 nZoomFac = o3tl::narrowing<sal_uInt16>(nFac);
+
+ SwViewOption aOpt( *pOpt );
+ if ( !GetViewFrame().GetFrame().IsInPlace() )
+ {
+ //Update MasterUsrPrefs and after that update the ViewOptions of the current View.
+ if ( !bViewOnly &&
+ (nZoomFac != pUsrPref->GetZoom() ||
+ eZoomType != pUsrPref->GetZoomType()) )
+ {
+ pUsrPref->SetZoom(nZoomFac);
+ pUsrPref->SetZoomType(eZoomType);
+ SW_MOD()->ApplyUsrPref(*pUsrPref, nullptr);
+ pUsrPref->SetModified();
+ }
+ if ( pOpt->GetZoom() != nZoomFac )
+ {
+ aOpt.SetZoom(nZoomFac);
+ aOpt.SetReadonly(pOpt->IsReadonly());
+ m_pWrtShell->ApplyViewOptions( aOpt );
+ }
+ if ( eZoomType != SvxZoomType::PERCENT )
+ {
+ Point aPos;
+
+ if ( eZoomType == SvxZoomType::WHOLEPAGE )
+ aPos.setY( m_pWrtShell->GetAnyCurRect(CurRectType::Page).Top() - DOCUMENTBORDER );
+ else
+ {
+ // Make sure that the cursor is in the visible range, so that
+ // the scrolling will be performed only once.
+ aPos.setX( lLeftMargin );
+ const SwRect &rCharRect = m_pWrtShell->GetCharRect();
+ if ( rCharRect.Top() > GetVisArea().Bottom() ||
+ rCharRect.Bottom() < aPos.Y() )
+ aPos.setY( rCharRect.Top() - rCharRect.Height() );
+ else
+ aPos.setY( GetVisArea().Top() );
+ }
+ SetVisArea( aPos );
+ }
+ // Compromise solution - Under certain circumstances SetZoom is called
+ // in CalcVisAreas again and thus be set wrong values.
+ const_cast<SwViewOption*>(m_pWrtShell->GetViewOptions())->SetZoomType( eZoomType );
+ CalcVisArea( rEditSize ); // for the recalculation of the viewable area
+ }
+ else if ( nZoomFac != pOpt->GetZoom() )
+ {
+ aOpt.SetZoom( nZoomFac );
+ m_pWrtShell->ApplyViewOptions( aOpt );
+ }
+
+ const Fraction aFrac( nFac, 100 );
+ m_pVRuler->SetZoom( aFrac );
+ m_pVRuler->ForceUpdate();
+ m_pHRuler->SetZoom( aFrac );
+ m_pHRuler->ForceUpdate();
+ const_cast<SwViewOption*>(m_pWrtShell->GetViewOptions())->SetZoomType( eZoomType );
+ } // end of SwActContext scope
+
+ m_pWrtShell->UnlockPaint();
+ if( bUnLockView )
+ m_pWrtShell->LockView( false );
+}
+
+void SwView::SetViewLayout( sal_uInt16 nColumns, bool bBookMode, bool bViewOnly )
+{
+ const bool bUnLockView = !m_pWrtShell->IsViewLocked();
+ m_pWrtShell->LockView( true );
+ m_pWrtShell->LockPaint(LockPaintReason::ViewLayout);
+
+ {
+
+ SwActContext aActContext(m_pWrtShell.get());
+
+ if ( !GetViewFrame().GetFrame().IsInPlace() && !bViewOnly )
+ {
+ const bool bWeb = dynamic_cast< const SwWebView *>( this ) != nullptr;
+ SwMasterUsrPref *pUsrPref = const_cast<SwMasterUsrPref*>(SW_MOD()->GetUsrPref(bWeb));
+
+ // Update MasterUsrPrefs and after that update the ViewOptions of the current View.
+ if ( nColumns != pUsrPref->GetViewLayoutColumns() ||
+ bBookMode != pUsrPref->IsViewLayoutBookMode() )
+ {
+ pUsrPref->SetViewLayoutColumns(nColumns);
+ pUsrPref->SetViewLayoutBookMode(bBookMode);
+ SW_MOD()->ApplyUsrPref(*pUsrPref, nullptr);
+ pUsrPref->SetModified();
+ }
+ }
+
+ const SwViewOption *pOpt = m_pWrtShell->GetViewOptions();
+
+ if ( nColumns != pOpt->GetViewLayoutColumns() ||
+ bBookMode != pOpt->IsViewLayoutBookMode() )
+ {
+ SwViewOption aOpt( *pOpt );
+ aOpt.SetViewLayoutColumns( nColumns );
+ aOpt.SetViewLayoutBookMode( bBookMode );
+ m_pWrtShell->ApplyViewOptions( aOpt );
+ }
+
+ m_pVRuler->ForceUpdate();
+ m_pHRuler->ForceUpdate();
+
+ }
+
+ m_pWrtShell->UnlockPaint();
+ if( bUnLockView )
+ m_pWrtShell->LockView( false );
+
+ SfxBindings& rBnd = GetViewFrame().GetBindings();
+ rBnd.Invalidate( SID_ATTR_VIEWLAYOUT );
+ rBnd.Invalidate( SID_ATTR_ZOOMSLIDER);
+}
+
+// Scrollbar - Handler
+
+IMPL_LINK( SwView, WindowChildEventListener, VclWindowEvent&, rEvent, void )
+{
+ OSL_ENSURE( rEvent.GetWindow(), "Window???" );
+ vcl::Window* pChildWin = static_cast< vcl::Window* >( rEvent.GetData() );
+
+ switch ( rEvent.GetId() )
+ {
+ case VclEventId::WindowHide:
+ if( pChildWin == m_pHScrollbar )
+ ShowHScrollbar( false );
+ else if( pChildWin == m_pVScrollbar )
+ ShowVScrollbar( false );
+ break;
+ case VclEventId::WindowShow:
+ if( pChildWin == m_pHScrollbar )
+ ShowHScrollbar( true );
+ else if( pChildWin == m_pVScrollbar )
+ ShowVScrollbar( true );
+ break;
+ default: break;
+ }
+}
+
+void SwView::CreateScrollbar( bool bHori )
+{
+ vcl::Window *pMDI = &GetViewFrame().GetWindow();
+ VclPtr<SwScrollbar>& ppScrollbar = bHori ? m_pHScrollbar : m_pVScrollbar;
+
+ assert(!ppScrollbar); //check beforehand!
+
+ ppScrollbar = VclPtr<SwScrollbar>::Create( pMDI, bHori );
+ UpdateScrollbars();
+ if(bHori)
+ ppScrollbar->SetScrollHdl( LINK( this, SwView, HoriScrollHdl ));
+ else
+ ppScrollbar->SetScrollHdl( LINK( this, SwView, VertScrollHdl ));
+
+ if(GetWindow())
+ InvalidateBorder();
+
+ if (!m_bShowAtResize)
+ ppScrollbar->ExtendedShow();
+}
+
+IMPL_LINK( SwView, MoveNavigationHdl, void*, p, void )
+{
+ bool* pbNext = static_cast<bool*>(p);
+ if ( !pbNext )
+ return;
+ const bool bNext = *pbNext;
+ SwWrtShell& rSh = GetWrtShell();
+ if ( NID_SRCH_REP != s_nMoveType)
+ {
+ if ( rSh.GetDrawView()->IsTextEdit() )
+ rSh.EndTextEdit();
+ if ( IsDrawMode() )
+ LeaveDrawCreate();
+ }
+ if ( NID_POSTIT != s_nMoveType && m_pPostItMgr )
+ {
+ sw::annotation::SwAnnotationWin* pActiveSidebarWin = m_pPostItMgr->GetActiveSidebarWin();
+ if (pActiveSidebarWin)
+ pActiveSidebarWin->SwitchToFieldPos();
+ }
+ if (NID_RECENCY != s_nMoveType && NID_PGE != s_nMoveType && NID_SRCH_REP != s_nMoveType)
+ rSh.addCurrentPosition();
+ switch( s_nMoveType )
+ {
+ case NID_PGE:
+ {
+ tools::Long nYPos;
+ SwVisiblePageNumbers aVisiblePageNumbers;
+ rSh.GetFirstLastVisPageNumbers(aVisiblePageNumbers);
+ if ((bNext && aVisiblePageNumbers.nLastPhy + 1 > rSh.GetPageCnt()) ||
+ (!bNext && aVisiblePageNumbers.nFirstPhy == 1))
+ {
+ nYPos = rSh.GetPagePos(bNext ? 1 : rSh.GetPageCnt()).Y();
+ SvxSearchDialogWrapper::SetSearchLabel(bNext ? SearchLabel::EndWrapped :
+ SearchLabel::StartWrapped);
+ }
+ else
+ {
+ auto nPage = bNext ? aVisiblePageNumbers.nLastPhy + 1 :
+ aVisiblePageNumbers.nFirstPhy - 1;
+ nYPos = rSh.GetPagePos(nPage).Y();
+ SvxSearchDialogWrapper::SetSearchLabel(SearchLabel::Empty);
+ }
+ const Point aPt(GetVisArea().Left(), nYPos);
+ Point aAlPt(AlignToPixel(aPt));
+ // If there is a difference, has been truncated --> then add one pixel,
+ // so that no residue of the previous page is visible.
+ if(aPt.Y() != aAlPt.Y())
+ aAlPt.AdjustY(3 * GetEditWin().PixelToLogic(Size(0, 1)).Height());
+ SetVisArea(aAlPt);
+ }
+ break;
+ case NID_TBL :
+ rSh.EnterStdMode();
+ if(bNext)
+ rSh.MoveTable(GotoNextTable, fnTableStart);
+ else
+ rSh.MoveTable(GotoPrevTable, fnTableStart);
+ break;
+ case NID_FRM :
+ case NID_GRF:
+ case NID_OLE:
+ {
+ GotoObjFlags eType = GotoObjFlags::FlyFrame;
+ if(s_nMoveType == NID_GRF)
+ eType = GotoObjFlags::FlyGrf;
+ else if(s_nMoveType == NID_OLE)
+ eType = GotoObjFlags::FlyOLE;
+ bool bSuccess = bNext ?
+ rSh.GotoNextFly(eType) :
+ rSh.GotoPrevFly(eType);
+ if(bSuccess)
+ {
+ rSh.HideCursor();
+ rSh.EnterSelFrameMode();
+ }
+ }
+ break;
+ case NID_CTRL:
+ if (!rSh.GetView().IsDesignMode())
+ rSh.GetView().GetFormShell()->SetDesignMode(true);
+ [[fallthrough]];
+ case NID_DRW:
+ {
+ bool bSuccess = rSh.GotoObj(bNext,
+ s_nMoveType == NID_DRW ?
+ GotoObjFlags::DrawSimple :
+ GotoObjFlags::DrawControl);
+ if(bSuccess)
+ {
+ rSh.HideCursor();
+ rSh.EnterSelFrameMode();
+ }
+ }
+ break;
+ case NID_REG :
+ rSh.EnterStdMode();
+ if(bNext)
+ rSh.MoveRegion(GotoNextRegion, fnRegionStart);
+ else
+ rSh.MoveRegion(GotoPrevRegion, fnRegionStart);
+
+ break;
+ case NID_BKM :
+ rSh.EnterStdMode();
+ GetViewFrame().GetDispatcher()->Execute(bNext ?
+ FN_NEXT_BOOKMARK :
+ FN_PREV_BOOKMARK);
+ break;
+ case NID_FIELD:
+ {
+ rSh.EnterStdMode();
+ rSh.StartAction();
+ SearchLabel eSearchLabel = SearchLabel::Empty;
+ if (!rSh.MoveFieldType(nullptr, bNext, SwFieldIds::Unknown))
+ {
+ // no field found in the move direction
+ // wrap and try again
+ SwShellCursor* pCursor = rSh.GetCursor_();
+ SwCursorSaveState aSaveState(*pCursor);
+ rSh.SttEndDoc(bNext);
+ // document might have a field at the start of the document
+ SwField* pField = rSh.GetCurField();
+ if ((bNext && pField && pField->GetTypeId() != SwFieldTypesEnum::Postit) ||
+ rSh.MoveFieldType(nullptr, bNext, SwFieldIds::Unknown))
+ {
+ eSearchLabel = bNext ? SearchLabel::EndWrapped : SearchLabel::StartWrapped;
+ }
+ else
+ {
+ // no visible fields found
+ pCursor->RestoreSavePos();
+ eSearchLabel = SearchLabel::NavElementNotFound;
+ }
+ }
+ SvxSearchDialogWrapper::SetSearchLabel(eSearchLabel);
+ rSh.EndAction();
+ }
+ break;
+ case NID_FIELD_BYTYPE:
+ {
+ // see: SwFieldMgr::GoNextPrev
+ SwField* pCurField = rSh.GetCurField(true);
+ if (!pCurField)
+ break;
+ rSh.EnterStdMode();
+ SwFieldType* pTyp = nullptr;
+ const SwFieldTypesEnum nTypeId = pCurField->GetTypeId();
+ if (SwFieldTypesEnum::SetInput == nTypeId || SwFieldTypesEnum::UserInput == nTypeId)
+ pTyp = rSh.GetFieldType(0, SwFieldIds::Input);
+ else
+ pTyp = pCurField->GetTyp();
+ if (pTyp)
+ {
+ if (pTyp->Which() == SwFieldIds::Database)
+ rSh.MoveFieldType(nullptr, bNext, SwFieldIds::Database);
+ else
+ rSh.MoveFieldType(pTyp, bNext);
+ }
+ }
+ break;
+ case NID_OUTL:
+ rSh.EnterStdMode();
+ bNext ? rSh.GotoNextOutline() : rSh.GotoPrevOutline();
+ break;
+ case NID_SEL :
+ rSh.GoNextPrevCursorSetSearchLabel(bNext);
+ break;
+ case NID_FTN:
+ {
+ bool bFrameTypeFootnote(rSh.GetFrameType(nullptr, false) & FrameTypeFlags::FOOTNOTE);
+
+ if (bFrameTypeFootnote)
+ {
+ rSh.LockView(true);
+ rSh.GotoFootnoteAnchor();
+ }
+
+ rSh.EnterStdMode();
+ bNext ?
+ rSh.GotoNextFootnoteAnchor() :
+ rSh.GotoPrevFootnoteAnchor();
+
+ if (bFrameTypeFootnote)
+ {
+ rSh.LockView(false);
+ rSh.GotoFootnoteText();
+ }
+ }
+ break;
+ case NID_MARK:
+ {
+ // unselect
+ rSh.MoveCursor();
+ rSh.EnterStdMode();
+
+ // collect and sort navigator reminder names
+ IDocumentMarkAccess* const pMarkAccess = rSh.getIDocumentMarkAccess();
+ std::vector< OUString > vNavMarkNames;
+ for(IDocumentMarkAccess::const_iterator_t ppMark = pMarkAccess->getAllMarksBegin();
+ ppMark != pMarkAccess->getAllMarksEnd();
+ ++ppMark)
+ {
+ if( IDocumentMarkAccess::GetType(**ppMark) == IDocumentMarkAccess::MarkType::NAVIGATOR_REMINDER )
+ vNavMarkNames.push_back((*ppMark)->GetName());
+ }
+ std::sort(vNavMarkNames.begin(), vNavMarkNames.end());
+
+ // move
+ if(!vNavMarkNames.empty())
+ {
+ SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::Empty );
+
+ if(bNext)
+ {
+ s_nActMark++;
+ if (s_nActMark >= MAX_MARKS || s_nActMark >= static_cast<sal_Int32>(vNavMarkNames.size()))
+ {
+ s_nActMark = 0;
+ SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::ReminderEndWrapped );
+ }
+ }
+ else
+ {
+ s_nActMark--;
+ if (s_nActMark < 0 || o3tl::make_unsigned(s_nActMark) >= vNavMarkNames.size())
+ {
+ s_nActMark = vNavMarkNames.size()-1;
+ SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::ReminderStartWrapped );
+ }
+ }
+ rSh.GotoMark(vNavMarkNames[s_nActMark]);
+ }
+ else
+ SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::NavElementNotFound );
+ }
+ break;
+
+ case NID_POSTIT:
+ {
+ if (m_pPostItMgr->HasNotes())
+ {
+ rSh.EnterStdMode();
+ m_pPostItMgr->AssureStdModeAtShell();
+ m_pPostItMgr->SetActiveSidebarWin(nullptr);
+ GetEditWin().GrabFocus();
+ SwShellCursor* pCursor = rSh.GetCursor_();
+ SwCursorSaveState aSaveState(*pCursor);
+ SwFieldType* pFieldType = rSh.GetFieldType(0, SwFieldIds::Postit);
+ bool bWrapped = false;
+ bool bFound = false;
+ rSh.StartAction();
+ while (!bFound)
+ {
+ if (!rSh.MoveFieldType(pFieldType, bNext))
+ {
+ if (bWrapped)
+ break;
+ bWrapped = true;
+ rSh.SttEndDoc(bNext);
+ continue;
+ }
+ do
+ {
+ auto pAnnotationWin = m_pPostItMgr->GetAnnotationWin(
+ rSh.GetPostItFieldAtCursor());
+ if (pAnnotationWin && pAnnotationWin->IsVisible())
+ bFound = true;
+ } while (!bFound && rSh.MoveFieldType(pFieldType, bNext));
+ }
+ if (!bFound)
+ {
+ pCursor->RestoreSavePos();
+ SvxSearchDialogWrapper::SetSearchLabel(SearchLabel::NavElementNotFound);
+ }
+ rSh.EndAction();
+ if (bFound)
+ {
+ GetViewFrame().GetDispatcher()->Execute(FN_POSTIT);
+ if (bWrapped)
+ SvxSearchDialogWrapper::SetSearchLabel(bNext ? SearchLabel::EndWrapped :
+ SearchLabel::StartWrapped);
+ else
+ SvxSearchDialogWrapper::SetSearchLabel(SearchLabel::Empty);
+ }
+ }
+ else
+ SvxSearchDialogWrapper::SetSearchLabel(SearchLabel::NavElementNotFound);
+ }
+ break;
+
+ case NID_SRCH_REP:
+ if(s_pSrchItem)
+ {
+ bool bBackward = s_pSrchItem->GetBackward();
+ if (rSh.HasSelection() && bNext != rSh.IsCursorPtAtEnd())
+ rSh.SwapPam();
+ s_pSrchItem->SetBackward(!bNext);
+ SfxRequest aReq(FN_REPEAT_SEARCH, SfxCallMode::SLOT, GetPool());
+ ExecSearch(aReq);
+ s_pSrchItem->SetBackward(bBackward);
+ }
+ break;
+ case NID_INDEX_ENTRY:
+ rSh.GotoNxtPrvTOXMark(bNext);
+ break;
+
+ case NID_TABLE_FORMULA:
+ rSh.GotoNxtPrvTableFormula( bNext );
+ break;
+
+ case NID_TABLE_FORMULA_ERROR:
+ rSh.GotoNxtPrvTableFormula( bNext, true );
+ break;
+
+ case NID_RECENCY :
+ rSh.EnterStdMode();
+ bNext ? rSh.GetNavigationMgr().goForward() : rSh.GetNavigationMgr().goBack();
+ break;
+ }
+ if (NID_POSTIT != s_nMoveType)
+ m_pEditWin->GrabFocus();
+ delete pbNext;
+}
+
+void SwView::CreateTab()
+{
+ m_pHRuler->SetActive(GetFrame() && IsActive());
+
+ m_pHRuler->Show();
+ InvalidateBorder();
+}
+
+void SwView::KillTab()
+{
+ m_pHRuler->Hide();
+ InvalidateBorder();
+}
+
+void SwView::ChangeTabMetric( FieldUnit eUnit )
+{
+ if(m_pHRuler->GetUnit() != eUnit )
+ {
+ m_pHRuler->SetUnit( eUnit );
+ m_pHRuler->Invalidate();
+ }
+}
+
+void SwView::ChangeVRulerMetric( FieldUnit eUnit )
+{
+ if(m_pVRuler->GetUnit() != eUnit)
+ {
+ m_pVRuler->SetUnit( eUnit );
+ m_pVRuler->Invalidate();
+ }
+}
+
+void SwView::GetVRulerMetric(FieldUnit& eToFill) const
+{
+ eToFill = m_pVRuler->GetUnit();
+}
+
+void SwView::GetHRulerMetric(FieldUnit& eToFill) const
+{
+ eToFill = m_pHRuler->GetUnit();
+}
+
+void SwView::CreateVRuler()
+{
+ m_pHRuler->SetBorderPos( m_pVRuler->GetSizePixel().Width()-1 );
+
+ m_pVRuler->SetActive(GetFrame() && IsActive());
+ m_pVRuler->Show();
+ InvalidateBorder();
+}
+
+void SwView::KillVRuler()
+{
+ m_pVRuler->Hide();
+ m_pHRuler->SetBorderPos();
+ InvalidateBorder();
+}
+
+IMPL_LINK( SwView, ExecRulerClick, Ruler *, pRuler, void )
+{
+ OUString sDefPage;
+ TypedWhichId<SfxStringItem> nDefDlg = SID_PARA_DLG;
+ switch( pRuler->GetClickType() )
+ {
+ case RulerType::DontKnow:
+ case RulerType::Outside:
+ sDefPage="labelTP_BORDER";
+ break;
+ case RulerType::Indent:
+ sDefPage="labelTP_PARA_STD";
+ break;
+ case RulerType::Margin1:
+ case RulerType::Margin2:
+ nDefDlg= FN_FORMAT_PAGE_DLG;
+ sDefPage = "page";
+ break;
+ default:
+ sDefPage = "labelTP_TABULATOR";
+
+ }
+
+ SfxStringItem aDefPage(nDefDlg, sDefPage);
+ GetViewFrame().GetDispatcher()->ExecuteList(nDefDlg,
+ SfxCallMode::SYNCHRON|SfxCallMode::RECORD,
+ { &aDefPage });
+}
+
+sal_uInt16 SwView::GetMoveType()
+{
+ return s_nMoveType;
+}
+
+void SwView::SetMoveType(sal_uInt16 nSet)
+{
+ s_nMoveType = nSet;
+}
+
+void SwView::SetActMark(sal_Int32 nSet)
+{
+ s_nActMark = nSet;
+}
+
+void SwView::ShowHScrollbar(bool bShow)
+{
+ assert(m_pHScrollbar && "Scrollbar invalid");
+ m_pHScrollbar->ExtendedShow(bShow);
+}
+
+bool SwView::IsHScrollbarVisible()const
+{
+ assert(m_pHScrollbar && "Scrollbar invalid");
+ return m_pHScrollbar->IsScrollbarVisible(false) || m_pHScrollbar->IsAuto();
+}
+
+void SwView::ShowVScrollbar(bool bShow)
+{
+ assert(m_pVScrollbar && "Scrollbar invalid");
+ m_pVScrollbar->ExtendedShow(bShow);
+}
+
+bool SwView::IsVScrollbarVisible()const
+{
+ assert(m_pVScrollbar && "Scrollbar invalid");
+ return m_pVScrollbar->IsScrollbarVisible(false);
+}
+
+void SwView::EnableHScrollbar(bool bEnable)
+{
+ if (m_bHScrollbarEnabled != bEnable)
+ {
+ m_bHScrollbarEnabled = bEnable;
+ InvalidateBorder();
+ }
+}
+
+void SwView::EnableVScrollbar(bool bEnable)
+{
+ if (m_bVScrollbarEnabled != bEnable)
+ {
+ m_bVScrollbarEnabled = bEnable;
+ InvalidateBorder();
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/viewport.cxx b/sw/source/uibase/uiview/viewport.cxx
new file mode 100644
index 0000000000..08d9b0c393
--- /dev/null
+++ b/sw/source/uibase/uiview/viewport.cxx
@@ -0,0 +1,1262 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <vcl/commandevent.hxx>
+#include <vcl/help.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/syswin.hxx>
+
+#include <svx/ruler.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <view.hxx>
+#include <wrtsh.hxx>
+#include <viewopt.hxx>
+#include <docsh.hxx>
+#include <cmdid.h>
+#include <edtwin.hxx>
+#include <scroll.hxx>
+
+#include <PostItMgr.hxx>
+
+#include <basegfx/utils/zoomtools.hxx>
+#include <comphelper/lok.hxx>
+#include <vcl/weld.hxx>
+#include <tools/svborder.hxx>
+#include <osl/diagnose.h>
+
+#include "viewfunc.hxx"
+
+#include <FrameControlsManager.hxx>
+
+// The SetVisArea of the DocShell must not be called from InnerResizePixel.
+// But our adjustments must take place.
+static bool bProtectDocShellVisArea = false;
+
+static sal_uInt16 nPgNum = 0;
+
+bool SwView::IsDocumentBorder()
+{
+ if (GetDocShell()->GetCreateMode() == SfxObjectCreateMode::EMBEDDED)
+ return true;
+
+ if (!m_pWrtShell)
+ return false;
+
+ return m_pWrtShell->GetViewOptions()->getBrowseMode() ||
+ SvxZoomType::PAGEWIDTH_NOBORDER == m_pWrtShell->GetViewOptions()->GetZoomType();
+}
+
+static tools::Long GetLeftMargin( SwView const &rView )
+{
+ SvxZoomType eType = rView.GetWrtShell().GetViewOptions()->GetZoomType();
+ tools::Long lRet = rView.GetWrtShell().GetAnyCurRect(CurRectType::PagePrt).Left();
+ return eType == SvxZoomType::PERCENT ? lRet + DOCUMENTBORDER :
+ eType == SvxZoomType::PAGEWIDTH || eType == SvxZoomType::PAGEWIDTH_NOBORDER ? 0 :
+ lRet + DOCUMENTBORDER + nLeftOfst;
+}
+
+static void lcl_GetPos(SwView const * pView,
+ Point& rPos,
+ const weld::Scrollbar& rScrollbar,
+ bool bHori,
+ bool bBorder)
+{
+ SwWrtShell &rSh = pView->GetWrtShell();
+ const Size aDocSz( rSh.GetDocSize() );
+
+ const tools::Long lBorder = bBorder ? DOCUMENTBORDER : DOCUMENTBORDER * 2;
+
+ const tools::Long lPos = rScrollbar.adjustment_get_value() + (bBorder ? DOCUMENTBORDER : 0);
+
+ tools::Long lDelta = lPos - (bHori ? rSh.VisArea().Pos().X() : rSh.VisArea().Pos().Y());
+
+ const tools::Long lSize = (bHori ? aDocSz.Width() : aDocSz.Height()) + lBorder;
+ // Should right or below are too much space,
+ // then they must be subtracted out of the VisArea!
+ tools::Long nTmp = pView->GetVisArea().Right()+lDelta;
+ if ( bHori && nTmp > lSize )
+ lDelta -= nTmp - lSize;
+ nTmp = pView->GetVisArea().Bottom()+lDelta;
+ if ( !bHori && nTmp > lSize )
+ lDelta -= nTmp - lSize;
+
+ bHori ? rPos.AdjustX(lDelta) : rPos.AdjustY(lDelta);
+ if ( bBorder && (bHori ? rPos.X() : rPos.Y()) < DOCUMENTBORDER )
+ bHori ? rPos.setX(DOCUMENTBORDER) : rPos.setY(DOCUMENTBORDER);
+}
+
+// Set zero ruler
+
+void SwView::InvalidateRulerPos()
+{
+ static sal_uInt16 aInval[] =
+ {
+ SID_ATTR_PARA_LRSPACE, SID_RULER_BORDERS, SID_RULER_PAGE_POS,
+ SID_RULER_LR_MIN_MAX, SID_ATTR_LONG_ULSPACE, SID_ATTR_LONG_LRSPACE,
+ SID_RULER_BORDER_DISTANCE,
+ SID_ATTR_PARA_LRSPACE_VERTICAL, SID_RULER_BORDERS_VERTICAL,
+ SID_RULER_TEXT_RIGHT_TO_LEFT,
+ SID_RULER_ROWS, SID_RULER_ROWS_VERTICAL, FN_STAT_PAGE,
+ 0
+ };
+
+ GetViewFrame().GetBindings().Invalidate(aInval);
+
+ assert(m_pHRuler && "Why is the ruler not there?");
+ m_pHRuler->ForceUpdate();
+ m_pVRuler->ForceUpdate();
+}
+
+// Limits the scrolling so far that only a quarter of the
+// screen can be scrolled up before the end of the document.
+
+tools::Long SwView::SetHScrollMax( tools::Long lMax )
+{
+ const tools::Long lBorder = IsDocumentBorder() ? DOCUMENTBORDER : DOCUMENTBORDER * 2;
+ const tools::Long lSize = GetDocSz().Width() + lBorder - m_aVisArea.GetWidth();
+
+ // At negative values the document is completely visible.
+ // In this case, no scrolling.
+ return std::clamp( lSize, tools::Long(0), lMax );
+}
+
+tools::Long SwView::SetVScrollMax( tools::Long lMax )
+{
+ const tools::Long lBorder = IsDocumentBorder() ? DOCUMENTBORDER : DOCUMENTBORDER * 2;
+ tools::Long lSize = GetDocSz().Height() + lBorder - m_aVisArea.GetHeight();
+ return std::clamp( lSize, tools::Long(0), lMax ); // see horizontal
+}
+
+Point SwView::AlignToPixel(const Point &rPt) const
+{
+ return GetEditWin().PixelToLogic( GetEditWin().LogicToPixel( rPt ) );
+}
+
+// Document size has changed.
+
+void SwView::DocSzChgd(const Size &rSz)
+{
+ m_aDocSz = rSz;
+
+ if( !m_pWrtShell || m_aVisArea.IsEmpty() ) // no shell -> no change
+ {
+ bDocSzUpdated = false;
+ return;
+ }
+
+ //If text has been deleted, it may be that the VisArea points behind the visible range.
+ tools::Rectangle aNewVisArea( m_aVisArea );
+ bool bModified = false;
+ SwTwips lGreenOffset = IsDocumentBorder() ? DOCUMENTBORDER : DOCUMENTBORDER * 2;
+ SwTwips lTmp = m_aDocSz.Width() + lGreenOffset;
+
+ if ( aNewVisArea.Right() >= lTmp )
+ {
+ lTmp = aNewVisArea.Right() - lTmp;
+ aNewVisArea.AdjustRight( -lTmp );
+ aNewVisArea.AdjustLeft( -lTmp );
+ bModified = true;
+ }
+
+ lTmp = m_aDocSz.Height() + lGreenOffset;
+ if ( aNewVisArea.Bottom() >= lTmp )
+ {
+ lTmp = aNewVisArea.Bottom() - lTmp;
+ aNewVisArea.AdjustBottom( -lTmp );
+ aNewVisArea.AdjustTop( -lTmp );
+ bModified = true;
+ }
+
+ if ( bModified )
+ SetVisArea( aNewVisArea, false );
+
+ if ( UpdateScrollbars() && !m_bInOuterResizePixel && !m_bInInnerResizePixel &&
+ !GetViewFrame().GetFrame().IsInPlace())
+ OuterResizePixel( Point(),
+ GetViewFrame().GetWindow().GetOutputSizePixel() );
+}
+
+// Set VisArea newly
+
+void SwView::SetVisArea( const tools::Rectangle &rRect, bool bUpdateScrollbar )
+{
+ Size aOldSz( m_aVisArea.GetSize() );
+ if (comphelper::LibreOfficeKit::isActive() && m_pWrtShell)
+ // If m_pWrtShell's visible area is the whole document, do the same here.
+ aOldSz = m_pWrtShell->VisArea().SSize();
+
+ if( rRect == m_aVisArea )
+ return;
+
+ const SwTwips lMin = IsDocumentBorder() ? DOCUMENTBORDER : 0;
+
+ // No negative position, no negative size
+ tools::Rectangle aLR = rRect;
+ if( aLR.Top() < lMin )
+ {
+ aLR.AdjustBottom(lMin - aLR.Top() );
+ aLR.SetTop( lMin );
+ }
+ if( aLR.Left() < lMin )
+ {
+ aLR.AdjustRight(lMin - aLR.Left() );
+ aLR.SetLeft( lMin );
+ }
+ if( aLR.Right() < 0 )
+ aLR.SetRight( 0 );
+ if( aLR.Bottom() < 0 )
+ aLR.SetBottom( 0 );
+
+ if( aLR == m_aVisArea )
+ return;
+
+ const Size aSize( aLR.GetSize() );
+ if( aSize.IsEmpty() )
+ return;
+
+ // Before the data can be changed, call an update if necessary. This
+ // ensures that adjacent Paints in document coordinates are converted
+ // correctly.
+ // As a precaution, we do this only when an action is running in the
+ // shell, because then it is not really drawn but the rectangles will
+ // be only marked (in document coordinates).
+ if ( m_pWrtShell && m_pWrtShell->ActionPend() )
+ m_pWrtShell->GetWin()->PaintImmediately();
+
+ m_aVisArea = aLR;
+
+ const bool bOuterResize = bUpdateScrollbar && UpdateScrollbars();
+
+ if ( m_pWrtShell )
+ {
+ m_pWrtShell->VisPortChgd( SwRect(m_aVisArea) );
+ if ( aOldSz != m_pWrtShell->VisArea().SSize() &&
+ ( std::abs(aOldSz.Width() - m_pWrtShell->VisArea().Width()) > 2 ||
+ std::abs(aOldSz.Height() - m_pWrtShell->VisArea().Height()) > 2 ) )
+ m_pWrtShell->InvalidateLayout( false );
+ }
+
+ if ( !bProtectDocShellVisArea )
+ {
+ // If the size of VisArea is unchanged, we extend the size of the VisArea
+ // InternalObject on. By that the transport of errors shall be avoided.
+ tools::Rectangle aVis( m_aVisArea );
+ if ( aVis.GetSize() == aOldSz )
+ aVis.SetSize( GetDocShell()->SfxObjectShell::GetVisArea(ASPECT_CONTENT).GetSize() );
+ // TODO/LATER: why casting?!
+ //GetDocShell()->SfxInPlaceObject::GetVisArea().GetSize() );
+
+ // With embedded always with modify...
+ // TODO/LATER: why casting?!
+ GetDocShell()->SfxObjectShell::SetVisArea( aVis );
+ /*
+ if ( GetDocShell()->GetCreateMode() == SfxObjectCreateMode::EMBEDDED )
+ GetDocShell()->SfxInPlaceObject::SetVisArea( aVis );
+ else
+ GetDocShell()->SvEmbeddedObject::SetVisArea( aVis );*/
+ }
+
+ SfxViewShell::VisAreaChanged();
+
+ InvalidateRulerPos();
+
+ if ( bOuterResize && !m_bInOuterResizePixel && !m_bInInnerResizePixel)
+ OuterResizePixel( Point(),
+ GetViewFrame().GetWindow().GetOutputSizePixel() );
+}
+
+// Set Pos VisArea
+
+void SwView::SetVisArea( const Point &rPt, bool bUpdateScrollbar )
+{
+ // Align once, so brushes will be inserted correctly.
+ // This goes wrong in the BrowseView, because the entire document may
+ // not be visible. Since the content in frames is fitting exactly,
+ // align is not possible (better idea?!?!)
+ // (fix: Bild.de, 200%) It does not work completely without alignment
+ // Let's see how far we get with half BrushSize.
+ Point aPt = GetEditWin().LogicToPixel( rPt );
+#if HAVE_FEATURE_DESKTOP
+ const tools::Long nTmp = 8;
+ aPt.AdjustX( -(aPt.X() % nTmp) );
+ aPt.AdjustY( -(aPt.Y() % nTmp) );
+#endif
+ aPt = GetEditWin().PixelToLogic( aPt );
+
+ if ( aPt == m_aVisArea.TopLeft() )
+ return;
+
+ if (GetWrtShell().GetViewOptions()->IsShowOutlineContentVisibilityButton())
+ GetEditWin().GetFrameControlsManager().HideControls(FrameControlType::Outline);
+
+ const tools::Long lXDiff = m_aVisArea.Left() - aPt.X();
+ const tools::Long lYDiff = m_aVisArea.Top() - aPt.Y();
+ SetVisArea( tools::Rectangle( aPt,
+ Point( m_aVisArea.Right() - lXDiff, m_aVisArea.Bottom() - lYDiff ) ),
+ bUpdateScrollbar);
+}
+
+void SwView::CheckVisArea()
+{
+ if (m_pHScrollbar)
+ m_pHScrollbar->SetAuto( m_pWrtShell->GetViewOptions()->getBrowseMode() &&
+ !GetViewFrame().GetFrame().IsInPlace() );
+ if ( IsDocumentBorder() )
+ {
+ if ( m_aVisArea.Left() != DOCUMENTBORDER ||
+ m_aVisArea.Top() != DOCUMENTBORDER )
+ {
+ tools::Rectangle aNewVisArea( m_aVisArea );
+ aNewVisArea.Move( DOCUMENTBORDER - m_aVisArea.Left(),
+ DOCUMENTBORDER - m_aVisArea.Top() );
+ SetVisArea( aNewVisArea );
+ }
+ }
+}
+
+/// Calculate the visible range.
+
+// OUT Point *pPt: new position of the visible area
+
+// IN Rectangle &rRect: Rectangle, which should be located
+// within the new visible area.
+// sal_uInt16 nRange optional accurate indication of the
+// range by which to scroll if necessary.
+
+void SwView::CalcPt( Point *pPt, const tools::Rectangle &rRect,
+ sal_uInt16 nRangeX, sal_uInt16 nRangeY)
+{
+
+ const SwTwips lMin = IsDocumentBorder() ? DOCUMENTBORDER : 0;
+
+ tools::Long nYScroll = GetYScroll();
+ tools::Long nDesHeight = rRect.GetHeight();
+ tools::Long nCurHeight = m_aVisArea.GetHeight();
+ nYScroll = std::min(nYScroll, nCurHeight - nDesHeight); // If it is scarce, then scroll not too much.
+ if(nDesHeight > nCurHeight) // the height is not sufficient, then nYScroll is no longer of interest
+ {
+ pPt->setY( rRect.Top() );
+ pPt->setY( std::max( lMin, SwTwips(pPt->Y()) ) );
+ }
+ else if ( rRect.Top() < m_aVisArea.Top() ) // Upward shift
+ {
+ pPt->setY( rRect.Top() - (nRangeY != USHRT_MAX ? nRangeY : nYScroll) );
+ pPt->setY( std::max( lMin, SwTwips(pPt->Y()) ) );
+ }
+ else if( rRect.Bottom() > m_aVisArea.Bottom() ) // Downward shift
+ {
+ pPt->setY( rRect.Bottom() -
+ (m_aVisArea.GetHeight()) + ( nRangeY != USHRT_MAX ?
+ nRangeY : nYScroll ) );
+ pPt->setY( SetVScrollMax( pPt->Y() ) );
+ }
+ tools::Long nXScroll = GetXScroll();
+ if ( rRect.Right() > m_aVisArea.Right() ) // Shift right
+ {
+ pPt->setX( rRect.Right() -
+ (m_aVisArea.GetWidth()) +
+ (nRangeX != USHRT_MAX ? nRangeX : nXScroll) );
+ pPt->setX( SetHScrollMax( pPt->X() ) );
+ }
+ else if ( rRect.Left() < m_aVisArea.Left() ) // Shift left
+ {
+ pPt->setX( rRect.Left() - (nRangeX != USHRT_MAX ? nRangeX : nXScroll) );
+ pPt->setX( std::max( ::GetLeftMargin( *this ) + nLeftOfst, pPt->X() ) );
+ pPt->setX( std::min( rRect.Left() - nScrollX, pPt->X() ) );
+ pPt->setX( std::max( tools::Long(0), pPt->X() ) );
+ }
+}
+
+// Scrolling
+
+bool SwView::IsScroll( const tools::Rectangle &rRect ) const
+{
+ return m_bCenterCursor || m_bTopCursor || !m_aVisArea.Contains(rRect);
+}
+
+void SwView::Scroll( const tools::Rectangle &rRect, sal_uInt16 nRangeX, sal_uInt16 nRangeY )
+{
+ if ( m_aVisArea.IsEmpty() )
+ return;
+
+ tools::Rectangle aOldVisArea( m_aVisArea );
+ tools::Long nDiffY = 0;
+
+ weld::Window* pCareDialog = SwViewShell::GetCareDialog(GetWrtShell());
+ if (pCareDialog)
+ {
+ int x, y, width, height;
+ tools::Rectangle aDlgRect;
+ if (pCareDialog->get_extents_relative_to(*GetEditWin().GetFrameWeld(), x, y, width, height))
+ {
+ AbsoluteScreenPixelPoint aTopLeftAbs(GetEditWin().GetSystemWindow()->OutputToAbsoluteScreenPixel(Point(x, y)));
+ Point aTopLeft = GetEditWin().AbsoluteScreenToOutputPixel(aTopLeftAbs);
+ aDlgRect = GetEditWin().PixelToLogic(tools::Rectangle(aTopLeft, Size(width, height)));
+ }
+
+ // Only if the dialogue is not the VisArea right or left:
+ if ( aDlgRect.Left() < m_aVisArea.Right() &&
+ aDlgRect.Right() > m_aVisArea.Left() )
+ {
+ // If we are not supposed to be centered, lying in the VisArea
+ // and are not covered by the dialogue ...
+ if ( !m_bCenterCursor && aOldVisArea.Contains( rRect )
+ && ( rRect.Left() > aDlgRect.Right()
+ || rRect.Right() < aDlgRect.Left()
+ || rRect.Top() > aDlgRect.Bottom()
+ || rRect.Bottom() < aDlgRect.Top() ) )
+ return;
+
+ // Is above or below the dialogue more space?
+ tools::Long nTopDiff = aDlgRect.Top() - m_aVisArea.Top();
+ tools::Long nBottomDiff = m_aVisArea.Bottom() - aDlgRect.Bottom();
+ if ( nTopDiff < nBottomDiff )
+ {
+ if ( nBottomDiff > 0 ) // Is there room below at all?
+ { // then we move the upper edge and we remember this
+ nDiffY = aDlgRect.Bottom() - m_aVisArea.Top();
+ m_aVisArea.AdjustTop(nDiffY );
+ }
+ }
+ else
+ {
+ if ( nTopDiff > 0 ) // Is there room below at all?
+ m_aVisArea.SetBottom( aDlgRect.Top() ); // Modify the lower edge
+ }
+ }
+ }
+
+ //s.o. !IsScroll()
+ if( !(m_bCenterCursor || m_bTopCursor) && m_aVisArea.Contains( rRect ) )
+ {
+ m_aVisArea = aOldVisArea;
+ return;
+ }
+ // If the rectangle is larger than the visible area -->
+ // upper left corner
+ Size aSize( rRect.GetSize() );
+ const Size aVisSize( m_aVisArea.GetSize() );
+ if( !m_aVisArea.IsEmpty() && (
+ aSize.Width() + GetXScroll() > aVisSize.Width() ||
+ aSize.Height()+ GetYScroll() > aVisSize.Height() ))
+ {
+ Point aPt( m_aVisArea.TopLeft() );
+ aSize.setWidth( std::min( aSize.Width(), aVisSize.Width() ) );
+ aSize.setHeight( std::min( aSize.Height(),aVisSize.Height()) );
+
+ CalcPt( &aPt, tools::Rectangle( rRect.TopLeft(), aSize ),
+ static_cast< sal_uInt16 >((aVisSize.Width() - aSize.Width()) / 2),
+ static_cast< sal_uInt16 >((aVisSize.Height()- aSize.Height())/ 2) );
+
+ if( m_bTopCursor )
+ {
+ const tools::Long nBorder = IsDocumentBorder() ? DOCUMENTBORDER : 0;
+ aPt.setY( std::min( std::max( nBorder, rRect.Top() ),
+ m_aDocSz.Height() + nBorder -
+ m_aVisArea.GetHeight() ) );
+ }
+ aPt.AdjustY( -nDiffY );
+ m_aVisArea = aOldVisArea;
+ SetVisArea( aPt );
+ return;
+ }
+ if( !m_bCenterCursor )
+ {
+ Point aPt( m_aVisArea.TopLeft() );
+ CalcPt( &aPt, rRect, nRangeX, nRangeY );
+
+ if( m_bTopCursor )
+ {
+ const tools::Long nBorder = IsDocumentBorder() ? DOCUMENTBORDER : 0;
+ aPt.setY( std::min( std::max( nBorder, rRect.Top() ),
+ m_aDocSz.Height() + nBorder -
+ m_aVisArea.GetHeight() ) );
+ }
+
+ aPt.AdjustY( -nDiffY );
+ m_aVisArea = aOldVisArea;
+ SetVisArea( aPt );
+ return;
+ }
+
+ //Center cursor
+ Point aPnt( m_aVisArea.TopLeft() );
+ // ... in Y-direction in any case
+ aPnt.AdjustY(( rRect.Top() + rRect.Bottom()
+ - m_aVisArea.Top() - m_aVisArea.Bottom() ) / 2 - nDiffY );
+ // ... in X-direction, only if the rectangle protrudes over the right or left of the VisArea.
+ if ( rRect.Right() > m_aVisArea.Right() || rRect.Left() < m_aVisArea.Left() )
+ {
+ aPnt.AdjustX(( rRect.Left() + rRect.Right()
+ - m_aVisArea.Left() - m_aVisArea.Right() ) / 2 );
+ aPnt.setX( SetHScrollMax( aPnt.X() ) );
+ const SwTwips lMin = IsDocumentBorder() ? DOCUMENTBORDER : 0;
+ aPnt.setX( std::max( (GetLeftMargin( *this ) - lMin) + nLeftOfst, aPnt.X() ) );
+ }
+ m_aVisArea = aOldVisArea;
+ if (pCareDialog)
+ {
+ // If we want to avoid only a dialogue, we do
+ // not want to go beyond the end of the document.
+ aPnt.setY( SetVScrollMax( aPnt.Y() ) );
+ }
+ SetVisArea( aPnt );
+}
+
+/// Scroll page by page
+// Returns the value by which to be scrolled with PageUp / Down
+
+bool SwView::GetPageScrollUpOffset( SwTwips &rOff ) const
+{
+ // in the LOK case, force the value set by the API
+ if (comphelper::LibreOfficeKit::isActive() && m_nLOKPageUpDownOffset > 0)
+ {
+ rOff = -m_nLOKPageUpDownOffset;
+ return true;
+ }
+
+ if ( !m_aVisArea.Top() || !m_aVisArea.GetHeight() )
+ return false;
+ tools::Long nYScrl = GetYScroll() / 2;
+ rOff = -(m_aVisArea.GetHeight() - nYScrl);
+ // Do not scroll before the beginning of the document.
+ if( m_aVisArea.Top() - rOff < 0 )
+ rOff = rOff - m_aVisArea.Top();
+ else if( GetWrtShell().GetCharRect().Top() < (m_aVisArea.Top() + nYScrl))
+ rOff += nYScrl;
+
+ return true;
+}
+
+bool SwView::GetPageScrollDownOffset( SwTwips &rOff ) const
+{
+ // in the LOK case, force the value set by the API
+ if (comphelper::LibreOfficeKit::isActive() && m_nLOKPageUpDownOffset > 0)
+ {
+ rOff = m_nLOKPageUpDownOffset;
+ return true;
+ }
+
+ if ( !m_aVisArea.GetHeight() ||
+ (m_aVisArea.GetHeight() > m_aDocSz.Height()) )
+ return false;
+ tools::Long nYScrl = GetYScroll() / 2;
+ rOff = m_aVisArea.GetHeight() - nYScrl;
+ // Do not scroll past the end of the document.
+ if ( m_aVisArea.Top() + rOff > m_aDocSz.Height() )
+ rOff = m_aDocSz.Height() - m_aVisArea.Bottom();
+ else if( GetWrtShell().GetCharRect().Bottom() >
+ ( m_aVisArea.Bottom() - nYScrl ))
+ rOff -= nYScrl;
+
+ return rOff > 0;
+}
+
+// Scroll page by page
+bool SwView::PageUp()
+{
+ if (!m_aVisArea.GetHeight())
+ return false;
+
+ Point aPos(m_aVisArea.TopLeft());
+ aPos.AdjustY( -(m_aVisArea.GetHeight() - (GetYScroll() / 2)) );
+ aPos.setY( std::max(tools::Long(0), aPos.Y()) );
+ SetVisArea( aPos );
+ return true;
+}
+
+bool SwView::PageDown()
+{
+ if ( !m_aVisArea.GetHeight() )
+ return false;
+ Point aPos( m_aVisArea.TopLeft() );
+ aPos.AdjustY(m_aVisArea.GetHeight() - (GetYScroll() / 2) );
+ aPos.setY( SetVScrollMax( aPos.Y() ) );
+ SetVisArea( aPos );
+ return true;
+}
+
+void SwView::PhyPageUp()
+{
+ // Check for the currently visible page, do not format
+ sal_uInt16 nActPage = m_pWrtShell->GetNextPrevPageNum( false );
+
+ if( USHRT_MAX != nActPage )
+ {
+ const Point aPt( m_aVisArea.Left(),
+ m_pWrtShell->GetPagePos( nActPage ).Y() );
+ Point aAlPt( AlignToPixel( aPt ) );
+ // If there is a difference, has been truncated --> then add one pixel,
+ // so that no residue of the previous page is visible.
+ if( aPt.Y() != aAlPt.Y() )
+ aAlPt.AdjustY(3 * GetEditWin().PixelToLogic( Size( 0, 1 ) ).Height() );
+ SetVisArea( aAlPt );
+ }
+}
+
+void SwView::PhyPageDown()
+{
+ // Check for the currently visible page, do not format
+ sal_uInt16 nActPage = m_pWrtShell->GetNextPrevPageNum();
+ // If the last page of the document is visible, do nothing.
+ if( USHRT_MAX != nActPage )
+ {
+ const Point aPt( m_aVisArea.Left(),
+ m_pWrtShell->GetPagePos( nActPage ).Y() );
+ Point aAlPt( AlignToPixel( aPt ) );
+ // If there is a difference, has been truncated --> then add one pixel,
+ // so that no residue of the previous page is visible.
+ if( aPt.Y() != aAlPt.Y() )
+ aAlPt.AdjustY(3 * GetEditWin().PixelToLogic( Size( 0, 1 ) ).Height() );
+ SetVisArea( aAlPt );
+ }
+}
+
+bool SwView::PageUpCursor( bool bSelect )
+{
+ if ( !bSelect )
+ {
+ const FrameTypeFlags eType = m_pWrtShell->GetFrameType(nullptr,true);
+ if ( eType & FrameTypeFlags::FOOTNOTE )
+ {
+ m_pWrtShell->MoveCursor();
+ m_pWrtShell->GotoFootnoteAnchor();
+ m_pWrtShell->Right(SwCursorSkipMode::Chars, false, 1, false );
+ return true;
+ }
+ }
+
+ SwTwips lOff = 0;
+ if ( GetPageScrollUpOffset( lOff ) &&
+ (m_pWrtShell->IsCursorReadonly() ||
+ !m_pWrtShell->PageCursor( lOff, bSelect )) &&
+ PageUp() )
+ {
+ m_pWrtShell->ResetCursorStack();
+ return true;
+ }
+ return false;
+}
+
+bool SwView::PageDownCursor(bool bSelect)
+{
+ SwTwips lOff = 0;
+ if ( GetPageScrollDownOffset( lOff ) &&
+ (m_pWrtShell->IsCursorReadonly() ||
+ !m_pWrtShell->PageCursor( lOff, bSelect )) &&
+ PageDown() )
+ {
+ m_pWrtShell->ResetCursorStack();
+ return true;
+ }
+ return false;
+}
+
+static void HideQuickHelp(vcl::Window* pParent) { Help::ShowQuickHelp(pParent, {}, {}); }
+
+// Handler of the scrollbars
+IMPL_LINK(SwView, VertScrollHdl, weld::Scrollbar&, rScrollbar, void)
+{
+ if ( GetWrtShell().ActionPend() )
+ return;
+
+ if (rScrollbar.get_scroll_type() == ScrollType::Drag)
+ m_pWrtShell->EnableSmooth( false );
+
+ bool bHidePending = nPgNum != 0;
+ nPgNum = 0; // avoid flicker from hiding then showing help window again
+ EndScrollHdl(rScrollbar, false);
+
+ if (!m_pWrtShell->GetViewOptions()->getBrowseMode() &&
+ rScrollbar.get_scroll_type() == ScrollType::Drag)
+ {
+ if ( !m_bWheelScrollInProgress && Help::IsQuickHelpEnabled() &&
+ m_pWrtShell->GetViewOptions()->IsShowScrollBarTips())
+ {
+
+ Point aPos( m_aVisArea.TopLeft() );
+ lcl_GetPos(this, aPos, rScrollbar, false, IsDocumentBorder());
+
+ sal_uInt16 nPhNum = 1;
+ sal_uInt16 nVirtNum = 1;
+
+ OUString sDisplay;
+ if(m_pWrtShell->GetPageNumber( aPos.Y(), false, nPhNum, nVirtNum, sDisplay ))
+ {
+ //QuickHelp:
+ if( m_pWrtShell->GetPageCnt() > 1 )
+ {
+ tools::Rectangle aRect;
+ aRect.SetLeft( m_pVScrollbar->GetParent()->OutputToScreenPixel(
+ m_pVScrollbar->GetPosPixel() ).X() -8 );
+ aRect.SetTop( m_pVScrollbar->OutputToScreenPixel(
+ m_pVScrollbar->GetPointerPosPixel() ).Y() );
+ aRect.SetRight( aRect.Left() );
+ aRect.SetBottom( aRect.Top() );
+
+ OUString sPageStr( GetPageStr( nPhNum, nVirtNum, sDisplay ));
+ SwContentAtPos aCnt(IsAttrAtPos::Outline | IsAttrAtPos::AllowContaining);
+ bool bSuccess = m_pWrtShell->GetContentAtPos(aPos, aCnt);
+ if (bSuccess && !aCnt.sStr.isEmpty())
+ {
+ sal_Int32 nChunkLen = std::min<sal_Int32>(aCnt.sStr.getLength(), 80);
+ std::u16string_view sChunk = aCnt.sStr.subView(0, nChunkLen);
+ sPageStr = sPageStr + " - " + sChunk;
+ sPageStr = sPageStr.replace('\t', ' ').replace(0x0a, ' ');
+ }
+
+ Help::ShowQuickHelp(m_pVScrollbar, aRect, sPageStr,
+ QuickHelpFlags::Right|QuickHelpFlags::VCenter);
+ bHidePending = false;
+ nPgNum = nPhNum;
+ }
+ }
+ }
+ }
+
+ if (bHidePending)
+ HideQuickHelp(m_pVScrollbar);
+
+ if (rScrollbar.get_scroll_type() == ScrollType::Drag)
+ m_pWrtShell->EnableSmooth( true );
+}
+
+// Handler of the scrollbars
+void SwView::EndScrollHdl(weld::Scrollbar& rScrollbar, bool bHorizontal)
+{
+ if ( GetWrtShell().ActionPend() )
+ return;
+
+ if(nPgNum)
+ {
+ nPgNum = 0;
+ HideQuickHelp(bHorizontal ? m_pHScrollbar : m_pVScrollbar);
+ }
+ Point aPos( m_aVisArea.TopLeft() );
+ bool bBorder = IsDocumentBorder();
+ lcl_GetPos(this, aPos, rScrollbar, bHorizontal, bBorder);
+ if ( bBorder && aPos == m_aVisArea.TopLeft() )
+ UpdateScrollbars();
+ else
+ SetVisArea( aPos, false );
+
+ GetViewFrame().GetBindings().Update(FN_STAT_PAGE);
+}
+
+IMPL_LINK(SwView, HoriScrollHdl, weld::Scrollbar&, rScrollBar, void)
+{
+ EndScrollHdl(rScrollBar, true);
+}
+
+// Calculates the size of the m_aVisArea in dependency of the size of
+// EditWin on the screen.
+
+void SwView::CalcVisArea( const Size &rOutPixel )
+{
+ Point aTopLeft;
+ tools::Rectangle aRect( aTopLeft, rOutPixel );
+ aRect = GetEditWin().PixelToLogic(aRect);
+
+ // The shifts to the right and/or below can now be incorrect
+ // (e.g. change zoom level, change view size).
+ const tools::Long lBorder = IsDocumentBorder() ? DOCUMENTBORDER : DOCUMENTBORDER*2;
+ if ( aRect.Left() )
+ {
+ const tools::Long lWidth = GetWrtShell().GetDocSize().Width() + lBorder;
+ if ( aRect.Right() > lWidth )
+ {
+ tools::Long lDelta = aRect.Right() - lWidth;
+ aRect.AdjustLeft( -lDelta );
+ aRect.AdjustRight( -lDelta );
+ }
+ }
+ if ( aRect.Top() )
+ {
+ const tools::Long lHeight = GetWrtShell().GetDocSize().Height() + lBorder;
+ if ( aRect.Bottom() > lHeight )
+ {
+ tools::Long lDelta = aRect.Bottom() - lHeight;
+ aRect.AdjustTop( -lDelta );
+ aRect.AdjustBottom( -lDelta );
+ }
+ }
+ SetVisArea( aRect );
+ GetViewFrame().GetBindings().Invalidate( SID_ATTR_ZOOM );
+ GetViewFrame().GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER ); // for snapping points
+}
+
+// Rearrange control elements
+
+void SwView::CalcAndSetBorderPixel( SvBorder &rToFill )
+{
+ bool bRightVRuler = m_pWrtShell->GetViewOptions()->IsVRulerRight();
+ if ( m_pVRuler->IsVisible() )
+ {
+ tools::Long nWidth = m_pVRuler->GetSizePixel().Width();
+ if(bRightVRuler)
+ rToFill.Right() = nWidth;
+ else
+ rToFill.Left() = nWidth;
+ }
+
+ OSL_ENSURE(m_pHRuler, "Why is the ruler not present?");
+ if ( m_pHRuler->IsVisible() )
+ rToFill.Top() = m_pHRuler->GetSizePixel().Height();
+
+ const StyleSettings &rSet = GetEditWin().GetSettings().GetStyleSettings();
+ const tools::Long nTmp = rSet.GetScrollBarSize();
+ if( m_pVScrollbar->IsScrollbarVisible(true) )
+ {
+ if(bRightVRuler)
+ rToFill.Left() = nTmp;
+ else
+ rToFill.Right() = nTmp;
+ }
+ if ( m_pHScrollbar->IsScrollbarVisible(true) )
+ rToFill.Bottom() = nTmp;
+
+ SetBorderPixel( rToFill );
+}
+
+void ViewResizePixel( const vcl::RenderContext &rRef,
+ const Point &rOfst,
+ const Size &rSize,
+ const Size &rEditSz,
+ SwScrollbar& rVScrollbar,
+ SwScrollbar& rHScrollbar,
+ SvxRuler* pVRuler,
+ SvxRuler* pHRuler,
+ bool bVRulerRight )
+{
+// ViewResizePixel is also used by Preview!!!
+
+ const bool bHRuler = pHRuler && pHRuler->IsVisible();
+ const tools::Long nHLinSzHeight = bHRuler ?
+ pHRuler->GetSizePixel().Height() : 0;
+ const bool bVRuler = pVRuler && pVRuler->IsVisible();
+ const tools::Long nVLinSzWidth = bVRuler ?
+ pVRuler->GetSizePixel().Width() : 0;
+
+ const tools::Long nScrollBarSize = rRef.GetSettings().GetStyleSettings().GetScrollBarSize();
+ const tools::Long nHBSzHeight = rHScrollbar.IsScrollbarVisible(true) ? nScrollBarSize : 0;
+ const tools::Long nVBSzWidth = rVScrollbar.IsScrollbarVisible(true) ? nScrollBarSize : 0;
+
+ if(pVRuler)
+ {
+ WinBits nStyle = pVRuler->GetStyle()&~WB_RIGHT_ALIGNED;
+ Point aPos( rOfst.X(), rOfst.Y()+nHLinSzHeight );
+ if(bVRulerRight)
+ {
+ aPos.AdjustX(rSize.Width() - nVLinSzWidth );
+ nStyle |= WB_RIGHT_ALIGNED;
+ }
+ Size aSize( nVLinSzWidth, rEditSz.Height() );
+ if(!aSize.Width())
+ aSize.setWidth( pVRuler->GetSizePixel().Width() );
+ pVRuler->SetStyle(nStyle);
+ pVRuler->SetPosSizePixel( aPos, aSize );
+ if(!pVRuler->IsVisible())
+ pVRuler->Resize();
+ }
+ // Ruler needs a resize, otherwise it will not work in the invisible condition
+ if(pHRuler)
+ {
+ Size aSize( rSize.Width(), nHLinSzHeight );
+ if ( nVBSzWidth && !bVRulerRight)
+ aSize.AdjustWidth( -nVBSzWidth );
+ if(!aSize.Height())
+ aSize.setHeight( pHRuler->GetSizePixel().Height() );
+ pHRuler->SetPosSizePixel( rOfst, aSize );
+ // VCL calls no resize on invisible windows
+ // but that is not a good idea for the ruler
+ if(!pHRuler->IsVisible())
+ pHRuler->Resize();
+ }
+
+ // Arrange scrollbars and SizeBox
+ Point aScrollFillPos;
+ {
+ Point aPos( rOfst.X(),
+ rOfst.Y()+rSize.Height()-nHBSzHeight );
+ if(bVRulerRight)
+ {
+ aPos.AdjustX(nVBSzWidth );
+ }
+
+ Size aSize( rSize.Width(), nHBSzHeight );
+ if ( nVBSzWidth )
+ aSize.AdjustWidth( -nVBSzWidth );
+ rHScrollbar.SetPosSizePixel( aPos, aSize );
+ aScrollFillPos.setY( aPos.Y() );
+ }
+ {
+ Point aPos( rOfst.X()+rSize.Width()-nVBSzWidth,
+ rOfst.Y() );
+ Size aSize( nVBSzWidth, rSize.Height() );
+ if(bVRulerRight)
+ {
+ aPos.setX( rOfst.X() );
+ if(bHRuler)
+ {
+ aPos.AdjustY(nHLinSzHeight );
+ aSize.AdjustHeight( -nHLinSzHeight );
+ }
+ }
+
+ if ( nHBSzHeight )
+ aSize.AdjustHeight( -nHBSzHeight );
+ rVScrollbar.SetPosSizePixel( aPos, aSize );
+
+ aPos.AdjustY(aSize.Height() );
+
+ aScrollFillPos.setX( aPos.X() );
+ }
+}
+
+void SwView::ShowAtResize()
+{
+ m_bShowAtResize = false;
+ if ( m_pWrtShell->GetViewOptions()->IsViewHRuler() )
+ m_pHRuler->Show();
+}
+
+void SwView::InnerResizePixel( const Point &rOfst, const Size &rSize, bool )
+{
+ Size aObjSize = GetObjectShell()->GetVisArea().GetSize();
+ if ( !aObjSize.IsEmpty() )
+ {
+ SvBorder aBorder( GetBorderPixel() );
+ Size aSize( rSize );
+ aSize.AdjustWidth( -(aBorder.Left() + aBorder.Right()) );
+ aSize.AdjustHeight( -(aBorder.Top() + aBorder.Bottom()) );
+ Size aObjSizePixel = GetWindow()->LogicToPixel(aObjSize, MapMode(MapUnit::MapTwip));
+ SfxViewShell::SetZoomFactor( Fraction( aSize.Width(), aObjSizePixel.Width() ),
+ Fraction( aSize.Height(), aObjSizePixel.Height() ) );
+ }
+
+ m_bInInnerResizePixel = true;
+ const bool bHScrollVisible = m_pHScrollbar->IsScrollbarVisible(true);
+ const bool bVScrollVisible = m_pVScrollbar->IsScrollbarVisible(true);
+ bool bRepeat = false;
+ do
+ {
+ Size aSz( rSize );
+ SvBorder aBorder;
+ CalcAndSetBorderPixel( aBorder );
+ if ( GetViewFrame().GetFrame().IsInPlace() )
+ {
+ Size aViewSize( aSz );
+ Point aViewPos( rOfst );
+ aViewSize.AdjustHeight( -(aBorder.Top() + aBorder.Bottom()) );
+ aViewSize.AdjustWidth( -(aBorder.Left() + aBorder.Right()) );
+ aViewPos.AdjustX(aBorder.Left() );
+ aViewPos.AdjustY(aBorder.Top() );
+ GetEditWin().SetPosSizePixel( aViewPos, aViewSize );
+ }
+ else
+ {
+ aSz.AdjustHeight(aBorder.Top() + aBorder.Bottom() );
+ aSz.AdjustWidth(aBorder.Left() + aBorder.Right() );
+ }
+
+ Size aEditSz( GetEditWin().GetOutputSizePixel() );
+ ViewResizePixel( *GetEditWin().GetOutDev(), rOfst, aSz, aEditSz, *m_pVScrollbar,
+ *m_pHScrollbar, m_pVRuler, m_pHRuler,
+ m_pWrtShell->GetViewOptions()->IsVRulerRight());
+ if ( m_bShowAtResize )
+ ShowAtResize();
+
+ if( m_pHRuler->IsVisible() || m_pVRuler->IsVisible() )
+ {
+ const Fraction& rFrac = GetEditWin().GetMapMode().GetScaleX();
+ tools::Long nZoom = 100;
+ if (rFrac.IsValid())
+ nZoom = tools::Long(rFrac * 100);
+
+ const Fraction aFrac( nZoom, 100 );
+ m_pVRuler->SetZoom( aFrac );
+ m_pHRuler->SetZoom( aFrac );
+ InvalidateRulerPos(); // Invalidate content.
+ }
+ // Reset the cursor stack because the cursor positions for PageUp/Down
+ // no longer fit the currently visible area.
+ m_pWrtShell->ResetCursorStack();
+
+ // EditWin never set!
+
+ // Set VisArea, but do not call the SetVisArea of the Docshell there!
+ bProtectDocShellVisArea = true;
+ CalcVisArea( aEditSz );
+ // Visibility changes of the automatic horizontal scrollbar
+ // require to repeat the ViewResizePixel() call - but only once!
+ if(bRepeat)
+ bRepeat = false;
+ else if(bHScrollVisible != m_pHScrollbar->IsScrollbarVisible(true) ||
+ bVScrollVisible != m_pVScrollbar->IsScrollbarVisible(true))
+ bRepeat = true;
+ }while( bRepeat );
+ bProtectDocShellVisArea = false;
+ m_bInInnerResizePixel = false;
+}
+
+void SwView::OuterResizePixel( const Point &rOfst, const Size &rSize )
+{
+ // #i16909# return, if no size (caused by minimize window).
+ if ( m_bInOuterResizePixel || ( !rSize.Width() && !rSize.Height() ) )
+ return;
+ m_bInOuterResizePixel = true;
+
+ // Determine whether scroll bars may be displayed.
+ bool bShowH = true,
+ bShowV = true,
+ bAuto = true,
+ bHAuto = true;
+
+ const SwViewOption *pVOpt = m_pWrtShell->GetViewOptions();
+ if ( !pVOpt->IsReadonly() || pVOpt->IsStarOneSetting() )
+ {
+ bShowH = pVOpt->IsViewHScrollBar();
+ bShowV = pVOpt->IsViewVScrollBar();
+ }
+
+ if (!m_bHScrollbarEnabled)
+ {
+ bHAuto = bShowH = false;
+ }
+ if (!m_bVScrollbarEnabled)
+ {
+ bAuto = bShowV = false;
+ }
+
+ SwDocShell* pDocSh = GetDocShell();
+ bool bIsPreview = pDocSh->IsPreview();
+ if( bIsPreview )
+ {
+ bShowH = bShowV = bHAuto = bAuto = false;
+ }
+ if(m_pHScrollbar->IsScrollbarVisible(false) != bShowH && !bHAuto)
+ ShowHScrollbar(bShowH);
+ m_pHScrollbar->SetAuto( bHAuto );
+ if(m_pVScrollbar->IsScrollbarVisible(false) != bShowV && !bAuto)
+ ShowVScrollbar(bShowV);
+ m_pVScrollbar->SetAuto(bAuto);
+
+ CurrShell aCurr( m_pWrtShell.get() );
+ bool bRepeat = false;
+ tools::Long nCnt = 0;
+
+ bool bUnLockView = !m_pWrtShell->IsViewLocked();
+ m_pWrtShell->LockView( true );
+ m_pWrtShell->LockPaint(LockPaintReason::OuterResize);
+
+ do {
+ ++nCnt;
+ const bool bScroll1 = m_pVScrollbar->IsScrollbarVisible(true);
+ const bool bScroll2 = m_pHScrollbar->IsScrollbarVisible(true);
+ SvBorder aBorder;
+ CalcAndSetBorderPixel( aBorder );
+ const Size aEditSz( GetEditWin().GetOutputSizePixel() );
+ ViewResizePixel( *GetEditWin().GetOutDev(), rOfst, rSize, aEditSz, *m_pVScrollbar,
+ *m_pHScrollbar, m_pVRuler, m_pHRuler,
+ m_pWrtShell->GetViewOptions()->IsVRulerRight() );
+ if ( m_bShowAtResize )
+ ShowAtResize();
+
+ if( m_pHRuler->IsVisible() || m_pVRuler->IsVisible() )
+ InvalidateRulerPos(); // Invalidate content.
+
+ // Reset the cursor stack because the cursor positions for PageUp/Down
+ // no longer fit the currently visible area.
+ m_pWrtShell->ResetCursorStack();
+
+ OSL_ENSURE( !GetEditWin().IsVisible() ||
+ !aEditSz.IsEmpty() || !m_aVisArea.IsEmpty(), "Small world, isn't it?" );
+
+ // Never set EditWin!
+
+ // Of course the VisArea must also be set.
+ // Now is the right time to re-calculate the zoom if it is not a simple factor.
+ m_pWrtShell->StartAction();
+ CalcVisArea( aEditSz );
+
+ //Thus also in the outplace editing the page width will be adjusted immediately.
+ //TODO/LATER: is that still necessary?!
+ /*
+ if ( pDocSh->GetCreateMode() == SfxObjectCreateMode::EMBEDDED )
+ pDocSh->SetVisArea(
+ pDocSh->SfxInPlaceObject::GetVisArea() );*/
+ if ( m_pWrtShell->GetViewOptions()->GetZoomType() != SvxZoomType::PERCENT &&
+ !m_pWrtShell->GetViewOptions()->getBrowseMode() )
+ SetZoom_( aEditSz, m_pWrtShell->GetViewOptions()->GetZoomType(), 100, true );
+ m_pWrtShell->EndAction();
+
+ bRepeat = bScroll1 != m_pVScrollbar->IsScrollbarVisible(true);
+ if ( !bRepeat )
+ bRepeat = bScroll2 != m_pHScrollbar->IsScrollbarVisible(true);
+
+ // Do no infinite loops.
+ // If possible stop when the (auto-) scroll bars are visible.
+ if ( bRepeat &&
+ ( nCnt > 10 || ( nCnt > 3 && bHAuto && bAuto ) )
+ )
+ {
+ bRepeat = false;
+ }
+
+ } while ( bRepeat );
+
+ m_pWrtShell->UnlockPaint();
+ if( bUnLockView )
+ m_pWrtShell->LockView( false );
+
+ m_bInOuterResizePixel = false;
+
+ if ( m_pPostItMgr )
+ {
+ m_pPostItMgr->CalcRects();
+ m_pPostItMgr->LayoutPostIts();
+ }
+}
+
+void SwView::SetZoomFactor( const Fraction &rX, const Fraction &rY )
+{
+ const Fraction &rFrac = rX < rY ? rX : rY;
+ SetZoom( SvxZoomType::PERCENT, static_cast<short>(tools::Long(rFrac * Fraction( 100, 1 ))) );
+
+ // To minimize rounding errors we also adjust the odd values
+ // of the base class if necessary.
+ SfxViewShell::SetZoomFactor( rX, rY );
+}
+
+bool SwView::UpdateScrollbars()
+{
+ bool bRet = false;
+ if ( !m_aVisArea.IsEmpty() )
+ {
+ const bool bBorder = IsDocumentBorder();
+ tools::Rectangle aTmpRect( m_aVisArea );
+ if ( bBorder )
+ {
+ Point aPt( DOCUMENTBORDER, DOCUMENTBORDER );
+ aPt = AlignToPixel( aPt );
+ aTmpRect.Move( -aPt.X(), -aPt.Y() );
+ }
+
+ Size aTmpSz( m_aDocSz );
+ const tools::Long lOfst = bBorder ? 0 : DOCUMENTBORDER * 2;
+ aTmpSz.AdjustWidth(lOfst ); aTmpSz.AdjustHeight(lOfst );
+
+ {
+ const bool bVScrollVisible = m_pVScrollbar->IsScrollbarVisible(true);
+ m_pVScrollbar->DocSzChgd( aTmpSz );
+ m_pVScrollbar->ViewPortChgd( aTmpRect );
+ if ( bVScrollVisible != m_pVScrollbar->IsScrollbarVisible(true) )
+ bRet = true;
+ }
+ {
+ const bool bHScrollVisible = m_pHScrollbar->IsScrollbarVisible(true);
+ m_pHScrollbar->DocSzChgd( aTmpSz );
+ m_pHScrollbar->ViewPortChgd( aTmpRect );
+ if ( bHScrollVisible != m_pHScrollbar->IsScrollbarVisible(true) )
+ bRet = true;
+ }
+ }
+ return bRet;
+}
+
+void SwView::Move()
+{
+ if ( GetWrtShell().IsInSelect() )
+ GetWrtShell().EndSelect();
+ SfxViewShell::Move();
+}
+
+bool SwView::HandleWheelCommands( const CommandEvent& rCEvt )
+{
+ bool bOk = false;
+ const CommandWheelData* pWData = rCEvt.GetWheelData();
+ if (pWData && CommandWheelMode::ZOOM == pWData->GetMode())
+ {
+ sal_uInt16 nFact = m_pWrtShell->GetViewOptions()->GetZoom();
+ if( 0L > pWData->GetDelta() )
+ nFact = std::max(MIN_ZOOM_PERCENT, basegfx::zoomtools::zoomOut( nFact ));
+ else
+ nFact = std::min(MAX_ZOOM_PERCENT, basegfx::zoomtools::zoomIn( nFact ));
+
+ SetZoom( SvxZoomType::PERCENT, nFact );
+ bOk = true;
+ }
+ else
+ {
+ if (pWData && pWData->GetMode()==CommandWheelMode::SCROLL)
+ {
+ // This influences whether quick help is shown
+ m_bWheelScrollInProgress=true;
+ }
+
+ if (pWData && (CommandWheelMode::SCROLL==pWData->GetMode()) &&
+ (COMMAND_WHEEL_PAGESCROLL == pWData->GetScrollLines()))
+ {
+ if (pWData->GetDelta()<0)
+ PhyPageDown();
+ else
+ PhyPageUp();
+ bOk = true;
+ }
+ else
+ bOk = m_pEditWin->HandleScrollCommand(rCEvt, m_pHScrollbar, m_pVScrollbar);
+
+ // Restore default state for case when scroll command comes from dragging scrollbar handle
+ m_bWheelScrollInProgress=false;
+ }
+ return bOk;
+}
+
+bool SwView::HandleGestureZoomCommand(const CommandEvent& rCEvt)
+{
+ const CommandGestureZoomData* pData = rCEvt.GetGestureZoomData();
+
+ if (pData->meEventType == GestureEventZoomType::Begin)
+ {
+ m_fLastZoomScale = pData->mfScaleDelta;
+ return true;
+ }
+
+ if (pData->meEventType == GestureEventZoomType::Update)
+ {
+ double deltaBetweenEvents = (pData->mfScaleDelta - m_fLastZoomScale) / m_fLastZoomScale;
+ m_fLastZoomScale = pData->mfScaleDelta;
+
+ // Accumulate fractional zoom to avoid small zoom changes from being ignored
+ m_fAccumulatedZoom += deltaBetweenEvents;
+ int nZoomChangePercent = m_fAccumulatedZoom * 100;
+ m_fAccumulatedZoom -= nZoomChangePercent / 100.0;
+
+ sal_uInt16 nFact = m_pWrtShell->GetViewOptions()->GetZoom();
+ nFact += nZoomChangePercent;
+ nFact = std::clamp<sal_uInt16>(nFact, MIN_ZOOM_PERCENT, MAX_ZOOM_PERCENT);
+ SetZoom(SvxZoomType::PERCENT, nFact);
+
+ return true;
+ }
+ return true;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/viewprt.cxx b/sw/source/uibase/uiview/viewprt.cxx
new file mode 100644
index 0000000000..bc9c5e19b8
--- /dev/null
+++ b/sw/source/uibase/uiview/viewprt.cxx
@@ -0,0 +1,376 @@
+/* -*- 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 <libxml/xmlwriter.h>
+#include <cmdid.h>
+#include <officecfg/Office/Common.hxx>
+#include <sfx2/request.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/stdtext.hxx>
+#include <vcl/weld.hxx>
+#include <sfx2/printer.hxx>
+#include <editeng/paperinf.hxx>
+#include <sfx2/dispatch.hxx>
+#include <svx/dialmgr.hxx>
+#include <svx/strings.hrc>
+#include <svl/eitem.hxx>
+#include <svl/stritem.hxx>
+#include <svl/intitem.hxx>
+#include <svl/flagitem.hxx>
+#include <sfx2/linkmgr.hxx>
+#include <osl/diagnose.h>
+#include <svtools/colorcfg.hxx>
+#include <o3tl/unreachable.hxx>
+
+#include <modcfg.hxx>
+#include <edtwin.hxx>
+#include <view.hxx>
+#include <wrtsh.hxx>
+#include <viewopt.hxx>
+#include <prtopt.hxx>
+#include <cfgitems.hxx>
+#include "viewfunc.hxx"
+#include <swmodule.hxx>
+#include <wview.hxx>
+#include <IDocumentDeviceAccess.hxx>
+
+#include <globals.hrc>
+#include <strings.hrc>
+#include <swabstdlg.hxx>
+
+#include <uivwimp.hxx>
+
+using namespace ::com::sun::star;
+
+// Hand over the printer to Sfx
+
+SfxPrinter* SwView::GetPrinter( bool bCreate )
+{
+ const IDocumentDeviceAccess& rIDDA = GetWrtShell().getIDocumentDeviceAccess();
+ SfxPrinter *pOld = rIDDA.getPrinter( false );
+ SfxPrinter *pPrt = rIDDA.getPrinter( bCreate );
+ if ( pOld != pPrt )
+ {
+ bool bWeb = dynamic_cast<SwWebView*>(this) != nullptr;
+ ::SetAppPrintOptions( &GetWrtShell(), bWeb );
+ }
+ return pPrt;
+}
+
+// Propagate printer change
+
+void SetPrinter( IDocumentDeviceAccess* pIDDA, SfxPrinter const * pNew, bool bWeb )
+{
+ SwPrintOptions* pOpt = SW_MOD()->GetPrtOptions(bWeb);
+ if( !pOpt)
+ return;
+
+ // Reading Application own printing options from SfxPrinter
+ const SfxItemSet& rSet = pNew->GetOptions();
+
+ const SwAddPrinterItem* pAddPrinterAttr =
+ rSet.GetItemIfSet( FN_PARAM_ADDPRINTER, false );
+ if( pAddPrinterAttr )
+ {
+ if( pIDDA )
+ pIDDA->setPrintData( *pAddPrinterAttr );
+ if( !pAddPrinterAttr->GetFaxName().isEmpty() )
+ pOpt->SetFaxName(pAddPrinterAttr->GetFaxName());
+ }
+}
+
+sal_uInt16 SwView::SetPrinter(SfxPrinter* pNew, SfxPrinterChangeFlags nDiffFlags )
+{
+ SwWrtShell &rSh = GetWrtShell();
+ SfxPrinter* pOld = rSh.getIDocumentDeviceAccess().getPrinter( false );
+ if ( pOld && pOld->IsPrinting() )
+ return SFX_PRINTERROR_BUSY;
+
+ if ( (SfxPrinterChangeFlags::JOBSETUP | SfxPrinterChangeFlags::PRINTER) & nDiffFlags )
+ {
+ rSh.getIDocumentDeviceAccess().setPrinter( pNew, true, true );
+ if ( nDiffFlags & SfxPrinterChangeFlags::PRINTER )
+ rSh.SetModified();
+ }
+ bool bWeb = dynamic_cast< const SwWebView *>( this ) != nullptr;
+ if ( nDiffFlags & SfxPrinterChangeFlags::OPTIONS )
+ ::SetPrinter( &rSh.getIDocumentDeviceAccess(), pNew, bWeb );
+
+ const bool bChgOri = bool(nDiffFlags & SfxPrinterChangeFlags::CHG_ORIENTATION);
+ const bool bChgSize = bool(nDiffFlags & SfxPrinterChangeFlags::CHG_SIZE);
+ if ( bChgOri || bChgSize )
+ {
+ rSh.StartAllAction();
+ if ( bChgOri )
+ rSh.ChgAllPageOrientation( pNew->GetOrientation() );
+ if ( bChgSize )
+ {
+ Size aSz( SvxPaperInfo::GetPaperSize( pNew ) );
+ rSh.ChgAllPageSize( aSz );
+ }
+ rSh.SetModified();
+ rSh.EndAllAction();
+ InvalidateRulerPos();
+ }
+ return 0;
+}
+
+bool SwView::HasPrintOptionsPage() const
+{
+ return true;
+}
+
+namespace
+{
+ class SvxPrtQryBox
+ {
+ private:
+ std::unique_ptr<weld::MessageDialog> m_xQueryBox;
+ public:
+ SvxPrtQryBox(weld::Window* pParent)
+ : m_xQueryBox(Application::CreateMessageDialog(pParent, VclMessageType::Question, VclButtonsType::NONE, SvxResId(RID_SVXSTR_QRY_PRINT_MSG)))
+ {
+ m_xQueryBox->set_title(SvxResId(RID_SVXSTR_QRY_PRINT_TITLE));
+
+ m_xQueryBox->add_button(SvxResId(RID_SVXSTR_QRY_PRINT_SELECTION), RET_OK);
+ m_xQueryBox->add_button(SvxResId(RID_SVXSTR_QRY_PRINT_ALL), 2);
+ m_xQueryBox->add_button(GetStandardText(StandardButtonType::Cancel), RET_CANCEL);
+ m_xQueryBox->set_default_response(RET_OK);
+ }
+ short run() { return m_xQueryBox->run(); }
+ };
+}
+
+// TabPage for application-specific print options
+
+std::unique_ptr<SfxTabPage> SwView::CreatePrintOptionsPage(weld::Container* pPage, weld::DialogController* pController,
+ const SfxItemSet& rSet)
+{
+ return ::CreatePrintOptionsPage(pPage, pController, rSet, false);
+}
+
+// Print dispatcher
+
+void SwView::ExecutePrint(SfxRequest& rReq)
+{
+ bool bWeb = dynamic_cast<SwWebView*>( this ) != nullptr;
+ ::SetAppPrintOptions( &GetWrtShell(), bWeb );
+ switch (rReq.GetSlot())
+ {
+ case FN_FAX:
+ {
+ SwPrintOptions* pPrintOptions = SW_MOD()->GetPrtOptions(bWeb);
+ const OUString& sFaxName(pPrintOptions->GetFaxName());
+ if (!sFaxName.isEmpty())
+ {
+ SfxStringItem aPrinterName(SID_PRINTER_NAME, sFaxName);
+ SfxBoolItem aSilent( SID_SILENT, true );
+ GetViewFrame().GetDispatcher()->ExecuteList(SID_PRINTDOC,
+ SfxCallMode::SYNCHRON|SfxCallMode::RECORD,
+ { &aPrinterName, &aSilent });
+ }
+ else
+ {
+ std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetEditWin().GetFrameWeld(),
+ VclMessageType::Info, VclButtonsType::Ok,
+ SwResId(STR_ERR_NO_FAX)));
+ TranslateId pResId = bWeb ? STR_WEBOPTIONS : STR_TEXTOPTIONS;
+ xInfoBox->set_primary_text(xInfoBox->get_primary_text().replaceFirst("%1", SwResId(pResId)));
+ xInfoBox->run();
+ SfxUInt16Item aDefPage(SID_SW_EDITOPTIONS, TP_OPTPRINT_PAGE);
+ GetViewFrame().GetDispatcher()->ExecuteList(SID_SW_EDITOPTIONS,
+ SfxCallMode::SYNCHRON|SfxCallMode::RECORD,
+ { &aDefPage });
+ }
+ }
+ break;
+ case SID_PRINTDOC:
+ case SID_PRINTDOCDIRECT:
+ {
+ SwWrtShell* pSh = &GetWrtShell();
+ const SfxBoolItem* pSilentItem = rReq.GetArg<SfxBoolItem>(SID_SILENT);
+ bool bSilent = pSilentItem && pSilentItem->GetValue();
+ const SfxBoolItem* pPrintFromMergeItem = rReq.GetArg<SfxBoolItem>(FN_QRY_MERGE);
+ if(pPrintFromMergeItem)
+ rReq.RemoveItem(FN_QRY_MERGE);
+ bool bFromMerge = pPrintFromMergeItem && pPrintFromMergeItem->GetValue();
+ bool bPrintSelection = false;
+ if(!bSilent && !bFromMerge &&
+ SW_MOD()->GetModuleConfig()->IsAskForMailMerge() && pSh->IsAnyDatabaseFieldInDoc())
+ {
+ std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetEditWin().GetFrameWeld(), "modules/swriter/ui/printmergedialog.ui"));
+ std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog("PrintMergeDialog"));
+ short nRet = xBox->run();
+ if(RET_NO != nRet)
+ {
+ if(RET_YES == nRet)
+ {
+ SfxBoolItem aBool(FN_QRY_MERGE, true);
+ GetViewFrame().GetDispatcher()->ExecuteList(
+ FN_QRY_MERGE, SfxCallMode::ASYNCHRON,
+ { &aBool });
+ rReq.Ignore();
+ }
+ return;
+ }
+ }
+ else if( rReq.GetSlot() == SID_PRINTDOCDIRECT && ! bSilent )
+ {
+ if( pSh->IsSelection() || pSh->IsFrameSelected() || pSh->IsObjSelected() )
+ {
+ SvxPrtQryBox aBox(GetEditWin().GetFrameWeld());
+ short nBtn = aBox.run();
+ if( RET_CANCEL == nBtn )
+ return;
+
+ if( RET_OK == nBtn )
+ bPrintSelection = true;
+ }
+ }
+
+ //#i61455# if master documents are printed silently without loaded links then update the links now
+ if( bSilent && pSh->IsGlobalDoc() && !pSh->IsGlblDocSaveLinks() )
+ {
+ pSh->GetLinkManager().UpdateAllLinks( false, false, nullptr );
+ }
+ SfxRequest aReq( rReq );
+ SfxBoolItem aBool(SID_SELECTION, bPrintSelection);
+ aReq.AppendItem( aBool );
+ SfxViewShell::ExecuteSlot( aReq, SfxViewShell::GetInterface() );
+ return;
+ }
+ default:
+ OSL_ENSURE(false, "wrong dispatcher");
+ return;
+ }
+}
+
+int SwView::getPart() const
+{
+ return 0;
+}
+
+void SwView::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+ (void)xmlTextWriterStartElement(pWriter, BAD_CAST("SwView"));
+ SfxViewShell::dumpAsXml(pWriter);
+ if (m_pWrtShell)
+ m_pWrtShell->dumpAsXml(pWriter);
+ (void)xmlTextWriterEndElement(pWriter);
+}
+
+void SwView::SetRedlineAuthor(const OUString& rAuthor)
+{
+ m_pViewImpl->m_sRedlineAuthor = rAuthor;
+}
+
+const OUString& SwView::GetRedlineAuthor() const
+{
+ return m_pViewImpl->m_sRedlineAuthor;
+}
+
+void SwView::NotifyCursor(SfxViewShell* pViewShell) const
+{
+ m_pWrtShell->NotifyCursor(pViewShell);
+}
+
+::Color SwView::GetColorConfigColor(svtools::ColorConfigEntry nColorType) const
+{
+ if (const SwViewOption* pViewOptions = GetWrtShell().GetViewOptions())
+ {
+ switch (nColorType)
+ {
+ case svtools::ColorConfigEntry::DOCCOLOR:
+ {
+ return pViewOptions->GetDocColor();
+ }
+ // Should never be called for an unimplemented color type
+ default:
+ {
+ O3TL_UNREACHABLE;
+ }
+ }
+ }
+ else
+ {
+ SAL_WARN("sw", "GetViewOptions() returned nullptr");
+ }
+
+ return {};
+}
+
+// Create page printer/additions for SwView and SwPagePreview
+
+std::unique_ptr<SfxTabPage> CreatePrintOptionsPage(weld::Container* pPage, weld::DialogController* pController,
+ const SfxItemSet &rOptions,
+ bool bPreview)
+{
+ SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
+
+ ::CreateTabPage fnCreatePage = pFact->GetTabPageCreatorFunc(TP_OPTPRINT_PAGE);
+ OSL_ENSURE(pFact, "No Page Creator");
+ if (!fnCreatePage)
+ return nullptr;
+
+ std::unique_ptr<SfxTabPage> xSfxPage = fnCreatePage(pPage, pController, &rOptions);
+ OSL_ENSURE(xSfxPage, "No page");
+ if (!xSfxPage)
+ return nullptr;
+
+ SfxAllItemSet aSet(*(rOptions.GetPool()));
+ aSet.Put(SfxBoolItem(SID_PREVIEWFLAG_TYPE, bPreview));
+ aSet.Put(SfxBoolItem(SID_FAX_LIST, true));
+ xSfxPage->PageCreated(aSet);
+ return xSfxPage;
+}
+
+void SetAppPrintOptions( SwViewShell* pSh, bool bWeb )
+{
+ const IDocumentDeviceAccess& rIDDA = pSh->getIDocumentDeviceAccess();
+ const SwPrintData& aPrtData = rIDDA.getPrintData();
+
+ if( !rIDDA.getPrinter( false ) )
+ return;
+
+ // Close application own printing options in SfxPrinter.
+ SwAddPrinterItem aAddPrinterItem(aPrtData);
+ SfxItemSetFixed<
+ SID_PRINTER_NOTFOUND_WARN, SID_PRINTER_NOTFOUND_WARN,
+ SID_PRINTER_CHANGESTODOC, SID_PRINTER_CHANGESTODOC,
+ SID_HTML_MODE, SID_HTML_MODE,
+ FN_PARAM_ADDPRINTER, FN_PARAM_ADDPRINTER> aSet( pSh->GetAttrPool() );
+
+ if(bWeb)
+ aSet.Put(SfxUInt16Item(SID_HTML_MODE,
+ ::GetHtmlMode(static_cast<SwWrtShell*>(pSh)->GetView().GetDocShell())));
+ aSet.Put(SfxBoolItem(SID_PRINTER_NOTFOUND_WARN,
+ officecfg::Office::Common::Print::Warning::NotFound::get() ));
+ aSet.Put(aAddPrinterItem);
+ aSet.Put( SfxFlagItem( SID_PRINTER_CHANGESTODOC,
+ static_cast<int>(officecfg::Office::Common::Print::Warning::PaperSize::get()
+ ? SfxPrinterChangeFlags::CHG_SIZE : SfxPrinterChangeFlags::NONE) |
+ static_cast<int>(officecfg::Office::Common::Print::Warning::PaperOrientation::get()
+ ? SfxPrinterChangeFlags::CHG_ORIENTATION : SfxPrinterChangeFlags::NONE )));
+
+ rIDDA.getPrinter( true )->SetOptions( aSet );
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/viewsrch.cxx b/sw/source/uibase/uiview/viewsrch.cxx
new file mode 100644
index 0000000000..5fc92d517b
--- /dev/null
+++ b/sw/source/uibase/uiview/viewsrch.cxx
@@ -0,0 +1,895 @@
+/* -*- 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 <string>
+
+#include <memory>
+#include <boost/property_tree/json_parser.hpp>
+
+#include <hintids.hxx>
+
+#include <sal/log.hxx>
+#include <svl/cjkoptions.hxx>
+#include <svl/ctloptions.hxx>
+#include <svx/pageitem.hxx>
+#include <svl/whiter.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <svl/eitem.hxx>
+#include <svl/srchitem.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/request.hxx>
+#include <sfx2/lokhelper.hxx>
+#include <svx/srchdlg.hxx>
+#include <swmodule.hxx>
+#include <swwait.hxx>
+#include <workctrl.hxx>
+#include <view.hxx>
+#include <wrtsh.hxx>
+#include <swundo.hxx>
+#include <uitool.hxx>
+#include <cmdid.h>
+#include <docsh.hxx>
+#include <LibreOfficeKit/LibreOfficeKitEnums.h>
+#include <comphelper/lok.hxx>
+#include <comphelper/string.hxx>
+
+#include <strings.hrc>
+#include <SwRewriter.hxx>
+
+#include <PostItMgr.hxx>
+
+using namespace com::sun::star;
+using namespace ::com::sun::star::i18n;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::util;
+
+//Search Parameter
+
+struct SwSearchOptions
+{
+ SwDocPositions eStart, eEnd;
+ bool bDontWrap;
+
+ SwSearchOptions( SwWrtShell const * pSh, bool bBackward );
+};
+
+/// Adds rMatches using rKey as a key to the rTree tree.
+static void lcl_addContainerToJson(boost::property_tree::ptree& rTree, const OString& rKey, const std::vector<OString>& rMatches)
+{
+ boost::property_tree::ptree aChildren;
+
+ for (const OString& rMatch : rMatches)
+ {
+ boost::property_tree::ptree aChild;
+ aChild.put("part", "0");
+ aChild.put("rectangles", rMatch.getStr());
+ aChildren.push_back(std::make_pair("", aChild));
+ }
+
+ rTree.add_child(rKey.getStr(), aChildren);
+}
+
+/// Emits LOK callbacks (count, selection) for search results.
+static void lcl_emitSearchResultCallbacks(SvxSearchItem const * pSearchItem, SwWrtShell const * pWrtShell, bool bHighlightAll)
+{
+ // Emit a callback also about the selection rectangles, grouped by matches.
+ SwPaM* pPaM = pWrtShell->GetCursor();
+ if (!pPaM)
+ return;
+
+ std::vector<OString> aMatches;
+ for (SwPaM& rPaM : pPaM->GetRingContainer())
+ {
+ if (SwShellCursor* pShellCursor = dynamic_cast<SwShellCursor*>(&rPaM))
+ {
+ std::vector<OString> aSelectionRectangles;
+ pShellCursor->SwSelPaintRects::Show(&aSelectionRectangles);
+ std::vector<OString> aRect;
+ for (const OString & rSelectionRectangle : aSelectionRectangles)
+ {
+ if (rSelectionRectangle.isEmpty())
+ continue;
+ aRect.push_back(rSelectionRectangle);
+ }
+ OString sRect = comphelper::string::join("; ", aRect);
+ aMatches.push_back(sRect);
+ }
+ }
+ boost::property_tree::ptree aTree;
+ aTree.put("searchString", pSearchItem->GetSearchString().toUtf8().getStr());
+ aTree.put("highlightAll", bHighlightAll);
+ lcl_addContainerToJson(aTree, "searchResultSelection"_ostr, aMatches);
+
+ std::stringstream aStream;
+ boost::property_tree::write_json(aStream, aTree);
+ OString aPayload( aStream.str() );
+
+ pWrtShell->GetSfxViewShell()->libreOfficeKitViewCallback(LOK_CALLBACK_SEARCH_RESULT_SELECTION, aPayload);
+
+ if(bHighlightAll)
+ { // FindAll disables this during find, do it once when done.
+ SfxLokHelper::notifyUpdate(pWrtShell->GetSfxViewShell(),LOK_CALLBACK_TEXT_SELECTION);
+ SfxLokHelper::notifyOtherViewsUpdatePerViewId(pWrtShell->GetSfxViewShell(), LOK_CALLBACK_TEXT_VIEW_SELECTION);
+ }
+}
+
+void SwView::ExecSearch(SfxRequest& rReq)
+{
+ GetWrtShell().addCurrentPosition();
+
+ const SfxItemSet* pArgs = rReq.GetArgs();
+ const SfxPoolItem* pItem = nullptr;
+ bool bQuiet = false;
+ if(pArgs && SfxItemState::SET == pArgs->GetItemState(SID_SEARCH_QUIET, false, &pItem))
+ bQuiet = static_cast<const SfxBoolItem*>( pItem)->GetValue();
+
+ sal_uInt16 nSlot = rReq.GetSlot();
+ if (nSlot == FN_REPEAT_SEARCH && !s_pSrchItem)
+ {
+ if(bQuiet)
+ {
+ rReq.SetReturnValue(SfxBoolItem(nSlot, false));
+ nSlot = 0;
+ }
+ }
+ if( m_pWrtShell->IsBlockMode() )
+ m_pWrtShell->LeaveBlockMode();
+ switch (nSlot)
+ {
+ // for now do nothing
+ case SID_SEARCH_ITEM:
+ {
+ delete s_pSrchItem;
+ s_pSrchItem = pArgs->Get(SID_SEARCH_ITEM).Clone();
+ }
+ break;
+
+ case FID_SEARCH_ON:
+ s_bJustOpened = true;
+ GetViewFrame().GetBindings().Invalidate(SID_SEARCH_ITEM);
+ break;
+
+ case FID_SEARCH_OFF:
+ if(pArgs)
+ {
+ // Unregister dialog
+ delete s_pSrchItem;
+ s_pSrchItem = pArgs->Get(SID_SEARCH_ITEM).Clone();
+
+ s_xSearchList.reset();
+ s_xReplaceList.reset();
+
+ SvxSearchDialog *const pSrchDlg(GetSearchDialog());
+ if (pSrchDlg)
+ {
+ // We will remember the search-/replace items.
+ const SearchAttrItemList* pList = pSrchDlg->GetSearchItemList();
+ if( nullptr != pList && pList->Count() )
+ s_xSearchList.reset(new SearchAttrItemList( *pList ));
+
+ pList = pSrchDlg->GetReplaceItemList();
+ if (nullptr != pList && pList->Count())
+ s_xReplaceList.reset(new SearchAttrItemList( *pList ));
+ }
+ }
+ break;
+
+ case FN_REPEAT_SEARCH:
+ case FID_SEARCH_NOW:
+ {
+ sal_uInt16 nMoveType = SwView::GetMoveType();
+ {
+ if(FID_SEARCH_NOW == nSlot && !rReq.IsAPI())
+ SwView::SetMoveType(NID_SRCH_REP);
+ }
+
+ SvxSearchDialog * pSrchDlg(GetSearchDialog());
+ if (pSrchDlg)
+ {
+ s_xSearchList.reset();
+ s_xReplaceList.reset();
+
+ const SearchAttrItemList* pList = pSrchDlg->GetSearchItemList();
+ if( nullptr != pList && pList->Count() )
+ s_xSearchList.reset(new SearchAttrItemList( *pList ));
+
+ pList = pSrchDlg->GetReplaceItemList();
+ if (nullptr != pList && pList->Count())
+ s_xReplaceList.reset(new SearchAttrItemList( *pList ));
+ }
+
+ if (nSlot == FN_REPEAT_SEARCH)
+ {
+ OSL_ENSURE(s_pSrchItem, "SearchItem missing");
+ if( !s_pSrchItem )
+ s_pSrchItem = new SvxSearchItem(SID_SEARCH_ITEM);
+ }
+ else
+ {
+ // Get SearchItem from request
+ OSL_ENSURE(pArgs, "Args missing");
+ if ( pArgs )
+ {
+ delete s_pSrchItem;
+ s_pSrchItem = pArgs->Get(SID_SEARCH_ITEM).Clone();
+ }
+ }
+ SvxSearchCmd eCommand = s_pSrchItem->GetCommand();
+ switch (eCommand)
+ {
+ case SvxSearchCmd::FIND:
+ {
+ bool bRet = SearchAndWrap(bQuiet);
+ if( bRet )
+ {
+ Scroll(m_pWrtShell->GetCharRect().SVRect());
+ if (comphelper::LibreOfficeKit::isActive())
+ lcl_emitSearchResultCallbacks(s_pSrchItem, m_pWrtShell.get(), /* bHighlightAll = */ false);
+ }
+ rReq.SetReturnValue(SfxBoolItem(nSlot, bRet));
+
+ GetDocShell()->Broadcast(SfxHint(SfxHintId::SwNavigatorUpdateTracking));
+ }
+ break;
+ case SvxSearchCmd::FIND_ALL:
+ {
+ // Disable LOK selection notifications during search.
+ m_pWrtShell->GetSfxViewShell()->setTiledSearching(true);
+ const auto nFound = SearchAll();
+ m_pWrtShell->GetSfxViewShell()->setTiledSearching(false);
+
+ GetDocShell()->Broadcast(
+ SfxHint(SfxHintId::SwNavigatorUpdateTracking));
+ GetDocShell()->Broadcast(
+ SfxHint(SfxHintId::SwNavigatorSelectOutlinesWithSelections));
+
+ if (nFound == 0)
+ {
+#if HAVE_FEATURE_DESKTOP
+ if( !bQuiet )
+ {
+ m_pWrtShell->GetSfxViewShell()->libreOfficeKitViewCallback(LOK_CALLBACK_SEARCH_NOT_FOUND, s_pSrchItem->GetSearchString().toUtf8());
+ SvxSearchDialogWrapper::SetSearchLabel(SearchLabel::NotFound);
+ }
+#endif
+ s_bFound = false;
+ }
+ else
+ {
+ if (comphelper::LibreOfficeKit::isActive())
+ lcl_emitSearchResultCallbacks(s_pSrchItem, m_pWrtShell.get(), /* bHighlightAll = */ true);
+ if (!bQuiet)
+ {
+ OUString sText(SwResId(STR_SEARCH_KEY_FOUND_TIMES));
+ sText = sText.replaceFirst("%1", OUString::number(nFound));
+ SvxSearchDialogWrapper::SetSearchLabel(sText);
+ }
+ }
+ rReq.SetReturnValue(SfxBoolItem(nSlot, nFound != 0));
+ }
+ break;
+ case SvxSearchCmd::REPLACE:
+ {
+
+ // 1) Replace selection (Not if only attributes should be replaced)
+//JP 27.04.95: Why?
+// what if you only want to assign attributes to the found??
+
+ SvxSearchCmd nCmd = SvxSearchCmd::FIND;
+ if( !s_pSrchItem->GetReplaceString().isEmpty() ||
+ !s_xReplaceList )
+ {
+ // Prevent, that the replaced string will be found again
+ // if the replacement string is containing the search string.
+ bool bBack = s_pSrchItem->GetBackward();
+ if (bBack)
+ m_pWrtShell->Push();
+ OUString aReplace( s_pSrchItem->GetReplaceString() );
+ i18nutil::SearchOptions2 aTmp( s_pSrchItem->GetSearchOptions() );
+ std::optional<OUString> xBackRef = sw::ReplaceBackReferences(aTmp,
+ m_pWrtShell->GetCursor(), m_pWrtShell->GetLayout());
+ if( xBackRef )
+ s_pSrchItem->SetReplaceString( *xBackRef );
+ Replace();
+ if( xBackRef )
+ {
+ s_pSrchItem->SetReplaceString( aReplace );
+ }
+ if (bBack)
+ {
+ m_pWrtShell->Pop();
+ m_pWrtShell->SwapPam();
+ }
+ }
+ else if( s_xReplaceList )
+ nCmd = SvxSearchCmd::REPLACE;
+
+ // 2) Search further (without replacing!)
+
+ SvxSearchCmd nOldCmd = s_pSrchItem->GetCommand();
+ s_pSrchItem->SetCommand( nCmd );
+ bool bRet = SearchAndWrap(bQuiet);
+ if( bRet )
+ Scroll( m_pWrtShell->GetCharRect().SVRect());
+ s_pSrchItem->SetCommand( nOldCmd );
+ rReq.SetReturnValue(SfxBoolItem(nSlot, bRet));
+ }
+ break;
+
+ case SvxSearchCmd::REPLACE_ALL:
+ {
+ SwSearchOptions aOpts( m_pWrtShell.get(), s_pSrchItem->GetBackward() );
+ s_bExtra = false;
+ sal_uLong nFound;
+
+ { //Scope for SwWait-Object
+ SwWait aWait( *GetDocShell(), true );
+ m_pWrtShell->StartAllAction();
+
+ // i#8288 "replace all" should not change cursor
+ // position, so save current cursor
+ m_pWrtShell->Push();
+
+ if (!s_pSrchItem->GetSelection())
+ {
+ // if we don't want to search in the selection...
+ m_pWrtShell->KillSelection(nullptr, false);
+ if (SwDocPositions::Start == aOpts.eEnd)
+ {
+ m_pWrtShell->EndOfSection();
+ }
+ else
+ {
+ m_pWrtShell->StartOfSection();
+ }
+ }
+ nFound = FUNC_Search( aOpts );
+ // create it just to overwrite it with stack cursor
+ m_pWrtShell->CreateCursor();
+ // i#8288 restore the original cursor position
+ m_pWrtShell->Pop(SwCursorShell::PopMode::DeleteCurrent);
+ m_pWrtShell->EndAllAction();
+ }
+
+ rReq.SetReturnValue(SfxBoolItem(nSlot, nFound != 0 && ULONG_MAX != nFound));
+ if( !nFound )
+ {
+#if HAVE_FEATURE_DESKTOP
+ if( !bQuiet )
+ {
+ m_pWrtShell->GetSfxViewShell()->libreOfficeKitViewCallback(LOK_CALLBACK_SEARCH_NOT_FOUND, s_pSrchItem->GetSearchString().toUtf8());
+ SvxSearchDialogWrapper::SetSearchLabel(SearchLabel::NotFound);
+ }
+#endif
+ s_bFound = false;
+ SwView::SetMoveType(nMoveType);
+ return;
+ }
+
+ if( !bQuiet && ULONG_MAX != nFound)
+ {
+ OUString sText( SwResId( STR_NB_REPLACED ) );
+ sText = sText.replaceFirst("XX", OUString::number( nFound ));
+ SvxSearchDialogWrapper::SetSearchLabel(sText);
+ }
+ }
+ break;
+ }
+
+ uno::Reference< frame::XDispatchRecorder > xRecorder =
+ GetViewFrame().GetBindings().GetRecorder();
+ //prevent additional dialogs in recorded macros
+ if ( xRecorder.is() )
+ rReq.AppendItem(SfxBoolItem(SID_SEARCH_QUIET, true));
+
+ rReq.Done();
+ m_eLastSearchCommand = s_pSrchItem->GetCommand();
+ SwView::SetMoveType(nMoveType);
+ }
+ break;
+ case FID_SEARCH_SEARCHSET:
+ case FID_SEARCH_REPLACESET:
+ {
+ static const WhichRangesContainer aNormalAttr(svl::Items<
+/* 0 */ RES_CHRATR_CASEMAP, RES_CHRATR_CASEMAP,
+/* 2 */ RES_CHRATR_COLOR, RES_CHRATR_POSTURE,
+/* 4 */ RES_CHRATR_SHADOWED, RES_CHRATR_WORDLINEMODE,
+/* 6 */ RES_CHRATR_BLINK, RES_CHRATR_BLINK,
+/* 8 */ RES_CHRATR_BACKGROUND, RES_CHRATR_BACKGROUND,
+/*10 */ RES_CHRATR_ROTATE, RES_CHRATR_ROTATE,
+/*12 */ RES_CHRATR_SCALEW, RES_CHRATR_RELIEF,
+/*14 */ RES_CHRATR_OVERLINE, RES_CHRATR_OVERLINE,
+/*16 */ RES_PARATR_LINESPACING, RES_PARATR_HYPHENZONE,
+/*18 */ RES_PARATR_REGISTER, RES_PARATR_REGISTER,
+/*20 */ RES_PARATR_VERTALIGN, RES_PARATR_VERTALIGN,
+ RES_MARGIN_FIRSTLINE, RES_MARGIN_RIGHT,
+ RES_UL_SPACE, RES_UL_SPACE,
+/*24 */ SID_ATTR_PARA_MODEL, SID_ATTR_PARA_KEEP
+ >);
+
+ SfxItemSet aSet(m_pWrtShell->GetAttrPool(), aNormalAttr);
+
+ if( SvtCTLOptions::IsCTLFontEnabled() )
+ {
+ aSet.MergeRange(RES_CHRATR_CTL_FONT, RES_CHRATR_CTL_WEIGHT);
+ }
+ if( SvtCJKOptions::IsAnyEnabled() )
+ {
+ aSet.MergeRange(RES_CHRATR_CJK_FONT, RES_CHRATR_CJK_WEIGHT);
+ aSet.MergeRange(RES_CHRATR_EMPHASIS_MARK, RES_CHRATR_TWO_LINES);
+ aSet.MergeRange(RES_PARATR_SCRIPTSPACE, RES_PARATR_FORBIDDEN_RULES);
+ }
+
+ TypedWhichId<SvxSetItem> nWhich = SID_SEARCH_SEARCHSET;
+
+ if ( FID_SEARCH_REPLACESET == nSlot )
+ {
+ nWhich = SID_SEARCH_REPLACESET;
+
+ if ( s_xReplaceList )
+ {
+ s_xReplaceList->Get( aSet );
+ s_xReplaceList.reset();
+ }
+ }
+ else if ( s_xSearchList )
+ {
+ s_xSearchList->Get( aSet );
+ s_xSearchList.reset();
+ }
+ rReq.SetReturnValue( SvxSetItem( nWhich, aSet ) );
+ }
+ break;
+ default:
+ SAL_WARN_IF( nSlot, "sw", "nSlot: " << nSlot << " wrong Dispatcher (viewsrch.cxx)" );
+ return;
+ }
+}
+
+bool SwView::SearchAndWrap(bool bApi)
+{
+ SwSearchOptions aOpts( m_pWrtShell.get(), s_pSrchItem->GetBackward() );
+
+ // Remember starting position of the search for wraparound
+ // Start- / EndAction perhaps because existing selections of 'search all'
+ m_pWrtShell->StartAllAction();
+ m_pWrtShell->Push();
+
+ // After a search all action we place the cursor at the beginning of
+ // the document so that the single search selects the first matching
+ // occurrence in the document instead of the second.
+ if( m_eLastSearchCommand == SvxSearchCmd::FIND_ALL )
+ {
+ if( SwDocPositions::Start == aOpts.eEnd )
+ m_pWrtShell->EndOfSection();
+ else
+ m_pWrtShell->StartOfSection();
+ }
+
+ // fdo#65014 : Ensure that the point of the cursor is at the extremity of the
+ // selection closest to the end being searched to as to exclude the selected
+ // region from the search. (This doesn't work in the case of multiple
+ // selected regions as the cursor doesn't mark the selection in that case.)
+ m_pWrtShell->GetCursor()->Normalize( s_pSrchItem->GetBackward() );
+
+ if (!m_pWrtShell->HasSelection() && (s_pSrchItem->HasStartPoint()))
+ {
+ // No selection -> but we have a start point (top left corner of the
+ // current view), start searching from there, not from the current
+ // cursor position.
+ SwEditShell& rShell = GetWrtShell();
+ Point aPosition(s_pSrchItem->GetStartPointX(), s_pSrchItem->GetStartPointY());
+ rShell.SetCursor(aPosition);
+ }
+
+ // If you want to search in selected areas, they must not be unselected.
+ if (!s_pSrchItem->GetSelection())
+ m_pWrtShell->KillSelection(nullptr, false);
+
+ std::optional<SwWait> oWait( std::in_place, *GetDocShell(), true );
+ if( FUNC_Search( aOpts ) )
+ {
+ s_bFound = true;
+ if(m_pWrtShell->IsSelFrameMode())
+ {
+ m_pWrtShell->UnSelectFrame();
+ m_pWrtShell->LeaveSelFrameMode();
+ }
+ m_pWrtShell->Pop();
+ m_pWrtShell->EndAllAction();
+ return true;
+ }
+ oWait.reset();
+
+ // Search in the specialized areas when no search is present in selections.
+ // When searching selections will already searched in these special areas.
+ bool bHasSrchInOther = s_bExtra;
+ if (!s_pSrchItem->GetSelection() && !s_bExtra )
+ {
+ s_bExtra = true;
+ if( FUNC_Search( aOpts ) )
+ {
+ s_bFound = true;
+ m_pWrtShell->Pop();
+ m_pWrtShell->EndAllAction();
+ return true;
+ }
+ s_bExtra = false;
+ }
+ else
+ s_bExtra = !s_bExtra;
+
+ // If starting position is at the end or beginning of the document.
+ if (aOpts.bDontWrap)
+ {
+ m_pWrtShell->EndAllAction();
+ if( !bApi )
+ {
+#if HAVE_FEATURE_DESKTOP
+ m_pWrtShell->GetSfxViewShell()->libreOfficeKitViewCallback(LOK_CALLBACK_SEARCH_NOT_FOUND, s_pSrchItem->GetSearchString().toUtf8());
+ SvxSearchDialogWrapper::SetSearchLabel(SearchLabel::NotFound);
+#endif
+ }
+ s_bFound = false;
+ m_pWrtShell->Pop();
+ return false;
+ }
+ m_pWrtShell->EndAllAction();
+ // Try again with WrapAround?
+
+ m_pWrtShell->StartAllAction();
+ m_pWrtShell->Pop(SwCursorShell::PopMode::DeleteCurrent);
+ oWait.emplace( *GetDocShell(), true );
+
+ bool bSrchBkwrd = SwDocPositions::Start == aOpts.eEnd;
+
+ aOpts.eEnd = bSrchBkwrd ? SwDocPositions::Start : SwDocPositions::End;
+ aOpts.eStart = bSrchBkwrd ? SwDocPositions::End : SwDocPositions::Start;
+
+ if (bHasSrchInOther)
+ {
+ m_pWrtShell->ClearMark();
+ // Select the start or the end of the entire document
+ if (bSrchBkwrd)
+ m_pWrtShell->SttEndDoc(false);
+ else
+ m_pWrtShell->SttEndDoc(true);
+ }
+
+ s_bFound = bool(FUNC_Search( aOpts ));
+
+ // If WrapAround found no matches in the body text, search in the special
+ // sections, too.
+ if (!s_bFound && !s_pSrchItem->GetSelection() && !s_bExtra)
+ {
+ s_bExtra = true;
+ if (FUNC_Search(aOpts))
+ s_bFound = true;
+ else
+ s_bExtra = false;
+ }
+
+ m_pWrtShell->EndAllAction();
+ oWait.reset();
+#if HAVE_FEATURE_DESKTOP
+ if (s_bFound)
+ {
+ if (!bSrchBkwrd)
+ SvxSearchDialogWrapper::SetSearchLabel(SearchLabel::End);
+ else
+ SvxSearchDialogWrapper::SetSearchLabel(SearchLabel::Start);
+ }
+ else if(!bApi)
+ {
+ m_pWrtShell->GetSfxViewShell()->libreOfficeKitViewCallback(LOK_CALLBACK_SEARCH_NOT_FOUND, s_pSrchItem->GetSearchString().toUtf8());
+ SvxSearchDialogWrapper::SetSearchLabel(SearchLabel::NotFound);
+ }
+#endif
+ return s_bFound;
+}
+
+sal_uInt16 SwView::SearchAll()
+{
+ SwWait aWait( *GetDocShell(), true );
+ m_pWrtShell->StartAllAction();
+
+ SwSearchOptions aOpts( m_pWrtShell.get(), s_pSrchItem->GetBackward() );
+
+ if (!s_pSrchItem->GetSelection())
+ {
+ // Cancel existing selections, if should not be sought in selected areas.
+ m_pWrtShell->KillSelection(nullptr, false);
+
+ if( SwDocPositions::Start == aOpts.eEnd )
+ m_pWrtShell->EndOfSection();
+ else
+ m_pWrtShell->StartOfSection();
+ }
+ s_bExtra = false;
+ sal_uInt16 nFound = o3tl::narrowing<sal_uInt16>(FUNC_Search( aOpts ));
+ s_bFound = 0 != nFound;
+
+ m_pWrtShell->EndAllAction();
+ return nFound;
+}
+
+void SwView::Replace()
+{
+ SwWait aWait( *GetDocShell(), true );
+
+ m_pWrtShell->StartAllAction();
+
+ if( s_pSrchItem->GetPattern() ) // Templates?
+ {
+ SwRewriter aRewriter;
+ aRewriter.AddRule(UndoArg1, s_pSrchItem->GetSearchString());
+ aRewriter.AddRule(UndoArg2, SwResId(STR_YIELDS));
+ aRewriter.AddRule(UndoArg3, s_pSrchItem->GetReplaceString());
+
+ m_pWrtShell->StartUndo(SwUndoId::UI_REPLACE_STYLE, &aRewriter);
+
+ m_pWrtShell->SetTextFormatColl( m_pWrtShell->GetParaStyle(
+ s_pSrchItem->GetReplaceString(),
+ SwWrtShell::GETSTYLE_CREATESOME ));
+
+ m_pWrtShell->EndUndo();
+ }
+ else
+ {
+ if (GetPostItMgr()->HasActiveSidebarWin())
+ GetPostItMgr()->Replace(s_pSrchItem);
+
+ bool bReqReplace = true;
+
+ if(m_pWrtShell->HasSelection())
+ {
+ /* check that the selection match the search string*/
+ //save state
+ SwPosition aStartPos = * m_pWrtShell->GetCursor()->Start();
+ SwPosition aEndPos = * m_pWrtShell->GetCursor()->End();
+ bool bHasSelection = s_pSrchItem->GetSelection();
+ SvxSearchCmd nOldCmd = s_pSrchItem->GetCommand();
+
+ //set state for checking if current selection has a match
+ s_pSrchItem->SetCommand( SvxSearchCmd::FIND );
+ s_pSrchItem->SetSelection(true);
+
+ //check if it matches
+ SwSearchOptions aOpts( m_pWrtShell.get(), s_pSrchItem->GetBackward() );
+ if( ! FUNC_Search(aOpts) )
+ {
+
+ //no matching therefore should not replace selection
+ // => remove selection
+
+ if(! s_pSrchItem->GetBackward() )
+ {
+ (* m_pWrtShell->GetCursor()->Start()) = aStartPos;
+ (* m_pWrtShell->GetCursor()->End()) = aEndPos;
+ }
+ else
+ {
+ (* m_pWrtShell->GetCursor()->Start()) = aEndPos;
+ (* m_pWrtShell->GetCursor()->End()) = aStartPos;
+ }
+ bReqReplace = false;
+ }
+
+ //set back old search state
+ s_pSrchItem->SetCommand( nOldCmd );
+ s_pSrchItem->SetSelection(bHasSelection);
+ }
+ /*
+ * remove current selection
+ * otherwise it is always replaced
+ * no matter if the search string exists or not in the selection
+ * Now the selection is removed and the next matching string is selected
+ */
+
+ if( bReqReplace )
+ {
+
+ bool bReplaced = m_pWrtShell->SwEditShell::Replace( s_pSrchItem->GetReplaceString(),
+ s_pSrchItem->GetRegExp());
+ if( bReplaced && s_xReplaceList && s_xReplaceList->Count() && m_pWrtShell->HasSelection() )
+ {
+ SfxItemSet aReplSet( m_pWrtShell->GetAttrPool(),
+ aTextFormatCollSetRange );
+ if( s_xReplaceList->Get( aReplSet ).Count() )
+ {
+ ::SfxToSwPageDescAttr( *m_pWrtShell, aReplSet );
+ m_pWrtShell->SwEditShell::SetAttrSet( aReplSet );
+ }
+ }
+ }
+ }
+
+ m_pWrtShell->EndAllAction();
+}
+
+SwSearchOptions::SwSearchOptions( SwWrtShell const * pSh, bool bBackward )
+ : eStart(SwDocPositions::Curr)
+{
+ if( bBackward )
+ {
+ eEnd = SwDocPositions::Start;
+ bDontWrap = pSh->IsEndOfDoc();
+ }
+ else
+ {
+ eEnd = SwDocPositions::End;
+ bDontWrap = pSh->IsStartOfDoc();
+ }
+}
+
+sal_uLong SwView::FUNC_Search( const SwSearchOptions& rOptions )
+{
+#if HAVE_FEATURE_DESKTOP
+ SvxSearchDialogWrapper::SetSearchLabel(SearchLabel::Empty);
+#endif
+ bool bDoReplace = s_pSrchItem->GetCommand() == SvxSearchCmd::REPLACE ||
+ s_pSrchItem->GetCommand() == SvxSearchCmd::REPLACE_ALL;
+
+ FindRanges eRanges = s_pSrchItem->GetSelection()
+ ? FindRanges::InSel
+ : s_bExtra
+ ? FindRanges::InOther : FindRanges::InBody;
+ if (s_pSrchItem->GetCommand() == SvxSearchCmd::FIND_ALL ||
+ s_pSrchItem->GetCommand() == SvxSearchCmd::REPLACE_ALL)
+ eRanges |= FindRanges::InSelAll;
+
+ m_pWrtShell->SttSelect();
+
+ static const WhichRangesContainer aSearchAttrRange(svl::Items<
+ RES_CHRATR_BEGIN, RES_CHRATR_END-1,
+ RES_PARATR_BEGIN, RES_PARATR_END-1,
+ RES_FRMATR_BEGIN, RES_FRMATR_END-1,
+ SID_ATTR_PARA_MODEL, SID_ATTR_PARA_KEEP
+ >);
+
+ SfxItemSet aSrchSet( m_pWrtShell->GetAttrPool(), aSearchAttrRange);
+ if( s_xSearchList && s_xSearchList->Count() )
+ {
+ s_xSearchList->Get( aSrchSet );
+
+ // -- Page break with page template
+ ::SfxToSwPageDescAttr( *m_pWrtShell, aSrchSet );
+ }
+
+ std::optional<SfxItemSet> xReplSet;
+ if( bDoReplace && s_xReplaceList && s_xReplaceList->Count() )
+ {
+ xReplSet.emplace( m_pWrtShell->GetAttrPool(), aSearchAttrRange );
+ s_xReplaceList->Get( *xReplSet );
+
+ // -- Page break with page template
+ ::SfxToSwPageDescAttr( *m_pWrtShell, *xReplSet );
+
+ if( !xReplSet->Count() ) // too bad, we don't know
+ xReplSet.reset(); // the attributes
+ }
+
+ // build SearchOptions to be used
+
+ i18nutil::SearchOptions2 aSearchOpt( s_pSrchItem->GetSearchOptions() );
+ aSearchOpt.Locale = GetAppLanguageTag().getLocale();
+ if( !bDoReplace )
+ aSearchOpt.replaceString.clear();
+
+ sal_Int32 nFound;
+ if( aSrchSet.Count() || ( xReplSet && xReplSet->Count() ))
+ {
+ nFound = m_pWrtShell->SearchAttr(
+ aSrchSet,
+ !s_pSrchItem->GetPattern(),
+ rOptions.eStart,
+ rOptions.eEnd,
+ eRanges,
+ !s_pSrchItem->GetSearchString().isEmpty() ? &aSearchOpt : nullptr,
+ xReplSet ? &*xReplSet : nullptr );
+ }
+ else if( s_pSrchItem->GetPattern() )
+ {
+ // Searching (and replacing) templates
+ const OUString& sRplStr( s_pSrchItem->GetReplaceString() );
+ nFound = m_pWrtShell->SearchTempl( s_pSrchItem->GetSearchString(),
+ rOptions.eStart,
+ rOptions.eEnd,
+ eRanges,
+ bDoReplace ? &sRplStr : nullptr );
+ }
+ else
+ {
+ // Normal search
+ nFound = m_pWrtShell->SearchPattern(aSearchOpt, s_pSrchItem->GetNotes(),
+ rOptions.eStart,
+ rOptions.eEnd,
+ eRanges,
+ bDoReplace );
+ }
+ m_pWrtShell->EndSelect();
+ return nFound;
+}
+
+SvxSearchDialog* SwView::GetSearchDialog()
+{
+#if HAVE_FEATURE_DESKTOP
+ const sal_uInt16 nId = SvxSearchDialogWrapper::GetChildWindowId();
+ SfxViewFrame* pViewFrm = SfxViewFrame::Current();
+ if (!pViewFrm)
+ return nullptr;
+ SvxSearchDialogWrapper *pWrp = static_cast<SvxSearchDialogWrapper*>(pViewFrm->GetChildWindow(nId));
+ if (!pWrp)
+ return nullptr;
+ return pWrp->getDialog();
+#else
+ return nullptr;
+#endif
+}
+
+void SwView::StateSearch(SfxItemSet &rSet)
+{
+ SfxWhichIter aIter(rSet);
+ sal_uInt16 nWhich = aIter.FirstWhich();
+
+ while(nWhich)
+ {
+ switch(nWhich)
+ {
+ case SID_SEARCH_OPTIONS:
+ {
+ SearchOptionFlags nOpt = SearchOptionFlags::ALL;
+ if( GetDocShell()->IsReadOnly() )
+ nOpt &= ~SearchOptionFlags( SearchOptionFlags::REPLACE |
+ SearchOptionFlags::REPLACE_ALL );
+ rSet.Put( SfxUInt16Item( SID_SEARCH_OPTIONS, static_cast<sal_uInt16>(nOpt) ));
+ }
+ break;
+ case SID_SEARCH_ITEM:
+ {
+ if ( !s_pSrchItem )
+ {
+ s_pSrchItem = new SvxSearchItem( SID_SEARCH_ITEM );
+ s_pSrchItem->SetFamily(SfxStyleFamily::Para);
+ s_pSrchItem->SetSearchString( m_pWrtShell->GetSelText() );
+ }
+
+ if( s_bJustOpened && m_pWrtShell->IsSelection() )
+ {
+ OUString aText;
+ if( 1 == m_pWrtShell->GetCursorCnt() &&
+ !( aText = m_pWrtShell->SwCursorShell::GetSelText() ).isEmpty() )
+ {
+ s_pSrchItem->SetSearchString( aText );
+ s_pSrchItem->SetSelection( false );
+ }
+ else
+ s_pSrchItem->SetSelection( true );
+ }
+
+ s_bJustOpened = false;
+ rSet.Put( *s_pSrchItem );
+ }
+ break;
+ }
+ nWhich = aIter.NextWhich();
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/viewstat.cxx b/sw/source/uibase/uiview/viewstat.cxx
new file mode 100644
index 0000000000..3c624274f4
--- /dev/null
+++ b/sw/source/uibase/uiview/viewstat.cxx
@@ -0,0 +1,691 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <memory>
+
+#include <hintids.hxx>
+#include <com/sun/star/linguistic2/XThesaurus.hpp>
+#include <svl/whiter.hxx>
+#include <svl/cjkoptions.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <svl/imageitm.hxx>
+#include <sfx2/linkmgr.hxx>
+#include <editeng/langitem.hxx>
+#include <editeng/brushitem.hxx>
+#include <editeng/tstpitem.hxx>
+#include <sfx2/htmlmode.hxx>
+#include <swmodule.hxx>
+#include <tox.hxx>
+#include <sfx2/dispatch.hxx>
+#include <view.hxx>
+#include <wrtsh.hxx>
+#include <uitool.hxx>
+#include <viewopt.hxx>
+#include <pagedesc.hxx>
+#include <wview.hxx>
+#include <globdoc.hxx>
+#include <svl/stritem.hxx>
+#include <unotools/moduleoptions.hxx>
+#include <comphelper/lok.hxx>
+#include <LibreOfficeKit/LibreOfficeKitEnums.h>
+#include <svl/visitem.hxx>
+#include <redline.hxx>
+#include <rootfrm.hxx>
+#include <docary.hxx>
+#include <sfx2/infobar.hxx>
+#include <docsh.hxx>
+#include <strings.hrc>
+
+#include <cmdid.h>
+#include <IDocumentRedlineAccess.hxx>
+
+#include <doc.hxx>
+#include <workctrl.hxx>
+
+using namespace ::com::sun::star;
+
+void SwView::GetState(SfxItemSet &rSet)
+{
+ SfxWhichIter aIter(rSet);
+ sal_uInt16 nWhich = aIter.FirstWhich();
+ FrameTypeFlags eFrameType = FrameTypeFlags::NONE;
+ bool bGetFrameType = false;
+ bool bWeb = dynamic_cast<SwWebView*>( this ) != nullptr;
+
+ while(nWhich)
+ {
+ switch(nWhich)
+ {
+ case SID_ZOOM_IN:
+ case SID_ZOOM_OUT:
+ {
+ tools::Long nFact = m_pWrtShell->GetViewOptions()->GetZoom();
+ if ((SID_ZOOM_IN == nWhich && nFact >= tools::Long(600)) ||
+ (SID_ZOOM_OUT == nWhich && nFact <= tools::Long(20)))
+ {
+ rSet.DisableItem(nWhich);
+ }
+ }
+ break;
+ case FN_TOGGLE_OUTLINE_CONTENT_VISIBILITY:
+ {
+ bool bDisable(true);
+ if (m_pWrtShell->GetViewOptions()->IsShowOutlineContentVisibilityButton())
+ {
+ SwOutlineNodes::size_type nPos = m_pWrtShell->GetOutlinePos();
+ if (nPos != SwOutlineNodes::npos)
+ bDisable = false;
+ }
+ if (bDisable)
+ rSet.DisableItem(nWhich);
+ }
+ break;
+ case FN_NAV_ELEMENT:
+ // used to update all instances of this control
+ rSet.InvalidateItem( nWhich );
+ break;
+ case FN_SCROLL_PREV:
+ case FN_SCROLL_NEXT:
+ {
+ if (s_nMoveType == NID_RECENCY)
+ {
+ if (!m_pWrtShell->GetNavigationMgr().forwardEnabled())
+ rSet.DisableItem(FN_SCROLL_NEXT);
+ if (!m_pWrtShell->GetNavigationMgr().backEnabled())
+ rSet.DisableItem(FN_SCROLL_PREV);
+ }
+ }
+ break;
+ case FN_EDIT_LINK_DLG:
+ if( m_pWrtShell->GetLinkManager().GetLinks().empty() )
+ rSet.DisableItem(nWhich);
+ else if( m_pWrtShell->IsSelFrameMode() &&
+ m_pWrtShell->IsSelObjProtected(FlyProtectFlags::Content) != FlyProtectFlags::NONE)
+ {
+ rSet.DisableItem(nWhich);
+ }
+ break;
+
+ case SID_DRAWTBX_LINES:
+ if ( bWeb )
+ rSet.DisableItem(nWhich);
+ break;
+
+ case SID_INSERT_GRAPHIC:
+ if( m_pWrtShell->CursorInsideInputField() )
+ {
+ rSet.DisableItem(nWhich);
+ }
+ break;
+ case SID_INSERT_SIGNATURELINE:
+ if( !( m_nSelectionType & SelectionType::Text ||
+ m_nSelectionType & SelectionType::NumberList ) )
+ {
+ rSet.DisableItem(nWhich);
+ }
+ break;
+ case SID_EDIT_SIGNATURELINE:
+ case SID_SIGN_SIGNATURELINE:
+ if (!isSignatureLineSelected() || isSignatureLineSigned())
+ rSet.DisableItem(nWhich);
+ break;
+ case SID_INSERT_QRCODE:
+ if( !( m_nSelectionType & SelectionType::Text ||
+ m_nSelectionType & SelectionType::NumberList ) )
+ {
+ rSet.DisableItem(nWhich);
+ }
+ break;
+ case SID_EDIT_QRCODE:
+ if (!isQRCodeSelected())
+ rSet.DisableItem(nWhich);
+ break;
+ case FN_INSERT_CAPTION:
+ {
+ // There are captions for graphics, OLE objects, frames and tables
+ if( !bGetFrameType )
+ {
+ eFrameType = m_pWrtShell->GetFrameType(nullptr, true);
+ bGetFrameType = true;
+ }
+ if (! ( ((eFrameType & FrameTypeFlags::FLY_ANY) && m_nSelectionType != SelectionType::DrawObjectEditMode)||
+ m_nSelectionType & SelectionType::Table ||
+ m_nSelectionType & SelectionType::DrawObject) )
+ {
+ rSet.DisableItem(nWhich);
+ }
+ else if((m_pWrtShell->IsObjSelected() || m_pWrtShell->IsFrameSelected()) &&
+ (m_pWrtShell->IsSelObjProtected( FlyProtectFlags::Parent) != FlyProtectFlags::NONE ||
+ m_pWrtShell->IsSelObjProtected( FlyProtectFlags::Content ) != FlyProtectFlags::NONE))
+ {
+ rSet.DisableItem(nWhich);
+ }
+ else if( m_pWrtShell->IsTableMode()
+ || isSignatureLineSelected()
+ || m_pWrtShell->CursorInsideInputField() )
+ {
+ rSet.DisableItem(nWhich);
+ }
+ }
+ break;
+
+ case FN_EDIT_FOOTNOTE:
+ {
+ if( !m_pWrtShell->GetCurFootnote() )
+ rSet.DisableItem(nWhich);
+ }
+ break;
+
+ case FN_CHANGE_PAGENUM:
+ {
+ FrameTypeFlags nType = m_pWrtShell->GetFrameType(nullptr,true);
+ if( ( FrameTypeFlags::FLY_ANY | FrameTypeFlags::HEADER | FrameTypeFlags::FOOTER |
+ FrameTypeFlags::FOOTNOTE | FrameTypeFlags::DRAWOBJ ) & nType )
+ rSet.DisableItem(nWhich);
+ else
+ rSet.Put(SfxUInt16Item(nWhich, m_pWrtShell->GetPageOffset()));
+ }
+ break;
+ case SID_PRINTDOC:
+ case SID_PRINTDOCDIRECT:
+ GetSlotState( nWhich, SfxViewShell::GetInterface(), &rSet );
+ break;
+ case SID_ATTR_PAGE_ORIENTATION:
+ case SID_ATTR_PAGE:
+ case SID_ATTR_PAGE_SIZE:
+ case SID_ATTR_PAGE_PAPERBIN:
+ case RES_PAPER_BIN:
+ case FN_PARAM_FTN_INFO:
+ {
+ const size_t nCurIdx = m_pWrtShell->GetCurPageDesc();
+ const SwPageDesc& rDesc = m_pWrtShell->GetPageDesc( nCurIdx );
+
+ // set correct parent to get the XFILL_NONE FillStyle as needed
+ if(!rSet.GetParent())
+ {
+ const SwFrameFormat& rMaster = rDesc.GetMaster();
+
+ rSet.SetParent(&rMaster.GetDoc()->GetDfltFrameFormat()->GetAttrSet());
+ }
+
+ ::PageDescToItemSet( rDesc, rSet);
+
+ if (nWhich == SID_ATTR_PAGE_ORIENTATION && comphelper::LibreOfficeKit::isActive())
+ {
+ OString aPayload = ".uno:Orientation="_ostr;
+ if (rDesc.GetLandscape())
+ {
+ aPayload += "IsLandscape";
+ }
+ else
+ {
+ aPayload += "IsPortrait";
+ }
+ libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED, aPayload);
+ }
+ }
+ break;
+ case RES_BACKGROUND:
+ case SID_ATTR_BRUSH:
+ {
+ const size_t nCurIdx = m_pWrtShell->GetCurPageDesc();
+ const SwPageDesc& rDesc = m_pWrtShell->GetPageDesc( nCurIdx );
+ const SwFrameFormat& rMaster = rDesc.GetMaster();
+ const SvxBrushItem& rBrush = rMaster.GetFormatAttr(RES_BACKGROUND);
+ rSet.Put(rBrush);
+ }
+ break;
+ case SID_CLEARHISTORY:
+ {
+ rSet.Put(SfxBoolItem(nWhich, m_pWrtShell->GetLastUndoInfo(nullptr, nullptr)));
+ }
+ break;
+ case SID_UNDO:
+ {
+ // which must not be present, so let them create:
+ if( !m_pShell )
+ SelectShell();
+
+ const SfxPoolItemHolder aResult(m_pShell->GetSlotState(SID_UNDO));
+ if(nullptr != aResult.getItem())
+ rSet.Put(*aResult.getItem());
+ else
+ rSet.DisableItem(nWhich);
+ }
+ break;
+ case FN_INSERT_OBJ_CTRL:
+ if( bWeb
+ || m_pWrtShell->CursorInsideInputField() )
+ {
+ rSet.DisableItem(nWhich);
+ }
+ break;
+
+ case FN_UPDATE_TOX:
+ if(!m_pWrtShell->GetTOXCount())
+ rSet.DisableItem(nWhich);
+ break;
+ case FN_EDIT_CURRENT_TOX:
+ case FN_UPDATE_CUR_TOX:
+ {
+ const SwTOXBase* pBase = nullptr;
+ if(nullptr == (pBase = m_pWrtShell->GetCurTOX()) ||
+ (FN_EDIT_CURRENT_TOX == nWhich && pBase->IsTOXBaseInReadonly()))
+ rSet.DisableItem(nWhich);
+ }
+ break;
+ case SID_TWAIN_SELECT:
+ case SID_TWAIN_TRANSFER:
+#if defined(_WIN32) || defined UNX
+ {
+ if(!SW_MOD()->GetScannerManager().is())
+ rSet.DisableItem(nWhich);
+ }
+#endif
+ break;
+ case RES_PARATR_TABSTOP:
+ case SID_ATTR_DEFTABSTOP:
+ {
+ const SvxTabStopItem& rDefTabs = m_pWrtShell->GetDefault(RES_PARATR_TABSTOP);
+ rSet.Put( SfxUInt16Item( nWhich,
+ o3tl::narrowing<sal_uInt16>(::GetTabDist(rDefTabs))));
+ }
+ break;
+ case SID_ATTR_LANGUAGE:
+ {
+ rSet.Put(m_pWrtShell->GetDefault(RES_CHRATR_LANGUAGE).CloneSetWhich(SID_ATTR_LANGUAGE));
+ }
+ break;
+ case RES_CHRATR_CJK_LANGUAGE:
+ {
+ rSet.Put(m_pWrtShell->GetDefault(RES_CHRATR_CJK_LANGUAGE)
+ .CloneSetWhich(RES_CHRATR_CJK_LANGUAGE));
+ }
+ break;
+ case RES_CHRATR_CTL_LANGUAGE:
+ {
+ rSet.Put(m_pWrtShell->GetDefault(RES_CHRATR_CTL_LANGUAGE)
+ .CloneSetWhich(RES_CHRATR_CTL_LANGUAGE));
+ }
+ break;
+ case FN_REDLINE_ON:
+ rSet.Put( SfxBoolItem( nWhich, GetDocShell()->IsChangeRecording() ) );
+ // When the view is new (e.g. on load), show the Hidden Track Changes infobar
+ // if Show Changes is disabled, but recording of changes is enabled
+ // or hidden tracked changes are there already in the document.
+ // Note: the infobar won't be shown, if the Track Changes toolbar is already
+ // enabled, see in sfx2.
+ if ( m_bForceChangesToolbar && m_pWrtShell->GetLayout()->IsHideRedlines() )
+ {
+ bool isRecording = GetDocShell()->IsChangeRecording();
+ bool hasRecorded =
+ m_pWrtShell->GetDoc()->getIDocumentRedlineAccess().GetRedlineTable().size();
+ if ( isRecording || hasRecorded )
+ {
+ GetDocShell()->AppendInfoBarWhenReady(
+ "hiddentrackchanges", SwResId(STR_HIDDEN_CHANGES),
+ SwResId( (isRecording && hasRecorded)
+ ? STR_HIDDEN_CHANGES_DETAIL
+ : isRecording
+ ? STR_HIDDEN_CHANGES_DETAIL2
+ : STR_HIDDEN_CHANGES_DETAIL3 ),
+ InfobarType::INFO);
+ }
+ }
+ m_bForceChangesToolbar = false;
+ break;
+ case FN_REDLINE_PROTECT :
+ rSet.Put( SfxBoolItem( nWhich, GetDocShell()->HasChangeRecordProtection() ) );
+ break;
+ case FN_REDLINE_SHOW:
+ {
+ rSet.Put(SfxBoolItem(nWhich, !m_pWrtShell->GetLayout()->IsHideRedlines()));
+ }
+ break;
+ case SID_AVMEDIA_PLAYER :
+ case FN_REDLINE_ACCEPT :
+ {
+ SfxViewFrame& rVFrame = GetViewFrame();
+ if (rVFrame.KnowsChildWindow(nWhich))
+ rSet.Put(SfxBoolItem( nWhich, rVFrame.HasChildWindow(nWhich)));
+ else
+ rSet.DisableItem(nWhich);
+ }
+ break;
+ case FN_REDLINE_ACCEPT_DIRECT:
+ case FN_REDLINE_REJECT_DIRECT:
+ case FN_REDLINE_ACCEPT_TONEXT:
+ case FN_REDLINE_REJECT_TONEXT:
+ {
+ SwDoc *pDoc = m_pWrtShell->GetDoc();
+ SwPaM *pCursor = m_pWrtShell->GetCursor();
+ bool bDisable = false;
+ if (GetDocShell()->HasChangeRecordProtection())
+ bDisable = true;
+ else if (pCursor->HasMark())
+ {
+ // If the selection does not contain redlines, disable accepting/rejecting changes.
+ SwRedlineTable::size_type index = 0;
+ const SwRedlineTable& table = pDoc->getIDocumentRedlineAccess().GetRedlineTable();
+ const SwRangeRedline* redline = table.FindAtPosition( *pCursor->Start(), index );
+ if( redline != nullptr && *redline->Start() == *pCursor->End())
+ redline = nullptr;
+ if( redline == nullptr )
+ {
+ // for table selections, GetCursor() gives only PaM of the first cell,
+ // so extend the redline limit to end of last cell of the selection
+ // TODO: adjust this for column selections, where the selected columns
+ // don't contain any redlines and any tracked row changes, but the
+ // adjacent not selected columns do to avoid false Enable
+ std::optional<SwPosition> oSelectionEnd;
+ if ( m_pWrtShell->IsTableMode() &&
+ m_pWrtShell->GetTableCursor()->GetSelectedBoxesCount() )
+ {
+ const SwSelBoxes& rBoxes = m_pWrtShell->GetTableCursor()->GetSelectedBoxes();
+ const SwStartNode *pSttNd = rBoxes.back()->GetSttNd();
+ const SwNode* pEndNode = pSttNd->GetNodes()[pSttNd->EndOfSectionIndex()];
+ oSelectionEnd.emplace(*pEndNode);
+ }
+ else
+ oSelectionEnd.emplace(*pCursor->End());
+
+ for(; index < table.size(); ++index )
+ {
+ const SwRangeRedline* tmp = table[ index ];
+ if( *tmp->Start() >= *oSelectionEnd )
+ break;
+ if( tmp->HasMark() && tmp->IsVisible())
+ {
+ redline = tmp;
+ break;
+ }
+ }
+ }
+ if( redline == nullptr )
+ bDisable = true;
+ }
+ else
+ {
+ // If the cursor position isn't on a redline, disable
+ // accepting/rejecting changes.
+ SwTableBox* pTableBox;
+ if (nullptr == pDoc->getIDocumentRedlineAccess().GetRedline(*pCursor->Start(), nullptr) &&
+ // except in the case of an inserted or deleted table row
+ ( !m_pWrtShell->IsCursorInTable() ||
+ (pTableBox = pCursor->Start()->GetNode().GetTableBox() ) == nullptr ||
+ (RedlineType::None == pTableBox->GetRedlineType() &&
+ RedlineType::None == pTableBox->GetUpper()->GetRedlineType()) ) )
+ {
+ bDisable = true;
+ }
+ }
+
+ // LibreOfficeKit wants to handle changes by index, so always allow here.
+ if (bDisable)
+ rSet.DisableItem(nWhich);
+ if (comphelper::LibreOfficeKit::isActive())
+ {
+ OString aPayload(".uno:TrackedChangeIndex="_ostr);
+ SwRedlineTable::size_type nRedline = 0;
+ if (pDoc->getIDocumentRedlineAccess().GetRedline(*pCursor->Start(), &nRedline))
+ aPayload += OString::number(nRedline);
+ libreOfficeKitViewCallback(LOK_CALLBACK_STATE_CHANGED, aPayload);
+ }
+ }
+ break;
+
+ case FN_REDLINE_NEXT_CHANGE:
+ case FN_REDLINE_PREV_CHANGE:
+ {
+ // Enable change navigation if we have any redlines. Ideally we should disable
+ // "Next Change" if we're at or past the last change, and similarly for
+ // "Previous Change"
+ if (0 == m_pWrtShell->GetRedlineCount())
+ rSet.DisableItem(nWhich);
+ }
+ break;
+
+ case SID_THESAURUS:
+ {
+ SwWrtShell &rSh = GetWrtShell();
+ if (2 <= rSh.GetCursorCnt()) // multi selection?
+ rSet.DisableItem(nWhich);
+ else
+ {
+ LanguageType nLang = rSh.GetCurLang();
+
+ // disable "Thesaurus" (menu entry and key shortcut) if the
+ // language is not supported (by default it is enabled)
+ uno::Reference< linguistic2::XThesaurus > xThes( ::GetThesaurus() );
+ if (!xThes.is() || nLang == LANGUAGE_NONE ||
+ !xThes->hasLocale( LanguageTag::convertToLocale( nLang ) ))
+ rSet.DisableItem(nWhich);
+ }
+ }
+ break;
+ case SID_HANGUL_HANJA_CONVERSION:
+ case SID_CHINESE_CONVERSION:
+ {
+ if (!SvtCJKOptions::IsAnyEnabled())
+ {
+ GetViewFrame().GetBindings().SetVisibleState( nWhich, false );
+ rSet.DisableItem(nWhich);
+ }
+ else
+ GetViewFrame().GetBindings().SetVisibleState( nWhich, true );
+ }
+ break;
+ case SID_MAIL_SCROLLBODY_PAGEDOWN:
+ {
+ const tools::Long nBottom = m_pWrtShell->GetDocSize().Height() + DOCUMENTBORDER;
+ const tools::Long nAct = GetVisArea().Bottom();
+ rSet.Put(SfxBoolItem(SID_MAIL_SCROLLBODY_PAGEDOWN, nAct < nBottom ));
+ }
+ break;
+
+ case SID_DOCUMENT_COMPARE:
+ case SID_DOCUMENT_MERGE:
+ if( dynamic_cast<const SwGlobalDocShell* >(GetDocShell()) != nullptr||
+ (SID_DOCUMENT_MERGE == nWhich && m_pWrtShell->getIDocumentRedlineAccess().GetRedlinePassword().hasElements()))
+ rSet.DisableItem(nWhich);
+ break;
+ case SID_VIEW_DATA_SOURCE_BROWSER:
+ if ( !SvtModuleOptions().IsModuleInstalled( SvtModuleOptions::EModule::DATABASE ) )
+ rSet.Put( SfxVisibilityItem( nWhich, false ) );
+ else
+ rSet.Put( SfxBoolItem( nWhich, GetViewFrame().HasChildWindow( SID_BROWSER ) ) );
+ break;
+ case SID_READONLY_MODE:
+ rSet.Put(SfxBoolItem(nWhich,
+ m_pWrtShell->HasReadonlySel()||GetDocShell()->IsReadOnly()));
+ break;
+ case SID_IMAGE_ORIENTATION:
+ {
+ SfxImageItem aImageItem(nWhich);
+ if(m_pWrtShell->IsInVerticalText())
+ aImageItem.SetRotation( 2700_deg10 );
+ if(m_pWrtShell->IsInRightToLeftText())
+ aImageItem.SetMirrored( true );
+ rSet.Put(aImageItem);
+ }
+ break;
+ case FN_INSERT_FIELD_DATA_ONLY :
+ if(!m_bInMailMerge && !GetViewFrame().HasChildWindow(nWhich))
+ rSet.DisableItem(nWhich);
+ break;
+ case FN_MAILMERGE_SENDMAIL_CHILDWINDOW:
+ break;
+ case SID_ALIGN_ANY_LEFT :
+ case SID_ALIGN_ANY_HCENTER :
+ case SID_ALIGN_ANY_RIGHT :
+ case SID_ALIGN_ANY_JUSTIFIED:
+ case SID_ALIGN_ANY_TOP :
+ case SID_ALIGN_ANY_VCENTER :
+ case SID_ALIGN_ANY_BOTTOM :
+ case SID_ALIGN_ANY_HDEFAULT :
+ case SID_ALIGN_ANY_VDEFAULT :
+ {
+ if( !m_pShell )
+ SelectShell();
+ sal_uInt16 nAlias = 0;
+ if( m_nSelectionType & (SelectionType::DrawObjectEditMode|SelectionType::Text) )
+ {
+ switch( nWhich )
+ {
+ case SID_ALIGN_ANY_LEFT : nAlias = SID_ATTR_PARA_ADJUST_LEFT; break;
+ case SID_ALIGN_ANY_HCENTER : nAlias = SID_ATTR_PARA_ADJUST_CENTER; break;
+ case SID_ALIGN_ANY_RIGHT : nAlias = SID_ATTR_PARA_ADJUST_RIGHT; break;
+ case SID_ALIGN_ANY_JUSTIFIED: nAlias = SID_ATTR_PARA_ADJUST_BLOCK; break;
+ case SID_ALIGN_ANY_TOP : nAlias = SID_TABLE_VERT_NONE; break;
+ case SID_ALIGN_ANY_VCENTER : nAlias = SID_TABLE_VERT_CENTER; break;
+ case SID_ALIGN_ANY_BOTTOM : nAlias = SID_TABLE_VERT_BOTTOM; break;
+ }
+ }
+ else
+ {
+ switch( nWhich )
+ {
+ case SID_ALIGN_ANY_LEFT : nAlias = SID_OBJECT_ALIGN_LEFT ; break;
+ case SID_ALIGN_ANY_HCENTER : nAlias = SID_OBJECT_ALIGN_CENTER ; break;
+ case SID_ALIGN_ANY_RIGHT : nAlias = SID_OBJECT_ALIGN_RIGHT ; break;
+ case SID_ALIGN_ANY_TOP : nAlias = SID_OBJECT_ALIGN_UP ; break;
+ case SID_ALIGN_ANY_VCENTER : nAlias = SID_OBJECT_ALIGN_MIDDLE ; break;
+ case SID_ALIGN_ANY_BOTTOM : nAlias = SID_OBJECT_ALIGN_DOWN ; break;
+ }
+ }
+ //these slots are either re-mapped to text or object alignment
+ SfxPoolItemHolder aResult;
+ if(nAlias)
+ GetViewFrame().GetDispatcher()->QueryState(nAlias, aResult);
+ if(nullptr != aResult.getItem())
+ {
+ if (!(m_nSelectionType & SelectionType::DrawObject))
+ {
+ rSet.Put(aResult.getItem()->CloneSetWhich(nWhich));
+ }
+ }
+ else
+ rSet.DisableItem(nWhich);
+ }
+ break;
+ }
+ nWhich = aIter.NextWhich();
+ }
+}
+
+void SwView::GetDrawState(SfxItemSet &rSet)
+{
+ SfxWhichIter aIter(rSet);
+ bool bWeb = dynamic_cast<SwWebView*>( this ) != nullptr;
+
+ for( sal_uInt16 nWhich = aIter.FirstWhich(); nWhich;
+ nWhich = aIter.NextWhich() )
+ switch(nWhich)
+ {
+ case SID_DRAW_LINE:
+ case SID_DRAW_XLINE:
+ case SID_LINE_ARROW_END:
+ case SID_LINE_ARROW_CIRCLE:
+ case SID_LINE_ARROW_SQUARE:
+ case SID_LINE_ARROW_START:
+ case SID_LINE_CIRCLE_ARROW:
+ case SID_LINE_SQUARE_ARROW:
+ case SID_LINE_ARROWS:
+ case SID_DRAW_MEASURELINE:
+ case SID_DRAW_RECT:
+ case SID_DRAW_ELLIPSE:
+ case SID_DRAW_XPOLYGON_NOFILL:
+ case SID_DRAW_XPOLYGON:
+ case SID_DRAW_POLYGON_NOFILL:
+ case SID_DRAW_POLYGON:
+ case SID_DRAW_BEZIER_NOFILL:
+ case SID_DRAW_BEZIER_FILL:
+ case SID_DRAW_FREELINE_NOFILL:
+ case SID_DRAW_FREELINE:
+ case SID_DRAW_ARC:
+ case SID_DRAW_PIE:
+ case SID_DRAW_CIRCLECUT:
+ case SID_DRAW_TEXT:
+ case SID_DRAW_CAPTION:
+ if ( bWeb )
+ rSet.DisableItem( nWhich );
+ else
+ if (nWhich != SID_DRAW_TEXT) //tdf#113171
+ rSet.Put( SfxBoolItem( nWhich, m_nDrawSfxId == nWhich ) );
+ break;
+
+ case SID_DRAW_TEXT_VERTICAL:
+ case SID_DRAW_CAPTION_VERTICAL:
+ if ( bWeb || !SvtCJKOptions::IsVerticalTextEnabled() )
+ rSet.DisableItem( nWhich );
+ else
+ if (nWhich != SID_DRAW_TEXT_VERTICAL) //tdf#113171
+ rSet.Put( SfxBoolItem( nWhich, m_nDrawSfxId == nWhich ) );
+ break;
+
+ case SID_DRAW_TEXT_MARQUEE:
+ if (::GetHtmlMode(GetDocShell()) & HTMLMODE_SOME_STYLES)
+ rSet.Put( SfxBoolItem(nWhich, m_nDrawSfxId == nWhich));
+ else
+ rSet.DisableItem(nWhich);
+ break;
+ case SID_OBJECT_SELECT:
+ rSet.Put( SfxBoolItem(nWhich, m_nDrawSfxId == nWhich ||
+ m_nFormSfxId == nWhich));
+ break;
+
+ case SID_INSERT_DRAW:
+ case SID_FONTWORK_GALLERY_FLOATER :
+ case SID_DRAWTBX_ARROWS:
+ {
+ if ( bWeb )
+ rSet.DisableItem( nWhich );
+ }
+ break;
+
+ case SID_DRAWTBX_CS_BASIC :
+ case SID_DRAWTBX_CS_SYMBOL :
+ case SID_DRAWTBX_CS_ARROW :
+ case SID_DRAWTBX_CS_FLOWCHART :
+ case SID_DRAWTBX_CS_CALLOUT :
+ case SID_DRAWTBX_CS_STAR :
+ {
+ if ( bWeb )
+ rSet.DisableItem( nWhich );
+ else
+ rSet.Put( SfxStringItem( nWhich, m_nDrawSfxId == nWhich ? m_sDrawCustom : OUString() ) );
+ }
+ break;
+
+ }
+}
+
+bool SwView::HasUIFeature(SfxShellFeature nFeature) const
+{
+ assert((nFeature & ~SfxShellFeature::SwMask) == SfxShellFeature::NONE);
+ switch(nFeature)
+ {
+ case SfxShellFeature::SwChildWindowLabel:
+ return m_pWrtShell->IsLabelDoc();
+ default:
+ return false;
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/uiview/viewtab.cxx b/sw/source/uibase/uiview/viewtab.cxx
new file mode 100644
index 0000000000..52a26eabb6
--- /dev/null
+++ b/sw/source/uibase/uiview/viewtab.cxx
@@ -0,0 +1,2562 @@
+/* -*- 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 <hintids.hxx>
+#include <uitool.hxx>
+#include <svx/rulritem.hxx>
+#include <svx/xflclit.hxx>
+#include <svx/xflgrit.hxx>
+#include <svx/xflhtit.hxx>
+#include <svx/xbtmpit.hxx>
+#include <svx/xfillit0.hxx>
+#include <tools/UnitConversion.hxx>
+#include <editeng/tstpitem.hxx>
+#include <sfx2/request.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <editeng/lrspitem.hxx>
+#include <editeng/ulspitem.hxx>
+#include <editeng/boxitem.hxx>
+#include <editeng/frmdiritem.hxx>
+#include <svl/eitem.hxx>
+#include <svl/whiter.hxx>
+#include <svx/ruler.hxx>
+#include <editeng/protitem.hxx>
+#include <svl/rectitem.hxx>
+#include <sfx2/bindings.hxx>
+#include <fmtfsize.hxx>
+#include <fmthdft.hxx>
+#include <fmtclds.hxx>
+#include <fmtornt.hxx>
+#include <frmatr.hxx>
+#include <view.hxx>
+#include <wrtsh.hxx>
+#include <cmdid.h>
+#include <viewopt.hxx>
+#include <tabcol.hxx>
+#include <frmfmt.hxx>
+#include <pagedesc.hxx>
+#include <wview.hxx>
+#include <fmtcol.hxx>
+#include <section.hxx>
+#include <ndtxt.hxx>
+#include <pam.hxx>
+#include <comphelper/lok.hxx>
+#include <LibreOfficeKit/LibreOfficeKitEnums.h>
+#include <boost/property_tree/json_parser.hpp>
+#include <osl/diagnose.h>
+
+#include <IDocumentSettingAccess.hxx>
+
+using namespace ::com::sun::star;
+
+// Pack columns
+static void lcl_FillSvxColumn(const SwFormatCol& rCol,
+ tools::Long nTotalWidth,
+ SvxColumnItem& rColItem,
+ tools::Long nDistance)
+{
+ const SwColumns& rCols = rCol.GetColumns();
+
+ bool bOrtho = rCol.IsOrtho() && !rCols.empty();
+ tools::Long nInnerWidth = 0;
+ if( bOrtho )
+ {
+ nInnerWidth = nTotalWidth;
+ for (const auto & i : rCols)
+ {
+ nInnerWidth -= i.GetLeft() + i.GetRight();
+ }
+ if( nInnerWidth < 0 )
+ nInnerWidth = 0;
+ else
+ nInnerWidth /= rCols.size();
+ }
+
+ tools::Long nWidth = 0;
+ for ( size_t i = 0; i < rCols.size(); ++i )
+ {
+ const SwColumn* pCol = &rCols[i];
+ const tools::Long nStart = pCol->GetLeft() + nWidth + nDistance;
+ if( bOrtho )
+ nWidth += nInnerWidth + pCol->GetLeft() + pCol->GetRight();
+ else
+ nWidth += rCol.CalcColWidth(i, static_cast< sal_uInt16 >(nTotalWidth));
+ const tools::Long nEnd = nWidth - pCol->GetRight() + nDistance;
+
+ SvxColumnDescription aColDesc(nStart, nEnd, true);
+ rColItem.Append(aColDesc);
+ }
+}
+
+// Transfer ColumnItem in ColumnInfo
+static void lcl_ConvertToCols(const SvxColumnItem& rColItem,
+ tools::Long nTotalWidth,
+ SwFormatCol& rCols)
+{
+ OSL_ENSURE( rCols.GetNumCols() == rColItem.Count(), "Column count mismatch" );
+ // ruler executes that change the columns shortly after the selection has changed
+ // can result in a crash
+ if(rCols.GetNumCols() != rColItem.Count())
+ return;
+
+ sal_uInt16 nLeft = 0;
+ SwTwips nSumAll= 0; // Sum up all columns and margins
+
+ SwColumns& rArr = rCols.GetColumns();
+
+ // Tabcols sequentially
+ for( sal_uInt16 i=0; i < rColItem.Count()-1; ++i )
+ {
+ OSL_ENSURE(rColItem[i+1].nStart >= rColItem[i].nEnd,"overlapping columns" );
+ const tools::Long nStart = std::max(rColItem[i+1].nStart, rColItem[i].nEnd);
+ const sal_uInt16 nRight = o3tl::narrowing<sal_uInt16>((nStart - rColItem[i].nEnd) / 2);
+
+ const tools::Long nWidth = rColItem[i].nEnd - rColItem[i].nStart + nLeft + nRight;
+
+ SwColumn* pCol = &rArr[i];
+ pCol->SetWishWidth( sal_uInt16(tools::Long(rCols.GetWishWidth()) * nWidth / nTotalWidth ));
+ pCol->SetLeft( nLeft );
+ pCol->SetRight( nRight );
+ nSumAll += pCol->GetWishWidth();
+
+ nLeft = nRight;
+ }
+ rArr[rColItem.Count()-1].SetLeft( nLeft );
+
+ // The difference between the total sum of the desired width and the so far
+ // calculated columns and margins should result in the width of the last column.
+ rArr[rColItem.Count()-1].SetWishWidth( rCols.GetWishWidth() - o3tl::narrowing<sal_uInt16>(nSumAll) );
+
+ rCols.SetOrtho(false, 0, 0 );
+}
+
+// Delete tabs
+static void lcl_EraseDefTabs(SvxTabStopItem& rTabStops)
+{
+ // Delete DefTabs
+ for ( sal_uInt16 i = 0; i < rTabStops.Count(); )
+ {
+ // Here also throw out the DefTab to zero
+ if ( SvxTabAdjust::Default == rTabStops[i].GetAdjustment() ||
+ rTabStops[i].GetTabPos() == 0 )
+ {
+ rTabStops.Remove(i);
+ continue;
+ }
+ ++i;
+ }
+}
+
+// Flip page margin
+void SwView::SwapPageMargin(const SwPageDesc& rDesc, SvxLRSpaceItem& rLRSpace)
+{
+ sal_uInt16 nPhyPage, nVirPage;
+ GetWrtShell().GetPageNum( nPhyPage, nVirPage );
+
+ if ( rDesc.GetUseOn() == UseOnPage::Mirror && (nPhyPage % 2) == 0 )
+ {
+ tools::Long nTmp = rLRSpace.GetRight();
+ rLRSpace.SetRight( rLRSpace.GetLeft() );
+ rLRSpace.SetLeft( nTmp );
+ }
+}
+
+// If the frame border is moved, the column separator
+// should stay in the same absolute position.
+static void lcl_Scale(tools::Long& nVal, tools::Long nScale)
+{
+ nVal *= nScale;
+ nVal >>= 8;
+}
+
+static void ResizeFrameCols(SwFormatCol& rCol,
+ tools::Long nOldWidth,
+ tools::Long nNewWidth,
+ tools::Long nLeftDelta )
+{
+ SwColumns& rArr = rCol.GetColumns();
+ tools::Long nWishSum = static_cast<tools::Long>(rCol.GetWishWidth());
+ tools::Long nWishDiff = (nWishSum * 100/nOldWidth * nNewWidth) / 100 - nWishSum;
+ tools::Long nNewWishWidth = nWishSum + nWishDiff;
+ if(nNewWishWidth > 0xffffl)
+ {
+ // If the desired width is getting too large, then all values
+ // must be scaled appropriately.
+ tools::Long nScale = (0xffffl << 8)/ nNewWishWidth;
+ for(SwColumn & i : rArr)
+ {
+ SwColumn* pCol = &i;
+ tools::Long nVal = pCol->GetWishWidth();
+ lcl_Scale(nVal, nScale);
+ pCol->SetWishWidth(o3tl::narrowing<sal_uInt16>(nVal));
+ nVal = pCol->GetLeft();
+ lcl_Scale(nVal, nScale);
+ pCol->SetLeft(o3tl::narrowing<sal_uInt16>(nVal));
+ nVal = pCol->GetRight();
+ lcl_Scale(nVal, nScale);
+ pCol->SetRight(o3tl::narrowing<sal_uInt16>(nVal));
+ }
+ lcl_Scale(nNewWishWidth, nScale);
+ lcl_Scale(nWishDiff, nScale);
+ }
+ rCol.SetWishWidth( o3tl::narrowing<sal_uInt16>(nNewWishWidth) );
+
+ if( nLeftDelta >= 2 || nLeftDelta <= -2)
+ rArr.front().SetWishWidth(rArr.front().GetWishWidth() + o3tl::narrowing<sal_uInt16>(nWishDiff));
+ else
+ rArr.back().SetWishWidth(rArr.back().GetWishWidth() + o3tl::narrowing<sal_uInt16>(nWishDiff));
+ // Reset auto width
+ rCol.SetOrtho(false, 0, 0 );
+}
+
+// Here all changes to the tab bar will be shot again into the model.
+void SwView::ExecTabWin( SfxRequest const & rReq )
+{
+ SwWrtShell &rSh = GetWrtShell();
+ const FrameTypeFlags nFrameType = rSh.IsObjSelected() ?
+ FrameTypeFlags::DRAWOBJ :
+ rSh.GetFrameType(nullptr,true);
+ const bool bFrameSelection = rSh.IsFrameSelected();
+ const bool bBrowse = rSh.GetViewOptions()->getBrowseMode();
+
+ const sal_uInt16 nSlot = rReq.GetSlot();
+ const SfxItemSet* pReqArgs = rReq.GetArgs();
+ const size_t nDescId = rSh.GetCurPageDesc();
+ const SwPageDesc& rDesc = rSh.GetPageDesc( nDescId );
+
+ const bool bVerticalWriting = rSh.IsInVerticalText();
+ const SwFormatHeader& rHeaderFormat = rDesc.GetMaster().GetHeader();
+ SwFrameFormat *pHeaderFormat = const_cast<SwFrameFormat*>(rHeaderFormat.GetHeaderFormat());
+
+ const SwFormatFooter& rFooterFormat = rDesc.GetMaster().GetFooter();
+ SwFrameFormat *pFooterFormat = const_cast<SwFrameFormat*>(rFooterFormat.GetFooterFormat());
+
+ const SwFormatFrameSize &rFrameSize = rDesc.GetMaster().GetFrameSize();
+
+ const SwRect& rPageRect = rSh.GetAnyCurRect(CurRectType::Page);
+ const tools::Long nPageWidth = bBrowse ? rPageRect.Width() : rFrameSize.GetWidth();
+ const tools::Long nPageHeight = bBrowse ? rPageRect.Height() : rFrameSize.GetHeight();
+
+ bool bUnlockView = false;
+ rSh.StartAllAction();
+ bool bSect = bool(nFrameType & FrameTypeFlags::COLSECT);
+
+ switch (nSlot)
+ {
+ case SID_ATTR_LONG_LRSPACE:
+ if ( pReqArgs )
+ {
+ SvxLongLRSpaceItem aLongLR( pReqArgs->Get( SID_ATTR_LONG_LRSPACE ) );
+ SvxLRSpaceItem aLR(RES_LR_SPACE);
+ if ( !bSect && (bFrameSelection || nFrameType & FrameTypeFlags::FLY_ANY) )
+ {
+ SwFrameFormat* pFormat = rSh.GetFlyFrameFormat();
+ const SwRect &rRect = rSh.GetAnyCurRect(CurRectType::FlyEmbedded);
+
+ bool bVerticalFrame(false);
+ {
+ bool bRTL;
+ bool bVertL2R;
+ bVerticalFrame = ( bFrameSelection &&
+ rSh.IsFrameVertical(true, bRTL, bVertL2R) ) ||
+ ( !bFrameSelection && bVerticalWriting);
+ }
+ tools::Long nDeltaX = bVerticalFrame ?
+ rRect.Right() - rPageRect.Right() + aLongLR.GetRight() :
+ rPageRect.Left() + aLongLR.GetLeft() - rRect.Left();
+
+ SfxItemSetFixed<RES_FRM_SIZE, RES_FRM_SIZE,
+ RES_VERT_ORIENT, RES_HORI_ORIENT,
+ RES_COL, RES_COL> aSet( GetPool() );
+
+ if(bVerticalFrame)
+ {
+ SwFormatVertOrient aVertOrient(pFormat->GetVertOrient());
+ aVertOrient.SetVertOrient(text::VertOrientation::NONE);
+ aVertOrient.SetPos(aVertOrient.GetPos() + nDeltaX );
+ aSet.Put( aVertOrient );
+ }
+ else
+ {
+ SwFormatHoriOrient aHoriOrient( pFormat->GetHoriOrient() );
+ aHoriOrient.SetHoriOrient( text::HoriOrientation::NONE );
+ aHoriOrient.SetPos( aHoriOrient.GetPos() + nDeltaX );
+ aSet.Put( aHoriOrient );
+ }
+
+ SwFormatFrameSize aSize( pFormat->GetFrameSize() );
+ tools::Long nOldWidth = aSize.GetWidth();
+
+ if(aSize.GetWidthPercent())
+ {
+ SwRect aRect;
+ rSh.CalcBoundRect(aRect, RndStdIds::FLY_AS_CHAR);
+ tools::Long nPrtWidth = aRect.Width();
+ aSize.SetWidthPercent(sal_uInt8((nPageWidth - aLongLR.GetLeft() - aLongLR.GetRight()) * 100 /nPrtWidth));
+ }
+ else
+ aSize.SetWidth( nPageWidth -
+ (aLongLR.GetLeft() + aLongLR.GetRight()));
+
+ if( nFrameType & FrameTypeFlags::COLUMN )
+ {
+ SwFormatCol aCol(pFormat->GetCol());
+
+ ::ResizeFrameCols(aCol, nOldWidth, aSize.GetWidth(), nDeltaX );
+ aSet.Put(aCol);
+ }
+
+ aSet.Put( aSize );
+
+ rSh.StartAction();
+ rSh.Push();
+ rSh.SetFlyFrameAttr( aSet );
+ // Cancel the frame selection
+ if(!bFrameSelection && rSh.IsFrameSelected())
+ {
+ rSh.UnSelectFrame();
+ rSh.LeaveSelFrameMode();
+ }
+ rSh.Pop();
+ rSh.EndAction();
+ }
+ else if ( nFrameType & ( FrameTypeFlags::HEADER | FrameTypeFlags::FOOTER ))
+ {
+ // Subtract out page margins
+ tools::Long nOld = rDesc.GetMaster().GetLRSpace().GetLeft();
+ aLongLR.SetLeft( nOld > aLongLR.GetLeft() ? 0 : aLongLR.GetLeft() - nOld );
+
+ nOld = rDesc.GetMaster().GetLRSpace().GetRight();
+ aLongLR.SetRight( nOld > aLongLR.GetRight() ? 0 : aLongLR.GetRight() - nOld );
+ aLR.SetLeft(aLongLR.GetLeft());
+ aLR.SetRight(aLongLR.GetRight());
+
+ if ( nFrameType & FrameTypeFlags::HEADER && pHeaderFormat )
+ pHeaderFormat->SetFormatAttr( aLR );
+ else if( nFrameType & FrameTypeFlags::FOOTER && pFooterFormat )
+ pFooterFormat->SetFormatAttr( aLR );
+ }
+ else if( nFrameType == FrameTypeFlags::DRAWOBJ)
+ {
+ SwRect aRect( rSh.GetObjRect() );
+ aRect.Left( aLongLR.GetLeft() + rPageRect.Left() );
+ aRect.Right( rPageRect.Right() - aLongLR.GetRight());
+ rSh.SetObjRect( aRect );
+ }
+ else if(bSect || rSh.IsDirectlyInSection())
+ {
+ //change the section indents and the columns if available
+ //at first determine the changes
+ SwRect aSectRect = rSh.GetAnyCurRect(CurRectType::SectionPrt);
+ const SwRect aTmpRect = rSh.GetAnyCurRect(CurRectType::Section);
+ aSectRect.Pos() += aTmpRect.Pos();
+ tools::Long nLeftDiff = aLongLR.GetLeft() - static_cast<tools::Long>(aSectRect.Left() - rPageRect.Left() );
+ tools::Long nRightDiff = aLongLR.GetRight() - static_cast<tools::Long>( rPageRect.Right() - aSectRect.Right());
+ //change the LRSpaceItem of the section accordingly
+ const SwSection* pCurrSect = rSh.GetCurrSection();
+ const SwSectionFormat* pSectFormat = pCurrSect->GetFormat();
+ SvxLRSpaceItem aLRTmp = pSectFormat->GetLRSpace();
+ aLRTmp.SetLeft(aLRTmp.GetLeft() + nLeftDiff);
+ aLRTmp.SetRight(aLRTmp.GetRight() + nRightDiff);
+ SfxItemSetFixed<RES_LR_SPACE, RES_LR_SPACE, RES_COL, RES_COL> aSet(rSh.GetAttrPool());
+ aSet.Put(aLRTmp);
+ //change the first/last column
+ if(bSect)
+ {
+ SwFormatCol aCols( pSectFormat->GetCol() );
+ tools::Long nDiffWidth = nLeftDiff + nRightDiff;
+ ::ResizeFrameCols(aCols, aSectRect.Width(), aSectRect.Width() - nDiffWidth, nLeftDiff );
+ aSet.Put( aCols );
+ }
+ SwSectionData aData(*pCurrSect);
+ rSh.UpdateSection(rSh.GetSectionFormatPos(*pSectFormat), aData, &aSet);
+ }
+ else
+ { // Adjust page margins
+ aLR.SetLeft(aLongLR.GetLeft());
+ aLR.SetRight(aLongLR.GetRight());
+ SwapPageMargin( rDesc, aLR );
+ SwPageDesc aDesc( rDesc );
+ aDesc.GetMaster().SetFormatAttr( aLR );
+ rSh.ChgPageDesc( nDescId, aDesc );
+ }
+ }
+ break;
+
+ // apply new left and right margins to current page style
+ case SID_ATTR_PAGE_LRSPACE:
+ if ( pReqArgs )
+ {
+ const SvxLongLRSpaceItem& aLongLR( pReqArgs->Get( SID_ATTR_PAGE_LRSPACE ) );
+
+ SwPageDesc aDesc( rDesc );
+ {
+ SvxLRSpaceItem aLR( RES_LR_SPACE );
+ aLR.SetLeft(aLongLR.GetLeft());
+ aLR.SetRight(aLongLR.GetRight());
+ SwapPageMargin( rDesc, aLR );
+ aDesc.GetMaster().SetFormatAttr( aLR );
+ }
+ rSh.ChgPageDesc( nDescId, aDesc );
+ }
+ break;
+
+ case SID_ATTR_LONG_ULSPACE:
+ if ( pReqArgs )
+ {
+ SvxLongULSpaceItem aLongULSpace( pReqArgs->Get( SID_ATTR_LONG_ULSPACE ) );
+
+ if( bFrameSelection || nFrameType & FrameTypeFlags::FLY_ANY )
+ {
+ SwFrameFormat* pFormat = rSh.GetFlyFrameFormat();
+ const SwRect &rRect = rSh.GetAnyCurRect(CurRectType::FlyEmbedded);
+ const tools::Long nDeltaY = rPageRect.Top() + aLongULSpace.GetUpper() - rRect.Top();
+ const tools::Long nHeight = nPageHeight - (aLongULSpace.GetUpper() + aLongULSpace.GetLower());
+
+ SfxItemSetFixed<RES_FRM_SIZE, RES_FRM_SIZE,
+ RES_VERT_ORIENT, RES_HORI_ORIENT> aSet( GetPool() );
+ //which of the orientation attributes is to be put depends on the frame's environment
+ bool bRTL;
+ bool bVertL2R;
+ if ( ( bFrameSelection &&
+ rSh.IsFrameVertical(true, bRTL, bVertL2R ) ) ||
+ ( !bFrameSelection && bVerticalWriting ) )
+ {
+ SwFormatHoriOrient aHoriOrient(pFormat->GetHoriOrient());
+ aHoriOrient.SetHoriOrient(text::HoriOrientation::NONE);
+ aHoriOrient.SetPos(aHoriOrient.GetPos() + nDeltaY );
+ aSet.Put( aHoriOrient );
+ }
+ else
+ {
+ SwFormatVertOrient aVertOrient(pFormat->GetVertOrient());
+ aVertOrient.SetVertOrient(text::VertOrientation::NONE);
+ aVertOrient.SetPos(aVertOrient.GetPos() + nDeltaY );
+ aSet.Put( aVertOrient );
+ }
+ SwFormatFrameSize aSize(pFormat->GetFrameSize());
+ if(aSize.GetHeightPercent())
+ {
+ SwRect aRect;
+ rSh.CalcBoundRect(aRect, RndStdIds::FLY_AS_CHAR);
+ tools::Long nPrtHeight = aRect.Height();
+ aSize.SetHeightPercent(sal_uInt8(nHeight * 100 /nPrtHeight));
+ }
+ else
+ aSize.SetHeight(nHeight );
+
+ aSet.Put( aSize );
+ rSh.SetFlyFrameAttr( aSet );
+ }
+ else if( nFrameType == FrameTypeFlags::DRAWOBJ )
+ {
+ SwRect aRect( rSh.GetObjRect() );
+ aRect.Top( aLongULSpace.GetUpper() + rPageRect.Top() );
+ aRect.Bottom( rPageRect.Bottom() - aLongULSpace.GetLower() );
+ rSh.SetObjRect( aRect ) ;
+ }
+ else if(bVerticalWriting && (bSect || rSh.IsDirectlyInSection()))
+ {
+ //change the section indents and the columns if available
+ //at first determine the changes
+ SwRect aSectRect = rSh.GetAnyCurRect(CurRectType::SectionPrt);
+ const SwRect aTmpRect = rSh.GetAnyCurRect(CurRectType::Section);
+ aSectRect.Pos() += aTmpRect.Pos();
+ const tools::Long nLeftDiff = aLongULSpace.GetUpper() - static_cast<tools::Long>(aSectRect.Top() - rPageRect.Top());
+ const tools::Long nRightDiff = aLongULSpace.GetLower() - static_cast<tools::Long>(nPageHeight - aSectRect.Bottom() + rPageRect.Top());
+ //change the LRSpaceItem of the section accordingly
+ const SwSection* pCurrSect = rSh.GetCurrSection();
+ const SwSectionFormat* pSectFormat = pCurrSect->GetFormat();
+ SvxLRSpaceItem aLR = pSectFormat->GetLRSpace();
+ aLR.SetLeft(aLR.GetLeft() + nLeftDiff);
+ aLR.SetRight(aLR.GetRight() + nRightDiff);
+ SfxItemSetFixed<RES_LR_SPACE, RES_LR_SPACE, RES_COL, RES_COL> aSet(rSh.GetAttrPool());
+ aSet.Put(aLR);
+ //change the first/last column
+ if(bSect)
+ {
+ SwFormatCol aCols( pSectFormat->GetCol() );
+ tools::Long nDiffWidth = nLeftDiff + nRightDiff;
+ ::ResizeFrameCols(aCols, aSectRect.Height(), aSectRect.Height() - nDiffWidth, nLeftDiff );
+ aSet.Put( aCols );
+ }
+ SwSectionData aData(*pCurrSect);
+ rSh.UpdateSection(rSh.GetSectionFormatPos(*pSectFormat), aData, &aSet);
+ }
+ else
+ { SwPageDesc aDesc( rDesc );
+
+ if ( nFrameType & ( FrameTypeFlags::HEADER | FrameTypeFlags::FOOTER ))
+ {
+
+ const bool bHead = bool(nFrameType & FrameTypeFlags::HEADER);
+ SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() );
+ if ( bHead )
+ aUL.SetUpper( o3tl::narrowing<sal_uInt16>(aLongULSpace.GetUpper()) );
+ else
+ aUL.SetLower( o3tl::narrowing<sal_uInt16>(aLongULSpace.GetLower()) );
+ aDesc.GetMaster().SetFormatAttr( aUL );
+
+ if( (bHead && pHeaderFormat) || (!bHead && pFooterFormat) )
+ {
+ SwFormatFrameSize aSz( bHead ? pHeaderFormat->GetFrameSize() :
+ pFooterFormat->GetFrameSize() );
+ aSz.SetHeightSizeType( SwFrameSize::Fixed );
+ aSz.SetHeight(nPageHeight - aLongULSpace.GetLower() -
+ aLongULSpace.GetUpper() );
+ if ( bHead )
+ pHeaderFormat->SetFormatAttr( aSz );
+ else
+ pFooterFormat->SetFormatAttr( aSz );
+ }
+ }
+ else
+ {
+ SvxULSpaceItem aUL(RES_UL_SPACE);
+ aUL.SetUpper(o3tl::narrowing<sal_uInt16>(aLongULSpace.GetUpper()));
+ aUL.SetLower(o3tl::narrowing<sal_uInt16>(aLongULSpace.GetLower()));
+ aDesc.GetMaster().SetFormatAttr(aUL);
+ }
+
+ rSh.ChgPageDesc( nDescId, aDesc );
+ }
+ }
+ break;
+
+ // apply new top and bottom margins to current page style
+ case SID_ATTR_PAGE_ULSPACE:
+ if ( pReqArgs )
+ {
+ const SvxLongULSpaceItem& aLongULSpace( pReqArgs->Get( SID_ATTR_PAGE_ULSPACE ) );
+
+ SwPageDesc aDesc( rDesc );
+ {
+ SvxULSpaceItem aUL(RES_UL_SPACE);
+ aUL.SetUpper(o3tl::narrowing<sal_uInt16>(aLongULSpace.GetUpper()));
+ aUL.SetLower(o3tl::narrowing<sal_uInt16>(aLongULSpace.GetLower()));
+ aDesc.GetMaster().SetFormatAttr(aUL);
+ }
+ rSh.ChgPageDesc( nDescId, aDesc );
+ }
+ break;
+
+ case SID_ATTR_PAGE_COLUMN:
+ if ( pReqArgs )
+ {
+ const SfxInt16Item aColumnItem( static_cast<const SfxInt16Item&>(pReqArgs->Get(nSlot)) );
+ const sal_uInt16 nPageColumnType = aColumnItem.GetValue();
+
+ // nPageColumnType =
+ // 1 - single-columned page
+ // 2 - two-columned page
+ // 3 - three-columned page
+ // 4 - two-columned page with left column width of 2/3 of page width
+ // 5 - two-columned page with right column width of 2/3 of page width
+
+ sal_uInt16 nCount = 2;
+ if ( nPageColumnType == 1 )
+ {
+ nCount = 0;
+ }
+ else if ( nPageColumnType == 3 )
+ {
+ nCount = 3;
+ }
+
+ const sal_uInt16 nGutterWidth = 0;
+
+ const SvxLRSpaceItem aLR( rDesc.GetMaster().GetLRSpace() );
+ const tools::Long nLeft = aLR.GetLeft();
+ const tools::Long nRight = aLR.GetRight();
+ const tools::Long nWidth = nPageWidth - nLeft - nRight;
+
+ SwFormatCol aCols( rDesc.GetMaster().GetCol() );
+ aCols.Init( nCount, nGutterWidth, nWidth );
+ aCols.SetWishWidth( nWidth );
+ aCols.SetGutterWidth( nGutterWidth, nWidth );
+ aCols.SetOrtho( false, nGutterWidth, nWidth );
+
+ tools::Long nColumnLeft = 0;
+ tools::Long nColumnRight = 0;
+ if ( nPageColumnType == 4 )
+ {
+ nColumnRight = static_cast<tools::Long>(nWidth/3);
+ nColumnLeft = nWidth - nColumnRight;
+ aCols.GetColumns()[0].SetWishWidth( nColumnLeft );
+ aCols.GetColumns()[1].SetWishWidth( nColumnRight );
+ }
+ else if ( nPageColumnType == 5 )
+ {
+ nColumnLeft = static_cast<tools::Long>(nWidth/3);
+ nColumnRight = nWidth - nColumnLeft;
+ aCols.GetColumns()[0].SetWishWidth( nColumnLeft );
+ aCols.GetColumns()[1].SetWishWidth( nColumnRight );
+ }
+
+ SwPageDesc aDesc( rDesc );
+ aDesc.GetMaster().SetFormatAttr( aCols );
+ rSh.ChgPageDesc( rSh.GetCurPageDesc(), aDesc );
+ }
+ break;
+
+ case SID_ATTR_TABSTOP_VERTICAL:
+ case SID_ATTR_TABSTOP:
+ if (pReqArgs)
+ {
+ const sal_uInt16 nWhich = GetPool().GetWhich(nSlot);
+ SvxTabStopItem aTabStops( static_cast<const SvxTabStopItem&>(pReqArgs->
+ Get( nWhich )));
+ aTabStops.SetWhich(RES_PARATR_TABSTOP);
+ const SvxTabStopItem& rDefTabs = rSh.GetDefault(RES_PARATR_TABSTOP);
+
+ // Default tab at pos 0
+ SfxItemSetFixed<RES_MARGIN_FIRSTLINE, RES_MARGIN_FIRSTLINE> aSet(GetPool());
+ rSh.GetCurAttr( aSet );
+ const SvxFirstLineIndentItem & rFirstLine(aSet.Get(RES_MARGIN_FIRSTLINE));
+
+ if (rFirstLine.GetTextFirstLineOffset() < 0)
+ {
+ SvxTabStop aSwTabStop( 0, SvxTabAdjust::Default );
+ aTabStops.Insert( aSwTabStop );
+ }
+
+ // Populate with default tabs.
+ ::MakeDefTabs( ::GetTabDist( rDefTabs ), aTabStops );
+
+ SwTextFormatColl* pColl = rSh.GetCurTextFormatColl();
+ if( pColl && pColl->IsAutoUpdateOnDirectFormat() )
+ {
+ SfxItemSetFixed<RES_PARATR_TABSTOP, RES_PARATR_TABSTOP> aTmp(GetPool());
+ aTmp.Put(aTabStops);
+ rSh.AutoUpdatePara( pColl, aTmp );
+ }
+ else
+ rSh.SetAttrItem( aTabStops );
+ }
+ break;
+ case SID_TABSTOP_ADD_OR_CHANGE:
+ if (pReqArgs)
+ {
+ const auto aIndexItem = static_cast<const SfxInt32Item&>(pReqArgs->Get(SID_TABSTOP_ATTR_INDEX));
+ const auto aPositionItem = static_cast<const SfxInt32Item&>(pReqArgs->Get(SID_TABSTOP_ATTR_POSITION));
+ const auto aRemoveItem = static_cast<const SfxBoolItem&>(pReqArgs->Get(SID_TABSTOP_ATTR_REMOVE));
+ const sal_Int32 nIndex = aIndexItem.GetValue();
+ const sal_Int32 nPosition = aPositionItem.GetValue();
+ const bool bRemove = aRemoveItem.GetValue();
+
+
+
+ SfxItemSetFixed<RES_PARATR_TABSTOP, RES_PARATR_TABSTOP> aItemSet(GetPool());
+ rSh.GetCurAttr(aItemSet);
+ SvxTabStopItem aTabStopItem(aItemSet.Get(RES_PARATR_TABSTOP));
+ lcl_EraseDefTabs(aTabStopItem);
+
+ if (nIndex < aTabStopItem.Count())
+ {
+ if (nIndex == -1)
+ {
+ SvxTabStop aSwTabStop(0, SvxTabAdjust::Default);
+ aTabStopItem.Insert(aSwTabStop);
+
+ const SvxTabStopItem& rDefaultTabs = rSh.GetDefault(RES_PARATR_TABSTOP);
+ MakeDefTabs(GetTabDist(rDefaultTabs), aTabStopItem);
+
+ SvxTabStop aTabStop(nPosition);
+ aTabStopItem.Insert(aTabStop);
+ }
+ else
+ {
+ SvxTabStop aTabStop = aTabStopItem.At(nIndex);
+ aTabStopItem.Remove(nIndex);
+ if (!bRemove)
+ {
+ aTabStop.GetTabPos() = nPosition;
+ aTabStopItem.Insert(aTabStop);
+
+ SvxTabStop aSwTabStop(0, SvxTabAdjust::Default);
+ aTabStopItem.Insert(aSwTabStop);
+ }
+ const SvxTabStopItem& rDefaultTabs = rSh.GetDefault(RES_PARATR_TABSTOP);
+ MakeDefTabs(GetTabDist(rDefaultTabs), aTabStopItem);
+ }
+ rSh.SetAttrItem(aTabStopItem);
+ }
+ }
+ break;
+ case SID_PARAGRAPH_CHANGE_STATE:
+ {
+ if (pReqArgs)
+ {
+ SfxItemSetFixed<RES_MARGIN_FIRSTLINE, RES_MARGIN_RIGHT> aLRSpaceSet(GetPool());
+ rSh.GetCurAttr( aLRSpaceSet );
+
+ if (const SfxStringItem *fLineIndent = pReqArgs->GetItemIfSet(SID_PARAGRAPH_FIRST_LINE_INDENT))
+ {
+ SvxFirstLineIndentItem firstLine(aLRSpaceSet.Get(RES_MARGIN_FIRSTLINE));
+ const OUString ratio = fLineIndent->GetValue();
+ firstLine.SetTextFirstLineOffset(nPageWidth * ratio.toFloat());
+ rSh.SetAttrItem(firstLine);
+ }
+ else if (const SfxStringItem *pLeftIndent = pReqArgs->GetItemIfSet(SID_PARAGRAPH_LEFT_INDENT))
+ {
+ SvxTextLeftMarginItem leftMargin(aLRSpaceSet.Get(RES_MARGIN_TEXTLEFT));
+ const OUString ratio = pLeftIndent->GetValue();
+ // this used to call SetLeft() but was probably a bug
+ leftMargin.SetTextLeft(nPageWidth * ratio.toFloat());
+ rSh.SetAttrItem(leftMargin);
+ }
+ else if (const SfxStringItem *pRightIndent = pReqArgs->GetItemIfSet(SID_PARAGRAPH_RIGHT_INDENT))
+ {
+ SvxRightMarginItem rightMargin(aLRSpaceSet.Get(RES_MARGIN_RIGHT));
+ const OUString ratio = pRightIndent->GetValue();
+ rightMargin.SetRight(nPageWidth * ratio.toFloat());
+ rSh.SetAttrItem(rightMargin);
+ }
+ }
+ break;
+ }
+ case SID_HANGING_INDENT:
+ {
+ SfxItemSetFixed<RES_MARGIN_FIRSTLINE, RES_MARGIN_RIGHT> aLRSpaceSet(GetPool());
+ rSh.GetCurAttr( aLRSpaceSet );
+ SvxFirstLineIndentItem firstLine(aLRSpaceSet.Get(RES_MARGIN_FIRSTLINE));
+ SvxTextLeftMarginItem leftMargin(aLRSpaceSet.Get(RES_MARGIN_TEXTLEFT));
+ leftMargin.SetTextLeft(leftMargin.GetTextLeft() + firstLine.GetTextFirstLineOffset());
+ firstLine.SetTextFirstLineOffset((firstLine.GetTextFirstLineOffset()) * -1);
+ firstLine.SetAutoFirst(false); // old code would do this, is it wanted?
+ rSh.SetAttrItem(firstLine);
+ rSh.SetAttrItem(leftMargin);
+ break;
+ }
+
+ case SID_ATTR_PARA_LRSPACE_VERTICAL:
+ case SID_ATTR_PARA_LRSPACE:
+ if ( pReqArgs )
+ {
+ SvxLRSpaceItem aParaMargin(static_cast<const SvxLRSpaceItem&>(pReqArgs->Get(nSlot)));
+
+ aParaMargin.SetRight( aParaMargin.GetRight() - m_nRightBorderDistance );
+ aParaMargin.SetTextLeft(aParaMargin.GetTextLeft() - m_nLeftBorderDistance );
+
+ aParaMargin.SetWhich( RES_LR_SPACE );
+ SwTextFormatColl* pColl = rSh.GetCurTextFormatColl();
+
+ SvxFirstLineIndentItem firstLine(RES_MARGIN_FIRSTLINE);
+ firstLine.SetTextFirstLineOffset(aParaMargin.GetTextFirstLineOffset(), aParaMargin.GetPropTextFirstLineOffset());
+ firstLine.SetAutoFirst(aParaMargin.IsAutoFirst());
+ SvxTextLeftMarginItem const leftMargin(aParaMargin.GetTextLeft(), RES_MARGIN_TEXTLEFT);
+ SvxRightMarginItem const rightMargin(aParaMargin.GetRight(), RES_MARGIN_RIGHT);
+
+ // #i23726#
+ if (m_pNumRuleNodeFromDoc)
+ {
+ // --> #i42922# Mouse move of numbering label
+ // has to consider the left indent of the paragraph
+ SfxItemSetFixed<RES_MARGIN_TEXTLEFT, RES_MARGIN_TEXTLEFT> aSet( GetPool() );
+ rSh.GetCurAttr( aSet );
+ const SvxTextLeftMarginItem & rLeftMargin(aSet.Get(RES_MARGIN_TEXTLEFT));
+
+ SwPosition aPos(*m_pNumRuleNodeFromDoc);
+ // #i90078#
+ rSh.SetIndent(static_cast<short>(aParaMargin.GetTextLeft() - rLeftMargin.GetTextLeft()), aPos);
+ // #i42921# invalidate state of indent in order to get a ruler update.
+ aParaMargin.SetWhich( nSlot );
+ GetViewFrame().GetBindings().SetState( aParaMargin );
+ }
+ else if( pColl && pColl->IsAutoUpdateOnDirectFormat() )
+ {
+ SfxItemSetFixed<RES_MARGIN_FIRSTLINE, RES_MARGIN_RIGHT> aSet(GetPool());
+ aSet.Put(firstLine);
+ aSet.Put(leftMargin);
+ aSet.Put(rightMargin);
+ rSh.AutoUpdatePara( pColl, aSet);
+ }
+ else
+ {
+ rSh.SetAttrItem(firstLine);
+ rSh.SetAttrItem(leftMargin);
+ rSh.SetAttrItem(rightMargin);
+ }
+
+ if ( aParaMargin.GetTextFirstLineOffset() < 0 )
+ {
+ SfxItemSetFixed<RES_PARATR_TABSTOP, RES_PARATR_TABSTOP> aSet( GetPool() );
+
+ rSh.GetCurAttr( aSet );
+ const SvxTabStopItem& rTabStops = aSet.Get(RES_PARATR_TABSTOP);
+
+ // Do we have a tab at position zero?
+ sal_uInt16 i;
+
+ for ( i = 0; i < rTabStops.Count(); ++i )
+ if ( rTabStops[i].GetTabPos() == 0 )
+ break;
+
+ if ( i >= rTabStops.Count() )
+ {
+ // No DefTab
+ std::unique_ptr<SvxTabStopItem> aTabStops(rTabStops.Clone());
+
+ ::lcl_EraseDefTabs(*aTabStops);
+
+ SvxTabStop aSwTabStop( 0, SvxTabAdjust::Default );
+ aTabStops->Insert(aSwTabStop);
+
+ const SvxTabStopItem& rDefTabs = rSh.GetDefault(RES_PARATR_TABSTOP);
+ ::MakeDefTabs( ::GetTabDist(rDefTabs), *aTabStops );
+
+ if( pColl && pColl->IsAutoUpdateOnDirectFormat())
+ {
+ SfxItemSetFixed<RES_PARATR_TABSTOP, RES_PARATR_TABSTOP> aSetTmp(GetPool());
+ aSetTmp.Put(std::move(aTabStops));
+ rSh.AutoUpdatePara( pColl, aSetTmp );
+ }
+ else
+ rSh.SetAttrItem( *aTabStops );
+ }
+ }
+ }
+ break;
+
+ case SID_ATTR_PARA_ULSPACE:
+ if ( pReqArgs )
+ {
+ SvxULSpaceItem aParaMargin(static_cast<const SvxULSpaceItem&>(pReqArgs->Get(nSlot)));
+
+ aParaMargin.SetUpper( aParaMargin.GetUpper() );
+ aParaMargin.SetLower(aParaMargin.GetLower());
+
+ aParaMargin.SetWhich( RES_UL_SPACE );
+ SwTextFormatColl* pColl = rSh.GetCurTextFormatColl();
+ if( pColl && pColl->IsAutoUpdateOnDirectFormat() )
+ {
+ SfxItemSetFixed<RES_UL_SPACE, RES_UL_SPACE> aSet(GetPool());
+ aSet.Put(aParaMargin);
+ rSh.AutoUpdatePara( pColl, aSet);
+ }
+ else
+ rSh.SetAttrItem( aParaMargin );
+ }
+ break;
+ case SID_PARASPACE_INCREASE:
+ case SID_PARASPACE_DECREASE:
+ {
+ SfxItemSetFixed<RES_UL_SPACE, RES_UL_SPACE> aULSpaceSet( GetPool() );
+ rSh.GetCurAttr( aULSpaceSet );
+ SvxULSpaceItem aULSpace( aULSpaceSet.Get( RES_UL_SPACE ) );
+ sal_uInt16 nUpper = aULSpace.GetUpper();
+ sal_uInt16 nLower = aULSpace.GetLower();
+
+ if ( nSlot == SID_PARASPACE_INCREASE )
+ {
+ nUpper = std::min< sal_uInt16 >( nUpper + 57, 5670 );
+ nLower = std::min< sal_uInt16 >( nLower + 57, 5670 );
+ }
+ else
+ {
+ nUpper = std::max< sal_Int16 >( nUpper - 57, 0 );
+ nLower = std::max< sal_Int16 >( nLower - 57, 0 );
+ }
+
+ aULSpace.SetUpper( nUpper );
+ aULSpace.SetLower( nLower );
+
+ SwTextFormatColl* pColl = rSh.GetCurTextFormatColl();
+ if( pColl && pColl->IsAutoUpdateOnDirectFormat() )
+ {
+ aULSpaceSet.Put( aULSpace );
+ rSh.AutoUpdatePara( pColl, aULSpaceSet );
+ }
+ else
+ rSh.SetAttrItem( aULSpace, SetAttrMode::DEFAULT, true );
+ }
+ break;
+
+ case SID_RULER_CHANGE_STATE:
+ if (pReqArgs)
+ {
+ if ( const SfxStringItem *pMargin1 = pReqArgs->GetItemIfSet(SID_RULER_MARGIN1) )
+ {
+ const OUString ratio = pMargin1->GetValue();
+ GetHRuler().SetValues(RulerChangeType::MARGIN1, GetHRuler().GetPageWidth() * ratio.toFloat());
+ }
+ else if ( const SfxStringItem *pMargin2 = pReqArgs->GetItemIfSet(SID_RULER_MARGIN2) )
+ {
+ const OUString ratio = pMargin2->GetValue();
+ GetHRuler().SetValues(RulerChangeType::MARGIN2, GetHRuler().GetPageWidth() * ratio.toFloat());
+ }
+ }
+ break;
+ case SID_RULER_BORDERS_VERTICAL:
+ case SID_RULER_BORDERS:
+ if ( pReqArgs )
+ {
+ SvxColumnItem aColItem(static_cast<const SvxColumnItem&>(pReqArgs->Get(nSlot)));
+
+ if( m_bSetTabColFromDoc || (!bSect && rSh.GetTableFormat()) )
+ {
+ OSL_ENSURE(aColItem.Count(), "ColDesc is empty!!");
+
+ const bool bSingleLine = rReq.
+ GetArgs()->Get(SID_RULER_ACT_LINE_ONLY).GetValue();
+
+ SwTabCols aTabCols;
+ if ( m_bSetTabColFromDoc )
+ rSh.GetMouseTabCols( aTabCols, m_aTabColFromDocPos );
+ else
+ rSh.GetTabCols(aTabCols);
+
+ // left table border
+ tools::Long nBorder = static_cast<tools::Long>(aColItem.GetLeft() - aTabCols.GetLeftMin());
+ aTabCols.SetLeft( nBorder );
+
+ nBorder = (bVerticalWriting ? nPageHeight : nPageWidth) - aTabCols.GetLeftMin() - aColItem.GetRight();
+
+ if ( aColItem.GetRight() > 0 )
+ aTabCols.SetRight( nBorder );
+
+ // Tabcols sequentially
+ // The last column is defined by the edge.
+ // Columns in right-to-left tables need to be mirrored
+ bool bIsTableRTL =
+ IsTabColFromDoc() ?
+ rSh.IsMouseTableRightToLeft(m_aTabColFromDocPos)
+ : rSh.IsTableRightToLeft();
+ const size_t nColCount = aColItem.Count() - 1;
+ if(bIsTableRTL)
+ {
+ for ( size_t i = 0; i < nColCount && i < aTabCols.Count(); ++i )
+ {
+ const SvxColumnDescription& rCol = aColItem[nColCount - i];
+ aTabCols[i] = aTabCols.GetRight() - rCol.nStart;
+ aTabCols.SetHidden( i, !rCol.bVisible );
+ }
+ }
+ else
+ {
+ for ( size_t i = 0; i < nColCount && i < aTabCols.Count(); ++i )
+ {
+ const SvxColumnDescription& rCol = aColItem[i];
+ aTabCols[i] = rCol.nEnd + aTabCols.GetLeft();
+ aTabCols.SetHidden( i, !rCol.bVisible );
+ }
+ }
+
+ if ( m_bSetTabColFromDoc )
+ {
+ if( !rSh.IsViewLocked() )
+ {
+ bUnlockView = true;
+ rSh.LockView( true );
+ }
+ rSh.SetMouseTabCols( aTabCols, bSingleLine,
+ m_aTabColFromDocPos );
+ }
+ else
+ rSh.SetTabCols(aTabCols, bSingleLine);
+
+ }
+ else
+ {
+ if ( bFrameSelection || nFrameType & FrameTypeFlags::FLY_ANY || bSect)
+ {
+ SwSectionFormat *pSectFormat = nullptr;
+ SfxItemSetFixed<RES_COL, RES_COL> aSet( GetPool() );
+ if(bSect)
+ {
+ SwSection *pSect = rSh.GetAnySection();
+ OSL_ENSURE( pSect, "Which section?");
+ pSectFormat = pSect->GetFormat();
+ }
+ else
+ {
+ rSh.GetFlyFrameAttr( aSet );
+ }
+ SwFormatCol aCols(
+ bSect ?
+ pSectFormat->GetCol() :
+ aSet.Get( RES_COL, false ));
+ SwRect aCurRect = rSh.GetAnyCurRect(bSect ? CurRectType::SectionPrt : CurRectType::FlyEmbeddedPrt);
+ const tools::Long lWidth = bVerticalWriting ? aCurRect.Height() : aCurRect.Width();
+ ::lcl_ConvertToCols( aColItem, lWidth, aCols );
+ aSet.Put( aCols );
+ if(bSect)
+ rSh.SetSectionAttr( aSet, pSectFormat );
+ else
+ {
+ rSh.StartAction();
+ rSh.Push();
+ rSh.SetFlyFrameAttr( aSet );
+ // Cancel the frame selection again
+ if(!bFrameSelection && rSh.IsFrameSelected())
+ {
+ rSh.UnSelectFrame();
+ rSh.LeaveSelFrameMode();
+ }
+ rSh.Pop();
+ rSh.EndAction();
+ }
+ }
+ else
+ {
+ SwFormatCol aCols( rDesc.GetMaster().GetCol() );
+ const SwRect aPrtRect = rSh.GetAnyCurRect(CurRectType::PagePrt);
+ ::lcl_ConvertToCols( aColItem,
+ bVerticalWriting ? aPrtRect.Height() : aPrtRect.Width(),
+ aCols );
+ SwPageDesc aDesc( rDesc );
+ aDesc.GetMaster().SetFormatAttr( aCols );
+ rSh.ChgPageDesc( rSh.GetCurPageDesc(), aDesc );
+ }
+ }
+ }
+ break;
+
+ case SID_RULER_ROWS :
+ case SID_RULER_ROWS_VERTICAL:
+ if (pReqArgs)
+ {
+ SvxColumnItem aColItem(static_cast<const SvxColumnItem&>(pReqArgs->Get(nSlot)));
+
+ if( m_bSetTabColFromDoc || (!bSect && rSh.GetTableFormat()) )
+ {
+ OSL_ENSURE(aColItem.Count(), "ColDesc is empty!!");
+
+ SwTabCols aTabCols;
+ if ( m_bSetTabRowFromDoc )
+ rSh.GetMouseTabRows( aTabCols, m_aTabColFromDocPos );
+ else
+ rSh.GetTabRows(aTabCols);
+
+ if ( bVerticalWriting )
+ {
+ aTabCols.SetRight(nPageWidth - aColItem.GetRight() - aColItem.GetLeft());
+ aTabCols.SetLeftMin(aColItem.GetLeft());
+ }
+ else
+ {
+ tools::Long nBorder = nPageHeight - aTabCols.GetLeftMin() - aColItem.GetRight();
+ aTabCols.SetRight( nBorder );
+ }
+
+ const size_t nColItems = aColItem.Count() - 1;
+ if(bVerticalWriting)
+ {
+ for ( size_t i = nColItems; i; --i )
+ {
+ const SvxColumnDescription& rCol = aColItem[i - 1];
+ tools::Long nColumnPos = aTabCols.GetRight() - rCol.nEnd ;
+ aTabCols[i - 1] = nColumnPos;
+ aTabCols.SetHidden( i - 1, !rCol.bVisible );
+ }
+ }
+ else
+ {
+ for ( size_t i = 0; i < nColItems; ++i )
+ {
+ const SvxColumnDescription& rCol = aColItem[i];
+ aTabCols[i] = rCol.nEnd + aTabCols.GetLeft();
+ aTabCols.SetHidden( i, !rCol.bVisible );
+ }
+ }
+ bool bSingleLine = false;
+ if( const SfxBoolItem* pSingleLine = rReq.GetArgs()->GetItemIfSet(SID_RULER_ACT_LINE_ONLY, false) )
+ bSingleLine = pSingleLine->GetValue();
+ if ( m_bSetTabRowFromDoc )
+ {
+ if( !rSh.IsViewLocked() )
+ {
+ bUnlockView = true;
+ rSh.LockView( true );
+ }
+ rSh.SetMouseTabRows( aTabCols, bSingleLine, m_aTabColFromDocPos );
+ }
+ else
+ rSh.SetTabRows(aTabCols, bSingleLine);
+ }
+ }
+ break;
+ case SID_TABLE_CHANGE_CURRENT_BORDER_POSITION:
+ {
+ if (pReqArgs)
+ {
+ const SfxStringItem *pBorderType = pReqArgs->GetItemIfSet(SID_TABLE_BORDER_TYPE);
+ const SfxUInt16Item *pIndex = pReqArgs->GetItemIfSet(SID_TABLE_BORDER_INDEX);
+ const SfxInt32Item *pOffset = pReqArgs->GetItemIfSet(SID_TABLE_BORDER_OFFSET);
+ constexpr tools::Long constDistanceOffset = 40;
+
+ if (pBorderType && pIndex && pOffset)
+ {
+ const OUString sType = pBorderType->GetValue();
+ const sal_uInt16 nIndex = pIndex->GetValue();
+ const sal_Int32 nOffset = pOffset->GetValue();
+
+ if (sType.startsWith("column"))
+ {
+ SwTabCols aTabCols;
+ rSh.GetTabCols(aTabCols);
+
+ if (sType == "column-left")
+ {
+ tools::Long nNewPosition = aTabCols.GetLeft() + nOffset;
+ if(aTabCols.Count() > 0)
+ {
+ auto & rEntry = aTabCols.GetEntry(0);
+ nNewPosition = std::min(nNewPosition, rEntry.nPos - constDistanceOffset);
+ }
+ aTabCols.SetLeft(nNewPosition);
+ }
+ else if (sType == "column-right")
+ {
+ tools::Long nNewPosition = aTabCols.GetRight() + nOffset;
+ if(aTabCols.Count() > 0)
+ {
+ auto & rEntry = aTabCols.GetEntry(aTabCols.Count() - 1);
+ nNewPosition = std::max(nNewPosition, rEntry.nPos + constDistanceOffset);
+ }
+ aTabCols.SetRight(nNewPosition);
+ }
+ else if (sType == "column-middle" && nIndex < aTabCols.Count())
+ {
+ auto & rEntry = aTabCols.GetEntry(nIndex);
+ tools::Long nNewPosition = rEntry.nPos + nOffset;
+ nNewPosition = std::clamp(nNewPosition, rEntry.nMin, rEntry.nMax - constDistanceOffset);
+ rEntry.nPos = nNewPosition;
+ }
+
+ rSh.SetTabCols(aTabCols, false);
+ }
+ else if (sType.startsWith("row"))
+ {
+ SwTabCols aTabRows;
+ rSh.GetTabRows(aTabRows);
+
+ if (sType == "row-left")
+ {
+ auto & rEntry = aTabRows.GetEntry(0);
+ tools::Long nNewPosition = aTabRows.GetLeft() + nOffset;
+ nNewPosition = std::min(nNewPosition, rEntry.nPos - constDistanceOffset);
+ aTabRows.SetLeft(nNewPosition);
+ }
+ else if (sType == "row-right")
+ {
+ tools::Long nNewPosition = aTabRows.GetRight() + nOffset;
+ if(aTabRows.Count() > 0)
+ {
+ auto & rEntry = aTabRows.GetEntry(aTabRows.Count() - 1);
+ nNewPosition = std::max(nNewPosition, rEntry.nPos + constDistanceOffset);
+ }
+ aTabRows.SetRight(nNewPosition);
+ }
+ else if (sType == "row-middle" && nIndex < aTabRows.Count())
+ {
+ auto & rEntry = aTabRows.GetEntry(nIndex);
+ tools::Long nNewPosition = rEntry.nPos + nOffset;
+ nNewPosition = std::clamp(nNewPosition, rEntry.nMin, rEntry.nMax - constDistanceOffset);
+ rEntry.nPos = nNewPosition;
+ }
+
+ rSh.SetTabRows(aTabRows, false);
+ }
+ }
+ }
+ }
+ break;
+ case SID_ATTR_PAGE_HEADER:
+ {
+ if ( pReqArgs )
+ {
+ const bool bHeaderOn = static_cast<const SfxBoolItem&>(pReqArgs->Get(SID_ATTR_PAGE_HEADER)).GetValue();
+ SwPageDesc aDesc(rDesc);
+ SwFrameFormat &rMaster = aDesc.GetMaster();
+ rMaster.SetFormatAttr( SwFormatHeader( bHeaderOn ));
+ rSh.ChgPageDesc(rSh.GetCurPageDesc(), aDesc);
+ }
+ }
+ break;
+ case SID_ATTR_PAGE_HEADER_LRMARGIN:
+ {
+ if ( pReqArgs && rDesc.GetMaster().GetHeader().IsActive() )
+ {
+ const SvxLongLRSpaceItem& aLongLR = pReqArgs->Get(SID_ATTR_PAGE_HEADER_LRMARGIN);
+ SvxLRSpaceItem aLR(RES_LR_SPACE);
+ SwPageDesc aDesc(rDesc);
+ aLR.SetLeft(aLongLR.GetLeft());
+ aLR.SetRight(aLongLR.GetRight());
+ SwFrameFormat* pFormat = const_cast<SwFrameFormat*>(aDesc.GetMaster().GetHeader().GetHeaderFormat());
+ pFormat->SetFormatAttr( aLR );
+ rSh.ChgPageDesc(rSh.GetCurPageDesc(), aDesc);
+ }
+ }
+ break;
+ case SID_ATTR_PAGE_HEADER_SPACING:
+ {
+ if ( pReqArgs && rDesc.GetMaster().GetHeader().IsActive())
+ {
+ const SvxLongULSpaceItem& aLongUL = pReqArgs->Get(SID_ATTR_PAGE_HEADER_SPACING);
+ SwPageDesc aDesc(rDesc);
+ SvxULSpaceItem aUL(0, aLongUL.GetLower(), RES_UL_SPACE );
+ SwFrameFormat* pFormat = const_cast<SwFrameFormat*>(aDesc.GetMaster().GetHeader().GetHeaderFormat());
+ pFormat->SetFormatAttr( aUL );
+ rSh.ChgPageDesc(rSh.GetCurPageDesc(), aDesc);
+ }
+ }
+ break;
+ case SID_ATTR_PAGE_HEADER_LAYOUT:
+ {
+ if ( pReqArgs && rDesc.GetMaster().GetHeader().IsActive())
+ {
+ const SfxInt16Item& aLayoutItem = pReqArgs->Get(SID_ATTR_PAGE_HEADER_LAYOUT);
+ sal_uInt16 nLayout = aLayoutItem.GetValue();
+ SwPageDesc aDesc(rDesc);
+ aDesc.ChgHeaderShare((nLayout>>1) == 0);
+ aDesc.ChgFirstShare((nLayout % 2) == 0); // FIXME control changes for both header footer - tdf#100287
+ rSh.ChgPageDesc(rSh.GetCurPageDesc(), aDesc);
+ }
+ }
+ break;
+ case SID_ATTR_PAGE_FOOTER:
+ {
+ if ( pReqArgs )
+ {
+ const bool bFooterOn = static_cast<const SfxBoolItem&>(pReqArgs->Get(SID_ATTR_PAGE_FOOTER)).GetValue();
+ SwPageDesc aDesc(rDesc);
+ SwFrameFormat &rMaster = aDesc.GetMaster();
+ rMaster.SetFormatAttr( SwFormatFooter( bFooterOn ));
+ rSh.ChgPageDesc(rSh.GetCurPageDesc(), aDesc);
+ }
+ }
+ break;
+ case SID_ATTR_PAGE_FOOTER_LRMARGIN:
+ {
+ if ( pReqArgs && rDesc.GetMaster().GetFooter().IsActive() )
+ {
+ const SvxLongLRSpaceItem& aLongLR = pReqArgs->Get(SID_ATTR_PAGE_FOOTER_LRMARGIN);
+ SvxLRSpaceItem aLR(RES_LR_SPACE);
+ SwPageDesc aDesc(rDesc);
+ aLR.SetLeft(aLongLR.GetLeft());
+ aLR.SetRight(aLongLR.GetRight());
+ SwFrameFormat* pFormat = const_cast<SwFrameFormat*>(aDesc.GetMaster().GetFooter().GetFooterFormat());
+ pFormat->SetFormatAttr( aLR );
+ rSh.ChgPageDesc(rSh.GetCurPageDesc(), aDesc);
+ }
+ }
+ break;
+ case SID_ATTR_PAGE_FOOTER_SPACING:
+ {
+ if ( pReqArgs && rDesc.GetMaster().GetFooter().IsActive())
+ {
+ const SvxLongULSpaceItem& aLongUL = pReqArgs->Get(SID_ATTR_PAGE_FOOTER_SPACING);
+ SwPageDesc aDesc(rDesc);
+ SvxULSpaceItem aUL(aLongUL.GetUpper(), 0, RES_UL_SPACE );
+ SwFrameFormat* pFormat = const_cast<SwFrameFormat*>(aDesc.GetMaster().GetFooter().GetFooterFormat());
+ pFormat->SetFormatAttr( aUL );
+ rSh.ChgPageDesc(rSh.GetCurPageDesc(), aDesc);
+ }
+ }
+ break;
+ case SID_ATTR_PAGE_FOOTER_LAYOUT:
+ {
+ if ( pReqArgs && rDesc.GetMaster().GetFooter().IsActive())
+ {
+ const SfxInt16Item& aLayoutItem = pReqArgs->Get(SID_ATTR_PAGE_FOOTER_LAYOUT);
+ sal_uInt16 nLayout = aLayoutItem.GetValue();
+ SwPageDesc aDesc(rDesc);
+ aDesc.ChgFooterShare((nLayout>>1) == 0);
+ aDesc.ChgFirstShare((nLayout % 2) == 0); // FIXME control changes for both header footer - tdf#100287
+ rSh.ChgPageDesc(rSh.GetCurPageDesc(), aDesc);
+ }
+ }
+ break;
+
+ case SID_ATTR_PAGE_COLOR:
+ case SID_ATTR_PAGE_FILLSTYLE:
+ case SID_ATTR_PAGE_GRADIENT:
+ case SID_ATTR_PAGE_HATCH:
+ case SID_ATTR_PAGE_BITMAP:
+ {
+ if(pReqArgs)
+ {
+ SwPageDesc aDesc(rDesc);
+ SwFrameFormat &rMaster = aDesc.GetMaster();
+ switch (nSlot)
+ {
+ case SID_ATTR_PAGE_FILLSTYLE:
+ {
+ XFillStyleItem aFSItem( pReqArgs->Get( XATTR_FILLSTYLE ) );
+ drawing::FillStyle eXFS = aFSItem.GetValue();
+
+ if ( eXFS == drawing::FillStyle_NONE )
+ rMaster.SetFormatAttr( XFillStyleItem( eXFS ) );
+ }
+ break;
+
+ case SID_ATTR_PAGE_COLOR:
+ {
+ XFillColorItem aColorItem( pReqArgs->Get( XATTR_FILLCOLOR ) );
+ rMaster.SetFormatAttr( XFillStyleItem( drawing::FillStyle_SOLID ) );
+ rMaster.SetFormatAttr( aColorItem );
+ }
+ break;
+
+ case SID_ATTR_PAGE_GRADIENT:
+ {
+ XFillGradientItem aGradientItem( pReqArgs->Get( XATTR_FILLGRADIENT ) );
+ rMaster.SetFormatAttr( XFillStyleItem( drawing::FillStyle_GRADIENT ) );
+ rMaster.SetFormatAttr( aGradientItem );
+ }
+ break;
+
+ case SID_ATTR_PAGE_HATCH:
+ {
+ XFillHatchItem aHatchItem( pReqArgs->Get( XATTR_FILLHATCH ) );
+ rMaster.SetFormatAttr( XFillStyleItem( drawing::FillStyle_HATCH ) );
+ rMaster.SetFormatAttr( aHatchItem );
+ }
+ break;
+
+ case SID_ATTR_PAGE_BITMAP:
+ {
+ XFillBitmapItem aBitmapItem( pReqArgs->Get( XATTR_FILLBITMAP ) );
+ rMaster.SetFormatAttr( XFillStyleItem( drawing::FillStyle_BITMAP ) );
+ rMaster.SetFormatAttr( aBitmapItem );
+ }
+ break;
+
+ default:
+ break;
+ }
+ rSh.ChgPageDesc(rSh.GetCurPageDesc(), aDesc);
+ }
+ }
+ break;
+
+ default:
+ OSL_ENSURE( false, "wrong SlotId");
+ }
+ rSh.EndAllAction();
+
+ if( bUnlockView )
+ rSh.LockView( false );
+
+ m_bSetTabColFromDoc = m_bSetTabRowFromDoc = m_bTabColFromDoc = m_bTabRowFromDoc = false;
+ SetNumRuleNodeFromDoc(nullptr);
+}
+
+// Here the status of the tab bar will be determined.
+// This means that all relevant attributes at the CursorPos
+// will be submitted to the tab bar.
+void SwView::StateTabWin(SfxItemSet& rSet)
+{
+ SwWrtShell &rSh = GetWrtShell();
+
+ const Point* pPt = IsTabColFromDoc() || IsTabRowFromDoc() ? &m_aTabColFromDocPos : nullptr;
+ const FrameTypeFlags nFrameType = rSh.IsObjSelected()
+ ? FrameTypeFlags::DRAWOBJ
+ : rSh.GetFrameType( pPt, true );
+
+ const bool bFrameSelection = rSh.IsFrameSelected();
+ const bool bBrowse = rSh.GetViewOptions()->getBrowseMode();
+ // PageOffset/limiter
+ const SwRect& rPageRect = rSh.GetAnyCurRect( CurRectType::Page, pPt );
+ const SwRect& rPagePrtRect = rSh.GetAnyCurRect( CurRectType::PagePrt, pPt );
+ const tools::Long nPageWidth = rPageRect.Width();
+ const tools::Long nPageHeight = rPageRect.Height();
+
+ const SwPageDesc& rDesc = rSh.GetPageDesc(
+ IsTabColFromDoc() || m_bTabRowFromDoc ?
+ rSh.GetMousePageDesc(m_aTabColFromDocPos) : rSh.GetCurPageDesc() );
+
+ const SvxFrameDirectionItem& rFrameDir = rDesc.GetMaster().GetFrameDir();
+ const bool bVerticalWriting = rSh.IsInVerticalText();
+
+ //enable tab stop display on the rulers depending on the writing direction
+ WinBits nRulerStyle = m_pHRuler->GetStyle() & ~WB_EXTRAFIELD;
+ m_pHRuler->SetStyle(bVerticalWriting||bBrowse ? nRulerStyle : nRulerStyle|WB_EXTRAFIELD);
+ nRulerStyle = m_pVRuler->GetStyle() & ~WB_EXTRAFIELD;
+ m_pVRuler->SetStyle(bVerticalWriting ? nRulerStyle|WB_EXTRAFIELD : nRulerStyle);
+
+ //#i24363# tab stops relative to indent
+ bool bRelative = rSh.getIDocumentSettingAccess().get(DocumentSettingId::TABS_RELATIVE_TO_INDENT);
+ m_pHRuler->SetTabsRelativeToIndent( bRelative );
+ m_pVRuler->SetTabsRelativeToIndent( bRelative );
+
+ SvxLRSpaceItem aPageLRSpace( rDesc.GetMaster().GetLRSpace() );
+ SwapPageMargin( rDesc, aPageLRSpace );
+
+ SfxItemSetFixed<RES_PARATR_TABSTOP, RES_PARATR_TABSTOP,
+ RES_MARGIN_FIRSTLINE, RES_MARGIN_RIGHT,
+ RES_UL_SPACE, RES_UL_SPACE> aCoreSet( GetPool() );
+ // get also the list level indent values, if needed.
+ rSh.GetCurAttr( aCoreSet, true );
+ const SelectionType nSelType = rSh.GetSelectionType();
+
+ SfxWhichIter aIter( rSet );
+ sal_uInt16 nWhich = aIter.FirstWhich();
+
+ while ( nWhich )
+ {
+ switch ( nWhich )
+ {
+
+ case SID_ATTR_PAGE_COLUMN:
+ {
+ sal_uInt16 nColumnType = 0;
+
+ const SwFrameFormat& rMaster = rDesc.GetMaster();
+ const SwFormatCol& aCol(rMaster.GetCol());
+ const sal_uInt16 nCols = aCol.GetNumCols();
+ if ( nCols == 0 )
+ {
+ nColumnType = 1;
+ }
+ else if ( nCols == 2 )
+ {
+ const sal_uInt16 nColLeft = aCol.CalcPrtColWidth(0, aCol.GetWishWidth());
+ const sal_uInt16 nColRight = aCol.CalcPrtColWidth(1, aCol.GetWishWidth());
+
+ if ( abs(nColLeft - nColRight) <= 10 )
+ {
+ nColumnType = 2;
+ }
+ else if( abs(nColLeft - nColRight*2) < 20 )
+ {
+ nColumnType = 4;
+ }
+ else if( abs(nColLeft*2 - nColRight) < 20 )
+ {
+ nColumnType = 5;
+ }
+ }
+ else if( nCols == 3 )
+ {
+ nColumnType = 3;
+ }
+ else
+ nColumnType = nCols;
+
+ rSet.Put( SfxInt16Item( SID_ATTR_PAGE_COLUMN, nColumnType ) );
+ }
+ break;
+
+ case SID_ATTR_LONG_LRSPACE:
+ {
+ SvxLongLRSpaceItem aLongLR( aPageLRSpace.GetLeft(),
+ aPageLRSpace.GetRight(),
+ SID_ATTR_LONG_LRSPACE);
+ if(bBrowse)
+ {
+ aLongLR.SetLeft(rPagePrtRect.Left());
+ aLongLR.SetRight(nPageWidth - rPagePrtRect.Right());
+ }
+ if ( ( nFrameType & FrameTypeFlags::HEADER || nFrameType & FrameTypeFlags::FOOTER ) &&
+ !(nFrameType & FrameTypeFlags::COLSECT) )
+ {
+ SwFrameFormat *pFormat = const_cast<SwFrameFormat*>((nFrameType & FrameTypeFlags::HEADER) ?
+ rDesc.GetMaster().GetHeader().GetHeaderFormat() :
+ rDesc.GetMaster().GetFooter().GetFooterFormat());
+ if( pFormat )// #i80890# if rDesc is not the one belonging to the current page is might crash
+ {
+ SwRect aRect( rSh.GetAnyCurRect( CurRectType::HeaderFooter, pPt));
+ aRect.Pos() -= rSh.GetAnyCurRect( CurRectType::Page, pPt ).Pos();
+ const SvxLRSpaceItem& aLR = pFormat->GetLRSpace();
+ aLongLR.SetLeft ( aLR.GetLeft() + aRect.Left() );
+ aLongLR.SetRight( nPageWidth - aRect.Right() + aLR.GetRight() );
+ }
+ }
+ else
+ {
+ SwRect aRect;
+ if( !bFrameSelection && ((nFrameType & FrameTypeFlags::COLSECT) || rSh.IsDirectlyInSection()) )
+ {
+ aRect = rSh.GetAnyCurRect(CurRectType::SectionPrt, pPt);
+ const SwRect aTmpRect = rSh.GetAnyCurRect(CurRectType::Section, pPt);
+ aRect.Pos() += aTmpRect.Pos();
+ }
+
+ else if ( bFrameSelection || nFrameType & FrameTypeFlags::FLY_ANY )
+ aRect = rSh.GetAnyCurRect(CurRectType::FlyEmbedded, pPt);
+ else if( nFrameType & FrameTypeFlags::DRAWOBJ)
+ aRect = rSh.GetObjRect();
+
+ if( aRect.Width() )
+ {
+ // make relative to page position:
+ aLongLR.SetLeft(aRect.Left() - rPageRect.Left());
+ aLongLR.SetRight(rPageRect.Right() - aRect.Right());
+ }
+ }
+ rSet.Put( aLongLR );
+ }
+ break;
+
+ // provide left and right margins of current page style
+ case SID_ATTR_PAGE_LRSPACE:
+ {
+ const SvxLRSpaceItem aTmpPageLRSpace( rDesc.GetMaster().GetLRSpace() );
+ const SvxLongLRSpaceItem aLongLR(
+ aTmpPageLRSpace.GetLeft(),
+ aTmpPageLRSpace.GetRight(),
+ SID_ATTR_PAGE_LRSPACE );
+ rSet.Put( aLongLR );
+ }
+ break;
+
+ case SID_ATTR_LONG_ULSPACE:
+ {
+ // Page margin top bottom
+ SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() );
+ SvxLongULSpaceItem aLongUL( static_cast<tools::Long>(aUL.GetUpper()),
+ static_cast<tools::Long>(aUL.GetLower()),
+ SID_ATTR_LONG_ULSPACE);
+
+ if ( bFrameSelection || nFrameType & FrameTypeFlags::FLY_ANY )
+ {
+ // Convert document coordinates into page coordinates.
+ const SwRect &rRect = rSh.GetAnyCurRect(CurRectType::FlyEmbedded, pPt);
+ aLongUL.SetUpper(rRect.Top() - rPageRect.Top());
+ aLongUL.SetLower(rPageRect.Bottom() - rRect.Bottom());
+ }
+ else if ( nFrameType & FrameTypeFlags::HEADER || nFrameType & FrameTypeFlags::FOOTER )
+ {
+ SwRect aRect( rSh.GetAnyCurRect( CurRectType::HeaderFooter, pPt));
+ aRect.Pos() -= rSh.GetAnyCurRect( CurRectType::Page, pPt ).Pos();
+ aLongUL.SetUpper( aRect.Top() );
+ aLongUL.SetLower( nPageHeight - aRect.Bottom() );
+ }
+ else if( nFrameType & FrameTypeFlags::DRAWOBJ)
+ {
+ const SwRect &rRect = rSh.GetObjRect();
+ aLongUL.SetUpper(rRect.Top() - rPageRect.Top());
+ aLongUL.SetLower(rPageRect.Bottom() - rRect.Bottom());
+ }
+ else if(bBrowse)
+ {
+ aLongUL.SetUpper(rPagePrtRect.Top());
+ aLongUL.SetLower(nPageHeight - rPagePrtRect.Bottom());
+ }
+ rSet.Put( aLongUL );
+ }
+ break;
+
+ // provide top and bottom margins of current page style
+ case SID_ATTR_PAGE_ULSPACE:
+ {
+ const SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() );
+ SvxLongULSpaceItem aLongUL(
+ static_cast<tools::Long>(aUL.GetUpper()),
+ static_cast<tools::Long>(aUL.GetLower()),
+ SID_ATTR_PAGE_ULSPACE );
+
+ rSet.Put( aLongUL );
+ }
+ break;
+
+ case SID_ATTR_TABSTOP_VERTICAL :
+ case RES_PARATR_TABSTOP:
+ {
+ if ( dynamic_cast< const SwWebView *>( this ) != nullptr ||
+ IsTabColFromDoc() ||
+ IsTabRowFromDoc() ||
+ ( nSelType & SelectionType::Graphic ) ||
+ ( nSelType & SelectionType::Frame ) ||
+ ( nSelType & SelectionType::Ole ) ||
+ (aCoreSet.GetItemState(RES_MARGIN_FIRSTLINE) < SfxItemState::DEFAULT) ||
+ (aCoreSet.GetItemState(RES_MARGIN_TEXTLEFT) < SfxItemState::DEFAULT) ||
+ (!bVerticalWriting && (SID_ATTR_TABSTOP_VERTICAL == nWhich) ) ||
+ ( bVerticalWriting && (RES_PARATR_TABSTOP == nWhich))
+ )
+ rSet.DisableItem( nWhich );
+ else
+ {
+ SvxTabStopItem aTabStops(aCoreSet.Get( RES_PARATR_TABSTOP ));
+
+ const SvxTabStopItem& rDefTabs = rSh.GetDefault(RES_PARATR_TABSTOP);
+
+ OSL_ENSURE(m_pHRuler, "why is there no ruler?");
+ const tools::Long nDefTabDist = ::GetTabDist(rDefTabs);
+ m_pHRuler->SetDefTabDist( nDefTabDist );
+ m_pVRuler->SetDefTabDist( nDefTabDist );
+ ::lcl_EraseDefTabs(aTabStops);
+ aTabStops.SetWhich(nWhich);
+ rSet.Put(aTabStops);
+
+ if (comphelper::LibreOfficeKit::isActive() && nWhich == RES_PARATR_TABSTOP)
+ {
+ boost::property_tree::ptree aRootTree;
+ boost::property_tree::ptree aEntries;
+
+ for (sal_uInt16 i = 0; i < aTabStops.Count(); ++i)
+ {
+ SvxTabStop const & rTabStop = aTabStops[i];
+ boost::property_tree::ptree aEntry;
+ aEntry.put("position", convertTwipToMm100(rTabStop.GetTabPos()));
+ aEntry.put("type", sal_uInt16(rTabStop.GetAdjustment()));
+ aEntry.put("decimal", OUString(rTabStop.GetDecimal()));
+ aEntry.put("fill", OUString(rTabStop.GetFill()));
+ aEntries.push_back(std::make_pair("", aEntry));
+ }
+ aRootTree.push_back(std::make_pair("tabstops", aEntries));
+
+ std::stringstream aStream;
+ boost::property_tree::write_json(aStream, aRootTree);
+ rSh.GetSfxViewShell()->libreOfficeKitViewCallback(LOK_CALLBACK_TAB_STOP_LIST, OString(aStream.str()));
+ }
+ }
+ break;
+ }
+
+ case SID_HANGING_INDENT:
+ {
+ SfxItemState e = aCoreSet.GetItemState(RES_MARGIN_FIRSTLINE);
+ if( e == SfxItemState::DISABLED )
+ rSet.DisableItem(nWhich);
+ break;
+ }
+
+ case SID_ATTR_PARA_LRSPACE_VERTICAL:
+ case SID_ATTR_PARA_LRSPACE:
+ case SID_ATTR_PARA_LEFTSPACE:
+ case SID_ATTR_PARA_RIGHTSPACE:
+ case SID_ATTR_PARA_FIRSTLINESPACE:
+ {
+ if ( nSelType & SelectionType::Graphic ||
+ nSelType & SelectionType::Frame ||
+ nSelType & SelectionType::Ole ||
+ nFrameType == FrameTypeFlags::DRAWOBJ ||
+ (!bVerticalWriting && (SID_ATTR_PARA_LRSPACE_VERTICAL == nWhich)) ||
+ ( bVerticalWriting && (SID_ATTR_PARA_LRSPACE == nWhich))
+ )
+ {
+ rSet.DisableItem(nWhich);
+ }
+ else
+ {
+ std::shared_ptr<SvxLRSpaceItem> aLR(std::make_shared<SvxLRSpaceItem>(RES_LR_SPACE));
+ if ( !IsTabColFromDoc() )
+ {
+ SvxFirstLineIndentItem const& rFirstLine(aCoreSet.Get(RES_MARGIN_FIRSTLINE));
+ SvxTextLeftMarginItem const& rLeftMargin(aCoreSet.Get(RES_MARGIN_TEXTLEFT));
+ SvxRightMarginItem const& rRightMargin(aCoreSet.Get(RES_MARGIN_RIGHT));
+ aLR->SetTextFirstLineOffset(rFirstLine.GetTextFirstLineOffset(), rFirstLine.GetPropTextFirstLineOffset());
+ aLR->SetAutoFirst(rFirstLine.IsAutoFirst());
+ aLR->SetTextLeft(rLeftMargin.GetTextLeft(), rLeftMargin.GetPropLeft());
+ aLR->SetRight(rRightMargin.GetRight(), rRightMargin.GetPropRight());
+
+ // #i23726#
+ if (m_pNumRuleNodeFromDoc)
+ {
+ short nOffset = static_cast< short >(aLR->GetTextLeft() +
+ // #i42922# Mouse move of numbering label
+ // has to consider the left indent of the paragraph
+ m_pNumRuleNodeFromDoc->GetLeftMarginWithNum( true ) );
+
+ short nFLOffset;
+ m_pNumRuleNodeFromDoc->GetFirstLineOfsWithNum( nFLOffset );
+
+ aLR->SetLeft( nOffset + nFLOffset );
+ }
+ }
+ aLR->SetWhich(nWhich);
+ rSet.Put(*aLR);
+ }
+ break;
+ }
+
+ case SID_ATTR_PARA_ULSPACE:
+ case SID_ATTR_PARA_ABOVESPACE:
+ case SID_ATTR_PARA_BELOWSPACE:
+ case SID_PARASPACE_INCREASE:
+ case SID_PARASPACE_DECREASE:
+ {
+ SvxULSpaceItem aUL = aCoreSet.Get(RES_UL_SPACE);
+ SfxItemState e = aCoreSet.GetItemState(RES_UL_SPACE);
+ if( e >= SfxItemState::DEFAULT )
+ {
+ if ( !aUL.GetUpper() && !aUL.GetLower() )
+ rSet.DisableItem( SID_PARASPACE_DECREASE );
+ else if ( aUL.GetUpper() >= 5670 && aUL.GetLower() >= 5670 )
+ rSet.DisableItem( SID_PARASPACE_INCREASE );
+ if ( nWhich == SID_ATTR_PARA_ULSPACE
+ || nWhich == SID_ATTR_PARA_ABOVESPACE
+ || nWhich == SID_ATTR_PARA_BELOWSPACE
+ )
+ {
+ aUL.SetWhich( nWhich );
+ rSet.Put( aUL );
+ }
+ }
+ else
+ {
+ rSet.DisableItem( SID_PARASPACE_INCREASE );
+ rSet.DisableItem( SID_PARASPACE_DECREASE );
+ rSet.InvalidateItem( SID_ATTR_PARA_ULSPACE );
+ rSet.InvalidateItem( SID_ATTR_PARA_ABOVESPACE );
+ rSet.InvalidateItem( SID_ATTR_PARA_BELOWSPACE );
+ }
+ }
+ break;
+
+ case SID_RULER_BORDER_DISTANCE:
+ {
+ m_nLeftBorderDistance = 0;
+ m_nRightBorderDistance = 0;
+ SfxItemSetFixed<RES_BOX, RES_BOX,
+ SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER> aCoreSet2(GetPool());
+ if ( nSelType & SelectionType::Graphic ||
+ nSelType & SelectionType::Frame ||
+ nSelType & SelectionType::Ole ||
+ nFrameType == FrameTypeFlags::DRAWOBJ )
+ rSet.DisableItem(SID_RULER_BORDER_DISTANCE);
+ else
+ {
+ SvxLRSpaceItem aDistLR(SID_RULER_BORDER_DISTANCE);
+ if(nFrameType & FrameTypeFlags::FLY_ANY)
+ {
+ if( IsTabColFromDoc() )
+ {
+ const SwRect& rFlyPrtRect = rSh.GetAnyCurRect( CurRectType::FlyEmbeddedPrt, pPt );
+ aDistLR.SetLeft(rFlyPrtRect.Left());
+ aDistLR.SetRight(rFlyPrtRect.Left());
+ rSet.Put(aDistLR);
+ }
+ else
+ {
+ SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
+ aCoreSet2.Put(aBoxInfo);
+ rSh.GetFlyFrameAttr(aCoreSet2);
+ const SvxBoxItem& rBox = aCoreSet2.Get(RES_BOX);
+ aDistLR.SetLeft(rBox.GetDistance(SvxBoxItemLine::LEFT));
+ aDistLR.SetRight(rBox.GetDistance(SvxBoxItemLine::RIGHT));
+ rSet.Put(aDistLR);
+
+ //add the paragraph border distance
+ SfxItemSetFixed<RES_BOX, RES_BOX> aCoreSet1( GetPool() );
+ rSh.GetCurAttr( aCoreSet1 );
+ const SvxBoxItem& rParaBox = aCoreSet1.Get(RES_BOX);
+ aDistLR.SetLeft(aDistLR.GetLeft() + rParaBox.GetDistance(SvxBoxItemLine::LEFT));
+ aDistLR.SetRight(aDistLR.GetRight() + rParaBox.GetDistance(SvxBoxItemLine::RIGHT));
+ }
+ m_nLeftBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetLeft());
+ m_nRightBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetRight());
+ }
+ else if ( IsTabColFromDoc() ||
+ ( rSh.GetTableFormat() && !bFrameSelection &&
+ !(nFrameType & FrameTypeFlags::COLSECT ) ) )
+ {
+ SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
+ aBoxInfo.SetTable(false);
+ aBoxInfo.SetDist(true);
+ aCoreSet2.Put(aBoxInfo);
+ rSh.GetTabBorders( aCoreSet2 );
+ const SvxBoxItem& rBox = aCoreSet2.Get(RES_BOX);
+ aDistLR.SetLeft(rBox.GetDistance(SvxBoxItemLine::LEFT));
+ aDistLR.SetRight(rBox.GetDistance(SvxBoxItemLine::RIGHT));
+ rSet.Put(aDistLR);
+
+ //add the border distance of the paragraph
+ SfxItemSetFixed<RES_BOX, RES_BOX> aCoreSet1( GetPool() );
+ rSh.GetCurAttr( aCoreSet1 );
+ const SvxBoxItem& rParaBox = aCoreSet1.Get(RES_BOX);
+ aDistLR.SetLeft(aDistLR.GetLeft() + rParaBox.GetDistance(SvxBoxItemLine::LEFT));
+ aDistLR.SetRight(aDistLR.GetRight() + rParaBox.GetDistance(SvxBoxItemLine::RIGHT));
+ m_nLeftBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetLeft());
+ m_nRightBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetRight());
+ }
+ else if ( !rSh.IsDirectlyInSection() )
+ {
+ //get the page/header/footer border distance
+ const SwFrameFormat& rMaster = rDesc.GetMaster();
+ const SvxBoxItem& rBox = rMaster.GetAttrSet().Get(RES_BOX);
+ aDistLR.SetLeft(rBox.GetDistance(SvxBoxItemLine::LEFT));
+ aDistLR.SetRight(rBox.GetDistance(SvxBoxItemLine::RIGHT));
+
+ const SvxBoxItem* pBox = nullptr;
+ if(nFrameType & FrameTypeFlags::HEADER)
+ {
+ rMaster.GetHeader();
+ const SwFormatHeader& rHeaderFormat = rMaster.GetHeader();
+ SwFrameFormat *pHeaderFormat = const_cast<SwFrameFormat*>(rHeaderFormat.GetHeaderFormat());
+ if( pHeaderFormat )// #i80890# if rDesc is not the one belonging to the current page is might crash
+ pBox = & pHeaderFormat->GetBox();
+ }
+ else if(nFrameType & FrameTypeFlags::FOOTER )
+ {
+ const SwFormatFooter& rFooterFormat = rMaster.GetFooter();
+ SwFrameFormat *pFooterFormat = const_cast<SwFrameFormat*>(rFooterFormat.GetFooterFormat());
+ if( pFooterFormat )// #i80890# if rDesc is not the one belonging to the current page is might crash
+ pBox = & pFooterFormat->GetBox();
+ }
+ if(pBox)
+ {
+ aDistLR.SetLeft(pBox->GetDistance(SvxBoxItemLine::LEFT));
+ aDistLR.SetRight(pBox->GetDistance(SvxBoxItemLine::RIGHT));
+ }
+ rSet.Put(aDistLR);
+
+ //add the border distance of the paragraph
+ rSh.GetCurAttr(aCoreSet2);
+ const SvxBoxItem& rParaBox = aCoreSet2.Get(RES_BOX);
+ aDistLR.SetLeft(aDistLR.GetLeft() + rParaBox.GetDistance(SvxBoxItemLine::LEFT));
+ aDistLR.SetRight(aDistLR.GetRight() + rParaBox.GetDistance(SvxBoxItemLine::RIGHT));
+ m_nLeftBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetLeft());
+ m_nRightBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetRight());
+ }
+ }
+ }
+ break;
+
+ case SID_RULER_TEXT_RIGHT_TO_LEFT:
+ {
+ if ( nSelType & SelectionType::Graphic ||
+ nSelType & SelectionType::Frame ||
+ nSelType & SelectionType::Ole ||
+ nFrameType == FrameTypeFlags::DRAWOBJ)
+ rSet.DisableItem(nWhich);
+ else
+ {
+ bool bFlag = rSh.IsInRightToLeftText();
+ rSet.Put(SfxBoolItem(nWhich, bFlag));
+ }
+ }
+ break;
+
+ case SID_RULER_BORDERS_VERTICAL:
+ case SID_RULER_BORDERS:
+ {
+ bool bFrameHasVerticalColumns(false);
+ {
+ bool bFrameRTL;
+ bool bFrameVertL2R;
+ bFrameHasVerticalColumns = rSh.IsFrameVertical(false, bFrameRTL, bFrameVertL2R) &&
+ bFrameSelection;
+ }
+ bool bHasTable = ( IsTabColFromDoc() ||
+ ( rSh.GetTableFormat() && !bFrameSelection &&
+ !(nFrameType & FrameTypeFlags::COLSECT ) ) );
+
+ bool bTableVertical = bHasTable && rSh.IsTableVertical();
+
+ if(((SID_RULER_BORDERS_VERTICAL == nWhich) &&
+ ((bHasTable && !bTableVertical) ||
+ (!bVerticalWriting && !bFrameSelection && !bHasTable ) ||
+ ( bFrameSelection && !bFrameHasVerticalColumns))) ||
+ ((SID_RULER_BORDERS == nWhich) &&
+ ((bHasTable && bTableVertical) ||
+ (bVerticalWriting && !bFrameSelection&& !bHasTable) || bFrameHasVerticalColumns)))
+ rSet.DisableItem(nWhich);
+ else if ( bHasTable )
+ {
+ SwTabCols aTabCols;
+ size_t nNum = 0;
+ m_bSetTabColFromDoc = IsTabColFromDoc();
+ if ( m_bSetTabColFromDoc )
+ {
+ rSh.GetMouseTabCols( aTabCols, m_aTabColFromDocPos );
+ nNum = rSh.GetCurMouseTabColNum( m_aTabColFromDocPos );
+ }
+ else
+ {
+ rSh.GetTabCols( aTabCols );
+ nNum = rSh.GetCurTabColNum();
+ if(rSh.IsTableRightToLeft())
+ nNum = aTabCols.Count() - nNum;
+ }
+
+ OSL_ENSURE(nNum <= aTabCols.Count(), "TabCol not found");
+ const int nLft = aTabCols.GetLeftMin() + aTabCols.GetLeft();
+ const int nRgt = (bTableVertical ? nPageHeight : nPageWidth) -
+ (aTabCols.GetLeftMin() + aTabCols.GetRight());
+
+ const sal_uInt16 nL = static_cast< sal_uInt16 >(std::max(nLft, 0));
+ const sal_uInt16 nR = static_cast< sal_uInt16 >(std::max(nRgt, 0));
+
+ SvxColumnItem aColItem(nNum, nL, nR);
+
+ tools::Long nStart = 0;
+ tools::Long nEnd = 0;
+
+ //columns in right-to-left tables need to be mirrored
+ bool bIsTableRTL =
+ IsTabColFromDoc() ?
+ rSh.IsMouseTableRightToLeft(m_aTabColFromDocPos)
+ : rSh.IsTableRightToLeft();
+ if(bIsTableRTL)
+ {
+ for ( size_t i = aTabCols.Count(); i; --i )
+ {
+ const SwTabColsEntry& rEntry = aTabCols.GetEntry( i - 1 );
+ nEnd = aTabCols.GetRight() - rEntry.nPos;
+ SvxColumnDescription aColDesc( nStart, nEnd,
+ aTabCols.GetRight() - rEntry.nMax,
+ aTabCols.GetRight() - rEntry.nMin,
+ !aTabCols.IsHidden(i - 1) );
+ aColItem.Append(aColDesc);
+ nStart = nEnd;
+ }
+ SvxColumnDescription aColDesc(nStart,
+ aTabCols.GetRight() - aTabCols.GetLeft(), true);
+ aColItem.Append(aColDesc);
+ }
+ else
+ {
+ for ( size_t i = 0; i < aTabCols.Count(); ++i )
+ {
+ const SwTabColsEntry& rEntry = aTabCols.GetEntry( i );
+ nEnd = rEntry.nPos - aTabCols.GetLeft();
+ SvxColumnDescription aColDesc( nStart, nEnd,
+ rEntry.nMin - aTabCols.GetLeft(), rEntry.nMax - aTabCols.GetLeft(),
+ !aTabCols.IsHidden(i) );
+ aColItem.Append(aColDesc);
+ nStart = nEnd;
+ }
+ SvxColumnDescription aColDesc(nStart, aTabCols.GetRight() - aTabCols.GetLeft(),
+ 0, 0, true);
+ aColItem.Append(aColDesc);
+ }
+ aColItem.SetWhich(nWhich);
+ rSet.Put(aColItem);
+ }
+ else if ( bFrameSelection || nFrameType & ( FrameTypeFlags::COLUMN | FrameTypeFlags::COLSECT ) )
+ {
+ // Out of frame or page?
+ sal_uInt16 nNum = 0;
+ if(bFrameSelection)
+ {
+ const SwFrameFormat* pFormat = rSh.GetFlyFrameFormat();
+ if(pFormat)
+ nNum = pFormat->GetCol().GetNumCols();
+ }
+ else
+ nNum = rSh.GetCurColNum();
+
+ if(
+ // For that matter FrameTypeFlags::COLSECT should not be included
+ // if the border is selected!
+ !bFrameSelection &&
+ nFrameType & FrameTypeFlags::COLSECT )
+ {
+ const SwSection *pSect = rSh.GetAnySection(false, pPt);
+ OSL_ENSURE( pSect, "Which section?");
+ if( pSect )
+ {
+ SwSectionFormat const *pFormat = pSect->GetFormat();
+ const SwFormatCol& rCol = pFormat->GetCol();
+ if (rSh.IsColRightToLeft())
+ nNum = rCol.GetColumns().size() - nNum;
+ else
+ --nNum;
+ SvxColumnItem aColItem(nNum);
+ SwRect aRect = rSh.GetAnyCurRect(CurRectType::SectionPrt, pPt);
+ const SwRect aTmpRect = rSh.GetAnyCurRect(CurRectType::Section, pPt);
+
+ ::lcl_FillSvxColumn(rCol, bVerticalWriting ? aRect.Height() : aRect.Width(), aColItem, 0);
+
+ if(bVerticalWriting)
+ {
+ aRect.Pos() += Point(aTmpRect.Left(), aTmpRect.Top());
+ aRect.Pos().AdjustY( -(rPageRect.Top()) );
+ aColItem.SetLeft(aRect.Top());
+ aColItem.SetRight(nPageHeight - aRect.Bottom());
+ }
+ else
+ {
+ aRect.Pos() += aTmpRect.Pos();
+
+ // make relative to page position:
+ aColItem.SetLeft (o3tl::narrowing<sal_uInt16>( aRect.Left() - rPageRect.Left() ));
+ aColItem.SetRight(o3tl::narrowing<sal_uInt16>( rPageRect.Right() - aRect.Right()));
+ }
+ aColItem.SetOrtho(aColItem.CalcOrtho());
+
+ aColItem.SetWhich(nWhich);
+ rSet.Put(aColItem);
+ }
+ }
+ else if( bFrameSelection || nFrameType & FrameTypeFlags::FLY_ANY )
+ {
+ // Columns in frame
+ if ( nNum )
+ {
+ const SwFrameFormat* pFormat = rSh.GetFlyFrameFormat() ;
+
+ const SwFormatCol& rCol = pFormat->GetCol();
+ if (rSh.IsColRightToLeft())
+ nNum = rCol.GetColumns().size() - nNum;
+ else
+ nNum--;
+ SvxColumnItem aColItem(nNum);
+ const SwRect &rSizeRect = rSh.GetAnyCurRect(CurRectType::FlyEmbeddedPrt, pPt);
+
+ bool bUseVertical = bFrameHasVerticalColumns || (!bFrameSelection && bVerticalWriting);
+ const tools::Long lWidth = bUseVertical ? rSizeRect.Height() : rSizeRect.Width();
+ const SwRect &rRect = rSh.GetAnyCurRect(CurRectType::FlyEmbedded, pPt);
+ tools::Long nDist2 = ((bUseVertical ? rRect.Height() : rRect.Width()) - lWidth) /2;
+ ::lcl_FillSvxColumn(rCol, lWidth, aColItem, nDist2);
+
+ if(bUseVertical)
+ {
+ aColItem.SetLeft(rRect.Top()- rPageRect.Top());
+ aColItem.SetRight(nPageHeight + rPageRect.Top() - rRect.Bottom());
+ }
+ else
+ {
+ aColItem.SetLeft(rRect.Left() - rPageRect.Left());
+ aColItem.SetRight(rPageRect.Right() - rRect.Right());
+ }
+
+ aColItem.SetOrtho(aColItem.CalcOrtho());
+
+ aColItem.SetWhich(nWhich);
+ rSet.Put(aColItem);
+ }
+ else
+ rSet.DisableItem(nWhich);
+ }
+ else
+ { // Columns on the page
+ const SwFrameFormat& rMaster = rDesc.GetMaster();
+ SwFormatCol aCol(rMaster.GetCol());
+ if(rFrameDir.GetValue() == SvxFrameDirection::Horizontal_RL_TB)
+ nNum = aCol.GetColumns().size() - nNum;
+ else
+ nNum--;
+
+ SvxColumnItem aColItem(nNum);
+ const SwRect aPrtRect = rSh.GetAnyCurRect(CurRectType::PagePrt, pPt);
+ const SvxBoxItem& rBox = rMaster.GetFormatAttr(RES_BOX);
+ tools::Long nDist = rBox.GetSmallestDistance();
+
+ lcl_FillSvxColumn(
+ aCol,
+ bVerticalWriting ? aPrtRect.Height() : aPrtRect.Width(),
+ aColItem, nDist);
+
+ if(bBrowse)
+ {
+ if (bVerticalWriting)
+ {
+ aColItem.SetLeft(o3tl::narrowing<sal_uInt16>(rPagePrtRect.Top()));
+ aColItem.SetRight(sal_uInt16(nPageHeight - rPagePrtRect.Bottom()));
+ }
+ else
+ {
+ aColItem.SetLeft(o3tl::narrowing<sal_uInt16>(rPagePrtRect.Left()));
+ aColItem.SetRight(sal_uInt16(nPageWidth - rPagePrtRect.Right()));
+ }
+ }
+ else
+ {
+ if (bVerticalWriting)
+ {
+ SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() );
+ aColItem.SetLeft (aUL.GetUpper());
+ aColItem.SetRight(aUL.GetLower());
+ }
+ else
+ {
+ aColItem.SetLeft (aPageLRSpace.GetLeft());
+ aColItem.SetRight(aPageLRSpace.GetRight());
+ }
+ }
+ aColItem.SetOrtho(aColItem.CalcOrtho());
+
+ aColItem.SetWhich(nWhich);
+ rSet.Put(aColItem);
+ }
+ }
+ else
+ rSet.DisableItem(nWhich);
+ break;
+ }
+
+ case SID_RULER_ROWS :
+ case SID_RULER_ROWS_VERTICAL:
+ {
+ bool bFrameHasVerticalColumns(false);
+ {
+ bool bFrameRTL;
+ bool bFrameVertL2R;
+ bFrameHasVerticalColumns = rSh.IsFrameVertical(false, bFrameRTL, bFrameVertL2R) &&
+ bFrameSelection;
+ }
+
+ if(((SID_RULER_ROWS == nWhich) &&
+ ((!bVerticalWriting && !bFrameSelection) || (bFrameSelection && !bFrameHasVerticalColumns))) ||
+ ((SID_RULER_ROWS_VERTICAL == nWhich) &&
+ ((bVerticalWriting && !bFrameSelection) || bFrameHasVerticalColumns)))
+ rSet.DisableItem(nWhich);
+ else if ( IsTabRowFromDoc() ||
+ ( rSh.GetTableFormat() && !bFrameSelection &&
+ !(nFrameType & FrameTypeFlags::COLSECT ) ) )
+ {
+ SwTabCols aTabCols;
+ m_bSetTabRowFromDoc = IsTabRowFromDoc();
+ if ( m_bSetTabRowFromDoc )
+ {
+ rSh.GetMouseTabRows( aTabCols, m_aTabColFromDocPos );
+ }
+ else
+ {
+ rSh.GetTabRows( aTabCols );
+ }
+
+ const int nLft = aTabCols.GetLeftMin();
+ const int nRgt = (bVerticalWriting ? nPageWidth : nPageHeight) -
+ (aTabCols.GetLeftMin() + aTabCols.GetRight());
+
+ const sal_uInt16 nL = static_cast< sal_uInt16 >(std::max(nLft, 0));
+ const sal_uInt16 nR = static_cast< sal_uInt16 >(std::max(nRgt, 0));
+
+ SvxColumnItem aColItem(0, nL, nR);
+
+ tools::Long nStart = 0;
+ tools::Long nEnd = 0;
+
+ for ( size_t i = 0; i < aTabCols.Count(); ++i )
+ {
+ const SwTabColsEntry& rEntry = aTabCols.GetEntry( i );
+ if(bVerticalWriting)
+ {
+ nEnd = aTabCols.GetRight() - rEntry.nPos;
+ SvxColumnDescription aColDesc( nStart, nEnd,
+ std::max(tools::Long(0), aTabCols.GetRight() - rEntry.nMax),
+ std::max(tools::Long(0), aTabCols.GetRight() - rEntry.nMin),
+ !aTabCols.IsHidden(i) );
+ aColItem.Append(aColDesc);
+ }
+ else
+ {
+ nEnd = rEntry.nPos - aTabCols.GetLeft();
+ SvxColumnDescription aColDesc( nStart, nEnd,
+ rEntry.nMin - aTabCols.GetLeft(),
+ rEntry.nMax - aTabCols.GetLeft(),
+ !aTabCols.IsHidden(i) );
+ aColItem.Append(aColDesc);
+ }
+ nStart = nEnd;
+ }
+ if(bVerticalWriting)
+ nEnd = aTabCols.GetRight();
+ else
+ nEnd = aTabCols.GetLeft();
+
+ SvxColumnDescription aColDesc( nStart, nEnd,
+ aTabCols.GetRight(),
+ aTabCols.GetRight(),
+ false );
+ aColItem.Append(aColDesc);
+
+ aColItem.SetWhich(nWhich);
+ rSet.Put(aColItem);
+ }
+ else
+ rSet.DisableItem(nWhich);
+ }
+ break;
+
+ case SID_RULER_PAGE_POS:
+ {
+ SvxPagePosSizeItem aPagePosSize(
+ Point( rPageRect.Left(), rPageRect.Top()) , nPageWidth, nPageHeight);
+
+ rSet.Put(aPagePosSize);
+ break;
+ }
+
+ case SID_RULER_LR_MIN_MAX:
+ {
+ tools::Rectangle aRectangle;
+ if( ( nFrameType & FrameTypeFlags::COLSECT ) && !IsTabColFromDoc() &&
+ ( nFrameType & ( FrameTypeFlags::TABLE|FrameTypeFlags::COLUMN ) ) )
+ {
+ if( nFrameType & FrameTypeFlags::TABLE )
+ {
+ const size_t nNum = rSh.GetCurTabColNum();
+ SwTabCols aTabCols;
+ rSh.GetTabCols( aTabCols );
+
+ const int nLft = aTabCols.GetLeftMin() + aTabCols.GetLeft();
+ const int nRgt = nPageWidth -(aTabCols.GetLeftMin() + aTabCols.GetRight());
+
+ const sal_uInt16 nL = static_cast< sal_uInt16 >(std::max(nLft, 0));
+ const sal_uInt16 nR = static_cast< sal_uInt16 >(std::max(nRgt, 0));
+
+ aRectangle.SetLeft( nL );
+ if(nNum > 1)
+ aRectangle.AdjustLeft(aTabCols[nNum - 2] );
+ if(nNum)
+ aRectangle.AdjustLeft(MINLAY );
+ if(aTabCols.Count() <= nNum + 1 )
+ aRectangle.SetRight( nR );
+ else
+ aRectangle.SetRight( nPageWidth - (nL + aTabCols[nNum + 1]) );
+
+ if(nNum < aTabCols.Count())
+ aRectangle.AdjustRight(MINLAY );
+ }
+ else
+ {
+ const SwFrameFormat* pFormat = rSh.GetFlyFrameFormat();
+ const SwFormatCol* pCols = pFormat ? &pFormat->GetCol():
+ &rDesc.GetMaster().GetCol();
+ const SwColumns& rCols = pCols->GetColumns();
+ sal_uInt16 nNum = rSh.GetCurOutColNum();
+ const sal_uInt16 nCount = std::min(sal_uInt16(nNum + 1), sal_uInt16(rCols.size()));
+ const SwRect aRect( rSh.GetAnyCurRect( pFormat
+ ? CurRectType::FlyEmbeddedPrt
+ : CurRectType::PagePrt, pPt ));
+ const SwRect aAbsRect( rSh.GetAnyCurRect( pFormat
+ ? CurRectType::FlyEmbedded
+ : CurRectType::Page, pPt ));
+
+ // The width of the frame or within the page margins.
+ const sal_uInt16 nTotalWidth = o3tl::narrowing<sal_uInt16>(aRect.Width());
+ // The entire frame width - The difference is twice the distance to the edge.
+ const sal_uInt16 nOuterWidth = o3tl::narrowing<sal_uInt16>(aAbsRect.Width());
+ int nWidth = 0,
+ nEnd = 0;
+ aRectangle.SetLeft( 0 );
+ for ( sal_uInt16 i = 0; i < nCount; ++i )
+ {
+ const SwColumn* pCol = &rCols[i];
+ const int nStart = pCol->GetLeft() + nWidth;
+ if(i == nNum - 2)
+ aRectangle.SetLeft( nStart );
+ nWidth += pCols->CalcColWidth( i, nTotalWidth );
+ nEnd = nWidth - pCol->GetRight();
+ }
+ aRectangle.SetRight( rPageRect.Right() - nEnd );
+ aRectangle.AdjustLeft( -(rPageRect.Left()) );
+
+ if(nNum > 1)
+ {
+ aRectangle.AdjustLeft(MINLAY );
+ aRectangle.AdjustLeft(aRect.Left() );
+ }
+ if(pFormat) // Range in frame - here you may up to the edge
+ {
+ aRectangle.SetLeft(0);
+ aRectangle.SetRight(0);
+ }
+ else
+ {
+ // Move the rectangle to the correct absolute position.
+ aRectangle.AdjustLeft(aAbsRect.Left() );
+ aRectangle.AdjustRight( -(aAbsRect.Left()) );
+ // Include distance to the border.
+ aRectangle.AdjustRight( -((nOuterWidth - nTotalWidth) / 2) );
+ }
+
+ if(nNum < rCols.size())
+ {
+ aRectangle.AdjustRight(MINLAY );
+ }
+ else
+ // Right is only the margin now.
+ aRectangle.SetRight( 0 );
+
+ }
+ }
+ else if ( ((nFrameType & FrameTypeFlags::TABLE) || IsTabColFromDoc()) &&
+ !bFrameSelection )
+ {
+ bool bColumn;
+ if ( IsTabColFromDoc() )
+ bColumn = rSh.GetCurMouseColNum( m_aTabColFromDocPos ) != 0;
+ else
+ bColumn = bool(nFrameType & (FrameTypeFlags::COLUMN|FrameTypeFlags::FLY_ANY|FrameTypeFlags::COLSECTOUTTAB));
+
+ if ( !bColumn )
+ {
+ if( nFrameType & FrameTypeFlags::FLY_ANY && IsTabColFromDoc() )
+ {
+ SwRect aRect( rSh.GetAnyCurRect(
+ CurRectType::FlyEmbeddedPrt, pPt ) );
+ aRect.Pos() += rSh.GetAnyCurRect( CurRectType::FlyEmbedded,
+ pPt ).Pos();
+
+ aRectangle.SetLeft( aRect.Left() - rPageRect.Left() );
+ aRectangle.SetRight( rPageRect.Right() - aRect.Right() );
+ }
+ else if( bBrowse )
+ {
+ aRectangle.SetLeft( rPagePrtRect.Left() );
+ aRectangle.SetRight( nPageWidth - rPagePrtRect.Right() );
+ }
+ else
+ {
+ aRectangle.SetLeft( aPageLRSpace.GetLeft() );
+ aRectangle.SetRight( aPageLRSpace.GetRight() );
+ }
+ }
+ else
+ { // Here only for table in multi-column pages and borders.
+ bool bSectOutTable = bool(nFrameType & FrameTypeFlags::TABLE);
+ bool bFrame = bool(nFrameType & FrameTypeFlags::FLY_ANY);
+ bool bColSct = bool(nFrameType & ( bSectOutTable
+ ? FrameTypeFlags::COLSECTOUTTAB
+ : FrameTypeFlags::COLSECT )
+ );
+ //So you can also drag with the mouse, without being in the table.
+ CurRectType eRecType = CurRectType::PagePrt;
+ size_t nNum = IsTabColFromDoc() ?
+ rSh.GetCurMouseColNum( m_aTabColFromDocPos ):
+ rSh.GetCurOutColNum();
+ const SwFrameFormat* pFormat = nullptr;
+ if( bColSct )
+ {
+ eRecType = bSectOutTable ? CurRectType::SectionOutsideTable
+ : CurRectType::Section;
+ const SwSection *pSect = rSh.GetAnySection( bSectOutTable, pPt );
+ OSL_ENSURE( pSect, "Which section?");
+ pFormat = pSect->GetFormat();
+ }
+ else if( bFrame )
+ {
+ pFormat = rSh.GetFlyFrameFormat();
+ eRecType = CurRectType::FlyEmbeddedPrt;
+ }
+
+ const SwFormatCol* pCols = pFormat ? &pFormat->GetCol():
+ &rDesc.GetMaster().GetCol();
+ const SwColumns& rCols = pCols->GetColumns();
+ const sal_uInt16 nBorder = pFormat
+ ? pFormat->GetBox().GetSmallestDistance()
+ : rDesc.GetMaster().GetBox().GetSmallestDistance();
+
+ // RECT_FLY_PRT_EMBEDDED returns the relative position to RECT_FLY_EMBEDDED
+ // the absolute position must be added here
+
+ SwRect aRect( rSh.GetAnyCurRect( eRecType, pPt ) );
+ if(CurRectType::FlyEmbeddedPrt == eRecType)
+ aRect.Pos() += rSh.GetAnyCurRect( CurRectType::FlyEmbedded,
+ pPt ).Pos();
+
+ const sal_uInt16 nTotalWidth = o3tl::narrowing<sal_uInt16>(aRect.Width());
+ // Initialize nStart and nEnd for nNum == 0
+ int nWidth = 0,
+ nStart = 0,
+ nEnd = nTotalWidth;
+
+ if( nNum > rCols.size() )
+ {
+ OSL_ENSURE( false, "wrong FormatCol is being edited!" );
+ nNum = rCols.size();
+ }
+
+ for( size_t i = 0; i < nNum; ++i )
+ {
+ const SwColumn* pCol = &rCols[i];
+ nStart = pCol->GetLeft() + nWidth;
+ nWidth += pCols->CalcColWidth( o3tl::narrowing<sal_uInt16>(i), nTotalWidth );
+ nEnd = nWidth - pCol->GetRight();
+ }
+ if( bFrame || bColSct )
+ {
+ aRectangle.SetLeft( aRect.Left() - rPageRect.Left() + nStart );
+ aRectangle.SetRight( nPageWidth - aRectangle.Left() - nEnd + nStart );
+ }
+ else if(!bBrowse)
+ {
+ aRectangle.SetLeft( aPageLRSpace.GetLeft() + nStart );
+ aRectangle.SetRight( nPageWidth - nEnd - aPageLRSpace.GetLeft() );
+ }
+ else
+ {
+ tools::Long nLeft = rPagePrtRect.Left();
+ aRectangle.SetLeft( nStart + nLeft );
+ aRectangle.SetRight( nPageWidth - nEnd - nLeft );
+ }
+ if(!bFrame)
+ {
+ aRectangle.AdjustLeft(nBorder );
+ aRectangle.AdjustRight( -nBorder );
+ }
+ }
+ }
+ else if ( nFrameType & ( FrameTypeFlags::HEADER | FrameTypeFlags::FOOTER ))
+ {
+ aRectangle.SetLeft( aPageLRSpace.GetLeft() );
+ aRectangle.SetRight( aPageLRSpace.GetRight() );
+ }
+ else
+ {
+ aRectangle.SetLeft(0);
+ aRectangle.SetRight(0);
+ }
+
+ SfxRectangleItem aLR( SID_RULER_LR_MIN_MAX , aRectangle);
+ rSet.Put(aLR);
+ }
+ break;
+
+ case SID_RULER_PROTECT:
+ {
+ if(bFrameSelection)
+ {
+ FlyProtectFlags nProtect = m_pWrtShell->IsSelObjProtected( FlyProtectFlags::Size|FlyProtectFlags::Pos|FlyProtectFlags::Content );
+
+ SvxProtectItem aProt(SID_RULER_PROTECT);
+ aProt.SetContentProtect(bool(nProtect & FlyProtectFlags::Content));
+ aProt.SetSizeProtect (bool(nProtect & FlyProtectFlags::Size));
+ aProt.SetPosProtect (bool(nProtect & FlyProtectFlags::Pos));
+ rSet.Put(aProt);
+ }
+ else
+ {
+ SvxProtectItem aProtect(SID_RULER_PROTECT);
+ if(bBrowse && !(nFrameType & (FrameTypeFlags::DRAWOBJ|FrameTypeFlags::COLUMN)) && !rSh.GetTableFormat())
+ {
+ aProtect.SetSizeProtect(true);
+ aProtect.SetPosProtect(true);
+ }
+ rSet.Put(aProtect);
+ }
+ }
+ break;
+
+ case SID_ATTR_PAGE_HEADER:
+ case SID_ATTR_PAGE_HEADER_LRMARGIN:
+ case SID_ATTR_PAGE_HEADER_SPACING:
+ case SID_ATTR_PAGE_HEADER_LAYOUT:
+ {
+ const SwFormatHeader& rHeader = rDesc.GetMaster().GetHeader();
+ bool bHeaderOn = rHeader.IsActive();
+ rSet.Put( SfxBoolItem(SID_ATTR_PAGE_HEADER, bHeaderOn ) );
+ if(bHeaderOn)
+ {
+ const SvxLRSpaceItem* pLR = rHeader.GetHeaderFormat()->GetAttrSet().GetItem(SID_ATTR_LRSPACE);
+ const SvxULSpaceItem* pUL = rHeader.GetHeaderFormat()->GetAttrSet().GetItem(SID_ATTR_ULSPACE);
+ if (pLR && pUL)
+ {
+ SvxLongLRSpaceItem aLR(pLR->GetLeft(), pLR->GetRight(), SID_ATTR_PAGE_HEADER_LRMARGIN);
+ rSet.Put(aLR);
+ SvxLongULSpaceItem aUL( pUL->GetUpper(), pUL->GetLower(), SID_ATTR_PAGE_HEADER_SPACING);
+ rSet.Put(aUL);
+ }
+
+ bool bShared = !rDesc.IsHeaderShared();
+ bool bFirst = !rDesc.IsFirstShared(); // FIXME control changes for both header footer - tdf#100287
+ sal_uInt16 nLayout = (static_cast<int>(bShared)<<1) + static_cast<int>(bFirst);
+ SfxInt16Item aLayoutItem(SID_ATTR_PAGE_HEADER_LAYOUT, nLayout);
+ rSet.Put(aLayoutItem);
+ }
+ }
+ break;
+ case SID_ATTR_PAGE_FOOTER:
+ case SID_ATTR_PAGE_FOOTER_LRMARGIN:
+ case SID_ATTR_PAGE_FOOTER_SPACING:
+ case SID_ATTR_PAGE_FOOTER_LAYOUT:
+ {
+ const SwFormatFooter& rFooter = rDesc.GetMaster().GetFooter();
+ bool bFooterOn = rFooter.IsActive();
+ rSet.Put( SfxBoolItem(SID_ATTR_PAGE_FOOTER, bFooterOn ) );
+ if (bFooterOn)
+ {
+ if (const SvxLRSpaceItem* rLR = rFooter.GetFooterFormat()->GetAttrSet().GetItem<SvxLRSpaceItem>(SID_ATTR_LRSPACE))
+ {
+ SvxLongLRSpaceItem aLR(rLR->GetLeft(), rLR->GetRight(), SID_ATTR_PAGE_FOOTER_LRMARGIN);
+ rSet.Put(aLR);
+ }
+ if (const SvxULSpaceItem* rUL = rFooter.GetFooterFormat()->GetAttrSet().GetItem<SvxULSpaceItem>(SID_ATTR_ULSPACE))
+ {
+ SvxLongULSpaceItem aUL( rUL->GetUpper(), rUL->GetLower(), SID_ATTR_PAGE_FOOTER_SPACING);
+ rSet.Put(aUL);
+ }
+ bool bShared = !rDesc.IsFooterShared();
+ bool bFirst = !rDesc.IsFirstShared(); // FIXME control changes for both header footer - tdf#100287
+ sal_uInt16 nLayout = (static_cast<int>(bShared)<<1) + static_cast<int>(bFirst);
+ SfxInt16Item aLayoutItem(SID_ATTR_PAGE_FOOTER_LAYOUT, nLayout);
+ rSet.Put(aLayoutItem);
+ }
+ }
+ break;
+
+ case SID_ATTR_PAGE_COLOR:
+ case SID_ATTR_PAGE_FILLSTYLE:
+ case SID_ATTR_PAGE_GRADIENT:
+ case SID_ATTR_PAGE_HATCH:
+ case SID_ATTR_PAGE_BITMAP:
+ {
+ const SfxItemSet& rMasterSet = rDesc.GetMaster().GetAttrSet();
+ if (const auto pFillStyleItem = rMasterSet.GetItem(XATTR_FILLSTYLE))
+ {
+ drawing::FillStyle eXFS = pFillStyleItem->GetValue();
+ XFillStyleItem aFillStyleItem( eXFS );
+ aFillStyleItem.SetWhich( SID_ATTR_PAGE_FILLSTYLE );
+ rSet.Put(aFillStyleItem);
+
+ switch(eXFS)
+ {
+ case drawing::FillStyle_SOLID:
+ {
+ if (const auto pItem = rMasterSet.GetItem<XFillColorItem>(XATTR_FILLCOLOR, false))
+ {
+ Color aColor = pItem->GetColorValue();
+ XFillColorItem aFillColorItem( OUString(), aColor );
+ aFillColorItem.SetWhich( SID_ATTR_PAGE_COLOR );
+ rSet.Put( aFillColorItem );
+ }
+ break;
+ }
+
+ case drawing::FillStyle_GRADIENT:
+ {
+ const basegfx::BGradient& aBGradient = rMasterSet.GetItem<XFillGradientItem>( XATTR_FILLGRADIENT )->GetGradientValue();
+ XFillGradientItem aFillGradientItem( OUString(), aBGradient, SID_ATTR_PAGE_GRADIENT );
+ rSet.Put( aFillGradientItem );
+ }
+ break;
+
+ case drawing::FillStyle_HATCH:
+ {
+ const XFillHatchItem *pFillHatchItem( rMasterSet.GetItem<XFillHatchItem>( XATTR_FILLHATCH ) );
+ XFillHatchItem aFillHatchItem( pFillHatchItem->GetName(), pFillHatchItem->GetHatchValue());
+ aFillHatchItem.SetWhich( SID_ATTR_PAGE_HATCH );
+ rSet.Put( aFillHatchItem );
+ }
+ break;
+
+ case drawing::FillStyle_BITMAP:
+ {
+ const XFillBitmapItem *pFillBitmapItem = rMasterSet.GetItem<XFillBitmapItem>( XATTR_FILLBITMAP );
+ XFillBitmapItem aFillBitmapItem( pFillBitmapItem->GetName(), pFillBitmapItem->GetGraphicObject() );
+ aFillBitmapItem.SetWhich( SID_ATTR_PAGE_BITMAP );
+ rSet.Put( aFillBitmapItem );
+ }
+ break;
+ case drawing::FillStyle_NONE:
+ {
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+ break;
+ }
+
+ }
+ nWhich = aIter.NextWhich();
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-01 19:02:40 +0000