summaryrefslogtreecommitdiffstats
path: root/sw/source/ui/frmdlg/frmpage.cxx
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 16:51:28 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 16:51:28 +0000
commit940b4d1848e8c70ab7642901a68594e8016caffc (patch)
treeeb72f344ee6c3d9b80a7ecc079ea79e9fba8676d /sw/source/ui/frmdlg/frmpage.cxx
parentInitial commit. (diff)
downloadlibreoffice-upstream.tar.xz
libreoffice-upstream.zip
Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'sw/source/ui/frmdlg/frmpage.cxx')
-rw-r--r--sw/source/ui/frmdlg/frmpage.cxx3142
1 files changed, 3142 insertions, 0 deletions
diff --git a/sw/source/ui/frmdlg/frmpage.cxx b/sw/source/ui/frmdlg/frmpage.cxx
new file mode 100644
index 000000000..c9fd24297
--- /dev/null
+++ b/sw/source/ui/frmdlg/frmpage.cxx
@@ -0,0 +1,3142 @@
+/* -*- 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/Aspects.hpp>
+#include <com/sun/star/embed/EmbedMisc.hpp>
+#include <com/sun/star/embed/XEmbeddedObject.hpp>
+
+#include <cmdid.h>
+#include <hintids.hxx>
+#include <bitmaps.hlst>
+#include <o3tl/safeint.hxx>
+#include <vcl/mnemonic.hxx>
+#include <svl/stritem.hxx>
+#include <sfx2/htmlmode.hxx>
+#include <editeng/sizeitem.hxx>
+#include <editeng/opaqitem.hxx>
+#include <editeng/protitem.hxx>
+#include <editeng/prntitem.hxx>
+#include <editeng/brushitem.hxx>
+#include <editeng/ulspitem.hxx>
+#include <editeng/frmdiritem.hxx>
+#include <svx/swframeposstrings.hxx>
+#include <svx/swframevalidation.hxx>
+#include <comphelper/classids.hxx>
+#include <tools/globname.hxx>
+#include <tools/urlobj.hxx>
+#include <fmturl.hxx>
+#include <fmteiro.hxx>
+#include <fmtcnct.hxx>
+#include <fmtsrnd.hxx>
+#include <view.hxx>
+#include <wrtsh.hxx>
+#include <swmodule.hxx>
+#include <uitool.hxx>
+#include <docsh.hxx>
+#include <viewopt.hxx>
+#include <frmdlg.hxx>
+#include <frmmgr.hxx>
+#include <frmpage.hxx>
+#include <colmgr.hxx>
+#include <grfatr.hxx>
+#include <fmtfollowtextflow.hxx>
+#include <svx/sdtaitm.hxx>
+#include <sal/macros.h>
+
+#include <strings.hrc>
+#include <svx/strings.hrc>
+#include <svx/dialmgr.hxx>
+#include <sfx2/filedlghelper.hxx>
+#include <com/sun/star/ui/dialogs/TemplateDescription.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 <vcl/graphicfilter.hxx>
+#include <svtools/embedhlp.hxx>
+#include <comphelper/lok.hxx>
+#include <memory>
+
+using namespace ::com::sun::star;
+using namespace ::sfx2;
+
+#define SwFPos SvxSwFramePosString
+
+namespace {
+
+struct StringIdPair_Impl
+{
+ SvxSwFramePosString::StringId eHori;
+ SvxSwFramePosString::StringId eVert;
+};
+
+}
+
+#define MAX_PERCENT_WIDTH 254
+#define MAX_PERCENT_HEIGHT 254
+
+namespace {
+
+enum class LB {
+ NONE = 0x00000000L,
+ Frame = 0x00000001L, // text region of the paragraph
+ PrintArea = 0x00000002L, // text region of the paragraph + indentions
+ VertFrame = 0x00000004L, // vertical text region of the paragraph
+ VertPrintArea = 0x00000008L, // vertical text region of the paragraph + indentions
+ RelFrameLeft = 0x00000010L, // left paragraph edge
+ RelFrameRight = 0x00000020L, // right paragraph edge
+
+ RelPageLeft = 0x00000040L, // left page edge
+ RelPageRight = 0x00000080L, // right page edge
+ RelPageFrame = 0x00000100L, // whole page
+ RelPagePrintArea = 0x00000200L, // text region of the page
+
+ FlyRelPageLeft = 0x00000400L, // left frame edge
+ FlyRelPageRight = 0x00000800L, // right frame edge
+ FlyRelPageFrame = 0x00001000L, // whole frame
+ FlyRelPagePrintArea = 0x00002000L, // inside of the frame
+
+ RelBase = 0x00010000L, // character alignment Base
+ RelChar = 0x00020000L, // character alignment Character
+ RelRow = 0x00040000L, // character alignment Row
+
+ FlyVertFrame = 0x00100000L, // vertical entire frame
+ FlyVertPrintArea = 0x00200000L, // vertical frame text area
+
+ VertLine = 0x00400000L, // vertical text line
+};
+
+}
+
+namespace o3tl {
+ template<> struct typed_flags<LB> : is_typed_flags<LB, 0x00773fffL> {};
+}
+
+namespace {
+
+struct RelationMap
+{
+ SvxSwFramePosString::StringId eStrId;
+ SvxSwFramePosString::StringId eMirrorStrId;
+ LB nLBRelation;
+ sal_Int16 nRelation;
+};
+
+}
+
+struct FrameMap
+{
+ SvxSwFramePosString::StringId eStrId;
+ SvxSwFramePosString::StringId eMirrorStrId;
+ sal_Int16 nAlign;
+ LB nLBRelations;
+};
+
+
+static RelationMap const aRelationMap[] =
+{
+ {SwFPos::FRAME, SwFPos::FRAME, LB::Frame, text::RelOrientation::FRAME},
+ {SwFPos::PRTAREA, SwFPos::PRTAREA, LB::PrintArea, text::RelOrientation::PRINT_AREA},
+ {SwFPos::REL_PG_LEFT, SwFPos::MIR_REL_PG_LEFT, LB::RelPageLeft, text::RelOrientation::PAGE_LEFT},
+ {SwFPos::REL_PG_RIGHT, SwFPos::MIR_REL_PG_RIGHT, LB::RelPageRight, text::RelOrientation::PAGE_RIGHT},
+ {SwFPos::REL_FRM_LEFT, SwFPos::MIR_REL_FRM_LEFT, LB::RelFrameLeft, text::RelOrientation::FRAME_LEFT},
+ {SwFPos::REL_FRM_RIGHT, SwFPos::MIR_REL_FRM_RIGHT, LB::RelFrameRight, text::RelOrientation::FRAME_RIGHT},
+ {SwFPos::REL_PG_FRAME, SwFPos::REL_PG_FRAME, LB::RelPageFrame, text::RelOrientation::PAGE_FRAME},
+ {SwFPos::REL_PG_PRTAREA, SwFPos::REL_PG_PRTAREA, LB::RelPagePrintArea, text::RelOrientation::PAGE_PRINT_AREA},
+ {SwFPos::REL_CHAR, SwFPos::REL_CHAR, LB::RelChar, text::RelOrientation::CHAR},
+
+ {SwFPos::FLY_REL_PG_LEFT, SwFPos::FLY_MIR_REL_PG_LEFT, LB::FlyRelPageLeft, text::RelOrientation::PAGE_LEFT},
+ {SwFPos::FLY_REL_PG_RIGHT, SwFPos::FLY_MIR_REL_PG_RIGHT, LB::FlyRelPageRight, text::RelOrientation::PAGE_RIGHT},
+ {SwFPos::FLY_REL_PG_FRAME, SwFPos::FLY_REL_PG_FRAME, LB::FlyRelPageFrame, text::RelOrientation::PAGE_FRAME},
+ {SwFPos::FLY_REL_PG_PRTAREA, SwFPos::FLY_REL_PG_PRTAREA, LB::FlyRelPagePrintArea, text::RelOrientation::PAGE_PRINT_AREA},
+
+ {SwFPos::REL_BORDER, SwFPos::REL_BORDER, LB::VertFrame, text::RelOrientation::FRAME},
+ {SwFPos::REL_PRTAREA, SwFPos::REL_PRTAREA, LB::VertPrintArea, text::RelOrientation::PRINT_AREA},
+
+ {SwFPos::FLY_REL_PG_FRAME, SwFPos::FLY_REL_PG_FRAME, LB::FlyVertFrame, text::RelOrientation::FRAME},
+ {SwFPos::FLY_REL_PG_PRTAREA, SwFPos::FLY_REL_PG_PRTAREA, LB::FlyVertPrintArea, text::RelOrientation::PRINT_AREA},
+
+ {SwFPos::REL_LINE, SwFPos::REL_LINE, LB::VertLine, text::RelOrientation::TEXT_LINE}
+};
+
+static RelationMap const aAsCharRelationMap[] =
+{
+ {SwFPos::REL_BASE, SwFPos::REL_BASE, LB::RelBase, text::RelOrientation::FRAME},
+ {SwFPos::REL_CHAR, SwFPos::REL_CHAR, LB::RelChar, text::RelOrientation::FRAME},
+ {SwFPos::REL_ROW, SwFPos::REL_ROW, LB::RelRow, text::RelOrientation::FRAME}
+};
+
+// site anchored
+static constexpr auto HORI_PAGE_REL = LB::RelPageFrame | LB::RelPagePrintArea | LB::RelPageLeft |
+ LB::RelPageRight;
+
+static FrameMap const aHPageMap[] =
+{
+ {SwFPos::LEFT, SwFPos::MIR_LEFT, text::HoriOrientation::LEFT, HORI_PAGE_REL},
+ {SwFPos::RIGHT, SwFPos::MIR_RIGHT, text::HoriOrientation::RIGHT, HORI_PAGE_REL},
+ {SwFPos::CENTER_HORI, SwFPos::CENTER_HORI, text::HoriOrientation::CENTER, HORI_PAGE_REL},
+ {SwFPos::FROMLEFT, SwFPos::MIR_FROMLEFT, text::HoriOrientation::NONE, HORI_PAGE_REL}
+};
+
+static FrameMap const aHPageHtmlMap[] =
+{
+ {SwFPos::FROMLEFT, SwFPos::MIR_FROMLEFT, text::HoriOrientation::NONE, LB::RelPageFrame}
+};
+
+#define VERT_PAGE_REL (LB::RelPageFrame|LB::RelPagePrintArea)
+
+static FrameMap const aVPageMap[] =
+{
+ {SwFPos::TOP, SwFPos::TOP, text::VertOrientation::TOP, VERT_PAGE_REL},
+ {SwFPos::BOTTOM, SwFPos::BOTTOM, text::VertOrientation::BOTTOM, VERT_PAGE_REL},
+ {SwFPos::CENTER_VERT, SwFPos::CENTER_VERT, text::VertOrientation::CENTER, VERT_PAGE_REL},
+ {SwFPos::FROMTOP, SwFPos::FROMTOP, text::VertOrientation::NONE, VERT_PAGE_REL}
+};
+
+static FrameMap const aVPageHtmlMap[] =
+{
+ {SwFPos::FROMTOP, SwFPos::FROMTOP, text::VertOrientation::NONE, LB::RelPageFrame}
+};
+
+// frame anchored
+static constexpr auto HORI_FRAME_REL = LB::FlyRelPageFrame | LB::FlyRelPagePrintArea |
+ LB::FlyRelPageLeft | LB::FlyRelPageRight;
+
+static FrameMap const aHFrameMap[] =
+{
+ {SwFPos::LEFT, SwFPos::MIR_LEFT, text::HoriOrientation::LEFT, HORI_FRAME_REL},
+ {SwFPos::RIGHT, SwFPos::MIR_RIGHT, text::HoriOrientation::RIGHT, HORI_FRAME_REL},
+ {SwFPos::CENTER_HORI, SwFPos::CENTER_HORI, text::HoriOrientation::CENTER, HORI_FRAME_REL},
+ {SwFPos::FROMLEFT, SwFPos::MIR_FROMLEFT, text::HoriOrientation::NONE, HORI_FRAME_REL}
+};
+
+static FrameMap const aHFlyHtmlMap[] =
+{
+ {SwFPos::LEFT, SwFPos::MIR_LEFT, text::HoriOrientation::LEFT, LB::FlyRelPageFrame},
+ {SwFPos::FROMLEFT, SwFPos::MIR_FROMLEFT, text::HoriOrientation::NONE, LB::FlyRelPageFrame}
+};
+
+// own vertical alignment map for objects anchored to frame
+#define VERT_FRAME_REL (LB::FlyVertFrame|LB::FlyVertPrintArea)
+
+static FrameMap const aVFrameMap[] =
+{
+ {SwFPos::TOP, SwFPos::TOP, text::VertOrientation::TOP, VERT_FRAME_REL},
+ {SwFPos::BOTTOM, SwFPos::BOTTOM, text::VertOrientation::BOTTOM, VERT_FRAME_REL},
+ {SwFPos::CENTER_VERT, SwFPos::CENTER_VERT, text::VertOrientation::CENTER, VERT_FRAME_REL},
+ {SwFPos::FROMTOP, SwFPos::FROMTOP, text::VertOrientation::NONE, VERT_FRAME_REL}
+};
+
+static FrameMap const aVFlyHtmlMap[] =
+{
+ {SwFPos::TOP, SwFPos::TOP, text::VertOrientation::TOP, LB::FlyVertFrame},
+ {SwFPos::FROMTOP, SwFPos::FROMTOP, text::VertOrientation::NONE, LB::FlyVertFrame}
+};
+
+// paragraph anchored
+static constexpr auto HORI_PARA_REL = LB::Frame | LB::PrintArea | LB::RelPageLeft | LB::RelPageRight |
+ LB::RelPageFrame | LB::RelPagePrintArea | LB::RelFrameLeft |
+ LB::RelFrameRight;
+
+static FrameMap const aHParaMap[] =
+{
+ {SwFPos::LEFT, SwFPos::MIR_LEFT, text::HoriOrientation::LEFT, HORI_PARA_REL},
+ {SwFPos::RIGHT, SwFPos::MIR_RIGHT, text::HoriOrientation::RIGHT, HORI_PARA_REL},
+ {SwFPos::CENTER_HORI, SwFPos::CENTER_HORI, text::HoriOrientation::CENTER, HORI_PARA_REL},
+ {SwFPos::FROMLEFT, SwFPos::MIR_FROMLEFT, text::HoriOrientation::NONE, HORI_PARA_REL}
+};
+
+#define HTML_HORI_PARA_REL (LB::Frame|LB::PrintArea)
+
+static FrameMap const aHParaHtmlMap[] =
+{
+ {SwFPos::LEFT, SwFPos::LEFT, text::HoriOrientation::LEFT, HTML_HORI_PARA_REL},
+ {SwFPos::RIGHT, SwFPos::RIGHT, text::HoriOrientation::RIGHT, HTML_HORI_PARA_REL}
+};
+
+static FrameMap const aHParaHtmlAbsMap[] =
+{
+ {SwFPos::LEFT, SwFPos::MIR_LEFT, text::HoriOrientation::LEFT, HTML_HORI_PARA_REL},
+ {SwFPos::RIGHT, SwFPos::MIR_RIGHT, text::HoriOrientation::RIGHT, HTML_HORI_PARA_REL}
+};
+
+// allow vertical alignment at page areas
+static constexpr auto VERT_PARA_REL = LB::VertFrame | LB::VertPrintArea |
+ LB::RelPageFrame | LB::RelPagePrintArea;
+
+static FrameMap const aVParaMap[] =
+{
+ {SwFPos::TOP, SwFPos::TOP, text::VertOrientation::TOP, VERT_PARA_REL},
+ {SwFPos::BOTTOM, SwFPos::BOTTOM, text::VertOrientation::BOTTOM, VERT_PARA_REL},
+ {SwFPos::CENTER_VERT, SwFPos::CENTER_VERT, text::VertOrientation::CENTER, VERT_PARA_REL},
+ {SwFPos::FROMTOP, SwFPos::FROMTOP, text::VertOrientation::NONE, VERT_PARA_REL}
+};
+
+static FrameMap const aVParaHtmlMap[] =
+{
+ {SwFPos::TOP, SwFPos::TOP, text::VertOrientation::TOP, LB::VertPrintArea}
+};
+
+// anchored relative to the character
+static constexpr auto HORI_CHAR_REL = LB::Frame|LB::PrintArea | LB::RelPageLeft | LB::RelPageRight |
+ LB::RelPageFrame | LB::RelPagePrintArea | LB::RelFrameLeft |
+ LB::RelFrameRight | LB::RelChar;
+
+static FrameMap const aHCharMap[] =
+{
+ {SwFPos::LEFT, SwFPos::MIR_LEFT, text::HoriOrientation::LEFT, HORI_CHAR_REL},
+ {SwFPos::RIGHT, SwFPos::MIR_RIGHT, text::HoriOrientation::RIGHT, HORI_CHAR_REL},
+ {SwFPos::CENTER_HORI, SwFPos::CENTER_HORI, text::HoriOrientation::CENTER, HORI_CHAR_REL},
+ {SwFPos::FROMLEFT, SwFPos::MIR_FROMLEFT, text::HoriOrientation::NONE, HORI_CHAR_REL}
+};
+
+#define HTML_HORI_CHAR_REL (LB::Frame|LB::PrintArea|LB::RelChar)
+
+static FrameMap const aHCharHtmlMap[] =
+{
+ {SwFPos::LEFT, SwFPos::LEFT, text::HoriOrientation::LEFT, HTML_HORI_CHAR_REL},
+ {SwFPos::RIGHT, SwFPos::RIGHT, text::HoriOrientation::RIGHT, HTML_HORI_CHAR_REL}
+};
+
+static FrameMap const aHCharHtmlAbsMap[] =
+{
+ {SwFPos::LEFT, SwFPos::MIR_LEFT, text::HoriOrientation::LEFT, LB::PrintArea|LB::RelChar},
+ {SwFPos::RIGHT, SwFPos::MIR_RIGHT, text::HoriOrientation::RIGHT, LB::PrintArea},
+ {SwFPos::FROMLEFT, SwFPos::MIR_FROMLEFT, text::HoriOrientation::NONE, LB::RelPageFrame}
+};
+
+// allow vertical alignment at page areas
+static constexpr auto VERT_CHAR_REL = LB::VertFrame | LB::VertPrintArea |
+ LB::RelPageFrame | LB::RelPagePrintArea;
+
+static FrameMap const aVCharMap[] =
+{
+ // introduce mappings for new vertical alignment at top of line <LB::VertLine>
+ // and correct mapping for vertical alignment at character for position <FROM_BOTTOM>
+ // Note: Because of these adjustments the map becomes ambiguous in its values
+ // <eStrId>/<eMirrorStrId> and <nAlign>. These ambiguities are considered
+ // in the methods <SwFramePage::FillRelLB(..)>, <SwFramePage::GetAlignment(..)>
+ // and <SwFramePage::FillPosLB(..)>
+ {SwFPos::TOP, SwFPos::TOP, text::VertOrientation::TOP, VERT_CHAR_REL|LB::RelChar},
+ {SwFPos::BOTTOM, SwFPos::BOTTOM, text::VertOrientation::BOTTOM, VERT_CHAR_REL|LB::RelChar},
+ {SwFPos::BELOW, SwFPos::BELOW, text::VertOrientation::CHAR_BOTTOM, LB::RelChar},
+ {SwFPos::CENTER_VERT, SwFPos::CENTER_VERT, text::VertOrientation::CENTER, VERT_CHAR_REL|LB::RelChar},
+ {SwFPos::FROMTOP, SwFPos::FROMTOP, text::VertOrientation::NONE, VERT_CHAR_REL},
+ {SwFPos::FROMBOTTOM, SwFPos::FROMBOTTOM, text::VertOrientation::NONE, LB::RelChar|LB::VertLine},
+ {SwFPos::TOP, SwFPos::TOP, text::VertOrientation::LINE_TOP, LB::VertLine},
+ {SwFPos::BOTTOM, SwFPos::BOTTOM, text::VertOrientation::LINE_BOTTOM, LB::VertLine},
+ {SwFPos::CENTER_VERT, SwFPos::CENTER_VERT, text::VertOrientation::LINE_CENTER, LB::VertLine}
+};
+
+static FrameMap const aVCharHtmlMap[] =
+{
+ {SwFPos::BELOW, SwFPos::BELOW, text::VertOrientation::CHAR_BOTTOM, LB::RelChar}
+};
+
+static FrameMap const aVCharHtmlAbsMap[] =
+{
+ {SwFPos::TOP, SwFPos::TOP, text::VertOrientation::TOP, LB::RelChar},
+ {SwFPos::BELOW, SwFPos::BELOW, text::VertOrientation::CHAR_BOTTOM, LB::RelChar}
+};
+
+// anchored as character
+static FrameMap const aVAsCharMap[] =
+{
+ {SwFPos::TOP, SwFPos::TOP, text::VertOrientation::TOP, LB::RelBase},
+ {SwFPos::BOTTOM, SwFPos::BOTTOM, text::VertOrientation::BOTTOM, LB::RelBase},
+ {SwFPos::CENTER_VERT, SwFPos::CENTER_VERT, text::VertOrientation::CENTER, LB::RelBase},
+
+ {SwFPos::TOP, SwFPos::TOP, text::VertOrientation::CHAR_TOP, LB::RelChar},
+ {SwFPos::BOTTOM, SwFPos::BOTTOM, text::VertOrientation::CHAR_BOTTOM, LB::RelChar},
+ {SwFPos::CENTER_VERT, SwFPos::CENTER_VERT, text::VertOrientation::CHAR_CENTER, LB::RelChar},
+
+ {SwFPos::TOP, SwFPos::TOP, text::VertOrientation::LINE_TOP, LB::RelRow},
+ {SwFPos::BOTTOM, SwFPos::BOTTOM, text::VertOrientation::LINE_BOTTOM, LB::RelRow},
+ {SwFPos::CENTER_VERT, SwFPos::CENTER_VERT, text::VertOrientation::LINE_CENTER, LB::RelRow},
+
+ {SwFPos::FROMBOTTOM, SwFPos::FROMBOTTOM, text::VertOrientation::NONE, LB::RelBase}
+};
+
+static FrameMap const aVAsCharHtmlMap[] =
+{
+ {SwFPos::TOP, SwFPos::TOP, text::VertOrientation::TOP, LB::RelBase},
+ {SwFPos::CENTER_VERT, SwFPos::CENTER_VERT, text::VertOrientation::CENTER, LB::RelBase},
+
+ {SwFPos::TOP, SwFPos::TOP, text::VertOrientation::CHAR_TOP, LB::RelChar},
+
+ {SwFPos::TOP, SwFPos::TOP, text::VertOrientation::LINE_TOP, LB::RelRow},
+ {SwFPos::BOTTOM, SwFPos::BOTTOM, text::VertOrientation::LINE_BOTTOM, LB::RelRow},
+ {SwFPos::CENTER_VERT, SwFPos::CENTER_VERT, text::VertOrientation::LINE_CENTER, LB::RelRow}
+};
+
+const sal_uInt16 SwFramePage::aPageRg[] = {
+ RES_FRM_SIZE, RES_FRM_SIZE,
+ RES_VERT_ORIENT, RES_ANCHOR,
+ RES_COL, RES_COL,
+ RES_FOLLOW_TEXT_FLOW, RES_FOLLOW_TEXT_FLOW,
+ 0
+};
+const sal_uInt16 SwFrameAddPage::aAddPgRg[] = {
+ RES_PROTECT, RES_PROTECT,
+ RES_PRINT, RES_PRINT,
+ FN_SET_FRM_NAME, FN_SET_FRM_NAME,
+ FN_SET_FRM_ALT_NAME, FN_SET_FRM_ALT_NAME,
+ FN_UNO_DESCRIPTION, FN_UNO_DESCRIPTION,
+ 0
+};
+
+static size_t lcl_GetFrameMapCount( const FrameMap* pMap)
+{
+ if ( pMap )
+ {
+ if( pMap == aVParaHtmlMap)
+ return SAL_N_ELEMENTS(aVParaHtmlMap);
+ if( pMap == aVAsCharHtmlMap)
+ return SAL_N_ELEMENTS(aVAsCharHtmlMap);
+ if( pMap == aHParaHtmlMap)
+ return SAL_N_ELEMENTS(aHParaHtmlMap);
+ if( pMap == aHParaHtmlAbsMap)
+ return SAL_N_ELEMENTS(aHParaHtmlAbsMap);
+ if ( pMap == aVPageMap )
+ return SAL_N_ELEMENTS(aVPageMap);
+ if ( pMap == aVPageHtmlMap )
+ return SAL_N_ELEMENTS(aVPageHtmlMap);
+ if ( pMap == aVAsCharMap )
+ return SAL_N_ELEMENTS(aVAsCharMap);
+ if ( pMap == aVParaMap )
+ return SAL_N_ELEMENTS(aVParaMap);
+ if ( pMap == aHParaMap )
+ return SAL_N_ELEMENTS(aHParaMap);
+ if ( pMap == aHFrameMap )
+ return SAL_N_ELEMENTS(aHFrameMap);
+ if ( pMap == aVFrameMap )
+ return SAL_N_ELEMENTS(aVFrameMap);
+ if ( pMap == aHCharMap )
+ return SAL_N_ELEMENTS(aHCharMap);
+ if ( pMap == aHCharHtmlMap )
+ return SAL_N_ELEMENTS(aHCharHtmlMap);
+ if ( pMap == aHCharHtmlAbsMap )
+ return SAL_N_ELEMENTS(aHCharHtmlAbsMap);
+ if ( pMap == aVCharMap )
+ return SAL_N_ELEMENTS(aVCharMap);
+ if ( pMap == aVCharHtmlMap )
+ return SAL_N_ELEMENTS(aVCharHtmlMap);
+ if ( pMap == aVCharHtmlAbsMap )
+ return SAL_N_ELEMENTS(aVCharHtmlAbsMap);
+ if ( pMap == aHPageHtmlMap )
+ return SAL_N_ELEMENTS(aHPageHtmlMap);
+ if ( pMap == aHFlyHtmlMap )
+ return SAL_N_ELEMENTS(aHFlyHtmlMap);
+ if ( pMap == aVFlyHtmlMap )
+ return SAL_N_ELEMENTS(aVFlyHtmlMap);
+ return SAL_N_ELEMENTS(aHPageMap);
+ }
+ return 0;
+}
+
+static void lcl_InsertVectors(weld::ComboBox& rBox,
+ const std::vector< OUString >& rPrev, const std::vector< OUString >& rThis,
+ const std::vector< OUString >& rNext, const std::vector< OUString >& rRemain)
+{
+ for(const auto& rItem : rPrev)
+ rBox.append_text(rItem);
+ for(const auto& rItem : rThis)
+ rBox.append_text(rItem);
+ for(const auto& rItem : rNext)
+ rBox.append_text(rItem);
+ rBox.append_separator("");
+ //now insert all strings sorted
+ const auto nStartPos = rBox.get_count();
+
+ for(const auto& rItem : rPrev)
+ ::InsertStringSorted("", rItem, rBox, nStartPos );
+ for(const auto& rItem : rThis)
+ ::InsertStringSorted("", rItem, rBox, nStartPos );
+ for(const auto& rItem : rNext)
+ ::InsertStringSorted("", rItem, rBox, nStartPos );
+ for(const auto& rItem : rRemain)
+ ::InsertStringSorted("", rItem, rBox, nStartPos );
+}
+
+// --> OD 2009-08-31 #mongolianlayout#
+// add input parameter
+static SvxSwFramePosString::StringId lcl_ChangeResIdToVerticalOrRTL(SvxSwFramePosString::StringId eStringId, bool bVertical, bool bVerticalL2R, bool bRTL)
+{
+ //special handling of STR_FROMLEFT
+ if ( SwFPos::FROMLEFT == eStringId )
+ {
+ eStringId = bVertical
+ ? ( bRTL
+ ? SwFPos::FROMBOTTOM
+ : SwFPos::FROMTOP )
+ : ( bRTL
+ ? SwFPos::FROMRIGHT
+ : SwFPos::FROMLEFT );
+ return eStringId;
+ }
+ // --> OD 2009-08-31 #mongolianlayout#
+ // special handling of STR_FROMTOP in case of mongolianlayout (vertical left-to-right)
+ if ( SwFPos::FROMTOP == eStringId &&
+ bVertical && bVerticalL2R )
+ {
+ eStringId = SwFPos::FROMLEFT;
+ return eStringId;
+ }
+ if ( bVertical )
+ {
+ //exchange horizontal strings with vertical strings and vice versa
+ static const StringIdPair_Impl aHoriIds[] =
+ {
+ {SwFPos::LEFT, SwFPos::TOP},
+ {SwFPos::RIGHT, SwFPos::BOTTOM},
+ {SwFPos::CENTER_HORI, SwFPos::CENTER_VERT},
+ {SwFPos::FROMTOP, SwFPos::FROMRIGHT},
+ {SwFPos::REL_PG_LEFT, SwFPos::REL_PG_TOP},
+ {SwFPos::REL_PG_RIGHT, SwFPos::REL_PG_BOTTOM} ,
+ {SwFPos::REL_FRM_LEFT, SwFPos::REL_FRM_TOP},
+ {SwFPos::REL_FRM_RIGHT, SwFPos::REL_FRM_BOTTOM}
+ };
+ static const StringIdPair_Impl aVertIds[] =
+ {
+ {SwFPos::TOP, SwFPos::RIGHT},
+ {SwFPos::BOTTOM, SwFPos::LEFT },
+ {SwFPos::CENTER_VERT, SwFPos::CENTER_HORI},
+ {SwFPos::FROMTOP, SwFPos::FROMRIGHT },
+ {SwFPos::REL_PG_TOP, SwFPos::REL_PG_LEFT },
+ {SwFPos::REL_PG_BOTTOM, SwFPos::REL_PG_RIGHT } ,
+ {SwFPos::REL_FRM_TOP, SwFPos::REL_FRM_LEFT },
+ {SwFPos::REL_FRM_BOTTOM, SwFPos::REL_FRM_RIGHT }
+ };
+ // --> OD 2009-08-31 #monglianlayout#
+ static const StringIdPair_Impl aVertL2RIds[] =
+ {
+ {SwFPos::TOP, SwFPos::LEFT },
+ {SwFPos::BOTTOM, SwFPos::RIGHT },
+ {SwFPos::CENTER_VERT, SwFPos::CENTER_HORI },
+ {SwFPos::FROMTOP, SwFPos::FROMLEFT },
+ {SwFPos::REL_PG_TOP, SwFPos::REL_PG_LEFT },
+ {SwFPos::REL_PG_BOTTOM, SwFPos::REL_PG_RIGHT } ,
+ {SwFPos::REL_FRM_TOP, SwFPos::REL_FRM_LEFT },
+ {SwFPos::REL_FRM_BOTTOM, SwFPos::REL_FRM_RIGHT }
+ };
+ for(const StringIdPair_Impl & rHoriId : aHoriIds)
+ {
+ if(rHoriId.eHori == eStringId)
+ {
+ eStringId = rHoriId.eVert;
+ return eStringId;
+ }
+ }
+ for(size_t nIndex = 0; nIndex < SAL_N_ELEMENTS(aVertIds); ++nIndex)
+ {
+ // --> OD 2009-08-31 #mongolianlayout#
+ if ( !bVerticalL2R )
+ {
+ if(aVertIds[nIndex].eHori == eStringId)
+ {
+ eStringId = aVertIds[nIndex].eVert;
+ break;
+ }
+ }
+ else
+ {
+ if(aVertL2RIds[nIndex].eHori == eStringId)
+ {
+ eStringId = aVertL2RIds[nIndex].eVert;
+ break;
+ }
+ }
+ }
+ }
+ return eStringId;
+}
+
+// helper method in order to determine all possible
+// listbox relations in a relation map for a given relation
+static LB lcl_GetLBRelationsForRelations( const sal_Int16 _nRel )
+{
+ LB nLBRelations = LB::NONE;
+
+ for (RelationMap const & i : aRelationMap)
+ {
+ if ( i.nRelation == _nRel )
+ {
+ nLBRelations |= i.nLBRelation;
+ }
+ }
+
+ return nLBRelations;
+}
+
+// helper method on order to determine all possible
+// listbox relations in a relation map for a given string ID
+static LB lcl_GetLBRelationsForStrID( const FrameMap* _pMap,
+ const SvxSwFramePosString::StringId _eStrId,
+ const bool _bUseMirrorStr )
+{
+ LB nLBRelations = LB::NONE;
+
+ size_t nRelMapSize = lcl_GetFrameMapCount( _pMap );
+ for ( size_t nRelMapPos = 0; nRelMapPos < nRelMapSize; ++nRelMapPos )
+ {
+ if ( ( !_bUseMirrorStr && _pMap[nRelMapPos].eStrId == _eStrId ) ||
+ ( _bUseMirrorStr && _pMap[nRelMapPos].eMirrorStrId == _eStrId ) )
+ {
+ nLBRelations |= _pMap[nRelMapPos].nLBRelations;
+ }
+ }
+
+ return nLBRelations;
+}
+
+// standard frame TabPage
+namespace
+{
+ void HandleAutoCB(bool _bChecked, weld::Label& _rFT_man, weld::Label& _rFT_auto, weld::MetricSpinButton& _rPF_Edit)
+ {
+ _rFT_man.set_visible( !_bChecked );
+ _rFT_auto.set_visible( _bChecked );
+ OUString accName = _bChecked ? _rFT_auto.get_label() : _rFT_man.get_label();
+ _rPF_Edit.set_accessible_name(accName);
+ }
+}
+
+SwFramePage::SwFramePage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet &rSet)
+ : SfxTabPage(pPage, pController, "modules/swriter/ui/frmtypepage.ui", "FrameTypePage", &rSet)
+ , m_bAtHorzPosModified(false)
+ , m_bAtVertPosModified(false)
+ , m_bFormat(false)
+ , m_bNew(true)
+ , m_bNoModifyHdl(true)
+ , m_bIsVerticalFrame(false)
+ , m_bIsVerticalL2R(false)
+ , m_bIsInRightToLeft(false)
+ , m_bHtmlMode(false)
+ , m_nHtmlMode(0)
+ , m_nUpperBorder(0)
+ , m_nLowerBorder(0)
+ , m_fWidthHeightRatio(1.0)
+ , mpToCharContentPos(nullptr)
+ , m_nOldH(text::HoriOrientation::CENTER)
+ , m_nOldHRel(text::RelOrientation::FRAME)
+ , m_nOldV(text::VertOrientation::TOP)
+ , m_nOldVRel(text::RelOrientation::PRINT_AREA)
+ , m_pVMap(nullptr)
+ , m_pHMap(nullptr)
+ , m_bAllowVertPositioning( true )
+ , m_bIsMathOLE(false)
+ , m_bIsMathBaselineAlignment(true)
+ , m_xWidthFT(m_xBuilder->weld_label("widthft"))
+ , m_xWidthAutoFT(m_xBuilder->weld_label("autowidthft"))
+ , m_xRelWidthCB(m_xBuilder->weld_check_button("relwidth"))
+ , m_xRelWidthRelationLB(m_xBuilder->weld_combo_box("relwidthrelation"))
+ , m_xAutoWidthCB(m_xBuilder->weld_check_button("autowidth"))
+ , m_xHeightFT(m_xBuilder->weld_label("heightft"))
+ , m_xHeightAutoFT(m_xBuilder->weld_label("autoheightft"))
+ , m_xRelHeightCB(m_xBuilder->weld_check_button("relheight"))
+ , m_xRelHeightRelationLB(m_xBuilder->weld_combo_box("relheightrelation"))
+ , m_xAutoHeightCB(m_xBuilder->weld_check_button("autoheight"))
+ , m_xFixedRatioCB(m_xBuilder->weld_check_button("ratio"))
+ , m_xRealSizeBT(m_xBuilder->weld_button("origsize"))
+ , m_xAnchorFrame(m_xBuilder->weld_widget("anchorframe"))
+ , m_xAnchorAtPageRB(m_xBuilder->weld_radio_button("topage"))
+ , m_xAnchorAtParaRB(m_xBuilder->weld_radio_button("topara"))
+ , m_xAnchorAtCharRB(m_xBuilder->weld_radio_button("tochar"))
+ , m_xAnchorAsCharRB(m_xBuilder->weld_radio_button("aschar"))
+ , m_xAnchorAtFrameRB(m_xBuilder->weld_radio_button("toframe"))
+ , m_xHorizontalFT(m_xBuilder->weld_label("horiposft"))
+ , m_xHorizontalDLB(m_xBuilder->weld_combo_box("horipos"))
+ , m_xAtHorzPosFT(m_xBuilder->weld_label("horibyft"))
+ , m_xAtHorzPosED(m_xBuilder->weld_metric_spin_button("byhori", FieldUnit::CM))
+ , m_xHoriRelationFT(m_xBuilder->weld_label("horitoft"))
+ , m_xHoriRelationLB(m_xBuilder->weld_combo_box("horianchor"))
+ , m_xMirrorPagesCB(m_xBuilder->weld_check_button("mirror"))
+ , m_xVerticalFT(m_xBuilder->weld_label("vertposft"))
+ , m_xVerticalDLB(m_xBuilder->weld_combo_box("vertpos"))
+ , m_xAtVertPosFT(m_xBuilder->weld_label("vertbyft"))
+ , m_xAtVertPosED(m_xBuilder->weld_metric_spin_button("byvert", FieldUnit::CM))
+ , m_xVertRelationFT(m_xBuilder->weld_label("verttoft"))
+ , m_xVertRelationLB(m_xBuilder->weld_combo_box("vertanchor"))
+ , m_xFollowTextFlowCB(m_xBuilder->weld_check_button("followtextflow"))
+ , m_xExampleWN(new weld::CustomWeld(*m_xBuilder, "preview", m_aExampleWN))
+ , m_xWidthED(new SwPercentField(m_xBuilder->weld_metric_spin_button("width", FieldUnit::CM)))
+ , m_xHeightED(new SwPercentField(m_xBuilder->weld_metric_spin_button("height", FieldUnit::CM)))
+{
+ const auto nWidthRequest = m_xAtHorzPosED->get_preferred_size().Width();
+ m_xAtHorzPosED->set_size_request(nWidthRequest, -1);
+ m_xAtVertPosED->set_size_request(nWidthRequest, -1);
+
+ setOptimalFrameWidth();
+ setOptimalRelWidth();
+
+ SetExchangeSupport();
+
+ Link<weld::MetricSpinButton&,void> aLk3 = LINK(this, SwFramePage, ModifyHdl);
+ m_xWidthED->connect_value_changed( aLk3 );
+ m_xHeightED->connect_value_changed( aLk3 );
+ m_xAtHorzPosED->connect_value_changed( aLk3 );
+ m_xAtVertPosED->connect_value_changed( aLk3 );
+ m_xFollowTextFlowCB->connect_toggled(LINK(this, SwFramePage, RangeModifyClickHdl));
+
+ Link<weld::ToggleButton&,void> aLk2 = LINK(this, SwFramePage, AnchorTypeHdl);
+ m_xAnchorAtPageRB->connect_toggled( aLk2 );
+ m_xAnchorAtParaRB->connect_toggled( aLk2 );
+ m_xAnchorAtCharRB->connect_toggled( aLk2 );
+ m_xAnchorAsCharRB->connect_toggled( aLk2 );
+ m_xAnchorAtFrameRB->connect_toggled( aLk2 );
+
+ m_xHorizontalDLB->connect_changed(LINK(this, SwFramePage, PosHdl));
+ m_xVerticalDLB->connect_changed(LINK(this, SwFramePage, PosHdl));
+
+ m_xHoriRelationLB->connect_changed(LINK(this, SwFramePage, RelHdl));
+ m_xVertRelationLB->connect_changed(LINK(this, SwFramePage, RelHdl));
+
+ m_xMirrorPagesCB->connect_toggled(LINK(this, SwFramePage, MirrorHdl));
+
+ aLk2 = LINK(this, SwFramePage, RelSizeClickHdl);
+ m_xRelWidthCB->connect_toggled(aLk2);
+ m_xRelHeightCB->connect_toggled(aLk2);
+
+ m_xAutoWidthCB->connect_toggled(LINK(this, SwFramePage, AutoWidthClickHdl));
+ m_xAutoHeightCB->connect_toggled(LINK(this, SwFramePage, AutoHeightClickHdl));
+
+ if (comphelper::LibreOfficeKit::isActive())
+ {
+ m_xAnchorAtPageRB->hide();
+ m_xAnchorAtParaRB->hide();
+ m_xAnchorAtFrameRB->hide();
+ }
+}
+
+SwFramePage::~SwFramePage()
+{
+}
+
+namespace
+{
+ struct FrameMaps
+ {
+ FrameMap const * pMap;
+ size_t nCount;
+ };
+}
+
+void SwFramePage::setOptimalFrameWidth()
+{
+ static FrameMaps const aMaps[] = {
+ { aHPageMap, SAL_N_ELEMENTS(aHPageMap) },
+ { aHPageHtmlMap, SAL_N_ELEMENTS(aHPageHtmlMap) },
+ { aVPageMap, SAL_N_ELEMENTS(aVPageMap) },
+ { aVPageHtmlMap, SAL_N_ELEMENTS(aVPageHtmlMap) },
+ { aHFrameMap, SAL_N_ELEMENTS(aHFrameMap) },
+ { aHFlyHtmlMap, SAL_N_ELEMENTS(aHFlyHtmlMap) },
+ { aVFrameMap, SAL_N_ELEMENTS(aVFrameMap) },
+ { aVFlyHtmlMap, SAL_N_ELEMENTS(aVFlyHtmlMap) },
+ { aHParaMap, SAL_N_ELEMENTS(aHParaMap) },
+ { aHParaHtmlMap, SAL_N_ELEMENTS(aHParaHtmlMap) },
+ { aHParaHtmlAbsMap, SAL_N_ELEMENTS(aHParaHtmlAbsMap) },
+ { aVParaMap, SAL_N_ELEMENTS(aVParaMap) },
+ { aVParaHtmlMap, SAL_N_ELEMENTS(aVParaHtmlMap) },
+ { aHCharMap, SAL_N_ELEMENTS(aHCharMap) },
+ { aHCharHtmlMap, SAL_N_ELEMENTS(aHCharHtmlMap) },
+ { aHCharHtmlAbsMap, SAL_N_ELEMENTS(aHCharHtmlAbsMap) },
+ { aVCharMap, SAL_N_ELEMENTS(aVCharMap) },
+ { aVCharHtmlMap, SAL_N_ELEMENTS(aVCharHtmlMap) },
+ { aVCharHtmlAbsMap, SAL_N_ELEMENTS(aVCharHtmlAbsMap) },
+ { aVAsCharMap, SAL_N_ELEMENTS(aVAsCharMap) },
+ { aVAsCharHtmlMap, SAL_N_ELEMENTS(aVAsCharHtmlMap) }
+ };
+
+ std::vector<SvxSwFramePosString::StringId> aFrames;
+ for (const FrameMaps & rMap : aMaps)
+ {
+ for (size_t j = 0; j < rMap.nCount; ++j)
+ {
+ aFrames.push_back(rMap.pMap[j].eStrId);
+ aFrames.push_back(rMap.pMap[j].eMirrorStrId);
+ }
+ }
+
+ std::sort(aFrames.begin(), aFrames.end());
+ aFrames.erase(std::unique(aFrames.begin(), aFrames.end()), aFrames.end());
+
+ for (const auto& rFrame : aFrames)
+ {
+ m_xHorizontalDLB->append_text(SvxSwFramePosString::GetString(rFrame));
+ }
+
+ Size aBiggest(m_xHorizontalDLB->get_preferred_size());
+ m_xHorizontalDLB->set_size_request(aBiggest.Width(), -1);
+ m_xVerticalDLB->set_size_request(aBiggest.Width(), -1);
+ m_xHorizontalDLB->clear();
+}
+
+namespace
+{
+ struct RelationMaps
+ {
+ RelationMap const * pMap;
+ size_t nCount;
+ };
+}
+
+void SwFramePage::setOptimalRelWidth()
+{
+ static const RelationMaps aMaps[] = {
+ { aRelationMap, SAL_N_ELEMENTS(aRelationMap) },
+ { aAsCharRelationMap, SAL_N_ELEMENTS(aAsCharRelationMap) }
+ };
+
+ std::vector<SvxSwFramePosString::StringId> aRels;
+ for (const RelationMaps & rMap : aMaps)
+ {
+ for (size_t j = 0; j < rMap.nCount; ++j)
+ {
+ aRels.push_back(rMap.pMap[j].eStrId);
+ aRels.push_back(rMap.pMap[j].eMirrorStrId);
+ }
+ }
+
+ std::sort(aRels.begin(), aRels.end());
+ aRels.erase(std::unique(aRels.begin(), aRels.end()), aRels.end());
+
+ for (const auto& rRel : aRels)
+ {
+ m_xHoriRelationLB->append_text(SvxSwFramePosString::GetString(rRel));
+ }
+
+ Size aBiggest(m_xHoriRelationLB->get_preferred_size());
+ m_xHoriRelationLB->set_size_request(aBiggest.Width(), -1);
+ m_xVertRelationLB->set_size_request(aBiggest.Width(), -1);
+ m_xRelWidthRelationLB->set_size_request(aBiggest.Width(), -1);
+ m_xRelHeightRelationLB->set_size_request(aBiggest.Width(), -1);
+ m_xHoriRelationLB->clear();
+}
+
+std::unique_ptr<SfxTabPage> SwFramePage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet *rSet)
+{
+ return std::make_unique<SwFramePage>(pPage, pController, *rSet);
+}
+
+void SwFramePage::EnableGraficMode()
+{
+ // i#39692 - mustn't be called more than once
+ if (!m_xRealSizeBT->get_visible())
+ {
+ m_xWidthFT->show();
+ m_xWidthAutoFT->hide();
+ m_xAutoHeightCB->hide();
+
+ m_xHeightFT->show();
+ m_xHeightAutoFT->hide();
+ m_xAutoWidthCB->hide();
+
+ m_xRealSizeBT->show();
+ }
+}
+
+SwWrtShell *SwFramePage::getFrameDlgParentShell()
+{
+ return static_cast<SwFrameDlg*>(GetDialogController())->GetWrtShell();
+}
+
+void SwFramePage::Reset( const SfxItemSet *rSet )
+{
+ SwWrtShell* pSh = m_bFormat ? ::GetActiveWrtShell() :
+ getFrameDlgParentShell();
+
+ m_nHtmlMode = ::GetHtmlMode(pSh->GetView().GetDocShell());
+ m_bHtmlMode = (m_nHtmlMode & HTMLMODE_ON) != 0;
+
+ FieldUnit aMetric = ::GetDfltMetric(m_bHtmlMode);
+ m_xWidthED->SetMetric(aMetric);
+ m_xHeightED->SetMetric(aMetric);
+ ::SetFieldUnit(*m_xAtHorzPosED, aMetric);
+ ::SetFieldUnit(*m_xAtVertPosED, aMetric);
+
+ const SfxPoolItem* pItem = nullptr;
+ const SwFormatAnchor& rAnchor = rSet->Get(RES_ANCHOR);
+
+ if (SfxItemState::SET == rSet->GetItemState(FN_OLE_IS_MATH, false, &pItem))
+ m_bIsMathOLE = static_cast<const SfxBoolItem*>(pItem)->GetValue();
+ if (SfxItemState::SET == rSet->GetItemState(FN_MATH_BASELINE_ALIGNMENT, false, &pItem))
+ m_bIsMathBaselineAlignment = static_cast<const SfxBoolItem*>(pItem)->GetValue();
+ EnableVerticalPositioning( !(m_bIsMathOLE && m_bIsMathBaselineAlignment
+ && RndStdIds::FLY_AS_CHAR == rAnchor.GetAnchorId()) );
+
+ if (m_bFormat)
+ {
+ // at formats no anchor editing
+ m_xAnchorFrame->set_sensitive(false);
+ m_xFixedRatioCB->set_sensitive(false);
+ }
+ else
+ {
+ if (rAnchor.GetAnchorId() != RndStdIds::FLY_AT_FLY && !pSh->IsFlyInFly())
+ m_xAnchorAtFrameRB->hide();
+ if ( pSh->IsFrameVertical( true, m_bIsInRightToLeft, m_bIsVerticalL2R ) )
+ {
+ OUString sHLabel = m_xHorizontalFT->get_label();
+ m_xHorizontalFT->set_label(m_xVerticalFT->get_label());
+ m_xVerticalFT->set_label(sHLabel);
+ m_bIsVerticalFrame = true;
+ }
+ }
+
+ if ( m_sDlgType == "PictureDialog" || m_sDlgType == "ObjectDialog" )
+ {
+ OSL_ENSURE(pSh , "shell not found");
+ //OS: only for the variant Insert/Graphic/Properties
+ if(SfxItemState::SET == rSet->GetItemState(FN_PARAM_GRF_REALSIZE, false, &pItem))
+ m_aGrfSize = static_cast<const SvxSizeItem*>(pItem)->GetSize();
+ else
+ pSh->GetGrfSize( m_aGrfSize );
+
+ if ( !m_bNew )
+ {
+ m_xRealSizeBT->connect_clicked(LINK(this, SwFramePage, RealSizeHdl));
+ EnableGraficMode();
+ }
+
+ if (m_sDlgType == "PictureDialog")
+ m_xFixedRatioCB->set_active(false);
+ else
+ {
+ if ( m_bNew )
+ SetPageTitle(SwResId(STR_FRMUI_OLE_INSERT));
+ else
+ SetPageTitle(SwResId(STR_FRMUI_OLE_EDIT));
+ }
+ }
+ else
+ {
+ m_aGrfSize = rSet->Get(RES_FRM_SIZE).GetSize();
+ }
+
+ // entering percent value made possible
+
+ // the available space is not yet known so the RefValue has to be calculated from size and relative size values
+ // this is needed only if relative values are already set
+ const SwFormatFrameSize& rFrameSize = rSet->Get(RES_FRM_SIZE);
+
+ m_xRelWidthRelationLB->append_text(SvxSwFramePosString::GetString(SwFPos::FRAME));
+ m_xRelWidthRelationLB->append_text(SvxSwFramePosString::GetString(SwFPos::REL_PG_FRAME));
+ if (rFrameSize.GetWidthPercent() != SwFormatFrameSize::SYNCED && rFrameSize.GetWidthPercent() != 0)
+ {
+ //calculate the reference value from the width and relative width values
+ sal_Int32 nSpace = rFrameSize.GetWidth() * 100 / rFrameSize.GetWidthPercent();
+ m_xWidthED->SetRefValue( nSpace );
+
+ m_xRelWidthRelationLB->set_sensitive(true);
+ }
+ else
+ m_xRelWidthRelationLB->set_sensitive(false);
+
+ m_xRelHeightRelationLB->append_text(SvxSwFramePosString::GetString(SwFPos::FRAME));
+ m_xRelHeightRelationLB->append_text(SvxSwFramePosString::GetString(SwFPos::REL_PG_FRAME));
+ if (rFrameSize.GetHeightPercent() != SwFormatFrameSize::SYNCED && rFrameSize.GetHeightPercent() != 0)
+ {
+ //calculate the reference value from the with and relative width values
+ sal_Int32 nSpace = rFrameSize.GetHeight() * 100 / rFrameSize.GetHeightPercent();
+ m_xHeightED->SetRefValue( nSpace );
+
+ m_xRelHeightRelationLB->set_sensitive(true);
+ }
+ else
+ m_xRelHeightRelationLB->set_sensitive(false);
+
+ // general initialisation part
+ switch(rAnchor.GetAnchorId())
+ {
+ case RndStdIds::FLY_AT_PAGE: m_xAnchorAtPageRB->set_active(true); break;
+ case RndStdIds::FLY_AT_PARA: m_xAnchorAtParaRB->set_active(true); break;
+ case RndStdIds::FLY_AT_CHAR: m_xAnchorAtCharRB->set_active(true); break;
+ case RndStdIds::FLY_AS_CHAR: m_xAnchorAsCharRB->set_active(true); break;
+ case RndStdIds::FLY_AT_FLY: m_xAnchorAtFrameRB->set_active(true);break;
+ default:; //prevent warning
+ }
+
+ // i#22341 - determine content position of character
+ // Note: content position can be NULL
+ mpToCharContentPos = rAnchor.GetContentAnchor();
+
+ // i#18732 - init checkbox value
+ {
+ const bool bFollowTextFlow =
+ rSet->Get(RES_FOLLOW_TEXT_FLOW).GetValue();
+ m_xFollowTextFlowCB->set_active(bFollowTextFlow);
+ }
+
+ if(m_bHtmlMode)
+ {
+ m_xAutoHeightCB->set_sensitive(false);
+ m_xAutoWidthCB->set_sensitive(false);
+ m_xMirrorPagesCB->hide();
+ if (m_sDlgType == "FrameDialog")
+ m_xFixedRatioCB->set_sensitive(false);
+ // i#18732 hide checkbox in HTML mode
+ m_xFollowTextFlowCB->hide();
+ }
+ else
+ {
+ // enable/disable of check box 'Mirror on..'
+ m_xMirrorPagesCB->set_sensitive(!m_xAnchorAsCharRB->get_active());
+
+ // enable/disable check box 'Follow text flow'.
+ // enable check box 'Follow text
+ // flow' also for anchor type to-frame.
+ m_xFollowTextFlowCB->set_sensitive(m_xAnchorAtParaRB->get_active() ||
+ m_xAnchorAtCharRB->get_active() ||
+ m_xAnchorAtFrameRB->get_active());
+ }
+
+ Init(*rSet);
+ m_xAtVertPosED->save_value();
+ m_xAtHorzPosED->save_value();
+ m_xFollowTextFlowCB->save_state();
+
+ m_xWidthED->save_value();
+ m_xHeightED->save_value();
+
+ m_bNoModifyHdl = false;
+ //lock PercentFields
+ m_xWidthED->LockAutoCalculation(true);
+ m_xHeightED->LockAutoCalculation(true);
+ RangeModifyHdl(); // set all maximum values initially
+ m_xHeightED->LockAutoCalculation(false);
+ m_xWidthED->LockAutoCalculation(false);
+
+ m_xAutoHeightCB->save_state();
+ m_xAutoWidthCB->save_state();
+
+ SwTwips nWidth = static_cast< SwTwips >(m_xWidthED->DenormalizePercent(m_xWidthED->get_value(FieldUnit::TWIP)));
+ SwTwips nHeight = static_cast< SwTwips >(m_xHeightED->DenormalizePercent(m_xHeightED->get_value(FieldUnit::TWIP)));
+ m_fWidthHeightRatio = nHeight ? double(nWidth) / double(nHeight) : 1.0;
+}
+
+// stuff attributes into the set when OK
+bool SwFramePage::FillItemSet(SfxItemSet *rSet)
+{
+ bool bRet = false;
+ SwWrtShell* pSh = m_bFormat ? ::GetActiveWrtShell()
+ : getFrameDlgParentShell();
+ OSL_ENSURE( pSh , "shell not found");
+ const SfxItemSet& rOldSet = GetItemSet();
+ const SfxPoolItem* pOldItem = nullptr;
+
+ RndStdIds eAnchorId = GetAnchor();
+
+ if ( !m_bFormat )
+ {
+ pOldItem = GetOldItem(*rSet, RES_ANCHOR);
+ if (m_bNew || !pOldItem || eAnchorId != static_cast<const SwFormatAnchor*>(pOldItem)->GetAnchorId())
+ {
+ SwFormatAnchor aAnc( eAnchorId, pSh->GetPhyPageNum() );
+ bRet = nullptr != rSet->Put( aAnc );
+ }
+ }
+
+ if ( m_pHMap )
+ {
+ SwFormatHoriOrient aHoriOrient( rOldSet.Get(RES_HORI_ORIENT) );
+
+ const sal_Int32 nMapPos = GetMapPos(m_pHMap, *m_xHorizontalDLB);
+ const sal_Int16 eHOri = GetAlignment(m_pHMap, nMapPos, *m_xHoriRelationLB);
+ const sal_Int16 eRel = GetRelation(*m_xHoriRelationLB);
+
+ aHoriOrient.SetHoriOrient( eHOri );
+ aHoriOrient.SetRelationOrient( eRel );
+ aHoriOrient.SetPosToggle(m_xMirrorPagesCB->get_active());
+
+ bool bMod = m_xAtHorzPosED->get_value_changed_from_saved();
+ bMod |= m_xMirrorPagesCB->get_state_changed_from_saved();
+
+ if ( eHOri == text::HoriOrientation::NONE &&
+ (m_bNew || (m_bAtHorzPosModified || bMod) || m_nOldH != eHOri ) )
+ {
+ SwTwips nX = static_cast< SwTwips >(m_xAtHorzPosED->denormalize(m_xAtHorzPosED->get_value(FieldUnit::TWIP)));
+ aHoriOrient.SetPos( nX );
+ }
+
+ pOldItem = GetOldItem(*rSet, FN_HORI_ORIENT);
+ bool bSame = false;
+ if ((m_bNew == m_bFormat) && pOldItem)
+ {
+ bSame = aHoriOrient == static_cast<const SwFormatHoriOrient&>(*pOldItem);
+ }
+ if ((m_bNew && !m_bFormat) || ((m_bAtHorzPosModified || bMod) && !bSame))
+ {
+ bRet |= nullptr != rSet->Put( aHoriOrient );
+ }
+ }
+
+ if ( m_pVMap )
+ {
+ // alignment vertical
+ SwFormatVertOrient aVertOrient( rOldSet.Get(RES_VERT_ORIENT) );
+
+ const sal_Int32 nMapPos = GetMapPos(m_pVMap, *m_xVerticalDLB);
+ const sal_Int16 eVOri = GetAlignment(m_pVMap, nMapPos, *m_xVertRelationLB);
+ const sal_Int16 eRel = GetRelation(*m_xVertRelationLB);
+
+ aVertOrient.SetVertOrient ( eVOri);
+ aVertOrient.SetRelationOrient( eRel );
+
+ bool bMod = m_xAtVertPosED->get_value_changed_from_saved();
+
+ if ( eVOri == text::VertOrientation::NONE &&
+ ( m_bNew || (m_bAtVertPosModified || bMod) || m_nOldV != eVOri) )
+ {
+ // vertical position
+ // recalculate offset for character bound frames
+ SwTwips nY = static_cast< SwTwips >(m_xAtVertPosED->denormalize(m_xAtVertPosED->get_value(FieldUnit::TWIP)));
+ if (eAnchorId == RndStdIds::FLY_AS_CHAR)
+ {
+ nY *= -1;
+ }
+ aVertOrient.SetPos( nY );
+ }
+ pOldItem = GetOldItem(*rSet, FN_VERT_ORIENT);
+ bool bSame = false;
+ if((m_bNew == m_bFormat) && pOldItem)
+ {
+ bSame = m_bFormat ?
+ aVertOrient.GetVertOrient() == static_cast<const SwFormatVertOrient*>(pOldItem)->GetVertOrient() &&
+ aVertOrient.GetRelationOrient() == static_cast<const SwFormatVertOrient*>(pOldItem)->GetRelationOrient() &&
+ aVertOrient.GetPos() == static_cast<const SwFormatVertOrient*>(pOldItem)->GetPos()
+ : aVertOrient == static_cast<const SwFormatVertOrient&>(*pOldItem);
+ }
+ if( ( m_bNew && !m_bFormat ) || ((m_bAtVertPosModified || bMod) && !bSame ))
+ {
+ bRet |= nullptr != rSet->Put( aVertOrient );
+ }
+ }
+
+ // set size
+ // new exception: when the size of pMgr(, 0), then the properties
+ // for a graphic that isn't even loaded, are set. Then no SetSize
+ // is done here when the size settings were not changed by the
+ // user.
+ const SwFormatFrameSize& rOldSize = rOldSet.Get(RES_FRM_SIZE);
+ SwFormatFrameSize aSz( rOldSize );
+
+ auto nRelWidthRelation = m_xRelWidthRelationLB->get_active();
+ if (nRelWidthRelation != -1)
+ {
+ if (nRelWidthRelation == 0)
+ aSz.SetWidthPercentRelation(text::RelOrientation::FRAME);
+ else if (nRelWidthRelation == 1)
+ aSz.SetWidthPercentRelation(text::RelOrientation::PAGE_FRAME);
+ }
+ auto nRelHeightRelation = m_xRelHeightRelationLB->get_active();
+ if (nRelHeightRelation != -1)
+ {
+ if (nRelHeightRelation == 0)
+ aSz.SetHeightPercentRelation(text::RelOrientation::FRAME);
+ else if (nRelHeightRelation == 1)
+ aSz.SetHeightPercentRelation(text::RelOrientation::PAGE_FRAME);
+ }
+
+ bool bValueModified = m_xWidthED->get_value_changed_from_saved() ||
+ m_xHeightED->get_value_changed_from_saved();
+ bool bCheckChanged = m_xRelWidthCB->get_state_changed_from_saved() ||
+ m_xRelHeightCB->get_state_changed_from_saved();
+
+ bool bLegalValue = !(!rOldSize.GetWidth () && !rOldSize.GetHeight() &&
+ m_xWidthED->get_value() == m_xWidthED->get_min() &&
+ m_xHeightED->get_value() == m_xHeightED->get_min());
+
+ if ((m_bNew && !m_bFormat) || ((bValueModified || bCheckChanged) && bLegalValue))
+ {
+ sal_Int64 nNewWidth = m_xWidthED->DenormalizePercent(m_xWidthED->GetRealValue(FieldUnit::TWIP));
+ sal_Int64 nNewHeight = m_xHeightED->DenormalizePercent(m_xHeightED->GetRealValue(FieldUnit::TWIP));
+ aSz.SetWidth (static_cast< SwTwips >(nNewWidth));
+ aSz.SetHeight(static_cast< SwTwips >(nNewHeight));
+
+ if (m_xRelWidthCB->get_active())
+ {
+ aSz.SetWidthPercent(static_cast<sal_uInt8>(std::min(MAX_PERCENT_WIDTH, m_xWidthED->Convert(m_xWidthED->NormalizePercent(nNewWidth), FieldUnit::TWIP, FieldUnit::PERCENT))));
+ }
+ else
+ aSz.SetWidthPercent(0);
+ if (m_xRelHeightCB->get_active())
+ aSz.SetHeightPercent(static_cast<sal_uInt8>(std::min(MAX_PERCENT_HEIGHT, m_xHeightED->Convert(m_xHeightED->NormalizePercent(nNewHeight), FieldUnit::TWIP, FieldUnit::PERCENT))));
+ else
+ aSz.SetHeightPercent(0);
+
+ if (m_xFixedRatioCB->get_active() && (m_xRelWidthCB->get_active() != m_xRelHeightCB->get_active()))
+ {
+ if (m_xRelWidthCB->get_active())
+ aSz.SetHeightPercent(SwFormatFrameSize::SYNCED);
+ else
+ aSz.SetWidthPercent(SwFormatFrameSize::SYNCED);
+ }
+ }
+ if( !IsInGraficMode() )
+ {
+ if (m_xAutoHeightCB->get_state_changed_from_saved())
+ {
+ SwFrameSize eFrameSize = m_xAutoHeightCB->get_active()? SwFrameSize::Minimum : SwFrameSize::Fixed;
+ if( eFrameSize != aSz.GetHeightSizeType() )
+ aSz.SetHeightSizeType(eFrameSize);
+ }
+ if (m_xAutoWidthCB->get_state_changed_from_saved())
+ {
+ SwFrameSize eFrameSize = m_xAutoWidthCB->get_active()? SwFrameSize::Minimum : SwFrameSize::Fixed;
+ if( eFrameSize != aSz.GetWidthSizeType() )
+ aSz.SetWidthSizeType( eFrameSize );
+ }
+ }
+ if (!m_bFormat && m_xFixedRatioCB->get_state_changed_from_saved())
+ bRet |= nullptr != rSet->Put(SfxBoolItem(FN_KEEP_ASPECT_RATIO, m_xFixedRatioCB->get_active()));
+
+ pOldItem = GetOldItem(*rSet, RES_FRM_SIZE);
+
+ if ((pOldItem && aSz != *pOldItem) || (!pOldItem && !m_bFormat) ||
+ (m_bFormat &&
+ (aSz.GetWidth() > 0 || aSz.GetWidthPercent() > 0) &&
+ (aSz.GetHeight() > 0 || aSz.GetHeightPercent() > 0)))
+ {
+ if (aSz.GetHeightSizeType() == SwFrameSize::Variable) // there is no VAR_SIZE in frames
+ aSz.SetHeightSizeType(SwFrameSize::Minimum);
+
+ bRet |= nullptr != rSet->Put( aSz );
+ }
+ if (m_xFollowTextFlowCB->get_state_changed_from_saved())
+ {
+ bRet |= nullptr != rSet->Put(SwFormatFollowTextFlow(m_xFollowTextFlowCB->get_active()));
+ }
+ return bRet;
+}
+
+// initialise horizontal and vertical Pos
+void SwFramePage::InitPos(RndStdIds eId,
+ sal_Int16 nH,
+ sal_Int16 nHRel,
+ sal_Int16 nV,
+ sal_Int16 nVRel,
+ long nX,
+ long nY)
+{
+ auto nPos = m_xVerticalDLB->get_active();
+ if (nPos != -1 && m_pVMap)
+ {
+ m_nOldV = m_pVMap[nPos].nAlign;
+
+ nPos = m_xVertRelationLB->get_active();
+ if (nPos != -1)
+ m_nOldVRel = reinterpret_cast<RelationMap*>(m_xVertRelationLB->get_id(nPos).toInt64())->nRelation;
+ }
+
+ nPos = m_xHorizontalDLB->get_active();
+ if (nPos != -1 && m_pHMap)
+ {
+ m_nOldH = m_pHMap[nPos].nAlign;
+
+ nPos = m_xHoriRelationLB->get_active();
+ if (nPos != -1)
+ m_nOldHRel = reinterpret_cast<RelationMap*>(m_xHoriRelationLB->get_id(nPos).toInt64())->nRelation;
+ }
+
+ bool bEnable = true;
+ if ( eId == RndStdIds::FLY_AT_PAGE )
+ {
+ m_pVMap = m_bHtmlMode ? aVPageHtmlMap : aVPageMap;
+ m_pHMap = m_bHtmlMode ? aHPageHtmlMap : aHPageMap;
+ }
+ else if ( eId == RndStdIds::FLY_AT_FLY )
+ {
+ // own vertical alignment map for to frame
+ // anchored objects.
+ m_pVMap = m_bHtmlMode ? aVFlyHtmlMap : aVFrameMap;
+ m_pHMap = m_bHtmlMode ? aHFlyHtmlMap : aHFrameMap;
+ }
+ else if ( eId == RndStdIds::FLY_AT_PARA )
+ {
+ if(m_bHtmlMode)
+ {
+ m_pVMap = aVParaHtmlMap;
+ m_pHMap = aHParaHtmlAbsMap;
+ }
+ else
+ {
+ m_pVMap = aVParaMap;
+ m_pHMap = aHParaMap;
+ }
+ }
+ else if ( eId == RndStdIds::FLY_AT_CHAR )
+ {
+ if(m_bHtmlMode)
+ {
+ m_pVMap = aVCharHtmlAbsMap;
+ m_pHMap = aHCharHtmlAbsMap;
+ }
+ else
+ {
+ m_pVMap = aVCharMap;
+ m_pHMap = aHCharMap;
+ }
+ }
+ else if ( eId == RndStdIds::FLY_AS_CHAR )
+ {
+ m_pVMap = m_bHtmlMode ? aVAsCharHtmlMap : aVAsCharMap;
+ m_pHMap = nullptr;
+ bEnable = false;
+ }
+ m_xHorizontalDLB->set_sensitive( bEnable );
+ m_xHorizontalFT->set_sensitive( bEnable );
+
+ // select current Pos
+ // horizontal
+ if ( nH < 0 )
+ {
+ nH = m_nOldH;
+ nHRel = m_nOldHRel;
+ }
+ sal_Int32 nMapPos = FillPosLB(m_pHMap, nH, nHRel, *m_xHorizontalDLB);
+ FillRelLB(m_pHMap, nMapPos, nH, nHRel, *m_xHoriRelationLB, *m_xHoriRelationFT);
+
+ // vertical
+ if ( nV < 0 )
+ {
+ nV = m_nOldV;
+ nVRel = m_nOldVRel;
+ }
+ nMapPos = FillPosLB(m_pVMap, nV, nVRel, *m_xVerticalDLB);
+ FillRelLB(m_pVMap, nMapPos, nV, nVRel, *m_xVertRelationLB, *m_xVertRelationFT);
+
+ bEnable = nH == text::HoriOrientation::NONE && eId != RndStdIds::FLY_AS_CHAR;
+ if (!bEnable)
+ m_xAtHorzPosED->set_value(0, FieldUnit::TWIP);
+ else
+ {
+ if (nX != LONG_MAX)
+ m_xAtHorzPosED->set_value(m_xAtHorzPosED->normalize(nX), FieldUnit::TWIP);
+ }
+ m_xAtHorzPosFT->set_sensitive( bEnable );
+ m_xAtHorzPosED->set_sensitive( bEnable );
+
+ bEnable = nV == text::VertOrientation::NONE;
+ if ( !bEnable )
+ m_xAtVertPosED->set_value(0, FieldUnit::TWIP);
+ else
+ {
+ if (eId == RndStdIds::FLY_AS_CHAR)
+ {
+ if ( nY == LONG_MAX )
+ nY = 0;
+ else
+ nY *= -1;
+ }
+ if ( nY != LONG_MAX )
+ m_xAtVertPosED->set_value(m_xAtVertPosED->normalize(nY), FieldUnit::TWIP);
+ }
+ m_xAtVertPosFT->set_sensitive( bEnable && m_bAllowVertPositioning );
+ m_xAtVertPosED->set_sensitive( bEnable && m_bAllowVertPositioning );
+ UpdateExample();
+}
+
+sal_Int32 SwFramePage::FillPosLB(const FrameMap* _pMap,
+ const sal_Int16 _nAlign,
+ const sal_Int16 _nRel,
+ weld::ComboBox& _rLB )
+{
+ OUString sSelEntry;
+ const OUString sOldEntry = _rLB.get_active_text();
+
+ _rLB.clear();
+
+ // i#22341 determine all possible listbox relations for
+ // given relation for map <aVCharMap>
+ const LB nLBRelations = (_pMap != aVCharMap)
+ ? LB::NONE
+ : ::lcl_GetLBRelationsForRelations( _nRel );
+
+ // fill Listbox
+ size_t nCount = ::lcl_GetFrameMapCount(_pMap);
+ for (size_t i = 0; _pMap && i < nCount; ++i)
+ {
+// Why not from the left/from inside or from above?
+ SvxSwFramePosString::StringId eStrId = m_xMirrorPagesCB->get_active() ? _pMap[i].eMirrorStrId : _pMap[i].eStrId;
+ // --> OD 2009-08-31 #mongolianlayout#
+ eStrId = lcl_ChangeResIdToVerticalOrRTL( eStrId,
+ m_bIsVerticalFrame,
+ m_bIsVerticalL2R,
+ m_bIsInRightToLeft);
+ OUString sEntry(SvxSwFramePosString::GetString(eStrId));
+ if (_rLB.find_text(sEntry) == -1)
+ {
+ // don't insert entries when frames are character bound
+ _rLB.append_text(sEntry);
+ }
+ // i#22341 - add condition to handle map <aVCharMap>
+ // that is ambiguous in the alignment.
+ if ( _pMap[i].nAlign == _nAlign &&
+ ( (_pMap != aVCharMap) || _pMap[i].nLBRelations & nLBRelations ) )
+ {
+ sSelEntry = sEntry;
+ }
+ }
+
+ _rLB.set_active_text(sSelEntry);
+ if (_rLB.get_active() == -1)
+ _rLB.set_active_text(sOldEntry);
+
+ if (_rLB.get_active() == -1)
+ _rLB.set_active(0);
+
+ PosHdl(_rLB);
+
+ return GetMapPos(_pMap, _rLB);
+}
+
+void SwFramePage::FillRelLB(const FrameMap* _pMap,
+ const sal_uInt16 _nLBSelPos,
+ const sal_Int16 _nAlign,
+ const sal_Int16 _nRel,
+ weld::ComboBox& _rLB,
+ weld::Label& _rFT)
+{
+ OUString sSelEntry;
+ LB nLBRelations = LB::NONE;
+ size_t nMapCount = ::lcl_GetFrameMapCount(_pMap);
+
+ _rLB.clear();
+
+ if (_nLBSelPos < nMapCount)
+ {
+ if (_pMap == aVAsCharHtmlMap || _pMap == aVAsCharMap)
+ {
+ const OUString sOldEntry(_rLB.get_active_text());
+ SvxSwFramePosString::StringId eStrId = _pMap[_nLBSelPos].eStrId;
+
+ for (size_t nMapPos = 0; nMapPos < nMapCount; nMapPos++)
+ {
+ if (_pMap[nMapPos].eStrId == eStrId)
+ {
+ nLBRelations = _pMap[nMapPos].nLBRelations;
+ for (RelationMap const & rCharMap : aAsCharRelationMap)
+ {
+ if (nLBRelations & rCharMap.nLBRelation)
+ {
+ // --> OD 2009-08-31 #mongolianlayout#
+ SvxSwFramePosString::StringId sStrId1 =
+ lcl_ChangeResIdToVerticalOrRTL( rCharMap.eStrId,
+ m_bIsVerticalFrame,
+ m_bIsVerticalL2R,
+ m_bIsInRightToLeft);
+ const OUString sEntry = SvxSwFramePosString::GetString(sStrId1);
+ _rLB.append(OUString::number(reinterpret_cast<sal_Int64>(&rCharMap)), sEntry);
+ if (_pMap[nMapPos].nAlign == _nAlign)
+ sSelEntry = sEntry;
+ break;
+ }
+ }
+ }
+ }
+ if (!sSelEntry.isEmpty())
+ _rLB.set_active_text(sSelEntry);
+ else
+ {
+ _rLB.set_active_text(sOldEntry);
+
+ if (_rLB.get_active() == -1)
+ {
+ for (int i = 0; i < _rLB.get_count(); i++)
+ {
+ RelationMap *pEntry = reinterpret_cast<RelationMap*>(_rLB.get_id(i).toInt64());
+ if (pEntry->nLBRelation == LB::RelChar) // default
+ {
+ _rLB.set_active(i);
+ break;
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ // special handling for map <aVCharMap>,
+ // because its ambiguous in its <eStrId>/<eMirrorStrId>.
+ if ( _pMap == aVCharMap )
+ {
+ nLBRelations = ::lcl_GetLBRelationsForStrID( _pMap,
+ ( m_xMirrorPagesCB->get_active()
+ ? _pMap[_nLBSelPos].eMirrorStrId
+ : _pMap[_nLBSelPos].eStrId),
+ m_xMirrorPagesCB->get_active() );
+ }
+ else
+ {
+ nLBRelations = _pMap[_nLBSelPos].nLBRelations;
+ }
+
+ for (sal_uLong nBit = 1; nBit < 0x80000000; nBit <<= 1)
+ {
+ if (nLBRelations & static_cast<LB>(nBit))
+ {
+ for (RelationMap const & rMap : aRelationMap)
+ {
+ if (rMap.nLBRelation == static_cast<LB>(nBit))
+ {
+ SvxSwFramePosString::StringId eStrId1 = m_xMirrorPagesCB->get_active() ?
+ rMap.eMirrorStrId : rMap.eStrId;
+ // --> OD 2009-08-31 #mongolianlayout#
+ eStrId1 =
+ lcl_ChangeResIdToVerticalOrRTL( eStrId1,
+ m_bIsVerticalFrame,
+ m_bIsVerticalL2R,
+ m_bIsInRightToLeft);
+ const OUString sEntry = SvxSwFramePosString::GetString(eStrId1);
+ _rLB.append(OUString::number(reinterpret_cast<sal_Int64>(&rMap)), sEntry);
+ if (sSelEntry.isEmpty() && rMap.nRelation == _nRel)
+ sSelEntry = sEntry;
+ }
+ }
+ }
+ }
+ if (!sSelEntry.isEmpty())
+ _rLB.set_active_text(sSelEntry);
+ else
+ {
+ // Probably anchor switch. So look for similar relation
+ sal_Int16 nSimRel = -1;
+ switch (_nRel)
+ {
+ case text::RelOrientation::FRAME:
+ nSimRel = text::RelOrientation::PAGE_FRAME;
+ break;
+ case text::RelOrientation::PRINT_AREA:
+ nSimRel = text::RelOrientation::PAGE_PRINT_AREA;
+ break;
+ case text::RelOrientation::PAGE_LEFT:
+ nSimRel = text::RelOrientation::FRAME_LEFT;
+ break;
+ case text::RelOrientation::PAGE_RIGHT:
+ nSimRel = text::RelOrientation::FRAME_RIGHT;
+ break;
+ case text::RelOrientation::FRAME_LEFT:
+ nSimRel = text::RelOrientation::PAGE_LEFT;
+ break;
+ case text::RelOrientation::FRAME_RIGHT:
+ nSimRel = text::RelOrientation::PAGE_RIGHT;
+ break;
+ case text::RelOrientation::PAGE_FRAME:
+ nSimRel = text::RelOrientation::FRAME;
+ break;
+ case text::RelOrientation::PAGE_PRINT_AREA:
+ nSimRel = text::RelOrientation::PRINT_AREA;
+ break;
+
+ default:
+ if (_rLB.get_active() != -1)
+ {
+ RelationMap *pEntry = reinterpret_cast<RelationMap*>(_rLB.get_id(_rLB.get_count() - 1).toInt64());
+ nSimRel = pEntry->nRelation;
+ }
+ break;
+ }
+
+ for (int i = 0; i < _rLB.get_count(); i++)
+ {
+ RelationMap *pEntry = reinterpret_cast<RelationMap*>(_rLB.get_id(i).toInt64());
+ if (pEntry->nRelation == nSimRel)
+ {
+ _rLB.set_active(i);
+ break;
+ }
+ }
+
+ if (_rLB.get_active() == -1)
+ _rLB.set_active(0);
+ }
+ }
+ }
+
+ const bool bEnable = _rLB.get_count() != 0
+ && (&_rLB != m_xVertRelationLB.get() || m_bAllowVertPositioning);
+ _rLB.set_sensitive( bEnable );
+ _rFT.set_sensitive( bEnable );
+
+ RelHdl(_rLB);
+}
+
+sal_Int16 SwFramePage::GetRelation(const weld::ComboBox& rRelationLB)
+{
+ const auto nPos = rRelationLB.get_active();
+ if (nPos != -1)
+ {
+ RelationMap *pEntry = reinterpret_cast<RelationMap *>(rRelationLB.get_id(nPos).toInt64());
+ return pEntry->nRelation;
+ }
+
+ return 0;
+}
+
+sal_Int16 SwFramePage::GetAlignment(FrameMap const *pMap, sal_Int32 nMapPos,
+ const weld::ComboBox& rRelationLB)
+{
+ if (!pMap || nMapPos < 0)
+ return 0;
+
+ const size_t nMapCount = ::lcl_GetFrameMapCount(pMap);
+
+ if (o3tl::make_unsigned(nMapPos) >= nMapCount)
+ return 0;
+
+ // i#22341 special handling also for map <aVCharMap>,
+ // because it contains ambiguous items for alignment
+ if ( pMap != aVAsCharHtmlMap && pMap != aVAsCharMap && pMap != aVCharMap )
+ return pMap[nMapPos].nAlign;
+
+ if (rRelationLB.get_active() == -1)
+ return 0;
+
+ const RelationMap *const pRelationMap = reinterpret_cast<const RelationMap *>(
+ rRelationLB.get_active_id().toInt64());
+ const LB nRel = pRelationMap->nLBRelation;
+ const SvxSwFramePosString::StringId eStrId = pMap[nMapPos].eStrId;
+
+ for (size_t i = 0; i < nMapCount; ++i)
+ {
+ if (pMap[i].eStrId == eStrId && (pMap[i].nLBRelations & nRel))
+ return pMap[i].nAlign;
+ }
+
+ return 0;
+}
+
+sal_Int32 SwFramePage::GetMapPos(const FrameMap *pMap, const weld::ComboBox& rAlignLB)
+{
+ sal_Int32 nMapPos = 0;
+ auto nLBSelPos = rAlignLB.get_active();
+
+ if (nLBSelPos != -1)
+ {
+ if (pMap == aVAsCharHtmlMap || pMap == aVAsCharMap)
+ {
+ const size_t nMapCount = ::lcl_GetFrameMapCount(pMap);
+ const OUString sSelEntry(rAlignLB.get_active_text());
+
+ for (size_t i = 0; i < nMapCount; i++)
+ {
+ SvxSwFramePosString::StringId eResId = pMap[i].eStrId;
+
+ OUString sEntry = SvxSwFramePosString::GetString(eResId);
+ sEntry = MnemonicGenerator::EraseAllMnemonicChars( sEntry );
+
+ if (sEntry == sSelEntry)
+ {
+ nMapPos = static_cast< sal_Int32 >(i);
+ break;
+ }
+ }
+ }
+ else
+ nMapPos = nLBSelPos;
+ }
+
+ return nMapPos;
+}
+
+RndStdIds SwFramePage::GetAnchor() const
+{
+ RndStdIds nRet = RndStdIds::FLY_AT_PAGE;
+ if (m_xAnchorAtParaRB->get_active())
+ {
+ nRet = RndStdIds::FLY_AT_PARA;
+ }
+ else if (m_xAnchorAtCharRB->get_active())
+ {
+ nRet = RndStdIds::FLY_AT_CHAR;
+ }
+ else if (m_xAnchorAsCharRB->get_active())
+ {
+ nRet = RndStdIds::FLY_AS_CHAR;
+ }
+ else if (m_xAnchorAtFrameRB->get_active())
+ {
+ nRet = RndStdIds::FLY_AT_FLY;
+ }
+ return nRet;
+}
+
+// Bsp - Update
+void SwFramePage::ActivatePage(const SfxItemSet& rSet)
+{
+ m_bNoModifyHdl = true;
+ Init(rSet);
+ m_bNoModifyHdl = false;
+ //lock PercentFields
+ m_xWidthED->LockAutoCalculation(true);
+ m_xHeightED->LockAutoCalculation(true);
+ RangeModifyHdl(); // set all maximum values initially
+ m_xHeightED->LockAutoCalculation(false);
+ m_xWidthED->LockAutoCalculation(false);
+ m_xFollowTextFlowCB->save_state();
+}
+
+DeactivateRC SwFramePage::DeactivatePage(SfxItemSet * _pSet)
+{
+ if ( _pSet )
+ {
+ FillItemSet( _pSet );
+
+ if (!m_bFormat) // tdf#112574 no anchor in styles
+ {
+ //FillItemSet doesn't set the anchor into the set when it matches
+ //the original. But for the other pages we need the current anchor.
+ SwWrtShell* pSh = m_bFormat ? ::GetActiveWrtShell()
+ : getFrameDlgParentShell();
+ RndStdIds eAnchorId = GetAnchor();
+ SwFormatAnchor aAnc( eAnchorId, pSh->GetPhyPageNum() );
+ _pSet->Put( aAnc );
+ }
+ }
+
+ return DeactivateRC::LeavePage;
+}
+
+// swap left/right with inside/outside
+IMPL_LINK_NOARG(SwFramePage, MirrorHdl, weld::ToggleButton&, void)
+{
+ RndStdIds eId = GetAnchor();
+ InitPos(eId, -1, 0, -1, 0, LONG_MAX, LONG_MAX);
+}
+
+IMPL_LINK( SwFramePage, RelSizeClickHdl, weld::ToggleButton&, rBtn, void )
+{
+ if (&rBtn == m_xRelWidthCB.get())
+ {
+ m_xWidthED->ShowPercent(rBtn.get_active());
+ m_xRelWidthRelationLB->set_sensitive(rBtn.get_active());
+ if (rBtn.get_active())
+ m_xWidthED->get()->set_max(MAX_PERCENT_WIDTH, FieldUnit::NONE);
+ }
+ else // rBtn == m_xRelHeightCB.get()
+ {
+ m_xHeightED->ShowPercent(rBtn.get_active());
+ m_xRelHeightRelationLB->set_sensitive(rBtn.get_active());
+ if (rBtn.get_active())
+ m_xHeightED->get()->set_max(MAX_PERCENT_HEIGHT, FieldUnit::NONE);
+ }
+
+ RangeModifyHdl(); // correct the values again
+
+ if (&rBtn == m_xRelWidthCB.get())
+ ModifyHdl(*m_xWidthED->get());
+ else // rBtn == m_xRelHeightCB.get()
+ ModifyHdl(*m_xHeightED->get());
+}
+
+// range check
+IMPL_LINK_NOARG(SwFramePage, RangeModifyClickHdl, weld::ToggleButton&, void)
+{
+ RangeModifyHdl();
+}
+
+void SwFramePage::RangeModifyHdl()
+{
+ if (m_bNoModifyHdl)
+ return;
+
+ SwWrtShell* pSh = m_bFormat ? ::GetActiveWrtShell()
+ : getFrameDlgParentShell();
+ OSL_ENSURE(pSh , "shell not found");
+ SwFlyFrameAttrMgr aMgr( m_bNew, pSh, GetItemSet() );
+ SvxSwFrameValidation aVal;
+
+ aVal.nAnchorType = GetAnchor();
+ aVal.bAutoHeight = m_xAutoHeightCB->get_active();
+ aVal.bMirror = m_xMirrorPagesCB->get_active();
+ aVal.bFollowTextFlow = m_xFollowTextFlowCB->get_active();
+
+ if ( m_pHMap )
+ {
+ // alignment horizontal
+ const sal_Int32 nMapPos = GetMapPos(m_pHMap, *m_xHorizontalDLB);
+ aVal.nHoriOrient = GetAlignment(m_pHMap, nMapPos, *m_xHoriRelationLB);
+ aVal.nHRelOrient = GetRelation(*m_xHoriRelationLB);
+ }
+ else
+ aVal.nHoriOrient = text::HoriOrientation::NONE;
+
+ if ( m_pVMap )
+ {
+ // alignment vertical
+ const sal_Int32 nMapPos = GetMapPos(m_pVMap, *m_xVerticalDLB);
+ aVal.nVertOrient = GetAlignment(m_pVMap, nMapPos, *m_xVertRelationLB);
+ aVal.nVRelOrient = GetRelation(*m_xVertRelationLB);
+ }
+ else
+ aVal.nVertOrient = text::VertOrientation::NONE;
+
+ const long nAtHorzPosVal = static_cast< long >(
+ m_xAtHorzPosED->denormalize(m_xAtHorzPosED->get_value(FieldUnit::TWIP)) );
+ const long nAtVertPosVal = static_cast< long >(
+ m_xAtVertPosED->denormalize(m_xAtVertPosED->get_value(FieldUnit::TWIP)) );
+
+ aVal.nHPos = nAtHorzPosVal;
+ aVal.nVPos = nAtVertPosVal;
+
+ aMgr.ValidateMetrics(aVal, mpToCharContentPos, true); // one time, to get reference values for percental values
+
+ // set reference values for percental values (100%) ...
+ m_xWidthED->SetRefValue(aVal.aPercentSize.Width());
+ m_xHeightED->SetRefValue(aVal.aPercentSize.Height());
+
+ // ... and correctly convert width and height with it
+ SwTwips nWidth = static_cast< SwTwips >(m_xWidthED->DenormalizePercent(m_xWidthED->get_value(FieldUnit::TWIP)));
+ SwTwips nHeight = static_cast< SwTwips >(m_xHeightED->DenormalizePercent(m_xHeightED->get_value(FieldUnit::TWIP)));
+ aVal.nWidth = nWidth;
+ aVal.nHeight = nHeight;
+
+ aMgr.ValidateMetrics(aVal, mpToCharContentPos); // one more time, to determine all remaining values with correct width and height.
+
+ // all columns have to be correct
+ const SfxItemSet* pExampleSet = GetDialogExampleSet();
+ if (pExampleSet && SfxItemState::DEFAULT <= pExampleSet->GetItemState(RES_COL))
+ {
+ const SwFormatCol& rCol = pExampleSet->Get(RES_COL);
+ if ( rCol.GetColumns().size() > 1 )
+ {
+ for (const SwColumn & i : rCol.GetColumns())
+ {
+ aVal.nMinWidth += i.GetLeft() +
+ i.GetRight() +
+ MINFLY;
+ }
+ aVal.nMinWidth -= MINFLY;//one was already in there!
+ }
+ }
+
+ nWidth = aVal.nWidth;
+ nHeight = aVal.nHeight;
+
+ // minimum range also for template
+ m_xHeightED->set_min(m_xHeightED->NormalizePercent(aVal.nMinHeight), FieldUnit::TWIP);
+ m_xWidthED->set_min(m_xWidthED->NormalizePercent(aVal.nMinWidth), FieldUnit::TWIP);
+
+ SwTwips nMaxWidth(aVal.nMaxWidth);
+ SwTwips nMaxHeight(aVal.nMaxHeight);
+
+ if (aVal.bAutoHeight && (m_sDlgType == "PictureDialog" || m_sDlgType == "ObjectDialog"))
+ {
+ SwTwips nTmp = std::min(nWidth * nMaxHeight / std::max(nHeight, 1L), nMaxHeight);
+ m_xWidthED->set_max(m_xWidthED->NormalizePercent(nTmp), FieldUnit::TWIP);
+
+ nTmp = std::min(nHeight * nMaxWidth / std::max(nWidth, 1L), nMaxWidth);
+ m_xHeightED->set_max(m_xWidthED->NormalizePercent(nTmp), FieldUnit::TWIP);
+ }
+ else
+ {
+ SwTwips nTmp = static_cast< SwTwips >(m_xHeightED->NormalizePercent(nMaxHeight));
+ m_xHeightED->set_max(nTmp, FieldUnit::TWIP);
+
+ nTmp = static_cast< SwTwips >(m_xWidthED->NormalizePercent(nMaxWidth));
+ m_xWidthED->set_max(nTmp, FieldUnit::TWIP);
+ }
+
+ m_xAtHorzPosED->set_range(m_xAtHorzPosED->normalize(aVal.nMinHPos),
+ m_xAtHorzPosED->normalize(aVal.nMaxHPos),
+ FieldUnit::TWIP);
+ if (aVal.nHPos != nAtHorzPosVal)
+ m_xAtHorzPosED->set_value(m_xAtHorzPosED->normalize(aVal.nHPos), FieldUnit::TWIP);
+
+ const SwTwips nUpperOffset = (aVal.nAnchorType == RndStdIds::FLY_AS_CHAR)
+ ? m_nUpperBorder : 0;
+ const SwTwips nLowerOffset = (aVal.nAnchorType == RndStdIds::FLY_AS_CHAR)
+ ? m_nLowerBorder : 0;
+
+ m_xAtVertPosED->set_range(m_xAtVertPosED->normalize(aVal.nMinVPos + nLowerOffset + nUpperOffset),
+ m_xAtVertPosED->normalize(aVal.nMaxVPos),
+ FieldUnit::TWIP);
+ if (aVal.nVPos != nAtVertPosVal)
+ m_xAtVertPosED->set_value(m_xAtVertPosED->normalize(aVal.nVPos), FieldUnit::TWIP);
+}
+
+IMPL_LINK_NOARG(SwFramePage, AnchorTypeHdl, weld::ToggleButton&, void)
+{
+ m_xMirrorPagesCB->set_sensitive(!m_xAnchorAsCharRB->get_active());
+
+ // i#18732 - enable check box 'Follow text flow' for anchor
+ // type to-paragraph' and to-character
+ // i#22305 - enable check box 'Follow text
+ // flow' also for anchor type to-frame.
+ m_xFollowTextFlowCB->set_sensitive(m_xAnchorAtParaRB->get_active() ||
+ m_xAnchorAtCharRB->get_active() ||
+ m_xAnchorAtFrameRB->get_active());
+
+ RndStdIds eId = GetAnchor();
+
+ InitPos( eId, -1, 0, -1, 0, LONG_MAX, LONG_MAX);
+ RangeModifyHdl();
+
+ if(m_bHtmlMode)
+ {
+ PosHdl(*m_xHorizontalDLB);
+ PosHdl(*m_xVerticalDLB);
+ }
+
+ EnableVerticalPositioning( !(m_bIsMathOLE && m_bIsMathBaselineAlignment
+ && RndStdIds::FLY_AS_CHAR == eId) );
+}
+
+IMPL_LINK( SwFramePage, PosHdl, weld::ComboBox&, rLB, void )
+{
+ bool bHori = &rLB == m_xHorizontalDLB.get();
+ weld::ComboBox *pRelLB = bHori ? m_xHoriRelationLB.get() : m_xVertRelationLB.get();
+ weld::Label *pRelFT = bHori ? m_xHoriRelationFT.get() : m_xVertRelationFT.get();
+ FrameMap const *pMap = bHori ? m_pHMap : m_pVMap;
+
+ const sal_Int32 nMapPos = GetMapPos(pMap, rLB);
+ const sal_Int16 nAlign = GetAlignment(pMap, nMapPos, *pRelLB);
+
+ if (bHori)
+ {
+ bool bEnable = text::HoriOrientation::NONE == nAlign;
+ m_xAtHorzPosED->set_sensitive( bEnable );
+ m_xAtHorzPosFT->set_sensitive( bEnable );
+ }
+ else
+ {
+ bool bEnable = text::VertOrientation::NONE == nAlign && m_bAllowVertPositioning;
+ m_xAtVertPosED->set_sensitive( bEnable );
+ m_xAtVertPosFT->set_sensitive( bEnable );
+ }
+
+ RangeModifyHdl();
+
+ sal_Int16 nRel = 0;
+ if (rLB.get_active() != -1)
+ {
+ if (pRelLB->get_active() != -1)
+ nRel = reinterpret_cast<RelationMap*>(pRelLB->get_active_id().toInt64())->nRelation;
+ FillRelLB(pMap, nMapPos, nAlign, nRel, *pRelLB, *pRelFT);
+ }
+ else
+ pRelLB->clear();
+
+ UpdateExample();
+
+ if (bHori)
+ m_bAtHorzPosModified = true;
+ else
+ m_bAtVertPosModified = true;
+
+ // special treatment for HTML-Mode with horizontal-vertical-dependencies
+ if(m_bHtmlMode && (RndStdIds::FLY_AT_CHAR == GetAnchor()))
+ {
+ bool bSet = false;
+ if(bHori)
+ {
+ // right is allowed only above - from the left only above
+ // from the left at character -> below
+ if((text::HoriOrientation::LEFT == nAlign || text::HoriOrientation::RIGHT == nAlign) &&
+ 0 == m_xVerticalDLB->get_active())
+ {
+ if(text::RelOrientation::FRAME == nRel)
+ m_xVerticalDLB->set_active(1);
+ else
+ m_xVerticalDLB->set_active(0);
+ bSet = true;
+ }
+ else if(text::HoriOrientation::LEFT == nAlign && 1 == m_xVerticalDLB->get_active())
+ {
+ m_xVerticalDLB->set_active(0);
+ bSet = true;
+ }
+ else if(text::HoriOrientation::NONE == nAlign && 1 == m_xVerticalDLB->get_active())
+ {
+ m_xVerticalDLB->set_active(0);
+ bSet = true;
+ }
+ if(bSet)
+ PosHdl(*m_xVerticalDLB);
+ }
+ else
+ {
+ if(text::VertOrientation::TOP == nAlign)
+ {
+ if (1 == m_xHorizontalDLB->get_active())
+ {
+ m_xHorizontalDLB->set_active(0);
+ bSet = true;
+ }
+ m_xHoriRelationLB->set_active(1);
+ }
+ else if(text::VertOrientation::CHAR_BOTTOM == nAlign)
+ {
+ if (2 == m_xHorizontalDLB->get_active())
+ {
+ m_xHorizontalDLB->set_active(0);
+ bSet = true;
+ }
+ m_xHoriRelationLB->set_active(0) ;
+ }
+ if(bSet)
+ PosHdl(*m_xHorizontalDLB);
+ }
+
+ }
+}
+
+// horizontal Pos
+IMPL_LINK( SwFramePage, RelHdl, weld::ComboBox&, rLB, void )
+{
+ bool bHori = &rLB == m_xHoriRelationLB.get();
+
+ UpdateExample();
+
+ if (bHori)
+ m_bAtHorzPosModified = true;
+ else
+ m_bAtVertPosModified = true;
+
+ if (m_bHtmlMode && (RndStdIds::FLY_AT_CHAR == GetAnchor()))
+ {
+ if(bHori)
+ {
+ const sal_Int16 nRel = GetRelation(*m_xHoriRelationLB);
+ if(text::RelOrientation::PRINT_AREA == nRel && 0 == m_xVerticalDLB->get_active())
+ {
+ m_xVerticalDLB->set_active(1);
+ }
+ else if(text::RelOrientation::CHAR == nRel && 1 == m_xVerticalDLB->get_active())
+ {
+ m_xVerticalDLB->set_active(0);
+ }
+ }
+ }
+ RangeModifyHdl();
+}
+
+IMPL_LINK_NOARG(SwFramePage, RealSizeHdl, weld::Button&, void)
+{
+ m_xWidthED->set_value(m_xWidthED->NormalizePercent(m_aGrfSize.Width()), FieldUnit::TWIP);
+ m_xHeightED->set_value(m_xHeightED->NormalizePercent(m_aGrfSize.Height()), FieldUnit::TWIP);
+ m_fWidthHeightRatio = m_aGrfSize.Height() ? double(m_aGrfSize.Width()) / double(m_aGrfSize.Height()) : 1.0;
+ UpdateExample();
+}
+
+IMPL_LINK_NOARG(SwFramePage, AutoWidthClickHdl, weld::ToggleButton&, void)
+{
+ if( !IsInGraficMode() )
+ HandleAutoCB( m_xAutoWidthCB->get_active(), *m_xWidthFT, *m_xWidthAutoFT, *m_xWidthED->get() );
+}
+
+IMPL_LINK_NOARG(SwFramePage, AutoHeightClickHdl, weld::ToggleButton&, void)
+{
+ if (!IsInGraficMode())
+ HandleAutoCB(m_xAutoHeightCB->get_active(), *m_xHeightFT, *m_xHeightAutoFT, *m_xWidthED->get());
+}
+
+IMPL_LINK( SwFramePage, ModifyHdl, weld::MetricSpinButton&, rEdit, void )
+{
+ SwTwips nWidth = static_cast< SwTwips >(m_xWidthED->DenormalizePercent(m_xWidthED->get_value(FieldUnit::TWIP)));
+ SwTwips nHeight = static_cast< SwTwips >(m_xHeightED->DenormalizePercent(m_xHeightED->get_value(FieldUnit::TWIP)));
+ if (m_xFixedRatioCB->get_active())
+ {
+ if (&rEdit == m_xWidthED->get())
+ {
+ nHeight = SwTwips(static_cast<double>(nWidth) / m_fWidthHeightRatio);
+ m_xHeightED->set_value(m_xHeightED->NormalizePercent(nHeight), FieldUnit::TWIP);
+ }
+ else if (&rEdit == m_xHeightED->get())
+ {
+ nWidth = SwTwips(static_cast<double>(nHeight) * m_fWidthHeightRatio);
+ m_xWidthED->set_value(m_xWidthED->NormalizePercent(nWidth), FieldUnit::TWIP);
+ }
+ }
+ m_fWidthHeightRatio = nHeight ? double(nWidth) / double(nHeight) : 1.0;
+ UpdateExample();
+}
+
+void SwFramePage::UpdateExample()
+{
+ auto nPos = m_xHorizontalDLB->get_active();
+ if (m_pHMap && nPos != -1)
+ {
+ const sal_Int32 nMapPos = GetMapPos(m_pHMap, *m_xHorizontalDLB);
+ m_aExampleWN.SetHAlign(GetAlignment(m_pHMap, nMapPos, *m_xHoriRelationLB));
+ m_aExampleWN.SetHoriRel(GetRelation(*m_xHoriRelationLB));
+ }
+
+ nPos = m_xVerticalDLB->get_active();
+ if (m_pVMap && nPos != -1)
+ {
+ const sal_Int32 nMapPos = GetMapPos(m_pVMap, *m_xVerticalDLB);
+ m_aExampleWN.SetVAlign(GetAlignment(m_pVMap, nMapPos, *m_xVertRelationLB));
+ m_aExampleWN.SetVertRel(GetRelation(*m_xVertRelationLB));
+ }
+
+ // size
+ auto nXPos = m_xAtHorzPosED->denormalize(m_xAtHorzPosED->get_value(FieldUnit::TWIP));
+ auto nYPos = m_xAtVertPosED->denormalize(m_xAtVertPosED->get_value(FieldUnit::TWIP));
+ m_aExampleWN.SetRelPos(Point(nXPos, nYPos));
+
+ m_aExampleWN.SetAnchor(GetAnchor());
+ m_aExampleWN.Invalidate();
+}
+
+void SwFramePage::Init(const SfxItemSet& rSet)
+{
+ if(!m_bFormat)
+ {
+ SwWrtShell* pSh = getFrameDlgParentShell();
+
+ // size
+ const bool bSizeFixed = pSh->IsSelObjProtected( FlyProtectFlags::Fixed ) != FlyProtectFlags::NONE;
+
+ m_xWidthED->set_sensitive( !bSizeFixed );
+ m_xHeightED->set_sensitive( !bSizeFixed );
+
+ // size controls for math OLE objects
+ if ( m_sDlgType == "ObjectDialog" && ! m_bNew )
+ {
+ // disable width and height for math objects
+ const SvGlobalName& rFactNm( pSh->GetOLEObject()->getClassID() );
+
+ static struct GlobalNameId {
+ sal_uInt32 n1;
+ sal_uInt16 n2, n3;
+ sal_uInt8 b8, b9, b10, b11, b12, b13, b14, b15;
+ } const aGlbNmIds[] = { { SO3_SM_CLASSID_60 }, { SO3_SM_CLASSID_50 },
+ { SO3_SM_CLASSID_40 }, { SO3_SM_CLASSID_30 } };
+
+ for (const GlobalNameId & rId : aGlbNmIds) {
+ SvGlobalName aGlbNm( rId.n1, rId.n2, rId.n3,
+ rId.b8, rId.b9, rId.b10, rId.b11,
+ rId.b12, rId.b13, rId.b14, rId.b15 );
+
+ if( rFactNm == aGlbNm )
+ {
+ // disable size controls for math OLE objects
+ m_xWidthFT->set_sensitive(false);
+ m_xWidthED->set_sensitive(false);
+ m_xRelWidthCB->set_sensitive(false);
+ m_xHeightFT->set_sensitive(false);
+ m_xHeightED->set_sensitive(false);
+ m_xRelHeightCB->set_sensitive(false);
+ m_xFixedRatioCB->set_sensitive(false);
+ m_xRealSizeBT->set_sensitive(false);
+ break;
+ }
+ }
+
+ // TODO/LATER: get correct aspect
+ if(0 != (pSh->GetOLEObject()->getStatus( embed::Aspects::MSOLE_CONTENT ) & embed::EmbedMisc::MS_EMBED_RECOMPOSEONRESIZE ) )
+ m_xRealSizeBT->set_sensitive(false);
+ }
+ }
+
+ const SwFormatFrameSize& rSize = rSet.Get(RES_FRM_SIZE);
+ sal_Int64 nWidth = m_xWidthED->NormalizePercent(rSize.GetWidth());
+ sal_Int64 nHeight = m_xHeightED->NormalizePercent(rSize.GetHeight());
+
+ if (nWidth != m_xWidthED->get_value(FieldUnit::TWIP))
+ m_xWidthED->set_value(nWidth, FieldUnit::TWIP);
+
+ if (nHeight != m_xHeightED->get_value(FieldUnit::TWIP))
+ m_xHeightED->set_value(nHeight, FieldUnit::TWIP);
+
+ if (!IsInGraficMode())
+ {
+ SwFrameSize eSize = rSize.GetHeightSizeType();
+ bool bCheck = eSize != SwFrameSize::Fixed;
+ m_xAutoHeightCB->set_active(bCheck);
+ HandleAutoCB( bCheck, *m_xHeightFT, *m_xHeightAutoFT, *m_xWidthED->get() );
+ if( eSize == SwFrameSize::Variable )
+ m_xHeightED->set_value(m_xHeightED->get_min());
+
+ eSize = rSize.GetWidthSizeType();
+ bCheck = eSize != SwFrameSize::Fixed;
+ m_xAutoWidthCB->set_active(bCheck);
+ HandleAutoCB( bCheck, *m_xWidthFT, *m_xWidthAutoFT, *m_xWidthED->get() );
+ if( eSize == SwFrameSize::Variable )
+ m_xWidthED->set_value(m_xWidthED->get_min());
+
+ if ( !m_bFormat )
+ {
+ SwWrtShell* pSh = getFrameDlgParentShell();
+ const SwFrameFormat* pFormat = pSh->GetFlyFrameFormat();
+ if( pFormat && pFormat->GetChain().GetNext() )
+ m_xAutoHeightCB->set_sensitive( false );
+ }
+ }
+ else
+ m_xAutoHeightCB->hide();
+
+ // organise circulation-gap for character bound frames
+ const SvxULSpaceItem &rUL = rSet.Get(RES_UL_SPACE);
+ m_nUpperBorder = rUL.GetUpper();
+ m_nLowerBorder = rUL.GetLower();
+
+ if(SfxItemState::SET == rSet.GetItemState(FN_KEEP_ASPECT_RATIO))
+ {
+ m_xFixedRatioCB->set_active(static_cast<const SfxBoolItem&>(rSet.Get(FN_KEEP_ASPECT_RATIO)).GetValue());
+ m_xFixedRatioCB->save_state();
+ }
+
+ // columns
+ SwFormatCol aCol( rSet.Get(RES_COL) );
+ ::FitToActualSize( aCol, static_cast<sal_uInt16>(rSize.GetWidth()) );
+
+ RndStdIds eAnchorId = GetAnchor();
+
+ if ( m_bNew && !m_bFormat )
+ InitPos(eAnchorId, -1, 0, -1, 0, LONG_MAX, LONG_MAX);
+ else
+ {
+ const SwFormatHoriOrient& rHori = rSet.Get(RES_HORI_ORIENT);
+ const SwFormatVertOrient& rVert = rSet.Get(RES_VERT_ORIENT);
+ m_nOldH = rHori.GetHoriOrient();
+ m_nOldHRel = rHori.GetRelationOrient();
+ m_nOldV = rVert.GetVertOrient();
+ m_nOldVRel = rVert.GetRelationOrient();
+
+ if (eAnchorId == RndStdIds::FLY_AT_PAGE)
+ {
+ if (m_nOldHRel == text::RelOrientation::FRAME)
+ m_nOldHRel = text::RelOrientation::PAGE_FRAME;
+ else if (m_nOldHRel == text::RelOrientation::PRINT_AREA)
+ m_nOldHRel = text::RelOrientation::PAGE_PRINT_AREA;
+ if (m_nOldVRel == text::RelOrientation::FRAME)
+ m_nOldVRel = text::RelOrientation::PAGE_FRAME;
+ else if (m_nOldVRel == text::RelOrientation::PRINT_AREA)
+ m_nOldVRel = text::RelOrientation::PAGE_PRINT_AREA;
+ }
+
+ m_xMirrorPagesCB->set_active(rHori.IsPosToggle());
+ m_xMirrorPagesCB->save_state();
+
+ InitPos(eAnchorId,
+ m_nOldH,
+ m_nOldHRel,
+ m_nOldV,
+ m_nOldVRel,
+ rHori.GetPos(),
+ rVert.GetPos());
+ }
+
+ // transparent for example
+ // circulation for example
+ const SwFormatSurround& rSurround = rSet.Get(RES_SURROUND);
+ m_aExampleWN.SetWrap( rSurround.GetSurround() );
+
+ if ( rSurround.GetSurround() == css::text::WrapTextMode_THROUGH )
+ {
+ const SvxOpaqueItem& rOpaque = rSet.Get(RES_OPAQUE);
+ m_aExampleWN.SetTransparent(!rOpaque.GetValue());
+ }
+
+ // switch to percent if applicable
+ RangeModifyHdl(); // set reference values (for 100%)
+
+ if (rSize.GetWidthPercent() == SwFormatFrameSize::SYNCED || rSize.GetHeightPercent() == SwFormatFrameSize::SYNCED)
+ m_xFixedRatioCB->set_active(true);
+ if (rSize.GetWidthPercent() && rSize.GetWidthPercent() != SwFormatFrameSize::SYNCED &&
+ !m_xRelWidthCB->get_active())
+ {
+ m_xRelWidthCB->set_active(true);
+ RelSizeClickHdl(*m_xRelWidthCB);
+ m_xWidthED->set_value(rSize.GetWidthPercent(), FieldUnit::PERCENT);
+ }
+ if (rSize.GetHeightPercent() && rSize.GetHeightPercent() != SwFormatFrameSize::SYNCED &&
+ !m_xRelHeightCB->get_active())
+ {
+ m_xRelHeightCB->set_active(true);
+ RelSizeClickHdl(*m_xRelHeightCB);
+ m_xHeightED->set_value(rSize.GetHeightPercent(), FieldUnit::PERCENT);
+ }
+ m_xRelWidthCB->save_state();
+ m_xRelHeightCB->save_state();
+
+ if (rSize.GetWidthPercentRelation() == text::RelOrientation::PAGE_FRAME)
+ m_xRelWidthRelationLB->set_active(1);
+ else
+ m_xRelWidthRelationLB->set_active(0);
+
+ if (rSize.GetHeightPercentRelation() == text::RelOrientation::PAGE_FRAME)
+ m_xRelHeightRelationLB->set_active(1);
+ else
+ m_xRelHeightRelationLB->set_active(0);
+}
+
+void SwFramePage::SetFormatUsed(bool bFormatUsed)
+{
+ m_bFormat = bFormatUsed;
+ if (m_bFormat)
+ m_xAnchorFrame->hide();
+}
+
+void SwFramePage::EnableVerticalPositioning( bool bEnable )
+{
+ m_bAllowVertPositioning = bEnable;
+ m_xVerticalFT->set_sensitive( bEnable );
+ m_xVerticalDLB->set_sensitive( bEnable );
+ m_xAtVertPosFT->set_sensitive( bEnable );
+ m_xAtVertPosED->set_sensitive( bEnable );
+ m_xVertRelationFT->set_sensitive( bEnable );
+ m_xVertRelationLB->set_sensitive( bEnable );
+}
+
+SwGrfExtPage::SwGrfExtPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet &rSet)
+ : SfxTabPage(pPage, pController, "modules/swriter/ui/picturepage.ui", "PicturePage", &rSet)
+ , m_bHtmlMode(false)
+ , m_xMirror(m_xBuilder->weld_widget("flipframe"))
+ , m_xMirrorVertBox(m_xBuilder->weld_check_button("vert"))
+ , m_xMirrorHorzBox(m_xBuilder->weld_check_button("hori"))
+ , m_xAllPagesRB(m_xBuilder->weld_radio_button("allpages"))
+ , m_xLeftPagesRB(m_xBuilder->weld_radio_button("leftpages"))
+ , m_xRightPagesRB(m_xBuilder->weld_radio_button("rightpages"))
+ , m_xConnectED(m_xBuilder->weld_entry("entry"))
+ , m_xBrowseBT(m_xBuilder->weld_button("browse"))
+ , m_xLinkFrame(m_xBuilder->weld_frame("linkframe"))
+ // RotGrfFlyFrame: Need Angle and RotateControls now
+ , m_xFlAngle(m_xBuilder->weld_frame("FL_ANGLE"))
+ , m_xNfAngle(m_xBuilder->weld_metric_spin_button("NF_ANGLE", FieldUnit::DEGREE))
+ , m_xCtlAngle(new svx::DialControl)
+ , m_xCtlAngleWin(new weld::CustomWeld(*m_xBuilder, "CTL_ANGLE", *m_xCtlAngle))
+ , m_xBmpWin(new weld::CustomWeld(*m_xBuilder, "preview", m_aBmpWin))
+{
+ m_aBmpWin.SetBitmapEx(BitmapEx(RID_BMP_PREVIEW_FALLBACK));
+
+ m_xCtlAngle->SetLinkedField(m_xNfAngle.get(), 2);
+
+ SetExchangeSupport();
+ m_xMirrorHorzBox->connect_toggled(LINK(this, SwGrfExtPage, MirrorHdl));
+ m_xMirrorVertBox->connect_toggled(LINK(this, SwGrfExtPage, MirrorHdl));
+ m_xBrowseBT->connect_clicked(LINK(this, SwGrfExtPage, BrowseHdl));
+}
+
+SwGrfExtPage::~SwGrfExtPage()
+{
+ m_xBmpWin.reset();
+ m_xCtlAngleWin.reset();
+ m_xCtlAngle.reset();
+ m_xGrfDlg.reset();
+}
+
+std::unique_ptr<SfxTabPage> SwGrfExtPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet *rSet)
+{
+ return std::make_unique<SwGrfExtPage>(pPage, pController, *rSet);
+}
+
+void SwGrfExtPage::Reset(const SfxItemSet *rSet)
+{
+ const SfxPoolItem* pItem;
+ const sal_uInt16 nHtmlMode = ::GetHtmlMode(static_cast<const SwDocShell*>(SfxObjectShell::Current()));
+ m_bHtmlMode = (nHtmlMode & HTMLMODE_ON) != 0;
+
+ if( SfxItemState::SET == rSet->GetItemState( FN_PARAM_GRF_CONNECT, true, &pItem)
+ && static_cast<const SfxBoolItem *>(pItem)->GetValue() )
+ {
+ m_xBrowseBT->set_sensitive(true);
+ m_xConnectED->set_editable(true);
+ }
+
+ // RotGrfFlyFrame: Get RotationAngle and set at control
+ if(SfxItemState::SET == rSet->GetItemState( SID_ATTR_TRANSFORM_ANGLE, false, &pItem))
+ {
+ m_xCtlAngle->SetRotation(static_cast<const SfxInt32Item*>(pItem)->GetValue());
+ }
+ else
+ {
+ m_xCtlAngle->SetRotation(0);
+ }
+ m_xCtlAngle->SaveValue();
+
+ ActivatePage(*rSet);
+}
+
+void SwGrfExtPage::ActivatePage(const SfxItemSet& rSet)
+{
+ const SvxProtectItem& rProt = rSet.Get(RES_PROTECT);
+ bool bProtContent = rProt.IsContentProtected();
+
+ const SfxPoolItem* pItem = nullptr;
+ bool bEnable = false;
+ bool bEnableMirrorRB = false;
+
+ SfxItemState eState = rSet.GetItemState(RES_GRFATR_MIRRORGRF, true, &pItem);
+ if (SfxItemState::UNKNOWN != eState && !bProtContent && !m_bHtmlMode)
+ {
+ if( SfxItemState::SET != eState )
+ pItem = &rSet.Get( RES_GRFATR_MIRRORGRF );
+
+ bEnable = true;
+
+ MirrorGraph eMirror = static_cast<const SwMirrorGrf* >(pItem)->GetValue();
+ switch( eMirror )
+ {
+ case MirrorGraph::Dont: break;
+ case MirrorGraph::Vertical: m_xMirrorHorzBox->set_active(true); break;
+ case MirrorGraph::Horizontal: m_xMirrorVertBox->set_active(true); break;
+ case MirrorGraph::Both: m_xMirrorHorzBox->set_active(true);
+ m_xMirrorVertBox->set_active(true);
+ break;
+ default:
+ ;
+ }
+
+ const int nPos = (static_cast<const SwMirrorGrf* >(pItem)->IsGrfToggle() ? 1 : 0)
+ + ((eMirror == MirrorGraph::Vertical || eMirror == MirrorGraph::Both) ? 2 : 0);
+
+ bEnableMirrorRB = nPos != 0;
+
+ switch (nPos)
+ {
+ case 1: // mirror at left / even pages
+ m_xLeftPagesRB->set_active(true);
+ m_xMirrorHorzBox->set_active(true);
+ break;
+ case 2: // mirror on all pages
+ m_xAllPagesRB->set_active(true);
+ break;
+ case 3: // mirror on right / odd pages
+ m_xRightPagesRB->set_active(true);
+ break;
+ default:
+ m_xAllPagesRB->set_active(true);
+ break;
+ }
+ }
+
+ if( SfxItemState::SET == rSet.GetItemState( SID_ATTR_GRAF_GRAPHIC, false, &pItem ) )
+ {
+ const SvxBrushItem& rBrush = *static_cast<const SvxBrushItem*>(pItem);
+ if( !rBrush.GetGraphicLink().isEmpty() )
+ {
+ aGrfName = aNewGrfName = rBrush.GetGraphicLink();
+ m_xConnectED->set_text(aNewGrfName);
+ }
+ OUString referer;
+ SfxStringItem const * it = static_cast<SfxStringItem const *>(
+ rSet.GetItem(SID_REFERER));
+ if (it != nullptr) {
+ referer = it->GetValue();
+ }
+ const Graphic* pGrf = rBrush.GetGraphic(referer);
+ if( pGrf )
+ m_aBmpWin.SetGraphic( *pGrf );
+ }
+
+ m_xConnectED->save_value();
+
+ m_xMirror->set_sensitive(bEnable);
+ m_xAllPagesRB->set_sensitive(bEnableMirrorRB);
+ m_xLeftPagesRB->set_sensitive(bEnableMirrorRB);
+ m_xRightPagesRB->set_sensitive(bEnableMirrorRB);
+
+ m_xAllPagesRB->save_state();
+ m_xLeftPagesRB->save_state();
+ m_xRightPagesRB->save_state();
+ m_xMirrorHorzBox->save_state();
+ m_xMirrorVertBox->save_state();
+
+ m_aBmpWin.MirrorHorz( m_xMirrorVertBox->get_active() );
+ m_aBmpWin.MirrorVert( m_xMirrorHorzBox->get_active() );
+ m_aBmpWin.Invalidate();
+}
+
+bool SwGrfExtPage::FillItemSet( SfxItemSet *rSet )
+{
+ bool bModified = false;
+ if ( m_xMirrorHorzBox->get_state_changed_from_saved() ||
+ m_xMirrorVertBox->get_state_changed_from_saved() ||
+ m_xAllPagesRB->get_state_changed_from_saved() ||
+ m_xLeftPagesRB->get_state_changed_from_saved() ||
+ m_xRightPagesRB->get_state_changed_from_saved() )
+ {
+ bModified = true;
+
+ bool bHori = false;
+
+ if (m_xMirrorHorzBox->get_active() &&
+ !m_xLeftPagesRB->get_active())
+ bHori = true;
+
+ MirrorGraph eMirror;
+ eMirror = m_xMirrorVertBox->get_active() && bHori ?
+ MirrorGraph::Both : bHori ?
+ MirrorGraph::Vertical : m_xMirrorVertBox->get_active() ?
+ MirrorGraph::Horizontal : MirrorGraph::Dont;
+
+ bool bMirror = !m_xAllPagesRB->get_active();
+ SwMirrorGrf aMirror( eMirror );
+ aMirror.SetGrfToggle(bMirror );
+ rSet->Put( aMirror );
+ }
+
+ if (aGrfName != aNewGrfName || m_xConnectED->get_value_changed_from_saved())
+ {
+ bModified = true;
+ aGrfName = m_xConnectED->get_text();
+ rSet->Put( SvxBrushItem( aGrfName, aFilterName, GPOS_LT,
+ SID_ATTR_GRAF_GRAPHIC ));
+ }
+
+ // RotGrfFlyFrame: Safe rotation if modified
+ if(m_xCtlAngle->IsValueModified())
+ {
+ rSet->Put(SfxInt32Item(GetWhich(SID_ATTR_TRANSFORM_ANGLE), m_xCtlAngle->GetRotation()));
+ bModified = true;
+ }
+
+ return bModified;
+}
+
+DeactivateRC SwGrfExtPage::DeactivatePage(SfxItemSet *_pSet)
+{
+ if( _pSet )
+ FillItemSet( _pSet );
+ return DeactivateRC::LeavePage;
+}
+
+IMPL_LINK_NOARG(SwGrfExtPage, BrowseHdl, weld::Button&, void)
+{
+ if(!m_xGrfDlg)
+ {
+ m_xGrfDlg.reset(new FileDialogHelper(
+ ui::dialogs::TemplateDescription::FILEOPEN_LINK_PREVIEW,
+ FileDialogFlags::Graphic, GetFrameWeld()));
+ m_xGrfDlg->SetTitle(m_xLinkFrame->get_label());
+ }
+ m_xGrfDlg->SetDisplayDirectory(m_xConnectED->get_text());
+ uno::Reference < ui::dialogs::XFilePicker3 > xFP = m_xGrfDlg->GetFilePicker();
+ uno::Reference < ui::dialogs::XFilePickerControlAccess > xCtrlAcc(xFP, uno::UNO_QUERY);
+ xCtrlAcc->setValue( ui::dialogs::ExtendedFilePickerElementIds::CHECKBOX_LINK, 0, uno::makeAny(true) );
+
+ if ( m_xGrfDlg->Execute() != ERRCODE_NONE )
+ return;
+
+// remember selected filter
+ aFilterName = m_xGrfDlg->GetCurrentFilter();
+ aNewGrfName = INetURLObject::decode( m_xGrfDlg->GetPath(),
+ INetURLObject::DecodeMechanism::Unambiguous );
+ m_xConnectED->set_text(aNewGrfName);
+ //reset mirrors because maybe a Bitmap was swapped with
+ //another type of graphic that cannot be mirrored.
+ m_xMirrorVertBox->set_active(false);
+ m_xMirrorHorzBox->set_active(false);
+ m_xAllPagesRB->set_sensitive(false);
+ m_xLeftPagesRB->set_sensitive(false);
+ m_xRightPagesRB->set_sensitive(false);
+ m_aBmpWin.MirrorHorz(false);
+ m_aBmpWin.MirrorVert(false);
+
+ Graphic aGraphic;
+ (void)GraphicFilter::LoadGraphic(m_xGrfDlg->GetPath(), OUString(), aGraphic);
+ m_aBmpWin.SetGraphic(aGraphic);
+
+ bool bEnable = GraphicType::Bitmap == aGraphic.GetType() ||
+ GraphicType::GdiMetafile == aGraphic.GetType();
+ m_xMirrorVertBox->set_sensitive(bEnable);
+ m_xMirrorHorzBox->set_sensitive(bEnable);
+ m_xAllPagesRB->set_sensitive(bEnable);
+ m_xLeftPagesRB->set_sensitive(bEnable);
+ m_xRightPagesRB->set_sensitive(bEnable);
+
+}
+
+IMPL_LINK_NOARG(SwGrfExtPage, MirrorHdl, weld::ToggleButton&, void)
+{
+ bool bEnable = m_xMirrorHorzBox->get_active();
+
+ m_aBmpWin.MirrorHorz( m_xMirrorVertBox->get_active() );
+ m_aBmpWin.MirrorVert( bEnable );
+
+ m_xAllPagesRB->set_sensitive(bEnable);
+ m_xLeftPagesRB->set_sensitive(bEnable);
+ m_xRightPagesRB->set_sensitive(bEnable);
+
+ if (!m_xAllPagesRB->get_active() && !m_xLeftPagesRB->get_active() && !m_xRightPagesRB->get_active())
+ m_xAllPagesRB->set_active(true);
+}
+
+// example window
+BmpWindow::BmpWindow()
+ : bHorz(false)
+ , bVert(false)
+ , bGraphic(false)
+{
+}
+
+void BmpWindow::SetDrawingArea(weld::DrawingArea* pDrawingArea)
+{
+ CustomWidgetController::SetDrawingArea(pDrawingArea);
+ Size aSize = pDrawingArea->get_ref_device().LogicToPixel(Size(127 , 66), MapMode(MapUnit::MapAppFont));
+ set_size_request(aSize.Width(), aSize.Height());
+ SetOutputSizePixel(aSize);
+}
+
+void BmpWindow::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&)
+{
+ // Setup
+ rRenderContext.SetBackground();
+ // #i119307# the graphic might have transparency, set up white as the color
+ // to use when drawing a rectangle under the image
+ rRenderContext.SetLineColor(COL_WHITE);
+ rRenderContext.SetFillColor(COL_WHITE);
+
+ // Paint
+ Point aPntPos;
+ Size aPntSz(GetOutputSizePixel());
+ Size aGrfSize;
+ if (bGraphic)
+ aGrfSize = ::GetGraphicSizeTwip(aGraphic, &rRenderContext);
+ //it should show the default bitmap also if no graphic can be found
+ if (!aGrfSize.Width() && !aGrfSize.Height())
+ aGrfSize = rRenderContext.PixelToLogic(aBmp.GetSizePixel());
+
+ long nRelGrf = aGrfSize.Width() * 100 / aGrfSize.Height();
+ long nRelWin = aPntSz.Width() * 100 / aPntSz.Height();
+ if (nRelGrf < nRelWin)
+ {
+ const long nWidth = aPntSz.Width();
+ // if we use a replacement preview, try to draw at original size
+ if (!bGraphic && (aGrfSize.Width() <= aPntSz.Width())
+ && (aGrfSize.Height() <= aPntSz.Height()))
+ {
+ const long nHeight = aPntSz.Height();
+ aPntSz.setWidth( aGrfSize.Width() );
+ aPntSz.setHeight( aGrfSize.Height() );
+ aPntPos.AdjustY((nHeight - aPntSz.Height()) / 2 );
+ }
+ else
+ aPntSz.setWidth( aPntSz.Height() * nRelGrf /100 );
+
+ aPntPos.AdjustX(nWidth - aPntSz.Width() ) ;
+ }
+
+ // #i119307# clear window background, the graphic might have transparency
+ rRenderContext.DrawRect(tools::Rectangle(aPntPos, aPntSz));
+
+ if (bHorz || bVert)
+ {
+ BitmapEx aTmpBmp(bGraphic ? aGraphic.GetBitmapEx() : aBmp);
+ BmpMirrorFlags nMirrorFlags(BmpMirrorFlags::NONE);
+ if (bHorz)
+ nMirrorFlags |= BmpMirrorFlags::Vertical;
+ if (bVert)
+ nMirrorFlags |= BmpMirrorFlags::Horizontal;
+ aTmpBmp.Mirror(nMirrorFlags);
+ rRenderContext.DrawBitmapEx(aPntPos, aPntSz, aTmpBmp);
+ }
+ else if (bGraphic) //draw unmirrored preview graphic
+ {
+ aGraphic.Draw(&rRenderContext, aPntPos, aPntSz);
+ }
+ else //draw unmirrored stock sample image
+ {
+ rRenderContext.DrawBitmapEx(aPntPos, aPntSz, aBmp);
+ }
+}
+
+BmpWindow::~BmpWindow()
+{
+}
+
+void BmpWindow::SetGraphic(const Graphic& rGraphic)
+{
+ aGraphic = rGraphic;
+ Size aSize = aGraphic.GetPrefSize();
+ bGraphic = aSize.Width() && aSize.Height();
+ Invalidate();
+}
+
+void BmpWindow::SetBitmapEx(const BitmapEx& rBmp)
+{
+ aBmp = rBmp;
+ Invalidate();
+}
+
+// set URL and ImageMap at frames
+SwFrameURLPage::SwFrameURLPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet &rSet)
+ : SfxTabPage(pPage, pController, "modules/swriter/ui/frmurlpage.ui", "FrameURLPage", &rSet)
+ , m_xURLED(m_xBuilder->weld_entry("url"))
+ , m_xSearchPB(m_xBuilder->weld_button("search"))
+ , m_xNameED(m_xBuilder->weld_entry("name"))
+ , m_xFrameCB(m_xBuilder->weld_combo_box("frame"))
+ , m_xServerCB(m_xBuilder->weld_check_button("server"))
+ , m_xClientCB(m_xBuilder->weld_check_button("client"))
+{
+ m_xSearchPB->connect_clicked(LINK(this, SwFrameURLPage, InsertFileHdl));
+}
+
+SwFrameURLPage::~SwFrameURLPage()
+{
+}
+
+void SwFrameURLPage::Reset( const SfxItemSet *rSet )
+{
+ const SfxPoolItem* pItem;
+ if ( SfxItemState::SET == rSet->GetItemState( SID_DOCFRAME, true, &pItem))
+ {
+ std::unique_ptr<TargetList> pList(new TargetList);
+ SfxFrame::GetDefaultTargetList(*pList);
+ size_t nCount = pList->size();
+ for (size_t i = 0; i < nCount; ++i)
+ {
+ m_xFrameCB->append_text(pList->at(i));
+ }
+ }
+
+ if ( SfxItemState::SET == rSet->GetItemState( RES_URL, true, &pItem ) )
+ {
+ const SwFormatURL* pFormatURL = static_cast<const SwFormatURL*>(pItem);
+ m_xURLED->set_text(INetURLObject::decode(pFormatURL->GetURL(),
+ INetURLObject::DecodeMechanism::Unambiguous));
+ m_xNameED->set_text(pFormatURL->GetName());
+
+ m_xClientCB->set_sensitive(pFormatURL->GetMap() != nullptr);
+ m_xClientCB->set_active(pFormatURL->GetMap() != nullptr);
+ m_xServerCB->set_active(pFormatURL->IsServerMap());
+
+ m_xFrameCB->set_entry_text(pFormatURL->GetTargetFrameName());
+ m_xFrameCB->save_value();
+ }
+ else
+ m_xClientCB->set_sensitive(false);
+
+ m_xServerCB->save_state();
+ m_xClientCB->save_state();
+}
+
+bool SwFrameURLPage::FillItemSet(SfxItemSet *rSet)
+{
+ bool bModified = false;
+ const SwFormatURL* pOldURL = GetOldItem(*rSet, RES_URL);
+ std::unique_ptr<SwFormatURL> pFormatURL;
+ if(pOldURL)
+ pFormatURL.reset(pOldURL->Clone());
+ else
+ pFormatURL.reset(new SwFormatURL());
+
+ {
+ const OUString sText = m_xURLED->get_text();
+
+ if( pFormatURL->GetURL() != sText ||
+ pFormatURL->GetName() != m_xNameED->get_text() ||
+ m_xServerCB->get_active() != pFormatURL->IsServerMap() )
+ {
+ pFormatURL->SetURL(sText, m_xServerCB->get_active());
+ pFormatURL->SetName(m_xNameED->get_text());
+ bModified = true;
+ }
+ }
+
+ if (!m_xClientCB->get_active() && pFormatURL->GetMap() != nullptr)
+ {
+ pFormatURL->SetMap(nullptr);
+ bModified = true;
+ }
+
+ if(pFormatURL->GetTargetFrameName() != m_xFrameCB->get_active_text())
+ {
+ pFormatURL->SetTargetFrameName(m_xFrameCB->get_active_text());
+ bModified = true;
+ }
+ rSet->Put(*pFormatURL);
+ return bModified;
+}
+
+std::unique_ptr<SfxTabPage> SwFrameURLPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet *rSet)
+{
+ return std::make_unique<SwFrameURLPage>(pPage, pController, *rSet);
+}
+
+IMPL_LINK_NOARG(SwFrameURLPage, InsertFileHdl, weld::Button&, void)
+{
+ FileDialogHelper aDlgHelper(ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE,
+ FileDialogFlags::NONE, GetFrameWeld());
+ uno::Reference < ui::dialogs::XFilePicker3 > xFP = aDlgHelper.GetFilePicker();
+
+ try
+ {
+ const OUString sTemp(m_xURLED->get_text());
+ if(!sTemp.isEmpty())
+ xFP->setDisplayDirectory(sTemp);
+ }
+ catch( const uno::Exception& ) {}
+ if( aDlgHelper.Execute() == ERRCODE_NONE )
+ {
+ m_xURLED->set_text(xFP->getSelectedFiles().getConstArray()[0]);
+ }
+}
+
+SwFrameAddPage::SwFrameAddPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet &rSet)
+ : SfxTabPage(pPage, pController, "modules/swriter/ui/frmaddpage.ui", "FrameAddPage", &rSet)
+ , m_pWrtSh(nullptr)
+ , m_bHtmlMode(false)
+ , m_bFormat(false)
+ , m_bNew(false)
+ , m_xNameFrame(m_xBuilder->weld_widget("nameframe"))
+ , m_xNameFT(m_xBuilder->weld_label("name_label"))
+ , m_xNameED(m_xBuilder->weld_entry("name"))
+ , m_xAltNameFT(m_xBuilder->weld_label("altname_label"))
+ , m_xAltNameED(m_xBuilder->weld_entry("altname"))
+ , m_xDescriptionFT(m_xBuilder->weld_label("description_label"))
+ , m_xDescriptionED(m_xBuilder->weld_text_view("description"))
+ , m_xPrevFT(m_xBuilder->weld_label("prev_label"))
+ , m_xPrevLB(m_xBuilder->weld_combo_box("prev"))
+ , m_xNextFT(m_xBuilder->weld_label("next_label"))
+ , m_xNextLB(m_xBuilder->weld_combo_box("next"))
+ , m_xProtectFrame(m_xBuilder->weld_widget("protect"))
+ , m_xProtectContentCB(m_xBuilder->weld_check_button("protectcontent"))
+ , m_xProtectFrameCB(m_xBuilder->weld_check_button("protectframe"))
+ , m_xProtectSizeCB(m_xBuilder->weld_check_button("protectsize"))
+ , m_xContentAlignFrame(m_xBuilder->weld_widget("contentalign"))
+ , m_xVertAlignLB(m_xBuilder->weld_combo_box("vertalign"))
+ , m_xPropertiesFrame(m_xBuilder->weld_widget("properties"))
+ , m_xEditInReadonlyCB(m_xBuilder->weld_check_button("editinreadonly"))
+ , m_xPrintFrameCB(m_xBuilder->weld_check_button("printframe"))
+ , m_xTextFlowFT(m_xBuilder->weld_label("textflow_label"))
+ , m_xTextFlowLB(new svx::FrameDirectionListBox(m_xBuilder->weld_combo_box("textflow")))
+{
+ m_xTextFlowLB->append(SvxFrameDirection::Horizontal_LR_TB, SvxResId(RID_SVXSTR_FRAMEDIR_LTR));
+ m_xTextFlowLB->append(SvxFrameDirection::Horizontal_RL_TB, SvxResId(RID_SVXSTR_FRAMEDIR_RTL));
+ m_xTextFlowLB->append(SvxFrameDirection::Vertical_RL_TB, SvxResId(RID_SVXSTR_PAGEDIR_RTL_VERT));
+ m_xTextFlowLB->append(SvxFrameDirection::Vertical_LR_TB, SvxResId(RID_SVXSTR_PAGEDIR_LTR_VERT));
+ m_xTextFlowLB->append(SvxFrameDirection::Vertical_LR_BT, SvxResId(RID_SVXSTR_PAGEDIR_LTR_BTT_VERT));
+ m_xTextFlowLB->append(SvxFrameDirection::Environment, SvxResId(RID_SVXSTR_FRAMEDIR_SUPER));
+ m_xDescriptionED->set_size_request(-1, m_xDescriptionED->get_preferred_size().Height());
+}
+
+SwFrameAddPage::~SwFrameAddPage()
+{
+ m_xTextFlowLB.reset();
+}
+
+std::unique_ptr<SfxTabPage> SwFrameAddPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet *rSet)
+{
+ return std::make_unique<SwFrameAddPage>(pPage, pController, *rSet);
+}
+
+void SwFrameAddPage::Reset(const SfxItemSet *rSet )
+{
+ const SfxPoolItem* pItem;
+ sal_uInt16 nHtmlMode = ::GetHtmlMode(static_cast<const SwDocShell*>(SfxObjectShell::Current()));
+ m_bHtmlMode = (nHtmlMode & HTMLMODE_ON) != 0;
+ if (m_bHtmlMode)
+ {
+ m_xProtectFrame->hide();
+ m_xEditInReadonlyCB->hide();
+ m_xPrintFrameCB->hide();
+ }
+ if (m_sDlgType == "PictureDialog" || m_sDlgType == "ObjectDialog")
+ {
+ m_xEditInReadonlyCB->hide();
+ if (m_bHtmlMode)
+ {
+ m_xPropertiesFrame->hide();
+ }
+ m_xContentAlignFrame->hide();
+ }
+
+ if(SfxItemState::SET == rSet->GetItemState(FN_SET_FRM_ALT_NAME, false, &pItem))
+ {
+ m_xAltNameED->set_text(static_cast<const SfxStringItem*>(pItem)->GetValue());
+ m_xAltNameED->save_value();
+ }
+
+ if(SfxItemState::SET == rSet->GetItemState(FN_UNO_DESCRIPTION, false, &pItem))
+ {
+ m_xDescriptionED->set_text(static_cast<const SfxStringItem*>(pItem)->GetValue());
+ m_xDescriptionED->save_value();
+ }
+
+ if(!m_bFormat)
+ {
+ // insert graphic - properties
+ // bNew is not set, so recognise by selection
+ OUString aTmpName1;
+ if(SfxItemState::SET == rSet->GetItemState(FN_SET_FRM_NAME, false, &pItem))
+ {
+ aTmpName1 = static_cast<const SfxStringItem*>(pItem)->GetValue();
+ }
+
+ OSL_ENSURE(m_pWrtSh, "no Shell?");
+ if( m_bNew || aTmpName1.isEmpty() )
+ {
+ if (m_sDlgType == "PictureDialog")
+ aTmpName1 = m_pWrtSh->GetUniqueGrfName();
+ else if (m_sDlgType == "ObjectDialog")
+ aTmpName1 = m_pWrtSh->GetUniqueOLEName();
+ else
+ aTmpName1 = m_pWrtSh->GetUniqueFrameName();
+
+ m_pWrtSh->SetFlyName(aTmpName1);
+ }
+
+ m_xNameED->set_text( aTmpName1 );
+ m_xNameED->save_value();
+ }
+ else
+ {
+ m_xNameED->set_sensitive( false );
+ m_xAltNameED->set_sensitive(false);
+ m_xNameFT->set_sensitive( false );
+ m_xAltNameFT->set_sensitive(false);
+ }
+ if (m_sDlgType == "FrameDialog" && m_xAltNameFT->get_visible())
+ {
+ m_xAltNameFT->hide();
+ m_xAltNameED->hide();
+ }
+ else
+ {
+ m_xNameED->connect_changed(LINK(this, SwFrameAddPage, EditModifyHdl));
+ }
+
+ if (!m_bNew)
+ {
+ SwFrameFormat* pFormat = m_pWrtSh->GetFlyFrameFormat();
+
+ if (pFormat)
+ {
+ const SwFormatChain &rChain = pFormat->GetChain();
+ const SwFlyFrameFormat* pFlyFormat;
+ OUString sNextChain, sPrevChain;
+ if ((pFlyFormat = rChain.GetPrev()) != nullptr)
+ {
+ sPrevChain = pFlyFormat->GetName();
+ }
+
+ if ((pFlyFormat = rChain.GetNext()) != nullptr)
+ {
+ sNextChain = pFlyFormat->GetName();
+ }
+ //determine chainable frames
+ std::vector< OUString > aPrevPageFrames;
+ std::vector< OUString > aThisPageFrames;
+ std::vector< OUString > aNextPageFrames;
+ std::vector< OUString > aRemainFrames;
+ m_pWrtSh->GetConnectableFrameFormats(*pFormat, sNextChain, false,
+ aPrevPageFrames, aThisPageFrames, aNextPageFrames, aRemainFrames );
+ for (sal_Int32 nEntry = m_xPrevLB->get_count(); nEntry > 1; nEntry--)
+ m_xPrevLB->remove(nEntry - 1);
+ lcl_InsertVectors(*m_xPrevLB, aPrevPageFrames, aThisPageFrames, aNextPageFrames, aRemainFrames);
+ if(!sPrevChain.isEmpty())
+ {
+ if (m_xPrevLB->find_text(sPrevChain) == -1)
+ m_xPrevLB->insert_text(1, sPrevChain);
+ m_xPrevLB->set_active_text(sPrevChain);
+ }
+ else
+ m_xPrevLB->set_active(0);
+ aPrevPageFrames.clear();
+ aNextPageFrames.clear();
+ aThisPageFrames.clear();
+ aRemainFrames.clear();
+
+ m_pWrtSh->GetConnectableFrameFormats(*pFormat, sPrevChain, true,
+ aPrevPageFrames, aThisPageFrames, aNextPageFrames, aRemainFrames );
+ for (sal_Int32 nEntry = m_xNextLB->get_count(); nEntry > 1; nEntry--)
+ m_xNextLB->remove(nEntry - 1);
+ lcl_InsertVectors(*m_xNextLB, aPrevPageFrames, aThisPageFrames, aNextPageFrames, aRemainFrames);
+ if(!sNextChain.isEmpty())
+ {
+ if (m_xNextLB->find_text(sNextChain) == -1)
+ m_xNextLB->insert_text(1, sNextChain);
+ m_xNextLB->set_active_text(sNextChain);
+ }
+ else
+ m_xNextLB->set_active(0);
+ Link<weld::ComboBox&,void> aLink(LINK(this, SwFrameAddPage, ChainModifyHdl));
+ m_xPrevLB->connect_changed(aLink);
+ m_xNextLB->connect_changed(aLink);
+ }
+ }
+ // Pos Protected
+ const SvxProtectItem& rProt = rSet->Get(RES_PROTECT);
+ m_xProtectFrameCB->set_active(rProt.IsPosProtected());
+ m_xProtectContentCB->set_active(rProt.IsContentProtected());
+ m_xProtectSizeCB->set_active(rProt.IsSizeProtected());
+
+ const SwFormatEditInReadonly& rEdit = rSet->Get(RES_EDIT_IN_READONLY);
+ m_xEditInReadonlyCB->set_active(rEdit.GetValue());
+ m_xEditInReadonlyCB->save_state();
+
+ // print
+ const SvxPrintItem& rPrt = rSet->Get(RES_PRINT);
+ m_xPrintFrameCB->set_active(rPrt.GetValue());
+ m_xPrintFrameCB->save_state();
+
+ // textflow
+ if( (!m_bHtmlMode || (0 != (nHtmlMode&HTMLMODE_SOME_STYLES)))
+ && m_sDlgType != "PictureDialog" && m_sDlgType != "ObjectDialog"
+ && SfxItemState::UNKNOWN != rSet->GetItemState( RES_FRAMEDIR ) )
+ {
+ m_xTextFlowFT->show();
+ m_xTextFlowLB->show();
+
+ //vertical text flow is not possible in HTML
+ if(m_bHtmlMode)
+ {
+ m_xTextFlowLB->remove_id(SvxFrameDirection::Vertical_RL_TB);
+ }
+ SvxFrameDirection nVal = rSet->Get(RES_FRAMEDIR).GetValue();
+ m_xTextFlowLB->set_active_id(nVal);
+ m_xTextFlowLB->save_value();
+ }
+ else
+ {
+ m_xTextFlowFT->hide();
+ m_xTextFlowLB->hide();
+ }
+
+ // Content alignment
+ if ( rSet->GetItemState(RES_TEXT_VERT_ADJUST) > SfxItemState::DEFAULT )
+ {
+ SdrTextVertAdjust nAdjust = rSet->Get(RES_TEXT_VERT_ADJUST).GetValue();
+ sal_Int32 nPos = 0;
+ switch(nAdjust)
+ {
+ case SDRTEXTVERTADJUST_TOP: nPos = 0; break;
+ case SDRTEXTVERTADJUST_CENTER:
+ case SDRTEXTVERTADJUST_BLOCK: nPos = 1; break;
+ case SDRTEXTVERTADJUST_BOTTOM: nPos = 2; break;
+ }
+ m_xVertAlignLB->set_active(nPos);
+ }
+ m_xVertAlignLB->save_value();
+}
+
+bool SwFrameAddPage::FillItemSet(SfxItemSet *rSet)
+{
+ bool bRet = false;
+ if (m_xNameED->get_value_changed_from_saved())
+ bRet |= nullptr != rSet->Put(SfxStringItem(FN_SET_FRM_NAME, m_xNameED->get_text()));
+ if (m_xAltNameED->get_value_changed_from_saved())
+ bRet |= nullptr != rSet->Put(SfxStringItem(FN_SET_FRM_ALT_NAME, m_xAltNameED->get_text()));
+ if (m_xDescriptionED->get_value_changed_from_saved())
+ bRet |= nullptr != rSet->Put(SfxStringItem(FN_UNO_DESCRIPTION, m_xDescriptionED->get_text()));
+
+ const SfxPoolItem* pOldItem;
+ SvxProtectItem aProt ( GetItemSet().Get(RES_PROTECT) );
+ aProt.SetContentProtect( m_xProtectContentCB->get_active() );
+ aProt.SetSizeProtect ( m_xProtectSizeCB->get_active() );
+ aProt.SetPosProtect ( m_xProtectFrameCB->get_active() );
+ if ( nullptr == (pOldItem = GetOldItem(*rSet, FN_SET_PROTECT)) ||
+ aProt != *pOldItem )
+ bRet |= nullptr != rSet->Put( aProt);
+
+ if ( m_xEditInReadonlyCB->get_state_changed_from_saved() )
+ bRet |= nullptr != rSet->Put( SwFormatEditInReadonly( RES_EDIT_IN_READONLY, m_xEditInReadonlyCB->get_active()));
+
+ if ( m_xPrintFrameCB->get_state_changed_from_saved() )
+ bRet |= nullptr != rSet->Put( SvxPrintItem( RES_PRINT, m_xPrintFrameCB->get_active()));
+
+ // textflow
+ if (m_xTextFlowLB->get_visible() && m_xTextFlowLB->get_value_changed_from_saved())
+ {
+ SvxFrameDirection eDirection = m_xTextFlowLB->get_active_id();
+ bRet |= nullptr != rSet->Put( SvxFrameDirectionItem(eDirection, RES_FRAMEDIR ));
+ }
+ if(m_pWrtSh)
+ {
+ const SwFrameFormat* pFormat = m_pWrtSh->GetFlyFrameFormat();
+ if (pFormat)
+ {
+ OUString sCurrentPrevChain, sCurrentNextChain;
+ if (m_xPrevLB->get_active())
+ sCurrentPrevChain = m_xPrevLB->get_active_text();
+ if (m_xNextLB->get_active())
+ sCurrentNextChain = m_xNextLB->get_active_text();
+ const SwFormatChain &rChain = pFormat->GetChain();
+ const SwFlyFrameFormat* pFlyFormat;
+ OUString sNextChain, sPrevChain;
+ if ((pFlyFormat = rChain.GetPrev()) != nullptr)
+ sPrevChain = pFlyFormat->GetName();
+
+ if ((pFlyFormat = rChain.GetNext()) != nullptr)
+ sNextChain = pFlyFormat->GetName();
+ if(sPrevChain != sCurrentPrevChain)
+ bRet |= nullptr != rSet->Put(SfxStringItem(FN_PARAM_CHAIN_PREVIOUS, sCurrentPrevChain));
+ if(sNextChain != sCurrentNextChain)
+ bRet |= nullptr != rSet->Put(SfxStringItem(FN_PARAM_CHAIN_NEXT, sCurrentNextChain));
+ }
+ }
+
+ if (m_xVertAlignLB->get_value_changed_from_saved())
+ {
+ SdrTextVertAdjust nAdjust;
+ switch (m_xVertAlignLB->get_active())
+ {
+ default:
+ case 0 : nAdjust = SDRTEXTVERTADJUST_TOP; break;
+ case 1 : nAdjust = SDRTEXTVERTADJUST_CENTER; break;
+ case 2 : nAdjust = SDRTEXTVERTADJUST_BOTTOM; break;
+ }
+ bRet |= nullptr != rSet->Put(SdrTextVertAdjustItem(nAdjust, RES_TEXT_VERT_ADJUST));
+ }
+
+ return bRet;
+}
+
+IMPL_LINK_NOARG(SwFrameAddPage, EditModifyHdl, weld::Entry&, void)
+{
+ bool bEnable = !m_xNameED->get_text().isEmpty();
+ m_xAltNameED->set_sensitive(bEnable);
+ m_xAltNameFT->set_sensitive(bEnable);
+}
+
+void SwFrameAddPage::SetFormatUsed(bool bFormatUsed)
+{
+ m_bFormat = bFormatUsed;
+ if (m_bFormat)
+ {
+ m_xNameFrame->hide();
+ }
+}
+
+IMPL_LINK(SwFrameAddPage, ChainModifyHdl, weld::ComboBox&, rBox, void)
+{
+ OUString sCurrentPrevChain, sCurrentNextChain;
+ if (m_xPrevLB->get_active())
+ sCurrentPrevChain = m_xPrevLB->get_active_text();
+ if (m_xNextLB->get_active())
+ sCurrentNextChain = m_xNextLB->get_active_text();
+ SwFrameFormat* pFormat = m_pWrtSh->GetFlyFrameFormat();
+ if (!pFormat)
+ return;
+
+ bool bNextBox = m_xNextLB.get() == &rBox;
+ weld::ComboBox& rChangeLB = bNextBox ? *m_xPrevLB : *m_xNextLB;
+ for (sal_Int32 nEntry = rChangeLB.get_count(); nEntry > 1; nEntry--)
+ rChangeLB.remove(nEntry - 1);
+ //determine chainable frames
+ std::vector< OUString > aPrevPageFrames;
+ std::vector< OUString > aThisPageFrames;
+ std::vector< OUString > aNextPageFrames;
+ std::vector< OUString > aRemainFrames;
+ m_pWrtSh->GetConnectableFrameFormats(*pFormat, bNextBox ? sCurrentNextChain : sCurrentPrevChain, !bNextBox,
+ aPrevPageFrames, aThisPageFrames, aNextPageFrames, aRemainFrames );
+ lcl_InsertVectors(rChangeLB,
+ aPrevPageFrames, aThisPageFrames, aNextPageFrames, aRemainFrames);
+ const OUString sToSelect = bNextBox ? sCurrentPrevChain : sCurrentNextChain;
+ if (rChangeLB.find_text(sToSelect) != -1)
+ rChangeLB.set_active_text(sToSelect);
+ else
+ rChangeLB.set_active(0);
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-30 09:01:29 +0000