summaryrefslogtreecommitdiffstats
path: root/editeng/source/items
diff options
context:
space:
mode:
Diffstat (limited to 'editeng/source/items')
-rw-r--r--editeng/source/items/CustomPropertyField.cxx72
-rw-r--r--editeng/source/items/borderline.cxx699
-rw-r--r--editeng/source/items/bulitem.cxx159
-rw-r--r--editeng/source/items/charhiddenitem.cxx52
-rw-r--r--editeng/source/items/flditem.cxx933
-rw-r--r--editeng/source/items/frmitems.cxx3421
-rw-r--r--editeng/source/items/itemtype.cxx232
-rw-r--r--editeng/source/items/justifyitem.cxx368
-rw-r--r--editeng/source/items/legacyitem.cxx824
-rw-r--r--editeng/source/items/numitem.cxx1001
-rw-r--r--editeng/source/items/optitems.cxx63
-rw-r--r--editeng/source/items/paperinf.cxx121
-rw-r--r--editeng/source/items/paraitem.cxx1231
-rw-r--r--editeng/source/items/svdfield.cxx37
-rw-r--r--editeng/source/items/svxfont.cxx781
-rw-r--r--editeng/source/items/textitem.cxx2699
-rw-r--r--editeng/source/items/writingmodeitem.cxx94
-rw-r--r--editeng/source/items/xmlcnitm.cxx211
18 files changed, 12998 insertions, 0 deletions
diff --git a/editeng/source/items/CustomPropertyField.cxx b/editeng/source/items/CustomPropertyField.cxx
new file mode 100644
index 000000000..b90c191a8
--- /dev/null
+++ b/editeng/source/items/CustomPropertyField.cxx
@@ -0,0 +1,72 @@
+/* -*- 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/.
+ *
+ */
+
+#include <editeng/CustomPropertyField.hxx>
+#include <vcl/metaact.hxx>
+#include <com/sun/star/beans/XPropertyContainer.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/document/XDocumentProperties.hpp>
+
+using namespace css;
+
+namespace editeng
+{
+
+CustomPropertyField::CustomPropertyField(OUString const & rName, OUString const & rCurrentPresentation)
+ : SvxFieldData()
+ , msName(rName)
+ , msCurrentPresentation(rCurrentPresentation)
+{}
+
+CustomPropertyField::~CustomPropertyField()
+{}
+
+std::unique_ptr<SvxFieldData> CustomPropertyField::Clone() const
+{
+ return std::make_unique<CustomPropertyField>(msName, msCurrentPresentation);
+}
+
+bool CustomPropertyField::operator==(const SvxFieldData& rOther) const
+{
+ if (typeid(rOther) != typeid(*this))
+ return false;
+
+ const CustomPropertyField& rOtherField = static_cast<const CustomPropertyField&>(rOther);
+ return (msName == rOtherField.msName &&
+ msCurrentPresentation == rOtherField.msCurrentPresentation);
+}
+
+MetaAction* CustomPropertyField::createBeginComment() const
+{
+ return new MetaCommentAction("FIELD_SEQ_BEGIN");
+}
+
+OUString CustomPropertyField::GetFormatted(uno::Reference<document::XDocumentProperties> const & xDocumentProperties)
+{
+ if (msName.isEmpty())
+ return OUString();
+ if (!xDocumentProperties.is())
+ return OUString();
+ uno::Reference<beans::XPropertyContainer> xPropertyContainer = xDocumentProperties->getUserDefinedProperties();
+ if (!xPropertyContainer.is())
+ return OUString();
+ uno::Reference<beans::XPropertySet> xPropertySet(xPropertyContainer, uno::UNO_QUERY);
+ if (!xPropertySet.is())
+ return OUString();
+ uno::Any aAny = xPropertySet->getPropertyValue(msName);
+ if (!aAny.has<OUString>())
+ return OUString();
+ msCurrentPresentation = aAny.get<OUString>();
+ return msCurrentPresentation;
+}
+
+} // end editeng namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/items/borderline.cxx b/editeng/source/items/borderline.cxx
new file mode 100644
index 000000000..3be1c2d46
--- /dev/null
+++ b/editeng/source/items/borderline.cxx
@@ -0,0 +1,699 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <algorithm>
+
+#include <basegfx/color/bcolor.hxx>
+#include <basegfx/color/bcolortools.hxx>
+
+#include <editeng/borderline.hxx>
+#include <editeng/itemtype.hxx>
+#include <editeng/editrids.hrc>
+#include <editeng/eerdll.hxx>
+
+using namespace ::com::sun::star::table::BorderLineStyle;
+
+// class SvxBorderLine --------------------------------------------------
+
+namespace {
+
+ Color lcl_compute3DColor( Color aMain, int nLight, int nMedium, int nDark )
+ {
+ basegfx::BColor color = aMain.getBColor( );
+ basegfx::BColor hsl = basegfx::utils::rgb2hsl( color );
+
+ int nCoef = 0;
+ if ( hsl.getZ( ) >= 0.5 )
+ nCoef = nLight;
+ else if ( 0.5 > hsl.getZ() && hsl.getZ() >= 0.25 )
+ nCoef = nMedium;
+ else
+ nCoef = nDark;
+
+ double L = std::min(hsl.getZ() * 255.0 + nCoef, 255.0);
+ hsl.setZ( L / 255.0 );
+ color = basegfx::utils::hsl2rgb( hsl );
+
+ return Color( color );
+ }
+} // Anonymous namespace
+
+namespace editeng {
+
+Color SvxBorderLine::darkColor( Color aMain )
+{
+ return aMain;
+}
+
+Color SvxBorderLine::lightColor( Color aMain )
+{
+
+ // Divide Luminance by 2
+ basegfx::BColor color = aMain.getBColor( );
+ basegfx::BColor hsl = basegfx::utils::rgb2hsl( color );
+ hsl.setZ( hsl.getZ() * 0.5 );
+ color = basegfx::utils::hsl2rgb( hsl );
+
+ return Color( color );
+}
+
+
+Color SvxBorderLine::threeDLightColor( Color aMain )
+{
+ // These values have been defined in an empirical way
+ return lcl_compute3DColor( aMain, 3, 40, 83 );
+}
+
+Color SvxBorderLine::threeDDarkColor( Color aMain )
+{
+ // These values have been defined in an empirical way
+ return lcl_compute3DColor( aMain, -85, -43, -1 );
+}
+
+Color SvxBorderLine::threeDMediumColor( Color aMain )
+{
+ // These values have been defined in an empirical way
+ return lcl_compute3DColor( aMain, -42, -0, 42 );
+}
+
+SvxBorderLine::SvxBorderLine( const Color *pCol, long nWidth,
+ SvxBorderLineStyle nStyle,
+ Color (*pColorOutFn)( Color ), Color (*pColorInFn)( Color ) )
+: m_nWidth( nWidth )
+, m_bMirrorWidths( false )
+, m_aWidthImpl( SvxBorderLine::getWidthImpl( nStyle ) )
+, m_nMult( 1 )
+, m_nDiv( 1 )
+, m_nStyle( nStyle )
+, m_bUseLeftTop( false )
+, m_pColorOutFn( pColorOutFn )
+, m_pColorInFn( pColorInFn )
+, m_pColorGapFn( nullptr )
+{
+ if ( pCol )
+ aColor = *pCol;
+}
+
+
+SvxBorderLineStyle
+ConvertBorderStyleFromWord(int const nWordLineStyle)
+{
+ switch (nWordLineStyle)
+ {
+ // First the single lines
+ case 1:
+ case 2: // thick line
+ case 5: // hairline
+ // and the unsupported special cases which we map to a single line
+ case 20:
+ return SvxBorderLineStyle::SOLID;
+ case 6:
+ return SvxBorderLineStyle::DOTTED;
+ case 7:
+ return SvxBorderLineStyle::DASHED;
+ case 22:
+ return SvxBorderLineStyle::FINE_DASHED;
+ case 8:
+ return SvxBorderLineStyle::DASH_DOT;
+ case 9:
+ return SvxBorderLineStyle::DASH_DOT_DOT;
+ // then the shading beams which we represent by a double line
+ case 23:
+ return SvxBorderLineStyle::DOUBLE;
+ // then the double lines, for which we have good matches
+ case 3:
+ case 10: // Don't have triple so use double
+ case 21: // Don't have double wave: use double instead
+ return SvxBorderLineStyle::DOUBLE;
+ case 11:
+ return SvxBorderLineStyle::THINTHICK_SMALLGAP;
+ case 12:
+ case 13: // Don't have thin thick thin, so use thick thin
+ return SvxBorderLineStyle::THICKTHIN_SMALLGAP;
+ case 14:
+ return SvxBorderLineStyle::THINTHICK_MEDIUMGAP;
+ case 15:
+ case 16: // Don't have thin thick thin, so use thick thin
+ return SvxBorderLineStyle::THICKTHIN_MEDIUMGAP;
+ case 17:
+ return SvxBorderLineStyle::THINTHICK_LARGEGAP;
+ case 18:
+ case 19: // Don't have thin thick thin, so use thick thin
+ return SvxBorderLineStyle::THICKTHIN_LARGEGAP;
+ case 24:
+ return SvxBorderLineStyle::EMBOSSED;
+ case 25:
+ return SvxBorderLineStyle::ENGRAVED;
+ case 26:
+ return SvxBorderLineStyle::OUTSET;
+ case 27:
+ return SvxBorderLineStyle::INSET;
+ default:
+ return SvxBorderLineStyle::NONE;
+ }
+}
+
+static const double THINTHICK_SMALLGAP_line2 = 15.0;
+static const double THINTHICK_SMALLGAP_gap = 15.0;
+static const double THINTHICK_LARGEGAP_line1 = 30.0;
+static const double THINTHICK_LARGEGAP_line2 = 15.0;
+static const double THICKTHIN_SMALLGAP_line1 = 15.0;
+static const double THICKTHIN_SMALLGAP_gap = 15.0;
+static const double THICKTHIN_LARGEGAP_line1 = 15.0;
+static const double THICKTHIN_LARGEGAP_line2 = 30.0;
+static const double OUTSET_line1 = 15.0;
+static const double INSET_line2 = 15.0;
+
+double
+ConvertBorderWidthFromWord(SvxBorderLineStyle const eStyle, double const i_fWidth,
+ int const nWordLineStyle)
+{
+ // fdo#68779: at least for RTF, 0.75pt is the default if width is missing
+ double const fWidth((i_fWidth == 0.0) ? 15.0 : i_fWidth);
+ switch (eStyle)
+ {
+ // Single lines
+ case SvxBorderLineStyle::SOLID:
+ switch (nWordLineStyle)
+ {
+ case 2:
+ return (fWidth * 2.0); // thick
+ case 5: // fdo#55526: map 0 hairline width to > 0
+ return std::max(fWidth, 1.0);
+ default:
+ return fWidth;
+ }
+ break;
+
+ case SvxBorderLineStyle::DOTTED:
+ case SvxBorderLineStyle::DASHED:
+ case SvxBorderLineStyle::DASH_DOT:
+ case SvxBorderLineStyle::DASH_DOT_DOT:
+ return fWidth;
+
+ // Display a minimum effective border width of 1pt
+ case SvxBorderLineStyle::FINE_DASHED:
+ return (fWidth > 0 && fWidth < 20) ? 20 : fWidth;
+
+ // Double lines
+ case SvxBorderLineStyle::DOUBLE:
+ return fWidth * 3.0;
+
+ case SvxBorderLineStyle::THINTHICK_MEDIUMGAP:
+ case SvxBorderLineStyle::THICKTHIN_MEDIUMGAP:
+ case SvxBorderLineStyle::EMBOSSED:
+ case SvxBorderLineStyle::ENGRAVED:
+ return fWidth * 2.0;
+
+ case SvxBorderLineStyle::THINTHICK_SMALLGAP:
+ return fWidth + THINTHICK_SMALLGAP_line2 + THINTHICK_SMALLGAP_gap;
+
+ case SvxBorderLineStyle::THINTHICK_LARGEGAP:
+ return fWidth + THINTHICK_LARGEGAP_line1 + THINTHICK_LARGEGAP_line2;
+
+ case SvxBorderLineStyle::THICKTHIN_SMALLGAP:
+ return fWidth + THICKTHIN_SMALLGAP_line1 + THICKTHIN_SMALLGAP_gap;
+
+ case SvxBorderLineStyle::THICKTHIN_LARGEGAP:
+ return fWidth + THICKTHIN_LARGEGAP_line1 + THICKTHIN_LARGEGAP_line2;
+
+ case SvxBorderLineStyle::OUTSET:
+ return (fWidth * 2.0) + OUTSET_line1;
+
+ case SvxBorderLineStyle::INSET:
+ return (fWidth * 2.0) + INSET_line2;
+
+ default:
+ assert(false); // should only be called for known border style
+ }
+ return 0;
+}
+
+double
+ConvertBorderWidthToWord(SvxBorderLineStyle const eStyle, double const fWidth)
+{
+ if ( !fWidth )
+ return 0;
+
+ switch (eStyle)
+ {
+ // Single lines
+ case SvxBorderLineStyle::SOLID:
+ case SvxBorderLineStyle::DOTTED:
+ case SvxBorderLineStyle::DASHED:
+ case SvxBorderLineStyle::FINE_DASHED:
+ case SvxBorderLineStyle::DASH_DOT:
+ case SvxBorderLineStyle::DASH_DOT_DOT:
+ return fWidth;
+
+ // Double lines
+ case SvxBorderLineStyle::DOUBLE:
+ case SvxBorderLineStyle::DOUBLE_THIN:
+ return std::max(1.0, fWidth / 3.0);
+
+ case SvxBorderLineStyle::THINTHICK_MEDIUMGAP:
+ case SvxBorderLineStyle::THICKTHIN_MEDIUMGAP:
+ case SvxBorderLineStyle::EMBOSSED:
+ case SvxBorderLineStyle::ENGRAVED:
+ return std::max(1.0, fWidth / 2.0);
+
+ case SvxBorderLineStyle::THINTHICK_SMALLGAP:
+ return std::max(1.0, fWidth - THINTHICK_SMALLGAP_line2 - THINTHICK_SMALLGAP_gap);
+
+ case SvxBorderLineStyle::THINTHICK_LARGEGAP:
+ return std::max(1.0, fWidth - THINTHICK_LARGEGAP_line1 - THINTHICK_LARGEGAP_line2);
+
+ case SvxBorderLineStyle::THICKTHIN_SMALLGAP:
+ return std::max(1.0, fWidth - THICKTHIN_SMALLGAP_line1 - THICKTHIN_SMALLGAP_gap);
+
+ case SvxBorderLineStyle::THICKTHIN_LARGEGAP:
+ return std::max(1.0, fWidth - THICKTHIN_LARGEGAP_line1 - THICKTHIN_LARGEGAP_line2);
+
+ case SvxBorderLineStyle::OUTSET:
+ return std::max(1.0, (fWidth - OUTSET_line1) / 2.0);
+
+ case SvxBorderLineStyle::INSET:
+ return std::max(1.0, (fWidth - INSET_line2) / 2.0);
+
+ case SvxBorderLineStyle::NONE:
+ return 0;
+
+ default:
+ assert(false); // should only be called for known border style
+ return 0;
+ }
+}
+
+/** Get the BorderWithImpl object corresponding to the given #nStyle, all the
+ units handled by the resulting object are Twips and the
+ BorderWidthImpl::GetLine1() corresponds to the Outer Line.
+ */
+BorderWidthImpl SvxBorderLine::getWidthImpl( SvxBorderLineStyle nStyle )
+{
+ BorderWidthImpl aImpl;
+
+ switch ( nStyle )
+ {
+ // No line: no width
+ case SvxBorderLineStyle::NONE:
+ aImpl = BorderWidthImpl( BorderWidthImplFlags::FIXED, 0.0 );
+ break;
+
+ // Single lines
+ case SvxBorderLineStyle::SOLID:
+ case SvxBorderLineStyle::DOTTED:
+ case SvxBorderLineStyle::DASHED:
+ case SvxBorderLineStyle::FINE_DASHED:
+ case SvxBorderLineStyle::DASH_DOT:
+ case SvxBorderLineStyle::DASH_DOT_DOT:
+ aImpl = BorderWidthImpl( BorderWidthImplFlags::CHANGE_LINE1, 1.0 );
+ break;
+
+ // Double lines
+
+ case SvxBorderLineStyle::DOUBLE:
+ aImpl = BorderWidthImpl(
+ BorderWidthImplFlags::CHANGE_LINE1 | BorderWidthImplFlags::CHANGE_LINE2 | BorderWidthImplFlags::CHANGE_DIST,
+ // fdo#46112 fdo#38542 fdo#43249:
+ // non-constant widths must sum to 1
+ 1.0/3.0, 1.0/3.0, 1.0/3.0 );
+ break;
+
+ case SvxBorderLineStyle::DOUBLE_THIN:
+ aImpl = BorderWidthImpl(BorderWidthImplFlags::CHANGE_DIST, 10.0, 10.0, 1.0);
+ break;
+
+ case SvxBorderLineStyle::THINTHICK_SMALLGAP:
+ aImpl = BorderWidthImpl( BorderWidthImplFlags::CHANGE_LINE1, 1.0,
+ THINTHICK_SMALLGAP_line2, THINTHICK_SMALLGAP_gap );
+ break;
+
+ case SvxBorderLineStyle::THINTHICK_MEDIUMGAP:
+ aImpl = BorderWidthImpl(
+ BorderWidthImplFlags::CHANGE_LINE1 | BorderWidthImplFlags::CHANGE_LINE2 | BorderWidthImplFlags::CHANGE_DIST,
+ 0.5, 0.25, 0.25 );
+ break;
+
+ case SvxBorderLineStyle::THINTHICK_LARGEGAP:
+ aImpl = BorderWidthImpl( BorderWidthImplFlags::CHANGE_DIST,
+ THINTHICK_LARGEGAP_line1, THINTHICK_LARGEGAP_line2, 1.0 );
+ break;
+
+ case SvxBorderLineStyle::THICKTHIN_SMALLGAP:
+ aImpl = BorderWidthImpl( BorderWidthImplFlags::CHANGE_LINE2, THICKTHIN_SMALLGAP_line1,
+ 1.0, THICKTHIN_SMALLGAP_gap );
+ break;
+
+ case SvxBorderLineStyle::THICKTHIN_MEDIUMGAP:
+ aImpl = BorderWidthImpl(
+ BorderWidthImplFlags::CHANGE_LINE1 | BorderWidthImplFlags::CHANGE_LINE2 | BorderWidthImplFlags::CHANGE_DIST,
+ 0.25, 0.5, 0.25 );
+ break;
+
+ case SvxBorderLineStyle::THICKTHIN_LARGEGAP:
+ aImpl = BorderWidthImpl( BorderWidthImplFlags::CHANGE_DIST, THICKTHIN_LARGEGAP_line1,
+ THICKTHIN_LARGEGAP_line2, 1.0 );
+ break;
+
+ // Engraved / Embossed
+ /*
+ * Word compat: the lines widths are exactly following this rule, should be:
+ * 0.75pt up to 3pt and then 3pt
+ */
+
+ case SvxBorderLineStyle::EMBOSSED:
+ case SvxBorderLineStyle::ENGRAVED:
+ aImpl = BorderWidthImpl(
+ BorderWidthImplFlags::CHANGE_LINE1 | BorderWidthImplFlags::CHANGE_LINE2 | BorderWidthImplFlags::CHANGE_DIST,
+ 0.25, 0.25, 0.5 );
+ break;
+
+ // Inset / Outset
+ /*
+ * Word compat: the gap width should be measured relatively to the biggest width for the
+ * row or column.
+ */
+ case SvxBorderLineStyle::OUTSET:
+ aImpl = BorderWidthImpl(
+ BorderWidthImplFlags::CHANGE_LINE2 | BorderWidthImplFlags::CHANGE_DIST,
+ OUTSET_line1, 0.5, 0.5 );
+ break;
+
+ case SvxBorderLineStyle::INSET:
+ aImpl = BorderWidthImpl(
+ BorderWidthImplFlags::CHANGE_LINE1 | BorderWidthImplFlags::CHANGE_DIST,
+ 0.5, INSET_line2, 0.5 );
+ break;
+ }
+
+ return aImpl;
+}
+
+void SvxBorderLine::ScaleMetrics( long nMult, long nDiv )
+{
+ m_nMult = nMult;
+ m_nDiv = nDiv;
+}
+
+void SvxBorderLine::GuessLinesWidths( SvxBorderLineStyle nStyle, sal_uInt16 nOut, sal_uInt16 nIn, sal_uInt16 nDist )
+{
+ if (SvxBorderLineStyle::NONE == nStyle)
+ {
+ nStyle = SvxBorderLineStyle::SOLID;
+ if ( nOut > 0 && nIn > 0 )
+ nStyle = SvxBorderLineStyle::DOUBLE;
+ }
+
+ if ( nStyle == SvxBorderLineStyle::DOUBLE )
+ {
+ static const SvxBorderLineStyle aDoubleStyles[] =
+ {
+ SvxBorderLineStyle::DOUBLE,
+ SvxBorderLineStyle::DOUBLE_THIN,
+ SvxBorderLineStyle::THINTHICK_SMALLGAP,
+ SvxBorderLineStyle::THINTHICK_MEDIUMGAP,
+ SvxBorderLineStyle::THINTHICK_LARGEGAP,
+ SvxBorderLineStyle::THICKTHIN_SMALLGAP,
+ SvxBorderLineStyle::THICKTHIN_MEDIUMGAP,
+ SvxBorderLineStyle::THICKTHIN_LARGEGAP
+ };
+
+ static size_t const len = SAL_N_ELEMENTS(aDoubleStyles);
+ long nWidth = 0;
+ SvxBorderLineStyle nTestStyle(SvxBorderLineStyle::NONE);
+ for (size_t i = 0; i < len && nWidth == 0; ++i)
+ {
+ nTestStyle = aDoubleStyles[i];
+ BorderWidthImpl aWidthImpl = getWidthImpl( nTestStyle );
+ nWidth = aWidthImpl.GuessWidth( nOut, nIn, nDist );
+ }
+
+ // If anything matched, then set it
+ if ( nWidth > 0 )
+ {
+ nStyle = nTestStyle;
+ SetBorderLineStyle(nStyle);
+ m_nWidth = nWidth;
+ }
+ else
+ {
+ // fdo#38542: not a known double, default to something custom...
+ SetBorderLineStyle(nStyle);
+ m_nWidth = nOut + nIn + nDist;
+ if (nOut + nIn + nDist)
+ {
+ m_aWidthImpl = BorderWidthImpl(
+ BorderWidthImplFlags::CHANGE_LINE1 | BorderWidthImplFlags::CHANGE_LINE2 | BorderWidthImplFlags::CHANGE_DIST,
+ static_cast<double>(nOut ) / static_cast<double>(m_nWidth),
+ static_cast<double>(nIn ) / static_cast<double>(m_nWidth),
+ static_cast<double>(nDist) / static_cast<double>(m_nWidth));
+ }
+ }
+ }
+ else
+ {
+ SetBorderLineStyle(nStyle);
+ if (nOut == 0 && nIn > 0)
+ {
+ // If only inner width is given swap inner and outer widths for
+ // single line styles, otherwise GuessWidth() marks this as invalid
+ // and returns a 0 width.
+ switch (nStyle)
+ {
+ case SvxBorderLineStyle::SOLID:
+ case SvxBorderLineStyle::DOTTED:
+ case SvxBorderLineStyle::DASHED:
+ case SvxBorderLineStyle::FINE_DASHED:
+ case SvxBorderLineStyle::DASH_DOT:
+ case SvxBorderLineStyle::DASH_DOT_DOT:
+ std::swap( nOut, nIn);
+ break;
+ default:
+ ; // nothing
+ }
+ }
+ m_nWidth = m_aWidthImpl.GuessWidth( nOut, nIn, nDist );
+ }
+}
+
+sal_uInt16 SvxBorderLine::GetOutWidth() const
+{
+ sal_uInt16 nOut = static_cast<sal_uInt16>(Scale( m_aWidthImpl.GetLine1( m_nWidth ), m_nMult, m_nDiv ));
+ if ( m_bMirrorWidths )
+ nOut = static_cast<sal_uInt16>(Scale( m_aWidthImpl.GetLine2( m_nWidth ), m_nMult, m_nDiv ));
+ return nOut;
+}
+
+sal_uInt16 SvxBorderLine::GetInWidth() const
+{
+ sal_uInt16 nIn = static_cast<sal_uInt16>(Scale( m_aWidthImpl.GetLine2( m_nWidth ), m_nMult, m_nDiv ));
+ if ( m_bMirrorWidths )
+ nIn = static_cast<sal_uInt16>(Scale( m_aWidthImpl.GetLine1( m_nWidth ), m_nMult, m_nDiv ));
+ return nIn;
+}
+
+sal_uInt16 SvxBorderLine::GetDistance() const
+{
+ return static_cast<sal_uInt16>(Scale( m_aWidthImpl.GetGap( m_nWidth ), m_nMult, m_nDiv ));
+}
+
+
+bool SvxBorderLine::operator==( const SvxBorderLine& rCmp ) const
+{
+ return ( ( aColor == rCmp.aColor ) &&
+ ( m_nWidth == rCmp.m_nWidth ) &&
+ ( m_bMirrorWidths == rCmp.m_bMirrorWidths ) &&
+ ( m_aWidthImpl == rCmp.m_aWidthImpl ) &&
+ ( m_nStyle == rCmp.GetBorderLineStyle()) &&
+ ( m_bUseLeftTop == rCmp.m_bUseLeftTop ) &&
+ ( m_pColorOutFn == rCmp.m_pColorOutFn ) &&
+ ( m_pColorInFn == rCmp.m_pColorInFn ) &&
+ ( m_pColorGapFn == rCmp.m_pColorGapFn ) );
+}
+
+void SvxBorderLine::SetBorderLineStyle( SvxBorderLineStyle nNew )
+{
+ m_nStyle = nNew;
+ m_aWidthImpl = getWidthImpl( m_nStyle );
+
+ switch ( nNew )
+ {
+ case SvxBorderLineStyle::EMBOSSED:
+ m_pColorOutFn = threeDLightColor;
+ m_pColorInFn = threeDDarkColor;
+ m_pColorGapFn = threeDMediumColor;
+ m_bUseLeftTop = true;
+ break;
+ case SvxBorderLineStyle::ENGRAVED:
+ m_pColorOutFn = threeDDarkColor;
+ m_pColorInFn = threeDLightColor;
+ m_pColorGapFn = threeDMediumColor;
+ m_bUseLeftTop = true;
+ break;
+ case SvxBorderLineStyle::OUTSET:
+ m_pColorOutFn = lightColor;
+ m_pColorInFn = darkColor;
+ m_bUseLeftTop = true;
+ m_pColorGapFn = nullptr;
+ break;
+ case SvxBorderLineStyle::INSET:
+ m_pColorOutFn = darkColor;
+ m_pColorInFn = lightColor;
+ m_bUseLeftTop = true;
+ m_pColorGapFn = nullptr;
+ break;
+ default:
+ m_pColorOutFn = darkColor;
+ m_pColorInFn = darkColor;
+ m_bUseLeftTop = false;
+ m_pColorGapFn = nullptr;
+ break;
+ }
+}
+
+Color SvxBorderLine::GetColorOut( bool bLeftOrTop ) const
+{
+ Color aResult = aColor;
+
+ if ( m_aWidthImpl.IsDouble() && m_pColorOutFn != nullptr )
+ {
+ if ( !bLeftOrTop && m_bUseLeftTop )
+ aResult = (*m_pColorInFn)( aColor );
+ else
+ aResult = (*m_pColorOutFn)( aColor );
+ }
+
+ return aResult;
+}
+
+Color SvxBorderLine::GetColorIn( bool bLeftOrTop ) const
+{
+ Color aResult = aColor;
+
+ if ( m_aWidthImpl.IsDouble() && m_pColorInFn != nullptr )
+ {
+ if ( !bLeftOrTop && m_bUseLeftTop )
+ aResult = (*m_pColorOutFn)( aColor );
+ else
+ aResult = (*m_pColorInFn)( aColor );
+ }
+
+ return aResult;
+}
+
+Color SvxBorderLine::GetColorGap( ) const
+{
+ Color aResult = aColor;
+
+ if ( m_aWidthImpl.IsDouble() && m_pColorGapFn != nullptr )
+ {
+ aResult = (*m_pColorGapFn)( aColor );
+ }
+
+ return aResult;
+}
+
+void SvxBorderLine::SetWidth( long nWidth )
+{
+ m_nWidth = nWidth;
+}
+
+OUString SvxBorderLine::GetValueString(MapUnit eSrcUnit,
+ MapUnit eDestUnit,
+ const IntlWrapper* pIntl,
+ bool bMetricStr) const
+{
+ static const char* aStyleIds[] =
+ {
+ RID_SOLID,
+ RID_DOTTED,
+ RID_DASHED,
+ RID_DOUBLE,
+ RID_THINTHICK_SMALLGAP,
+ RID_THINTHICK_MEDIUMGAP,
+ RID_THINTHICK_LARGEGAP,
+ RID_THICKTHIN_SMALLGAP,
+ RID_THICKTHIN_MEDIUMGAP,
+ RID_THICKTHIN_LARGEGAP,
+ RID_EMBOSSED,
+ RID_ENGRAVED,
+ RID_OUTSET,
+ RID_INSET,
+ RID_FINE_DASHED,
+ RID_DOUBLE_THIN,
+ RID_DASH_DOT,
+ RID_DASH_DOT_DOT
+ };
+ OUString aStr = "(" + ::GetColorString( aColor ) + cpDelim;
+
+ if ( static_cast<int>(m_nStyle) < int(SAL_N_ELEMENTS(aStyleIds)) )
+ {
+ const char* pResId = aStyleIds[static_cast<int>(m_nStyle)];
+ aStr += EditResId(pResId);
+ }
+ else
+ {
+ OUString sMetric = EditResId(GetMetricId( eDestUnit ));
+ aStr += GetMetricText( static_cast<long>(GetInWidth()), eSrcUnit, eDestUnit, pIntl );
+ if ( bMetricStr )
+ aStr += sMetric;
+ aStr += cpDelim +
+ GetMetricText( static_cast<long>(GetOutWidth()), eSrcUnit, eDestUnit, pIntl );
+ if ( bMetricStr )
+ aStr += sMetric;
+ aStr += cpDelim +
+ GetMetricText( static_cast<long>(GetDistance()), eSrcUnit, eDestUnit, pIntl );
+ if ( bMetricStr )
+ aStr += sMetric;
+ }
+ aStr += ")";
+ return aStr;
+}
+
+bool SvxBorderLine::HasPriority( const SvxBorderLine& rOtherLine ) const
+{
+ const sal_uInt16 nThisSize = GetScaledWidth();
+ const sal_uInt16 nOtherSize = rOtherLine.GetScaledWidth();
+
+ if ( nThisSize > nOtherSize )
+ {
+ return true;
+ }
+ else if ( nThisSize < nOtherSize )
+ {
+ return false;
+ }
+ else if ( rOtherLine.GetInWidth() && !GetInWidth() )
+ {
+ return true;
+ }
+
+ return false;
+}
+
+bool operator!=( const SvxBorderLine& rLeft, const SvxBorderLine& rRight )
+{
+ return !(rLeft == rRight);
+}
+
+} // namespace editeng
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/items/bulitem.cxx b/editeng/source/items/bulitem.cxx
new file mode 100644
index 000000000..769179748
--- /dev/null
+++ b/editeng/source/items/bulitem.cxx
@@ -0,0 +1,159 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <vcl/outdev.hxx>
+
+#include <editeng/bulletitem.hxx>
+
+SvxBulletItem::SvxBulletItem( sal_uInt16 _nWhich )
+ : SfxPoolItem(_nWhich)
+ , aFont(OutputDevice::GetDefaultFont( DefaultFontType::FIXED, LANGUAGE_SYSTEM, GetDefaultFontFlags::NONE ))
+ , nStart(1)
+ , nStyle(SvxBulletStyle::N123)
+ , nWidth(1200) // 1.2cm
+ , nScale(75)
+ , cSymbol(' ')
+{
+ aFont.SetAlignment(ALIGN_BOTTOM);
+ aFont.SetTransparent( true );
+}
+
+
+SvxBulletItem::SvxBulletItem( const SvxBulletItem& rItem )
+ : SfxPoolItem(rItem)
+ , aFont(rItem.aFont)
+ , pGraphicObject(rItem.pGraphicObject ? new GraphicObject( *rItem.pGraphicObject ) : nullptr)
+ , aPrevText(rItem.aPrevText)
+ , aFollowText(rItem.aFollowText)
+ , nStart(rItem.nStart)
+ , nStyle(rItem.nStyle)
+ , nWidth(rItem.nWidth)
+ , nScale(rItem.nScale)
+ , cSymbol(rItem.cSymbol)
+{
+}
+
+
+SvxBulletItem::~SvxBulletItem()
+{
+}
+
+SvxBulletItem* SvxBulletItem::Clone( SfxItemPool * /*pPool*/ ) const
+{
+ return new SvxBulletItem( *this );
+}
+
+void SvxBulletItem::CopyValidProperties( const SvxBulletItem& rCopyFrom )
+{
+ vcl::Font _aFont = GetFont();
+ vcl::Font aNewFont = rCopyFrom.GetFont();
+ _aFont.SetFamilyName( aNewFont.GetFamilyName() );
+ _aFont.SetFamily( aNewFont.GetFamilyType() );
+ _aFont.SetStyleName( aNewFont.GetStyleName() );
+ _aFont.SetColor( aNewFont.GetColor() );
+ SetSymbol( rCopyFrom.cSymbol );
+ SetGraphicObject( rCopyFrom.GetGraphicObject() );
+ SetScale( rCopyFrom.nScale );
+ SetStart( rCopyFrom.nStart );
+ SetStyle( rCopyFrom.nStyle );
+ aPrevText = rCopyFrom.aPrevText;
+ aFollowText = rCopyFrom.aFollowText;
+ SetFont( _aFont );
+}
+
+
+bool SvxBulletItem::operator==( const SfxPoolItem& rItem ) const
+{
+ assert(SfxPoolItem::operator==(rItem));
+ const SvxBulletItem& rBullet = static_cast<const SvxBulletItem&>(rItem);
+ // Compare with ValidMask, otherwise no put possible in an AttrSet if the
+ // item differs only in terms of the ValidMask from an existing one.
+ if( nStyle != rBullet.nStyle ||
+ nScale != rBullet.nScale ||
+ nWidth != rBullet.nWidth ||
+ nStart != rBullet.nStart ||
+ cSymbol != rBullet.cSymbol ||
+ aPrevText != rBullet.aPrevText ||
+ aFollowText != rBullet.aFollowText )
+ return false;
+
+ if( ( nStyle != SvxBulletStyle::BMP ) && ( aFont != rBullet.aFont ) )
+ return false;
+
+ if( nStyle == SvxBulletStyle::BMP )
+ {
+ if( ( pGraphicObject && !rBullet.pGraphicObject ) || ( !pGraphicObject && rBullet.pGraphicObject ) )
+ return false;
+
+ if( ( pGraphicObject && rBullet.pGraphicObject ) &&
+ ( ( *pGraphicObject != *rBullet.pGraphicObject ) ||
+ ( pGraphicObject->GetPrefSize() != rBullet.pGraphicObject->GetPrefSize() ) ) )
+ {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+
+OUString SvxBulletItem::GetFullText() const
+{
+ return aPrevText + OUStringChar(cSymbol) + aFollowText;
+}
+
+
+bool SvxBulletItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper&
+) const
+{
+ rText = GetFullText();
+ return true;
+}
+
+
+const GraphicObject& SvxBulletItem::GetGraphicObject() const
+{
+ if( pGraphicObject )
+ return *pGraphicObject;
+ else
+ {
+ static const GraphicObject aDefaultObject;
+ return aDefaultObject;
+ }
+}
+
+
+void SvxBulletItem::SetGraphicObject( const GraphicObject& rGraphicObject )
+{
+ if( ( GraphicType::NONE == rGraphicObject.GetType() ) || ( GraphicType::Default == rGraphicObject.GetType() ) )
+ {
+ pGraphicObject.reset();
+ }
+ else
+ {
+ pGraphicObject.reset( new GraphicObject( rGraphicObject ) );
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/items/charhiddenitem.cxx b/editeng/source/items/charhiddenitem.cxx
new file mode 100644
index 000000000..8d0753c91
--- /dev/null
+++ b/editeng/source/items/charhiddenitem.cxx
@@ -0,0 +1,52 @@
+/* -*- 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 <editeng/charhiddenitem.hxx>
+#include <editeng/editrids.hrc>
+#include <editeng/eerdll.hxx>
+
+
+SvxCharHiddenItem::SvxCharHiddenItem( const bool bHidden, const sal_uInt16 nId ) :
+ SfxBoolItem( nId, bHidden )
+{
+}
+
+SvxCharHiddenItem* SvxCharHiddenItem::Clone( SfxItemPool * ) const
+{
+ return new SvxCharHiddenItem( *this );
+}
+
+bool SvxCharHiddenItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText,
+ const IntlWrapper & /*rIntl*/
+) const
+{
+ const char* pId = RID_SVXITEMS_CHARHIDDEN_FALSE;
+
+ if ( GetValue() )
+ pId = RID_SVXITEMS_CHARHIDDEN_TRUE;
+ rText = EditResId(pId);
+ return true;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/items/flditem.cxx b/editeng/source/items/flditem.cxx
new file mode 100644
index 000000000..2b57402ae
--- /dev/null
+++ b/editeng/source/items/flditem.cxx
@@ -0,0 +1,933 @@
+/* -*- 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 <osl/file.hxx>
+#include <vcl/metaact.hxx>
+#include <svl/zforlist.hxx>
+#include <tools/urlobj.hxx>
+
+#include <editeng/flditem.hxx>
+#include <editeng/CustomPropertyField.hxx>
+#include <editeng/measfld.hxx>
+#include <editeng/unonames.hxx>
+
+#include <tools/debug.hxx>
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/text/XTextContent.hpp>
+#include <com/sun/star/text/FilenameDisplayFormat.hpp>
+#include <com/sun/star/util/DateTime.hpp>
+
+using namespace com::sun::star;
+
+SvxFieldData* SvxFieldData::Create(const uno::Reference<text::XTextContent>& xTextContent)
+{
+ uno::Reference<beans::XPropertySet> xPropSet(xTextContent, uno::UNO_QUERY);
+ if (!xPropSet.is())
+ return nullptr;
+
+ // we do not support these fields from Writer, so make sure we do not throw
+ // here - see fdo#63436 how to possibly extend Writer to make use of this
+ uno::Any aAny;
+ try {
+ aAny = xPropSet->getPropertyValue(UNO_TC_PROP_TEXTFIELD_TYPE);
+ if ( !aAny.has<sal_Int32>() )
+ return nullptr;
+
+ sal_Int32 nFieldType = aAny.get<sal_Int32>();
+
+ switch (nFieldType)
+ {
+ case text::textfield::Type::TIME:
+ case text::textfield::Type::EXTENDED_TIME:
+ case text::textfield::Type::DATE:
+ {
+ bool bIsDate = false;
+ xPropSet->getPropertyValue(UNO_TC_PROP_IS_DATE) >>= bIsDate;
+
+ if (bIsDate)
+ {
+ util::DateTime aDateTime = xPropSet->getPropertyValue(UNO_TC_PROP_DATE_TIME).get<util::DateTime>();
+ Date aDate(aDateTime.Day, aDateTime.Month, aDateTime.Year);
+ bool bIsFixed = false;
+ xPropSet->getPropertyValue(UNO_TC_PROP_IS_FIXED) >>= bIsFixed;
+
+ SvxDateField* pData = new SvxDateField(aDate, bIsFixed ? SvxDateType::Fix : SvxDateType::Var);
+ sal_Int32 nNumFmt = -1;
+ xPropSet->getPropertyValue(UNO_TC_PROP_NUMFORMAT) >>= nNumFmt;
+ if (static_cast<SvxDateFormat>(nNumFmt) >= SvxDateFormat::AppDefault &&
+ static_cast<SvxDateFormat>(nNumFmt) <= SvxDateFormat::F)
+ pData->SetFormat(static_cast<SvxDateFormat>(nNumFmt));
+
+ return pData;
+ }
+
+ if (nFieldType != text::textfield::Type::TIME)
+ {
+ util::DateTime aDateTime = xPropSet->getPropertyValue(UNO_TC_PROP_DATE_TIME).get<util::DateTime>();
+ tools::Time aTime(aDateTime);
+
+ bool bIsFixed = false;
+ xPropSet->getPropertyValue(UNO_TC_PROP_IS_FIXED) >>= bIsFixed;
+
+ SvxExtTimeField* pData = new SvxExtTimeField(aTime, bIsFixed ? SvxTimeType::Fix : SvxTimeType::Var);
+
+ sal_Int32 nNumFmt = -1;
+ xPropSet->getPropertyValue(UNO_TC_PROP_NUMFORMAT) >>= nNumFmt;
+ if (static_cast<SvxTimeFormat>(nNumFmt) >= SvxTimeFormat::AppDefault &&
+ static_cast<SvxTimeFormat>(nNumFmt) <= SvxTimeFormat::HH12_MM_SS_00_AMPM)
+ pData->SetFormat(static_cast<SvxTimeFormat>(nNumFmt));
+
+ return pData;
+ }
+
+ return new SvxTimeField();
+ }
+ case text::textfield::Type::URL:
+ {
+ OUString aRep, aTarget, aURL;
+ sal_Int16 nFmt = -1;
+ xPropSet->getPropertyValue(UNO_TC_PROP_URL_REPRESENTATION) >>= aRep;
+ xPropSet->getPropertyValue(UNO_TC_PROP_URL_TARGET) >>= aTarget;
+ xPropSet->getPropertyValue(UNO_TC_PROP_URL) >>= aURL;
+ xPropSet->getPropertyValue(UNO_TC_PROP_URL_FORMAT) >>= nFmt;
+ SvxURLField* pData = new SvxURLField(aURL, aRep, aRep.isEmpty() ? SvxURLFormat::Url : SvxURLFormat::Repr);
+ pData->SetTargetFrame(aTarget);
+ if (static_cast<SvxURLFormat>(nFmt) >= SvxURLFormat::AppDefault &&
+ static_cast<SvxURLFormat>(nFmt) <= SvxURLFormat::Repr)
+ pData->SetFormat(static_cast<SvxURLFormat>(nFmt));
+
+ return pData;
+ }
+ case text::textfield::Type::PAGE:
+ return new SvxPageField();
+ case text::textfield::Type::PAGES:
+ return new SvxPagesField();
+ case text::textfield::Type::PAGE_NAME:
+ return new SvxPageTitleField();
+ case text::textfield::Type::DOCINFO_TITLE:
+ return new SvxFileField();
+ case text::textfield::Type::TABLE:
+ {
+ sal_Int32 nTab = 0;
+ xPropSet->getPropertyValue(UNO_TC_PROP_TABLE_POSITION) >>= nTab;
+ return new SvxTableField(nTab);
+ }
+ case text::textfield::Type::EXTENDED_FILE:
+ {
+ OUString aPresentation;
+ bool bIsFixed = false;
+ sal_Int16 nFmt = text::FilenameDisplayFormat::FULL;
+ xPropSet->getPropertyValue(UNO_TC_PROP_IS_FIXED) >>= bIsFixed;
+ xPropSet->getPropertyValue(UNO_TC_PROP_CURRENT_PRESENTATION) >>= aPresentation;
+ xPropSet->getPropertyValue(UNO_TC_PROP_FILE_FORMAT) >>= nFmt;
+
+ SvxFileFormat eFmt = SvxFileFormat::NameAndExt;
+ switch (nFmt)
+ {
+ case text::FilenameDisplayFormat::FULL: eFmt = SvxFileFormat::PathFull; break;
+ case text::FilenameDisplayFormat::PATH: eFmt = SvxFileFormat::PathOnly; break;
+ case text::FilenameDisplayFormat::NAME: eFmt = SvxFileFormat::NameOnly; break;
+ default:;
+ }
+
+ // pass fixed attribute to constructor
+ return new SvxExtFileField(
+ aPresentation, bIsFixed ? SvxFileType::Fix : SvxFileType::Var, eFmt);
+ }
+ case text::textfield::Type::AUTHOR:
+ {
+ bool bIsFixed = false;
+ bool bFullName = false;
+ sal_Int16 nFmt = -1;
+ OUString aPresentation, aContent, aFirstName, aLastName;
+ xPropSet->getPropertyValue(UNO_TC_PROP_IS_FIXED) >>= bIsFixed;
+ xPropSet->getPropertyValue(UNO_TC_PROP_AUTHOR_FULLNAME) >>= bFullName;
+ xPropSet->getPropertyValue(UNO_TC_PROP_CURRENT_PRESENTATION) >>= aPresentation;
+ xPropSet->getPropertyValue(UNO_TC_PROP_AUTHOR_CONTENT) >>= aContent;
+ xPropSet->getPropertyValue(UNO_TC_PROP_AUTHOR_FORMAT) >>= nFmt;
+
+ // do we have CurrentPresentation given? Mimic behaviour of
+ // writer, which means: prefer CurrentPresentation over Content
+ // if both are given.
+ if (!aPresentation.isEmpty())
+ aContent = aPresentation;
+
+ sal_Int32 nPos = aContent.lastIndexOf(' ', 0);
+ if (nPos > 0)
+ {
+ aFirstName = aContent.copy(0, nPos);
+ aLastName = aContent.copy(nPos + 1);
+ }
+ else
+ {
+ aLastName = aContent;
+ }
+
+ // #92009# pass fixed attribute to constructor
+ SvxAuthorField* pData = new SvxAuthorField(
+ aFirstName, aLastName, OUString(), bIsFixed ? SvxAuthorType::Fix : SvxAuthorType::Var);
+
+ if (!bIsFixed)
+ {
+ if (!bFullName)
+ {
+ pData->SetFormat(SvxAuthorFormat::ShortName);
+ }
+ else if (static_cast<SvxAuthorFormat>(nFmt) >= SvxAuthorFormat::FullName &&
+ static_cast<SvxAuthorFormat>(nFmt) <= SvxAuthorFormat::ShortName)
+ {
+ pData->SetFormat(static_cast<SvxAuthorFormat>(nFmt));
+ }
+ }
+
+ return pData;
+ }
+ case text::textfield::Type::MEASURE:
+ {
+ SdrMeasureFieldKind eKind = SdrMeasureFieldKind::Value;
+ sal_Int16 nTmp = -1;
+ xPropSet->getPropertyValue(UNO_TC_PROP_MEASURE_KIND) >>= nTmp;
+ if (nTmp == static_cast<sal_Int16>(SdrMeasureFieldKind::Unit) ||
+ nTmp == static_cast<sal_Int16>(SdrMeasureFieldKind::Rotate90Blanks))
+ eKind = static_cast<SdrMeasureFieldKind>(nTmp);
+
+ return new SdrMeasureField(eKind);
+ }
+ case text::textfield::Type::PRESENTATION_HEADER:
+ return new SvxHeaderField();
+ case text::textfield::Type::PRESENTATION_FOOTER:
+ return new SvxFooterField();
+ case text::textfield::Type::PRESENTATION_DATE_TIME:
+ return new SvxDateTimeField();
+ case text::textfield::Type::DOCINFO_CUSTOM:
+ {
+ OUString sName;
+ xPropSet->getPropertyValue(UNO_TC_PROP_NAME) >>= sName;
+
+ OUString sCurrentPresentation;
+ xPropSet->getPropertyValue(UNO_TC_PROP_CURRENT_PRESENTATION) >>= sCurrentPresentation;
+
+ return new editeng::CustomPropertyField(sName, sCurrentPresentation);
+ }
+ default:
+ ;
+ };
+ } catch ( const beans::UnknownPropertyException& )
+ {
+ return nullptr;
+ }
+
+ return nullptr;
+}
+
+
+SvxFieldData::SvxFieldData()
+{
+}
+
+
+SvxFieldData::~SvxFieldData()
+{
+}
+
+
+std::unique_ptr<SvxFieldData> SvxFieldData::Clone() const
+{
+ return std::make_unique<SvxFieldData>();
+}
+
+
+bool SvxFieldData::operator==( const SvxFieldData& rFld ) const
+{
+ DBG_ASSERT( typeid(*this) == typeid(rFld), "==: Different Types" );
+ (void)rFld;
+ return true; // Basic class is always the same.
+}
+
+
+MetaAction* SvxFieldData::createBeginComment() const
+{
+ return new MetaCommentAction( "FIELD_SEQ_BEGIN" );
+}
+
+MetaAction* SvxFieldData::createEndComment()
+{
+ return new MetaCommentAction( "FIELD_SEQ_END" );
+}
+
+
+SvxFieldItem::SvxFieldItem( std::unique_ptr<SvxFieldData> pField, const sal_uInt16 nId ) :
+ SfxPoolItem( nId )
+ , mpField( std::move(pField) )
+{
+}
+
+SvxFieldItem::SvxFieldItem( const SvxFieldData& rField, const sal_uInt16 nId ) :
+ SfxPoolItem( nId )
+ , mpField( rField.Clone() )
+{
+}
+
+
+SvxFieldItem::SvxFieldItem( const SvxFieldItem& rItem ) :
+ SfxPoolItem ( rItem )
+ , mpField( rItem.mpField ? rItem.mpField->Clone() : nullptr )
+{
+}
+
+SvxFieldItem::~SvxFieldItem()
+{
+}
+
+SvxFieldItem* SvxFieldItem::Clone( SfxItemPool* ) const
+{
+ return new SvxFieldItem(*this);
+}
+
+bool SvxFieldItem::operator==( const SfxPoolItem& rItem ) const
+{
+ assert(SfxPoolItem::operator==(rItem));
+
+ const SvxFieldData* pOtherFld = static_cast<const SvxFieldItem&>(rItem).GetField();
+ if( mpField.get() == pOtherFld )
+ return true;
+ if( mpField == nullptr || pOtherFld == nullptr )
+ return false;
+ return ( typeid(*mpField) == typeid(*pOtherFld) )
+ && ( *mpField == *pOtherFld );
+}
+
+
+// The following are the derivatives of SvxFieldData ...
+
+
+SvxDateField::SvxDateField()
+{
+ nFixDate = Date( Date::SYSTEM ).GetDate();
+ eType = SvxDateType::Var;
+ eFormat = SvxDateFormat::StdSmall;
+}
+
+
+SvxDateField::SvxDateField( const Date& rDate, SvxDateType eT, SvxDateFormat eF )
+{
+ nFixDate = rDate.GetDate();
+ eType = eT;
+ eFormat = eF;
+}
+
+
+std::unique_ptr<SvxFieldData> SvxDateField::Clone() const
+{
+ return std::make_unique<SvxDateField>( *this );
+}
+
+
+bool SvxDateField::operator==( const SvxFieldData& rOther ) const
+{
+ if ( typeid(rOther) != typeid(*this) )
+ return false;
+
+ const SvxDateField& rOtherFld = static_cast<const SvxDateField&>(rOther);
+ return ( ( nFixDate == rOtherFld.nFixDate ) &&
+ ( eType == rOtherFld.eType ) &&
+ ( eFormat == rOtherFld.eFormat ) );
+}
+
+
+
+OUString SvxDateField::GetFormatted( SvNumberFormatter& rFormatter, LanguageType eLang ) const
+{
+ Date aDate( Date::EMPTY );
+ if ( eType == SvxDateType::Fix )
+ aDate.SetDate( nFixDate );
+ else
+ aDate = Date( Date::SYSTEM ); // current date
+
+ return GetFormatted( aDate, eFormat, rFormatter, eLang );
+}
+
+OUString SvxDateField::GetFormatted( Date const & aDate, SvxDateFormat eFormat, SvNumberFormatter& rFormatter, LanguageType eLang )
+{
+ if ( eFormat == SvxDateFormat::System )
+ {
+ OSL_FAIL( "SvxDateFormat::System not implemented!" );
+ eFormat = SvxDateFormat::StdSmall;
+ }
+ else if ( eFormat == SvxDateFormat::AppDefault )
+ {
+ OSL_FAIL( "SvxDateFormat::AppDefault: take them from where? ");
+ eFormat = SvxDateFormat::StdSmall;
+ }
+
+ sal_uInt32 nFormatKey;
+
+ switch( eFormat )
+ {
+ case SvxDateFormat::StdSmall:
+ // short
+ nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYSTEM_SHORT, eLang );
+ break;
+ case SvxDateFormat::StdBig:
+ // long
+ nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYSTEM_LONG, eLang );
+ break;
+ case SvxDateFormat::A:
+ // 13.02.96
+ nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_DDMMYY, eLang );
+ break;
+ case SvxDateFormat::B:
+ // 13.02.1996
+ nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_DDMMYYYY, eLang );
+ break;
+ case SvxDateFormat::C:
+ // 13. Feb 1996
+ nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_DMMMYYYY, eLang );
+ break;
+ case SvxDateFormat::D:
+ // 13. February 1996
+ nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_DMMMMYYYY, eLang );
+ break;
+ case SvxDateFormat::E:
+ // The, 13. February 1996
+ nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_NNDMMMMYYYY, eLang );
+ break;
+ case SvxDateFormat::F:
+ // Tuesday, 13. February 1996
+ nFormatKey = rFormatter.GetFormatIndex( NF_DATE_SYS_NNNNDMMMMYYYY, eLang );
+ break;
+ default:
+ nFormatKey = rFormatter.GetStandardFormat( SvNumFormatType::DATE, eLang );
+ }
+
+ double fDiffDate = aDate - rFormatter.GetNullDate();
+ OUString aStr;
+ Color* pColor = nullptr;
+ rFormatter.GetOutputString( fDiffDate, nFormatKey, aStr, &pColor );
+ return aStr;
+}
+
+MetaAction* SvxDateField::createBeginComment() const
+{
+ return new MetaCommentAction( "FIELD_SEQ_BEGIN" );
+}
+
+SvxURLField::SvxURLField()
+{
+ eFormat = SvxURLFormat::Url;
+}
+
+
+SvxURLField::SvxURLField( const OUString& rURL, const OUString& rRepres, SvxURLFormat eFmt )
+ : aURL( rURL ), aRepresentation( rRepres )
+{
+ eFormat = eFmt;
+}
+
+
+std::unique_ptr<SvxFieldData> SvxURLField::Clone() const
+{
+ return std::make_unique<SvxURLField>( *this );
+}
+
+
+bool SvxURLField::operator==( const SvxFieldData& rOther ) const
+{
+ if ( typeid(rOther) != typeid(*this) )
+ return false;
+
+ const SvxURLField& rOtherFld = static_cast<const SvxURLField&>(rOther);
+ return ( ( eFormat == rOtherFld.eFormat ) &&
+ ( aURL == rOtherFld.aURL ) &&
+ ( aRepresentation == rOtherFld.aRepresentation ) &&
+ ( aTargetFrame == rOtherFld.aTargetFrame ) );
+}
+
+
+MetaAction* SvxURLField::createBeginComment() const
+{
+ // #i46618# Adding target URL to metafile comment
+ return new MetaCommentAction( "FIELD_SEQ_BEGIN",
+ 0,
+ reinterpret_cast<const sal_uInt8*>(aURL.getStr()),
+ 2*aURL.getLength() );
+}
+
+//
+// SvxPageTitleField methods
+//
+
+SvxPageTitleField::SvxPageTitleField() {}
+
+std::unique_ptr<SvxFieldData> SvxPageTitleField::Clone() const
+{
+ return std::make_unique<SvxPageTitleField>();
+}
+
+bool SvxPageTitleField::operator==( const SvxFieldData& rCmp ) const
+{
+ return ( dynamic_cast< const SvxPageTitleField *>(&rCmp) != nullptr );
+}
+
+MetaAction* SvxPageTitleField::createBeginComment() const
+{
+ return new MetaCommentAction( "FIELD_SEQ_BEGIN;PageTitleField" );
+}
+
+//
+// SvxPagesField
+//
+// The fields that were removed from Calc:
+
+
+SvxPageField::SvxPageField() {}
+
+std::unique_ptr<SvxFieldData> SvxPageField::Clone() const
+{
+ return std::make_unique<SvxPageField>(); // empty
+}
+
+bool SvxPageField::operator==( const SvxFieldData& rCmp ) const
+{
+ return ( dynamic_cast< const SvxPageField *>(&rCmp) != nullptr );
+}
+
+MetaAction* SvxPageField::createBeginComment() const
+{
+ return new MetaCommentAction( "FIELD_SEQ_BEGIN;PageField" );
+}
+
+
+SvxPagesField::SvxPagesField() {}
+
+std::unique_ptr<SvxFieldData> SvxPagesField::Clone() const
+{
+ return std::make_unique<SvxPagesField>(); // empty
+}
+
+bool SvxPagesField::operator==( const SvxFieldData& rCmp ) const
+{
+ return ( dynamic_cast< const SvxPagesField *>(&rCmp) != nullptr);
+}
+
+SvxTimeField::SvxTimeField() {}
+
+std::unique_ptr<SvxFieldData> SvxTimeField::Clone() const
+{
+ return std::make_unique<SvxTimeField>(); // empty
+}
+
+bool SvxTimeField::operator==( const SvxFieldData& rCmp ) const
+{
+ return ( dynamic_cast< const SvxTimeField *>(&rCmp) != nullptr);
+}
+
+MetaAction* SvxTimeField::createBeginComment() const
+{
+ return new MetaCommentAction( "FIELD_SEQ_BEGIN" );
+}
+
+SvxFileField::SvxFileField() {}
+
+std::unique_ptr<SvxFieldData> SvxFileField::Clone() const
+{
+ return std::make_unique<SvxFileField>(); // empty
+}
+
+bool SvxFileField::operator==( const SvxFieldData& rCmp ) const
+{
+ return ( dynamic_cast< const SvxFileField *>(&rCmp) != nullptr );
+}
+
+SvxTableField::SvxTableField() : mnTab(0) {}
+
+SvxTableField::SvxTableField(int nTab) : mnTab(nTab) {}
+
+void SvxTableField::SetTab(int nTab)
+{
+ mnTab = nTab;
+}
+
+
+std::unique_ptr<SvxFieldData> SvxTableField::Clone() const
+{
+ return std::make_unique<SvxTableField>(mnTab);
+}
+
+bool SvxTableField::operator==( const SvxFieldData& rCmp ) const
+{
+ if (dynamic_cast<const SvxTableField *>(&rCmp) == nullptr)
+ return false;
+
+ return mnTab == static_cast<const SvxTableField&>(rCmp).mnTab;
+}
+
+// SvxExtTimeField
+
+
+SvxExtTimeField::SvxExtTimeField()
+ : m_nFixTime( tools::Time(tools::Time::SYSTEM).GetTime() )
+{
+ eType = SvxTimeType::Var;
+ eFormat = SvxTimeFormat::Standard;
+}
+
+
+SvxExtTimeField::SvxExtTimeField( const tools::Time& rTime, SvxTimeType eT, SvxTimeFormat eF )
+ : m_nFixTime( rTime.GetTime() )
+{
+ eType = eT;
+ eFormat = eF;
+}
+
+
+std::unique_ptr<SvxFieldData> SvxExtTimeField::Clone() const
+{
+ return std::make_unique<SvxExtTimeField>( *this );
+}
+
+
+bool SvxExtTimeField::operator==( const SvxFieldData& rOther ) const
+{
+ if ( typeid(rOther) != typeid(*this) )
+ return false;
+
+ const SvxExtTimeField& rOtherFld = static_cast<const SvxExtTimeField&>(rOther);
+ return ((m_nFixTime == rOtherFld.m_nFixTime) &&
+ ( eType == rOtherFld.eType ) &&
+ ( eFormat == rOtherFld.eFormat ) );
+}
+
+
+OUString SvxExtTimeField::GetFormatted( SvNumberFormatter& rFormatter, LanguageType eLang ) const
+{
+ tools::Time aTime( tools::Time::EMPTY );
+ if ( eType == SvxTimeType::Fix )
+ aTime.SetTime(m_nFixTime);
+ else
+ aTime = tools::Time( tools::Time::SYSTEM ); // current time
+ return GetFormatted( aTime, eFormat, rFormatter, eLang );
+}
+
+OUString SvxExtTimeField::GetFormatted( tools::Time const & aTime, SvxTimeFormat eFormat, SvNumberFormatter& rFormatter, LanguageType eLang )
+{
+ switch( eFormat )
+ {
+ case SvxTimeFormat::System :
+ OSL_FAIL( "SvxTimeFormat::System: not implemented" );
+ eFormat = SvxTimeFormat::Standard;
+ break;
+ case SvxTimeFormat::AppDefault :
+ OSL_FAIL( "SvxTimeFormat::AppDefault: not implemented" );
+ eFormat = SvxTimeFormat::Standard;
+ break;
+ default: ;//prevent warning
+ }
+
+ sal_uInt32 nFormatKey;
+
+ switch( eFormat )
+ {
+ case SvxTimeFormat::HH12_MM:
+ nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HHMMAMPM, eLang );
+ break;
+ case SvxTimeFormat::HH12_MM_SS_00:
+ {
+ // no builtin format available, try to insert or reuse
+ OUString aFormatCode( "HH:MM:SS.00 AM/PM" );
+ sal_Int32 nCheckPos;
+ SvNumFormatType nType;
+ rFormatter.PutandConvertEntry( aFormatCode, nCheckPos, nType,
+ nFormatKey, LANGUAGE_ENGLISH_US, eLang, true);
+ DBG_ASSERT( nCheckPos == 0, "SvxTimeFormat::HH12_MM_SS_00: could not insert format code" );
+ if ( nCheckPos )
+ {
+ nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HH_MMSS00, eLang );
+ }
+ break;
+ }
+ case SvxTimeFormat::HH24_MM:
+ nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HHMM, eLang );
+ break;
+ case SvxTimeFormat::HH24_MM_SS_00:
+ nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HH_MMSS00, eLang );
+ break;
+ case SvxTimeFormat::HH12_MM_SS:
+ nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HHMMSSAMPM, eLang );
+ break;
+ case SvxTimeFormat::HH24_MM_SS:
+ nFormatKey = rFormatter.GetFormatIndex( NF_TIME_HHMMSS, eLang );
+ break;
+ case SvxTimeFormat::Standard:
+ default:
+ nFormatKey = rFormatter.GetStandardFormat( SvNumFormatType::TIME, eLang );
+ }
+
+ double fFracTime = aTime.GetTimeInDays();
+ OUString aStr;
+ Color* pColor = nullptr;
+ rFormatter.GetOutputString( fFracTime, nFormatKey, aStr, &pColor );
+ return aStr;
+}
+
+MetaAction* SvxExtTimeField::createBeginComment() const
+{
+ return new MetaCommentAction( "FIELD_SEQ_BEGIN" );
+}
+
+
+// SvxExtFileField
+
+
+SvxExtFileField::SvxExtFileField()
+{
+ eType = SvxFileType::Var;
+ eFormat = SvxFileFormat::PathFull;
+}
+
+
+SvxExtFileField::SvxExtFileField( const OUString& rStr, SvxFileType eT, SvxFileFormat eF )
+{
+ aFile = rStr;
+ eType = eT;
+ eFormat = eF;
+}
+
+
+std::unique_ptr<SvxFieldData> SvxExtFileField::Clone() const
+{
+ return std::make_unique<SvxExtFileField>( *this );
+}
+
+
+bool SvxExtFileField::operator==( const SvxFieldData& rOther ) const
+{
+ if ( typeid(rOther) != typeid(*this) )
+ return false;
+
+ const SvxExtFileField& rOtherFld = static_cast<const SvxExtFileField&>(rOther);
+ return ( ( aFile == rOtherFld.aFile ) &&
+ ( eType == rOtherFld.eType ) &&
+ ( eFormat == rOtherFld.eFormat ) );
+}
+
+
+OUString SvxExtFileField::GetFormatted() const
+{
+ OUString aString;
+
+ INetURLObject aURLObj( aFile );
+
+ if( INetProtocol::NotValid == aURLObj.GetProtocol() )
+ {
+ // invalid? try to interpret string as system file name
+ OUString aURLStr;
+
+ osl::FileBase::getFileURLFromSystemPath( aFile, aURLStr );
+
+ aURLObj.SetURL( aURLStr );
+ }
+
+ // #92009# Be somewhat liberate when trying to
+ // get formatted content out of the FileField
+ if( INetProtocol::NotValid == aURLObj.GetProtocol() )
+ {
+ // still not valid? Then output as is
+ aString = aFile;
+ }
+ else if( INetProtocol::File == aURLObj.GetProtocol() )
+ {
+ switch( eFormat )
+ {
+ case SvxFileFormat::PathFull:
+ aString = aURLObj.getFSysPath(FSysStyle::Detect);
+ break;
+
+ case SvxFileFormat::PathOnly:
+ aURLObj.removeSegment(INetURLObject::LAST_SEGMENT, false);
+ // #101742# Leave trailing slash at the pathname
+ aURLObj.setFinalSlash();
+ aString = aURLObj.getFSysPath(FSysStyle::Detect);
+ break;
+
+ case SvxFileFormat::NameOnly:
+ aString = aURLObj.getBase(INetURLObject::LAST_SEGMENT,true,INetURLObject::DecodeMechanism::Unambiguous);
+ break;
+
+ case SvxFileFormat::NameAndExt:
+ aString = aURLObj.getName(INetURLObject::LAST_SEGMENT,true,INetURLObject::DecodeMechanism::Unambiguous);
+ break;
+ }
+ }
+ else
+ {
+ switch( eFormat )
+ {
+ case SvxFileFormat::PathFull:
+ aString = aURLObj.GetMainURL( INetURLObject::DecodeMechanism::ToIUri );
+ break;
+
+ case SvxFileFormat::PathOnly:
+ aURLObj.removeSegment(INetURLObject::LAST_SEGMENT, false);
+ // #101742# Leave trailing slash at the pathname
+ aURLObj.setFinalSlash();
+ aString = aURLObj.GetMainURL( INetURLObject::DecodeMechanism::ToIUri );
+ break;
+
+ case SvxFileFormat::NameOnly:
+ aString = aURLObj.getBase();
+ break;
+
+ case SvxFileFormat::NameAndExt:
+ aString = aURLObj.getName();
+ break;
+ }
+ }
+
+ return aString;
+}
+
+
+// SvxAuthorField
+
+
+SvxAuthorField::SvxAuthorField( const OUString& rFirstName,
+ const OUString& rLastName,
+ const OUString& rShortName,
+ SvxAuthorType eT, SvxAuthorFormat eF )
+{
+ aName = rLastName;
+ aFirstName = rFirstName;
+ aShortName = rShortName;
+ eType = eT;
+ eFormat = eF;
+}
+
+
+std::unique_ptr<SvxFieldData> SvxAuthorField::Clone() const
+{
+ return std::make_unique<SvxAuthorField>( *this );
+}
+
+
+bool SvxAuthorField::operator==( const SvxFieldData& rOther ) const
+{
+ if ( typeid(rOther) != typeid(*this) )
+ return false;
+
+ const SvxAuthorField& rOtherFld = static_cast<const SvxAuthorField&>(rOther);
+ return ( ( aName == rOtherFld.aName ) &&
+ ( aFirstName == rOtherFld.aFirstName ) &&
+ ( aShortName == rOtherFld.aShortName ) &&
+ ( eType == rOtherFld.eType ) &&
+ ( eFormat == rOtherFld.eFormat ) );
+}
+
+
+OUString SvxAuthorField::GetFormatted() const
+{
+ OUString aString;
+
+ switch( eFormat )
+ {
+ case SvxAuthorFormat::FullName:
+ aString = aFirstName + " " + aName;
+ break;
+ case SvxAuthorFormat::LastName:
+ aString = aName;
+ break;
+
+ case SvxAuthorFormat::FirstName:
+ aString = aFirstName;
+ break;
+
+ case SvxAuthorFormat::ShortName:
+ aString = aShortName;
+ break;
+ }
+
+ return aString;
+}
+
+SvxHeaderField::SvxHeaderField() {}
+
+std::unique_ptr<SvxFieldData> SvxHeaderField::Clone() const
+{
+ return std::make_unique<SvxHeaderField>(); // empty
+}
+
+bool SvxHeaderField::operator==( const SvxFieldData& rCmp ) const
+{
+ return ( dynamic_cast< const SvxHeaderField *>(&rCmp) != nullptr );
+}
+
+SvxFooterField::SvxFooterField() {}
+
+std::unique_ptr<SvxFieldData> SvxFooterField::Clone() const
+{
+ return std::make_unique<SvxFooterField>(); // empty
+}
+
+bool SvxFooterField::operator==( const SvxFieldData& rCmp ) const
+{
+ return ( dynamic_cast< const SvxFooterField *>(&rCmp) != nullptr );
+}
+
+std::unique_ptr<SvxFieldData> SvxDateTimeField::Clone() const
+{
+ return std::make_unique<SvxDateTimeField>(); // empty
+}
+
+bool SvxDateTimeField::operator==( const SvxFieldData& rCmp ) const
+{
+ return ( dynamic_cast< const SvxDateTimeField *>(&rCmp) != nullptr );
+}
+
+SvxDateTimeField::SvxDateTimeField() {}
+
+OUString SvxDateTimeField::GetFormatted(
+ Date const & rDate, tools::Time const & rTime,
+ SvxDateFormat eDateFormat, SvxTimeFormat eTimeFormat,
+ SvNumberFormatter& rFormatter, LanguageType eLanguage )
+{
+ OUString aRet;
+
+ if(eDateFormat != SvxDateFormat::AppDefault)
+ {
+ aRet = SvxDateField::GetFormatted( rDate, eDateFormat, rFormatter, eLanguage );
+ }
+
+ if(eTimeFormat != SvxTimeFormat::AppDefault)
+ {
+ OUStringBuffer aBuf(aRet);
+
+ if (!aRet.isEmpty())
+ aBuf.append(' ');
+
+ aBuf.append(
+ SvxExtTimeField::GetFormatted(rTime, eTimeFormat, rFormatter, eLanguage));
+
+ aRet = aBuf.makeStringAndClear();
+ }
+
+ return aRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/items/frmitems.cxx b/editeng/source/items/frmitems.cxx
new file mode 100644
index 000000000..d931ed6f8
--- /dev/null
+++ b/editeng/source/items/frmitems.cxx
@@ -0,0 +1,3421 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http: // mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http: // www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <memory>
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/drawing/LineStyle.hpp>
+#include <com/sun/star/script/Converter.hpp>
+#include <com/sun/star/table/ShadowLocation.hpp>
+#include <com/sun/star/table/ShadowFormat.hpp>
+#include <com/sun/star/table/BorderLine2.hpp>
+#include <com/sun/star/table/BorderLineStyle.hpp>
+#include <com/sun/star/style/BreakType.hpp>
+#include <com/sun/star/style/GraphicLocation.hpp>
+#include <com/sun/star/awt/Size.hpp>
+#include <com/sun/star/text/WritingMode2.hpp>
+#include <com/sun/star/frame/status/UpperLowerMarginScale.hpp>
+#include <com/sun/star/frame/status/LeftRightMarginScale.hpp>
+#include <com/sun/star/drawing/ShadingPattern.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+
+#include <osl/diagnose.h>
+#include <sal/log.hxx>
+#include <i18nutil/unicode.hxx>
+#include <unotools/ucbstreamhelper.hxx>
+#include <comphelper/processfactory.hxx>
+#include <vcl/GraphicObject.hxx>
+#include <tools/urlobj.hxx>
+#include <svl/memberid.h>
+#include <rtl/math.hxx>
+#include <rtl/ustring.hxx>
+#include <tools/mapunit.hxx>
+#include <vcl/graphicfilter.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/svapp.hxx>
+#include <editeng/editrids.hrc>
+#include <editeng/pbinitem.hxx>
+#include <editeng/sizeitem.hxx>
+#include <editeng/lrspitem.hxx>
+#include <editeng/ulspitem.hxx>
+#include <editeng/prntitem.hxx>
+#include <editeng/opaqitem.hxx>
+#include <editeng/protitem.hxx>
+#include <editeng/shaditem.hxx>
+#include <editeng/borderline.hxx>
+#include <editeng/boxitem.hxx>
+#include <editeng/formatbreakitem.hxx>
+#include <editeng/keepitem.hxx>
+#include <editeng/lineitem.hxx>
+#include <editeng/brushitem.hxx>
+#include <editeng/frmdiritem.hxx>
+#include <editeng/itemtype.hxx>
+#include <editeng/eerdll.hxx>
+#include <editeng/memberids.h>
+#include <libxml/xmlwriter.h>
+#include <o3tl/enumrange.hxx>
+#include <o3tl/safeint.hxx>
+#include <vcl/GraphicLoader.hxx>
+
+#include <boost/property_tree/ptree.hpp>
+
+using namespace ::editeng;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::table::BorderLineStyle;
+
+
+SfxPoolItem* SvxPaperBinItem::CreateDefault() { return new SvxPaperBinItem(0);}
+SfxPoolItem* SvxSizeItem::CreateDefault() { return new SvxSizeItem(0);}
+SfxPoolItem* SvxLRSpaceItem::CreateDefault() { return new SvxLRSpaceItem(0);}
+SfxPoolItem* SvxULSpaceItem::CreateDefault() { return new SvxULSpaceItem(0);}
+SfxPoolItem* SvxProtectItem::CreateDefault() { return new SvxProtectItem(0);}
+SfxPoolItem* SvxBrushItem::CreateDefault() { return new SvxBrushItem(0);}
+SfxPoolItem* SvxShadowItem::CreateDefault() { return new SvxShadowItem(0);}
+SfxPoolItem* SvxBoxItem::CreateDefault() { return new SvxBoxItem(0);}
+SfxPoolItem* SvxBoxInfoItem::CreateDefault() { return new SvxBoxInfoItem(0);}
+SfxPoolItem* SvxFormatBreakItem::CreateDefault() { return new SvxFormatBreakItem(SvxBreak::NONE, 0);}
+SfxPoolItem* SvxFormatKeepItem::CreateDefault() { return new SvxFormatKeepItem(false, 0);}
+SfxPoolItem* SvxLineItem::CreateDefault() { return new SvxLineItem(0);}
+
+SvxPaperBinItem* SvxPaperBinItem::Clone( SfxItemPool* ) const
+{
+ return new SvxPaperBinItem( *this );
+}
+
+bool SvxPaperBinItem::GetPresentation
+(
+ SfxItemPresentation ePres,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper&
+) const
+{
+ switch ( ePres )
+ {
+ case SfxItemPresentation::Nameless:
+ rText = OUString::number( GetValue() );
+ return true;
+
+ case SfxItemPresentation::Complete:
+ {
+ sal_uInt8 nValue = GetValue();
+
+ if ( PAPERBIN_PRINTER_SETTINGS == nValue )
+ rText = EditResId(RID_SVXSTR_PAPERBIN_SETTINGS);
+ else
+ {
+ rText = EditResId(RID_SVXSTR_PAPERBIN) + " " + OUString::number( nValue );
+ }
+ return true;
+ }
+ //no break necessary
+ default: ; //prevent warning
+ }
+
+ return false;
+}
+
+
+SvxSizeItem::SvxSizeItem( const sal_uInt16 nId, const Size& rSize ) :
+
+ SfxPoolItem( nId ),
+
+ m_aSize( rSize )
+{
+}
+
+
+bool SvxSizeItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
+ nMemberId &= ~CONVERT_TWIPS;
+
+ awt::Size aTmp(m_aSize.Width(), m_aSize.Height());
+ if( bConvert )
+ {
+ aTmp.Height = convertTwipToMm100(aTmp.Height);
+ aTmp.Width = convertTwipToMm100(aTmp.Width);
+ }
+
+ switch( nMemberId )
+ {
+ case MID_SIZE_SIZE: rVal <<= aTmp; break;
+ case MID_SIZE_WIDTH: rVal <<= aTmp.Width; break;
+ case MID_SIZE_HEIGHT: rVal <<= aTmp.Height; break;
+ default: OSL_FAIL("Wrong MemberId!"); return false;
+ }
+
+ return true;
+}
+
+
+bool SvxSizeItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
+ nMemberId &= ~CONVERT_TWIPS;
+
+ switch( nMemberId )
+ {
+ case MID_SIZE_SIZE:
+ {
+ awt::Size aTmp;
+ if( rVal >>= aTmp )
+ {
+ if(bConvert)
+ {
+ aTmp.Height = convertMm100ToTwip(aTmp.Height);
+ aTmp.Width = convertMm100ToTwip(aTmp.Width);
+ }
+ m_aSize = Size( aTmp.Width, aTmp.Height );
+ }
+ else
+ {
+ return false;
+ }
+ }
+ break;
+ case MID_SIZE_WIDTH:
+ {
+ sal_Int32 nVal = 0;
+ if(!(rVal >>= nVal ))
+ return false;
+
+ m_aSize.setWidth( bConvert ? convertMm100ToTwip(nVal) : nVal );
+ }
+ break;
+ case MID_SIZE_HEIGHT:
+ {
+ sal_Int32 nVal = 0;
+ if(!(rVal >>= nVal))
+ return true;
+
+ m_aSize.setHeight( bConvert ? convertMm100ToTwip(nVal) : nVal );
+ }
+ break;
+ default: OSL_FAIL("Wrong MemberId!");
+ return false;
+ }
+ return true;
+}
+
+
+SvxSizeItem::SvxSizeItem( const sal_uInt16 nId ) :
+
+ SfxPoolItem( nId )
+{
+}
+
+
+bool SvxSizeItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ assert(SfxPoolItem::operator==(rAttr));
+
+ return ( m_aSize == static_cast<const SvxSizeItem&>( rAttr ).GetSize() );
+}
+
+SvxSizeItem* SvxSizeItem::Clone( SfxItemPool* ) const
+{
+ return new SvxSizeItem( *this );
+}
+
+bool SvxSizeItem::GetPresentation
+(
+ SfxItemPresentation ePres,
+ MapUnit eCoreUnit,
+ MapUnit ePresUnit,
+ OUString& rText, const IntlWrapper& rIntl
+) const
+{
+ OUString cpDelimTmp(cpDelim);
+ switch ( ePres )
+ {
+ case SfxItemPresentation::Nameless:
+ rText = GetMetricText( m_aSize.Width(), eCoreUnit, ePresUnit, &rIntl ) +
+ cpDelimTmp +
+ GetMetricText( m_aSize.Height(), eCoreUnit, ePresUnit, &rIntl );
+ return true;
+
+ case SfxItemPresentation::Complete:
+ rText = EditResId(RID_SVXITEMS_SIZE_WIDTH) +
+ GetMetricText( m_aSize.Width(), eCoreUnit, ePresUnit, &rIntl ) +
+ " " + EditResId(GetMetricId(ePresUnit)) +
+ cpDelimTmp +
+ EditResId(RID_SVXITEMS_SIZE_HEIGHT) +
+ GetMetricText( m_aSize.Height(), eCoreUnit, ePresUnit, &rIntl ) +
+ " " + EditResId(GetMetricId(ePresUnit));
+ return true;
+ // no break necessary
+ default: ; // prevent warning
+
+ }
+ return false;
+}
+
+
+void SvxSizeItem::ScaleMetrics( long nMult, long nDiv )
+{
+ m_aSize.setWidth( Scale( m_aSize.Width(), nMult, nDiv ) );
+ m_aSize.setHeight( Scale( m_aSize.Height(), nMult, nDiv ) );
+}
+
+
+bool SvxSizeItem::HasMetrics() const
+{
+ return true;
+}
+
+
+SvxLRSpaceItem::SvxLRSpaceItem( const sal_uInt16 nId ) :
+
+ SfxPoolItem( nId ),
+
+ nTxtLeft ( 0 ),
+ nLeftMargin ( 0 ),
+ nRightMargin ( 0 ),
+ nPropFirstLineOffset( 100 ),
+ nPropLeftMargin( 100 ),
+ nPropRightMargin( 100 ),
+ nFirstLineOffset ( 0 ),
+ bAutoFirst ( false ),
+ bExplicitZeroMarginValRight(false),
+ bExplicitZeroMarginValLeft(false)
+{
+}
+
+
+SvxLRSpaceItem::SvxLRSpaceItem( const long nLeft, const long nRight,
+ const long nTLeft, const short nOfset,
+ const sal_uInt16 nId )
+: SfxPoolItem( nId ),
+
+ nTxtLeft ( nTLeft ),
+ nLeftMargin ( nLeft ),
+ nRightMargin ( nRight ),
+ nPropFirstLineOffset( 100 ),
+ nPropLeftMargin( 100 ),
+ nPropRightMargin( 100 ),
+ nFirstLineOffset ( nOfset ),
+ bAutoFirst ( false ),
+ bExplicitZeroMarginValRight(false),
+ bExplicitZeroMarginValLeft(false)
+{
+}
+
+
+bool SvxLRSpaceItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ bool bRet = true;
+ bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
+ nMemberId &= ~CONVERT_TWIPS;
+ switch( nMemberId )
+ {
+ // now all signed
+ case 0:
+ {
+ css::frame::status::LeftRightMarginScale aLRSpace;
+ aLRSpace.Left = static_cast<sal_Int32>(bConvert ? convertTwipToMm100(nLeftMargin) : nLeftMargin);
+ aLRSpace.TextLeft = static_cast<sal_Int32>(bConvert ? convertTwipToMm100(nTxtLeft) : nTxtLeft);
+ aLRSpace.Right = static_cast<sal_Int32>(bConvert ? convertTwipToMm100(nRightMargin) : nRightMargin);
+ aLRSpace.ScaleLeft = static_cast<sal_Int16>(nPropLeftMargin);
+ aLRSpace.ScaleRight = static_cast<sal_Int16>(nPropRightMargin);
+ aLRSpace.FirstLine = static_cast<sal_Int32>(bConvert ? convertTwipToMm100(nFirstLineOffset) : nFirstLineOffset);
+ aLRSpace.ScaleFirstLine = static_cast<sal_Int16>(nPropFirstLineOffset);
+ aLRSpace.AutoFirstLine = IsAutoFirst();
+ rVal <<= aLRSpace;
+ break;
+ }
+ case MID_L_MARGIN:
+ rVal <<= static_cast<sal_Int32>(bConvert ? convertTwipToMm100(nLeftMargin) : nLeftMargin);
+ break;
+
+ case MID_TXT_LMARGIN :
+ rVal <<= static_cast<sal_Int32>(bConvert ? convertTwipToMm100(nTxtLeft) : nTxtLeft);
+ break;
+ case MID_R_MARGIN:
+ rVal <<= static_cast<sal_Int32>(bConvert ? convertTwipToMm100(nRightMargin) : nRightMargin);
+ break;
+ case MID_L_REL_MARGIN:
+ rVal <<= static_cast<sal_Int16>(nPropLeftMargin);
+ break;
+ case MID_R_REL_MARGIN:
+ rVal <<= static_cast<sal_Int16>(nPropRightMargin);
+ break;
+
+ case MID_FIRST_LINE_INDENT:
+ rVal <<= static_cast<sal_Int32>(bConvert ? convertTwipToMm100(nFirstLineOffset) : nFirstLineOffset);
+ break;
+
+ case MID_FIRST_LINE_REL_INDENT:
+ rVal <<= static_cast<sal_Int16>(nPropFirstLineOffset);
+ break;
+
+ case MID_FIRST_AUTO:
+ rVal <<= IsAutoFirst();
+ break;
+
+ default:
+ bRet = false;
+ // SfxDispatchController_Impl::StateChanged calls this with hardcoded 0 triggering this; there used to be a MID_LR_MARGIN 0 but what type would it have?
+ OSL_FAIL("unknown MemberId");
+ }
+ return bRet;
+}
+
+
+bool SvxLRSpaceItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ bool bConvert = 0 != (nMemberId&CONVERT_TWIPS);
+ nMemberId &= ~CONVERT_TWIPS;
+ sal_Int32 nVal = 0;
+ if( nMemberId != 0 && nMemberId != MID_FIRST_AUTO &&
+ nMemberId != MID_L_REL_MARGIN && nMemberId != MID_R_REL_MARGIN)
+ if(!(rVal >>= nVal))
+ return false;
+
+ switch( nMemberId )
+ {
+ case 0:
+ {
+ css::frame::status::LeftRightMarginScale aLRSpace;
+ if(!(rVal >>= aLRSpace))
+ return false;
+
+ SetLeft( bConvert ? convertMm100ToTwip(aLRSpace.Left) : aLRSpace.Left );
+ SetTextLeft( bConvert ? convertMm100ToTwip(aLRSpace.TextLeft) : aLRSpace.TextLeft );
+ SetRight(bConvert ? convertMm100ToTwip(aLRSpace.Right) : aLRSpace.Right);
+ nPropLeftMargin = aLRSpace.ScaleLeft;
+ nPropRightMargin = aLRSpace.ScaleRight;
+ SetTextFirstLineOffset(static_cast<short>(bConvert ? convertMm100ToTwip(aLRSpace.FirstLine) : aLRSpace.FirstLine));
+ SetPropTextFirstLineOffset ( static_cast<sal_uInt16>(aLRSpace.ScaleFirstLine) );
+ SetAutoFirst( aLRSpace.AutoFirstLine );
+ break;
+ }
+ case MID_L_MARGIN:
+ SetLeft( bConvert ? convertMm100ToTwip(nVal) : nVal );
+ break;
+
+ case MID_TXT_LMARGIN :
+ SetTextLeft( bConvert ? convertMm100ToTwip(nVal) : nVal );
+ break;
+
+ case MID_R_MARGIN:
+ SetRight(bConvert ? convertMm100ToTwip(nVal) : nVal);
+ break;
+ case MID_L_REL_MARGIN:
+ case MID_R_REL_MARGIN:
+ {
+ sal_Int32 nRel = 0;
+ if((rVal >>= nRel) && nRel >= 0 && nRel < SAL_MAX_UINT16)
+ {
+ if(MID_L_REL_MARGIN== nMemberId)
+ nPropLeftMargin = static_cast<sal_uInt16>(nRel);
+ else
+ nPropRightMargin = static_cast<sal_uInt16>(nRel);
+ }
+ else
+ return false;
+ }
+ break;
+ case MID_FIRST_LINE_INDENT :
+ SetTextFirstLineOffset(static_cast<short>(bConvert ? convertMm100ToTwip(nVal) : nVal));
+ break;
+
+ case MID_FIRST_LINE_REL_INDENT:
+ SetPropTextFirstLineOffset ( static_cast<sal_uInt16>(nVal) );
+ break;
+
+ case MID_FIRST_AUTO:
+ SetAutoFirst( Any2Bool(rVal) );
+ break;
+
+ default:
+ OSL_FAIL("unknown MemberId");
+ return false;
+ }
+ return true;
+}
+
+
+/// Adapt nLeftMargin and nTxtLeft.
+void SvxLRSpaceItem::AdjustLeft()
+{
+ if ( 0 > nFirstLineOffset )
+ nLeftMargin = nTxtLeft + nFirstLineOffset;
+ else
+ nLeftMargin = nTxtLeft;
+}
+
+
+bool SvxLRSpaceItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ assert(SfxPoolItem::operator==(rAttr));
+
+ const SvxLRSpaceItem& rOther = static_cast<const SvxLRSpaceItem&>(rAttr);
+
+ return (
+ nFirstLineOffset == rOther.GetTextFirstLineOffset() &&
+ nTxtLeft == rOther.GetTextLeft() &&
+ nLeftMargin == rOther.GetLeft() &&
+ nRightMargin == rOther.GetRight() &&
+ nPropFirstLineOffset == rOther.GetPropTextFirstLineOffset() &&
+ nPropLeftMargin == rOther.GetPropLeft() &&
+ nPropRightMargin == rOther.GetPropRight() &&
+ bAutoFirst == rOther.IsAutoFirst() &&
+ bExplicitZeroMarginValRight == rOther.IsExplicitZeroMarginValRight() &&
+ bExplicitZeroMarginValLeft == rOther.IsExplicitZeroMarginValLeft() );
+}
+
+SvxLRSpaceItem* SvxLRSpaceItem::Clone( SfxItemPool* ) const
+{
+ return new SvxLRSpaceItem( *this );
+}
+
+bool SvxLRSpaceItem::GetPresentation
+(
+ SfxItemPresentation ePres,
+ MapUnit eCoreUnit,
+ MapUnit ePresUnit,
+ OUString& rText, const IntlWrapper& rIntl
+) const
+{
+ switch ( ePres )
+ {
+ case SfxItemPresentation::Nameless:
+ {
+ if ( 100 != nPropLeftMargin )
+ {
+ rText = unicode::formatPercent(nPropLeftMargin,
+ Application::GetSettings().GetUILanguageTag());
+ }
+ else
+ rText = GetMetricText( nLeftMargin,
+ eCoreUnit, ePresUnit, &rIntl );
+ rText += OUString(cpDelim);
+ if ( 100 != nPropFirstLineOffset )
+ {
+ rText += unicode::formatPercent(nPropFirstLineOffset,
+ Application::GetSettings().GetUILanguageTag());
+ }
+ else
+ rText += GetMetricText( static_cast<long>(nFirstLineOffset),
+ eCoreUnit, ePresUnit, &rIntl );
+ rText += OUString(cpDelim);
+ if ( 100 != nRightMargin )
+ {
+ rText += unicode::formatPercent(nRightMargin,
+ Application::GetSettings().GetUILanguageTag());
+ }
+ else
+ rText += GetMetricText( nRightMargin,
+ eCoreUnit, ePresUnit, &rIntl );
+ return true;
+ }
+ case SfxItemPresentation::Complete:
+ {
+ rText = EditResId(RID_SVXITEMS_LRSPACE_LEFT);
+ if ( 100 != nPropLeftMargin )
+ rText += unicode::formatPercent(nPropLeftMargin,
+ Application::GetSettings().GetUILanguageTag());
+ else
+ {
+ rText += GetMetricText( nLeftMargin, eCoreUnit, ePresUnit, &rIntl ) +
+ " " + EditResId(GetMetricId(ePresUnit));
+ }
+ rText += OUString(cpDelim);
+ if ( 100 != nPropFirstLineOffset || nFirstLineOffset )
+ {
+ rText += EditResId(RID_SVXITEMS_LRSPACE_FLINE);
+ if ( 100 != nPropFirstLineOffset )
+ rText += unicode::formatPercent(nPropFirstLineOffset,
+ Application::GetSettings().GetUILanguageTag());
+ else
+ {
+ rText += GetMetricText( static_cast<long>(nFirstLineOffset),
+ eCoreUnit, ePresUnit, &rIntl ) +
+ " " + EditResId(GetMetricId(ePresUnit));
+ }
+ rText += OUString(cpDelim);
+ }
+ rText += EditResId(RID_SVXITEMS_LRSPACE_RIGHT);
+ if ( 100 != nPropRightMargin )
+ rText += unicode::formatPercent(nPropRightMargin,
+ Application::GetSettings().GetUILanguageTag());
+ else
+ {
+ rText += GetMetricText( nRightMargin,
+ eCoreUnit, ePresUnit, &rIntl ) +
+ " " + EditResId(GetMetricId(ePresUnit));
+ }
+ return true;
+ }
+ default: ; // prevent warning
+ }
+ return false;
+}
+
+
+void SvxLRSpaceItem::ScaleMetrics( long nMult, long nDiv )
+{
+ nFirstLineOffset = static_cast<short>(Scale( nFirstLineOffset, nMult, nDiv ));
+ nTxtLeft = Scale( nTxtLeft, nMult, nDiv );
+ nLeftMargin = Scale( nLeftMargin, nMult, nDiv );
+ nRightMargin = Scale( nRightMargin, nMult, nDiv );
+}
+
+
+bool SvxLRSpaceItem::HasMetrics() const
+{
+ return true;
+}
+
+
+void SvxLRSpaceItem::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+ xmlTextWriterStartElement(pWriter, BAD_CAST("SvxLRSpaceItem"));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nFirstLineOffset"), BAD_CAST(OString::number(nFirstLineOffset).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nTxtLeft"), BAD_CAST(OString::number(nTxtLeft).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nLeftMargin"), BAD_CAST(OString::number(nLeftMargin).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nRightMargin"), BAD_CAST(OString::number(nRightMargin).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPropFirstLineOffset"), BAD_CAST(OString::number(nPropFirstLineOffset).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPropLeftMargin"), BAD_CAST(OString::number(nPropLeftMargin).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPropRightMargin"), BAD_CAST(OString::number(nPropRightMargin).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bAutoFirst"), BAD_CAST(OString::number(int(bAutoFirst)).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bExplicitZeroMarginValRight"), BAD_CAST(OString::number(int(bExplicitZeroMarginValRight)).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bExplicitZeroMarginValLeft"), BAD_CAST(OString::number(int(bExplicitZeroMarginValLeft)).getStr()));
+ xmlTextWriterEndElement(pWriter);
+}
+
+
+boost::property_tree::ptree SvxLRSpaceItem::dumpAsJSON() const
+{
+ boost::property_tree::ptree aTree = SfxPoolItem::dumpAsJSON();
+
+ boost::property_tree::ptree aState;
+
+ MapUnit eTargetUnit = MapUnit::MapInch;
+
+ OUString sLeft = GetMetricText(GetLeft(),
+ MapUnit::MapTwip, eTargetUnit, nullptr);
+
+ OUString sRight = GetMetricText(GetRight(),
+ MapUnit::MapTwip, eTargetUnit, nullptr);
+
+ OUString sFirstline = GetMetricText(GetTextFirstLineOffset(),
+ MapUnit::MapTwip, eTargetUnit, nullptr);
+
+ aState.put("left", sLeft);
+ aState.put("right", sRight);
+ aState.put("firstline", sFirstline);
+ aState.put("unit", "inch");
+
+ aTree.push_back(std::make_pair("state", aState));
+
+ return aTree;
+}
+
+
+SvxULSpaceItem::SvxULSpaceItem( const sal_uInt16 nId )
+ : SfxPoolItem(nId)
+ , nUpper(0)
+ , nLower(0)
+ , bContext(false)
+ , nPropUpper(100)
+ , nPropLower(100)
+{
+}
+
+
+SvxULSpaceItem::SvxULSpaceItem( const sal_uInt16 nUp, const sal_uInt16 nLow,
+ const sal_uInt16 nId )
+ : SfxPoolItem(nId)
+ , nUpper(nUp)
+ , nLower(nLow)
+ , bContext(false)
+ , nPropUpper(100)
+ , nPropLower(100)
+{
+}
+
+
+bool SvxULSpaceItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
+ nMemberId &= ~CONVERT_TWIPS;
+ switch( nMemberId )
+ {
+ // now all signed
+ case 0:
+ {
+ css::frame::status::UpperLowerMarginScale aUpperLowerMarginScale;
+ aUpperLowerMarginScale.Upper = static_cast<sal_Int32>(bConvert ? convertTwipToMm100(nUpper) : nUpper);
+ aUpperLowerMarginScale.Lower = static_cast<sal_Int32>(bConvert ? convertTwipToMm100(nLower) : nPropUpper);
+ aUpperLowerMarginScale.ScaleUpper = static_cast<sal_Int16>(nPropUpper);
+ aUpperLowerMarginScale.ScaleLower = static_cast<sal_Int16>(nPropLower);
+ rVal <<= aUpperLowerMarginScale;
+ break;
+ }
+ case MID_UP_MARGIN: rVal <<= static_cast<sal_Int32>(bConvert ? convertTwipToMm100(nUpper) : nUpper); break;
+ case MID_LO_MARGIN: rVal <<= static_cast<sal_Int32>(bConvert ? convertTwipToMm100(nLower) : nLower); break;
+ case MID_CTX_MARGIN: rVal <<= bContext; break;
+ case MID_UP_REL_MARGIN: rVal <<= static_cast<sal_Int16>(nPropUpper); break;
+ case MID_LO_REL_MARGIN: rVal <<= static_cast<sal_Int16>(nPropLower); break;
+ }
+ return true;
+}
+
+
+bool SvxULSpaceItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
+ nMemberId &= ~CONVERT_TWIPS;
+ sal_Int32 nVal = 0;
+ bool bVal = false;
+ switch( nMemberId )
+ {
+ case 0:
+ {
+ css::frame::status::UpperLowerMarginScale aUpperLowerMarginScale;
+ if ( !(rVal >>= aUpperLowerMarginScale ))
+ return false;
+ {
+ SetUpper(static_cast<sal_uInt16>(bConvert ? convertMm100ToTwip( aUpperLowerMarginScale.Upper ) : aUpperLowerMarginScale.Upper));
+ SetLower(static_cast<sal_uInt16>(bConvert ? convertMm100ToTwip( aUpperLowerMarginScale.Lower ) : aUpperLowerMarginScale.Lower));
+ if( aUpperLowerMarginScale.ScaleUpper > 1 )
+ nPropUpper = aUpperLowerMarginScale.ScaleUpper;
+ if( aUpperLowerMarginScale.ScaleLower > 1 )
+ nPropUpper = aUpperLowerMarginScale.ScaleLower;
+ }
+ }
+ break;
+ case MID_UP_MARGIN :
+ if(!(rVal >>= nVal) || nVal < 0)
+ return false;
+ SetUpper(static_cast<sal_uInt16>(bConvert ? convertMm100ToTwip(nVal) : nVal));
+ break;
+ case MID_LO_MARGIN :
+ if(!(rVal >>= nVal) || nVal < 0)
+ return false;
+ SetLower(static_cast<sal_uInt16>(bConvert ? convertMm100ToTwip(nVal) : nVal));
+ break;
+ case MID_CTX_MARGIN :
+ if (!(rVal >>= bVal))
+ return false;
+ SetContextValue(bVal);
+ break;
+ case MID_UP_REL_MARGIN:
+ case MID_LO_REL_MARGIN:
+ {
+ sal_Int32 nRel = 0;
+ if((rVal >>= nRel) && nRel > 1 )
+ {
+ if(MID_UP_REL_MARGIN == nMemberId)
+ nPropUpper = static_cast<sal_uInt16>(nRel);
+ else
+ nPropLower = static_cast<sal_uInt16>(nRel);
+ }
+ else
+ return false;
+ }
+ break;
+
+ default:
+ OSL_FAIL("unknown MemberId");
+ return false;
+ }
+ return true;
+}
+
+
+bool SvxULSpaceItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ assert(SfxPoolItem::operator==(rAttr));
+
+ const SvxULSpaceItem& rSpaceItem = static_cast<const SvxULSpaceItem&>( rAttr );
+ return ( nUpper == rSpaceItem.nUpper &&
+ nLower == rSpaceItem.nLower &&
+ bContext == rSpaceItem.bContext &&
+ nPropUpper == rSpaceItem.nPropUpper &&
+ nPropLower == rSpaceItem.nPropLower );
+}
+
+SvxULSpaceItem* SvxULSpaceItem::Clone( SfxItemPool* ) const
+{
+ return new SvxULSpaceItem( *this );
+}
+
+bool SvxULSpaceItem::GetPresentation
+(
+ SfxItemPresentation ePres,
+ MapUnit eCoreUnit,
+ MapUnit ePresUnit,
+ OUString& rText,
+ const IntlWrapper& rIntl
+) const
+{
+ switch ( ePres )
+ {
+ case SfxItemPresentation::Nameless:
+ {
+ if ( 100 != nPropUpper )
+ {
+ rText = unicode::formatPercent(nPropUpper,
+ Application::GetSettings().GetUILanguageTag());
+ }
+ else
+ rText = GetMetricText( static_cast<long>(nUpper), eCoreUnit, ePresUnit, &rIntl );
+ rText += OUString(cpDelim);
+ if ( 100 != nPropLower )
+ {
+ rText += unicode::formatPercent(nPropLower,
+ Application::GetSettings().GetUILanguageTag());
+ }
+ else
+ rText += GetMetricText( static_cast<long>(nLower), eCoreUnit, ePresUnit, &rIntl );
+ return true;
+ }
+ case SfxItemPresentation::Complete:
+ {
+ rText = EditResId(RID_SVXITEMS_ULSPACE_UPPER);
+ if ( 100 != nPropUpper )
+ {
+ rText += unicode::formatPercent(nPropUpper,
+ Application::GetSettings().GetUILanguageTag());
+ }
+ else
+ {
+ rText += GetMetricText( static_cast<long>(nUpper), eCoreUnit, ePresUnit, &rIntl ) +
+ " " + EditResId(GetMetricId(ePresUnit));
+ }
+ rText += cpDelim + EditResId(RID_SVXITEMS_ULSPACE_LOWER);
+ if ( 100 != nPropLower )
+ {
+ rText += unicode::formatPercent(nPropLower,
+ Application::GetSettings().GetUILanguageTag());
+ }
+ else
+ {
+ rText += GetMetricText( static_cast<long>(nLower), eCoreUnit, ePresUnit, &rIntl ) +
+ " " + EditResId(GetMetricId(ePresUnit));
+ }
+ return true;
+ }
+ default: ; // prevent warning
+ }
+ return false;
+}
+
+
+void SvxULSpaceItem::ScaleMetrics( long nMult, long nDiv )
+{
+ nUpper = static_cast<sal_uInt16>(Scale( nUpper, nMult, nDiv ));
+ nLower = static_cast<sal_uInt16>(Scale( nLower, nMult, nDiv ));
+}
+
+
+bool SvxULSpaceItem::HasMetrics() const
+{
+ return true;
+}
+
+
+void SvxULSpaceItem::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+ xmlTextWriterStartElement(pWriter, BAD_CAST("SvxULSpaceItem"));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nUpper"), BAD_CAST(OString::number(nUpper).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nLower"), BAD_CAST(OString::number(nLower).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("bContext"), BAD_CAST(OString::boolean(bContext).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPropUpper"), BAD_CAST(OString::number(nPropUpper).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nPropLower"), BAD_CAST(OString::number(nPropLower).getStr()));
+ xmlTextWriterEndElement(pWriter);
+}
+
+boost::property_tree::ptree SvxULSpaceItem::dumpAsJSON() const
+{
+ boost::property_tree::ptree aTree = SfxPoolItem::dumpAsJSON();
+
+ boost::property_tree::ptree aState;
+
+ MapUnit eTargetUnit = MapUnit::MapInch;
+
+ OUString sUpper = GetMetricText(GetUpper(),
+ MapUnit::MapTwip, eTargetUnit, nullptr);
+
+ OUString sLower = GetMetricText(GetLower(),
+ MapUnit::MapTwip, eTargetUnit, nullptr);
+
+ aState.put("upper", sUpper);
+ aState.put("lower", sLower);
+ aState.put("unit", "inch");
+
+ aTree.push_back(std::make_pair("state", aState));
+
+ return aTree;
+}
+
+SvxPrintItem* SvxPrintItem::Clone( SfxItemPool* ) const
+{
+ return new SvxPrintItem( *this );
+}
+
+bool SvxPrintItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper&
+) const
+{
+ const char* pId = RID_SVXITEMS_PRINT_FALSE;
+
+ if ( GetValue() )
+ pId = RID_SVXITEMS_PRINT_TRUE;
+ rText = EditResId(pId);
+ return true;
+}
+
+SvxOpaqueItem* SvxOpaqueItem::Clone( SfxItemPool* ) const
+{
+ return new SvxOpaqueItem( *this );
+}
+
+bool SvxOpaqueItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper&
+) const
+{
+ const char* pId = RID_SVXITEMS_OPAQUE_FALSE;
+
+ if ( GetValue() )
+ pId = RID_SVXITEMS_OPAQUE_TRUE;
+ rText = EditResId(pId);
+ return true;
+}
+
+
+bool SvxProtectItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ assert(SfxPoolItem::operator==(rAttr));
+
+ const SvxProtectItem& rItem = static_cast<const SvxProtectItem&>(rAttr);
+ return ( bCntnt == rItem.bCntnt &&
+ bSize == rItem.bSize &&
+ bPos == rItem.bPos );
+}
+
+
+bool SvxProtectItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ bool bValue;
+ switch(nMemberId)
+ {
+ case MID_PROTECT_CONTENT : bValue = bCntnt; break;
+ case MID_PROTECT_SIZE : bValue = bSize; break;
+ case MID_PROTECT_POSITION: bValue = bPos; break;
+ default:
+ OSL_FAIL("Wrong MemberId");
+ return false;
+ }
+
+ rVal <<= bValue;
+ return true;
+}
+
+
+bool SvxProtectItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ bool bVal( Any2Bool(rVal) );
+ switch(nMemberId)
+ {
+ case MID_PROTECT_CONTENT : bCntnt = bVal; break;
+ case MID_PROTECT_SIZE : bSize = bVal; break;
+ case MID_PROTECT_POSITION: bPos = bVal; break;
+ default:
+ OSL_FAIL("Wrong MemberId");
+ return false;
+ }
+ return true;
+}
+
+SvxProtectItem* SvxProtectItem::Clone( SfxItemPool* ) const
+{
+ return new SvxProtectItem( *this );
+}
+
+bool SvxProtectItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper&
+) const
+{
+ const char* pId = RID_SVXITEMS_PROT_CONTENT_FALSE;
+
+ if ( bCntnt )
+ pId = RID_SVXITEMS_PROT_CONTENT_TRUE;
+ rText = EditResId(pId) + cpDelim;
+ pId = RID_SVXITEMS_PROT_SIZE_FALSE;
+
+ if ( bSize )
+ pId = RID_SVXITEMS_PROT_SIZE_TRUE;
+ rText += EditResId(pId) + cpDelim;
+ pId = RID_SVXITEMS_PROT_POS_FALSE;
+
+ if ( bPos )
+ pId = RID_SVXITEMS_PROT_POS_TRUE;
+ rText += EditResId(pId);
+ return true;
+}
+
+
+void SvxProtectItem::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+ xmlTextWriterStartElement(pWriter, BAD_CAST("SvxProtectItem"));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("content"), BAD_CAST(OString::boolean(bCntnt).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("size"), BAD_CAST(OString::boolean(bSize).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("position"), BAD_CAST(OString::boolean(bPos).getStr()));
+ xmlTextWriterEndElement(pWriter);
+}
+
+
+SvxShadowItem::SvxShadowItem( const sal_uInt16 nId,
+ const Color *pColor, const sal_uInt16 nW,
+ const SvxShadowLocation eLoc ) :
+ SfxEnumItemInterface( nId ),
+ aShadowColor(COL_GRAY),
+ nWidth ( nW ),
+ eLocation ( eLoc )
+{
+ if ( pColor )
+ aShadowColor = *pColor;
+}
+
+
+bool SvxShadowItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
+ nMemberId &= ~CONVERT_TWIPS;
+
+ table::ShadowFormat aShadow;
+ table::ShadowLocation eSet = table::ShadowLocation_NONE;
+ switch( eLocation )
+ {
+ case SvxShadowLocation::TopLeft : eSet = table::ShadowLocation_TOP_LEFT ; break;
+ case SvxShadowLocation::TopRight : eSet = table::ShadowLocation_TOP_RIGHT ; break;
+ case SvxShadowLocation::BottomLeft : eSet = table::ShadowLocation_BOTTOM_LEFT ; break;
+ case SvxShadowLocation::BottomRight: eSet = table::ShadowLocation_BOTTOM_RIGHT; break;
+ default: ; // prevent warning
+ }
+ aShadow.Location = eSet;
+ aShadow.ShadowWidth = bConvert ? convertTwipToMm100(nWidth) : nWidth;
+ aShadow.IsTransparent = aShadowColor.GetTransparency() > 0;
+ aShadow.Color = sal_Int32(aShadowColor);
+
+ sal_Int8 nTransparence = rtl::math::round(float(aShadowColor.GetTransparency() * 100) / 255);
+
+ switch ( nMemberId )
+ {
+ case MID_LOCATION: rVal <<= aShadow.Location; break;
+ case MID_WIDTH: rVal <<= aShadow.ShadowWidth; break;
+ case MID_TRANSPARENT: rVal <<= aShadow.IsTransparent; break;
+ case MID_BG_COLOR: rVal <<= aShadow.Color; break;
+ case 0: rVal <<= aShadow; break;
+ case MID_SHADOW_TRANSPARENCE: rVal <<= nTransparence; break;
+ default: OSL_FAIL("Wrong MemberId!"); return false;
+ }
+
+ return true;
+}
+
+bool SvxShadowItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
+ nMemberId &= ~CONVERT_TWIPS;
+
+ table::ShadowFormat aShadow;
+ uno::Any aAny;
+ bool bRet = QueryValue( aAny, bConvert ? CONVERT_TWIPS : 0 ) && ( aAny >>= aShadow );
+ switch ( nMemberId )
+ {
+ case MID_LOCATION:
+ {
+ bRet = (rVal >>= aShadow.Location);
+ if ( !bRet )
+ {
+ sal_Int16 nVal = 0;
+ bRet = (rVal >>= nVal);
+ aShadow.Location = static_cast<table::ShadowLocation>(nVal);
+ }
+
+ break;
+ }
+
+ case MID_WIDTH: rVal >>= aShadow.ShadowWidth; break;
+ case MID_TRANSPARENT: rVal >>= aShadow.IsTransparent; break;
+ case MID_BG_COLOR: rVal >>= aShadow.Color; break;
+ case 0: rVal >>= aShadow; break;
+ case MID_SHADOW_TRANSPARENCE:
+ {
+ sal_Int32 nTransparence = 0;
+ if ((rVal >>= nTransparence) && !o3tl::checked_multiply<sal_Int32>(nTransparence, 255, nTransparence))
+ {
+ Color aColor(aShadow.Color);
+ aColor.SetTransparency(rtl::math::round(float(nTransparence) / 100));
+ aShadow.Color = sal_Int32(aColor);
+ }
+ break;
+ }
+ default: OSL_FAIL("Wrong MemberId!"); return false;
+ }
+
+ if ( bRet )
+ {
+ switch( aShadow.Location )
+ {
+ case table::ShadowLocation_NONE : eLocation = SvxShadowLocation::NONE; break;
+ case table::ShadowLocation_TOP_LEFT : eLocation = SvxShadowLocation::TopLeft; break;
+ case table::ShadowLocation_TOP_RIGHT : eLocation = SvxShadowLocation::TopRight; break;
+ case table::ShadowLocation_BOTTOM_LEFT : eLocation = SvxShadowLocation::BottomLeft ; break;
+ case table::ShadowLocation_BOTTOM_RIGHT: eLocation = SvxShadowLocation::BottomRight; break;
+ default: ; // prevent warning
+ }
+
+ nWidth = bConvert ? convertMm100ToTwip(aShadow.ShadowWidth) : aShadow.ShadowWidth;
+ Color aSet(aShadow.Color);
+ aShadowColor = aSet;
+ }
+
+ return bRet;
+}
+
+
+bool SvxShadowItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ assert(SfxPoolItem::operator==(rAttr));
+
+ const SvxShadowItem& rItem = static_cast<const SvxShadowItem&>(rAttr);
+ return ( ( aShadowColor == rItem.aShadowColor ) &&
+ ( nWidth == rItem.GetWidth() ) &&
+ ( eLocation == rItem.GetLocation() ) );
+}
+
+SvxShadowItem* SvxShadowItem::Clone( SfxItemPool* ) const
+{
+ return new SvxShadowItem( *this );
+}
+
+sal_uInt16 SvxShadowItem::CalcShadowSpace( SvxShadowItemSide nShadow ) const
+{
+ sal_uInt16 nSpace = 0;
+
+ switch ( nShadow )
+ {
+ case SvxShadowItemSide::TOP:
+ if ( eLocation == SvxShadowLocation::TopLeft ||
+ eLocation == SvxShadowLocation::TopRight )
+ nSpace = nWidth;
+ break;
+
+ case SvxShadowItemSide::BOTTOM:
+ if ( eLocation == SvxShadowLocation::BottomLeft ||
+ eLocation == SvxShadowLocation::BottomRight )
+ nSpace = nWidth;
+ break;
+
+ case SvxShadowItemSide::LEFT:
+ if ( eLocation == SvxShadowLocation::TopLeft ||
+ eLocation == SvxShadowLocation::BottomLeft )
+ nSpace = nWidth;
+ break;
+
+ case SvxShadowItemSide::RIGHT:
+ if ( eLocation == SvxShadowLocation::TopRight ||
+ eLocation == SvxShadowLocation::BottomRight )
+ nSpace = nWidth;
+ break;
+
+ default:
+ OSL_FAIL( "wrong shadow" );
+ }
+ return nSpace;
+}
+
+static const char* RID_SVXITEMS_SHADOW[] =
+{
+ RID_SVXITEMS_SHADOW_NONE,
+ RID_SVXITEMS_SHADOW_TOPLEFT,
+ RID_SVXITEMS_SHADOW_TOPRIGHT,
+ RID_SVXITEMS_SHADOW_BOTTOMLEFT,
+ RID_SVXITEMS_SHADOW_BOTTOMRIGHT
+};
+
+bool SvxShadowItem::GetPresentation
+(
+ SfxItemPresentation ePres,
+ MapUnit eCoreUnit,
+ MapUnit ePresUnit,
+ OUString& rText, const IntlWrapper& rIntl
+) const
+{
+ switch ( ePres )
+ {
+ case SfxItemPresentation::Nameless:
+ {
+ rText = ::GetColorString( aShadowColor ) + cpDelim;
+ const char* pId = RID_SVXITEMS_TRANSPARENT_FALSE;
+
+ if ( aShadowColor.GetTransparency() )
+ pId = RID_SVXITEMS_TRANSPARENT_TRUE;
+ rText += EditResId(pId) +
+ cpDelim +
+ GetMetricText( static_cast<long>(nWidth), eCoreUnit, ePresUnit, &rIntl ) +
+ cpDelim +
+ EditResId(RID_SVXITEMS_SHADOW[static_cast<int>(eLocation)]);
+ return true;
+ }
+ case SfxItemPresentation::Complete:
+ {
+ rText = EditResId(RID_SVXITEMS_SHADOW_COMPLETE) +
+ ::GetColorString( aShadowColor ) +
+ cpDelim;
+
+ const char* pId = RID_SVXITEMS_TRANSPARENT_FALSE;
+ if ( aShadowColor.GetTransparency() )
+ pId = RID_SVXITEMS_TRANSPARENT_TRUE;
+ rText += EditResId(pId) +
+ cpDelim +
+ GetMetricText( static_cast<long>(nWidth), eCoreUnit, ePresUnit, &rIntl ) +
+ " " + EditResId(GetMetricId(ePresUnit)) +
+ cpDelim +
+ EditResId(RID_SVXITEMS_SHADOW[static_cast<int>(eLocation)]);
+ return true;
+ }
+ default: ; // prevent warning
+ }
+ return false;
+}
+
+
+void SvxShadowItem::ScaleMetrics( long nMult, long nDiv )
+{
+ nWidth = static_cast<sal_uInt16>(Scale( nWidth, nMult, nDiv ));
+}
+
+
+bool SvxShadowItem::HasMetrics() const
+{
+ return true;
+}
+
+
+sal_uInt16 SvxShadowItem::GetValueCount() const
+{
+ return sal_uInt16(SvxShadowLocation::End); // SvxShadowLocation::BottomRight + 1
+}
+
+sal_uInt16 SvxShadowItem::GetEnumValue() const
+{
+ return static_cast<sal_uInt16>(GetLocation());
+}
+
+
+void SvxShadowItem::SetEnumValue( sal_uInt16 nVal )
+{
+ SetLocation( static_cast<SvxShadowLocation>(nVal) );
+}
+
+void SvxShadowItem::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+ xmlTextWriterStartElement(pWriter, BAD_CAST("SvxShadowItem"));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("aShadowColor"), BAD_CAST(aShadowColor.AsRGBHexString().toUtf8().getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nWidth"), BAD_CAST(OString::number(nWidth).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eLocation"), BAD_CAST(OString::number(static_cast<int>(eLocation)).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(EditResId(RID_SVXITEMS_SHADOW[static_cast<int>(eLocation)]).toUtf8().getStr()));
+ xmlTextWriterEndElement(pWriter);
+}
+
+// class SvxBoxItem ------------------------------------------------------
+
+SvxBoxItem::SvxBoxItem( const SvxBoxItem& rCpy ) :
+
+ SfxPoolItem ( rCpy ),
+ pTop ( rCpy.pTop ? new SvxBorderLine( *rCpy.pTop ) : nullptr ),
+ pBottom ( rCpy.pBottom ? new SvxBorderLine( *rCpy.pBottom ) : nullptr ),
+ pLeft ( rCpy.pLeft ? new SvxBorderLine( *rCpy.pLeft ) : nullptr ),
+ pRight ( rCpy.pRight ? new SvxBorderLine( *rCpy.pRight ) : nullptr ),
+ nTopDist ( rCpy.nTopDist ),
+ nBottomDist ( rCpy.nBottomDist ),
+ nLeftDist ( rCpy.nLeftDist ),
+ nRightDist ( rCpy.nRightDist ),
+ bRemoveAdjCellBorder ( rCpy.bRemoveAdjCellBorder )
+{
+}
+
+
+SvxBoxItem::SvxBoxItem( const sal_uInt16 nId ) :
+ SfxPoolItem( nId ),
+ nTopDist ( 0 ),
+ nBottomDist ( 0 ),
+ nLeftDist ( 0 ),
+ nRightDist ( 0 ),
+ bRemoveAdjCellBorder ( false )
+{
+}
+
+
+SvxBoxItem::~SvxBoxItem()
+{
+}
+
+
+static bool CmpBrdLn( const std::unique_ptr<SvxBorderLine> & pBrd1, const SvxBorderLine* pBrd2 )
+{
+ if( pBrd1.get() == pBrd2 )
+ return true;
+ if( pBrd1 == nullptr || pBrd2 == nullptr)
+ return false;
+ return *pBrd1 == *pBrd2;
+}
+
+
+bool SvxBoxItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ assert(SfxPoolItem::operator==(rAttr));
+
+ const SvxBoxItem& rBoxItem = static_cast<const SvxBoxItem&>(rAttr);
+ return (
+ ( nTopDist == rBoxItem.nTopDist ) &&
+ ( nBottomDist == rBoxItem.nBottomDist ) &&
+ ( nLeftDist == rBoxItem.nLeftDist ) &&
+ ( nRightDist == rBoxItem.nRightDist ) &&
+ ( bRemoveAdjCellBorder == rBoxItem.bRemoveAdjCellBorder ) &&
+ CmpBrdLn( pTop, rBoxItem.GetTop() ) &&
+ CmpBrdLn( pBottom, rBoxItem.GetBottom() ) &&
+ CmpBrdLn( pLeft, rBoxItem.GetLeft() ) &&
+ CmpBrdLn( pRight, rBoxItem.GetRight() ) );
+}
+
+
+table::BorderLine2 SvxBoxItem::SvxLineToLine(const SvxBorderLine* pLine, bool bConvert)
+{
+ table::BorderLine2 aLine;
+ if(pLine)
+ {
+ aLine.Color = sal_Int32(pLine->GetColor());
+ aLine.InnerLineWidth = sal_uInt16( bConvert ? convertTwipToMm100(pLine->GetInWidth() ): pLine->GetInWidth() );
+ aLine.OuterLineWidth = sal_uInt16( bConvert ? convertTwipToMm100(pLine->GetOutWidth()): pLine->GetOutWidth() );
+ aLine.LineDistance = sal_uInt16( bConvert ? convertTwipToMm100(pLine->GetDistance()): pLine->GetDistance() );
+ aLine.LineStyle = sal_Int16(pLine->GetBorderLineStyle());
+ aLine.LineWidth = sal_uInt32( bConvert ? convertTwipToMm100( pLine->GetWidth( ) ) : pLine->GetWidth( ) );
+ }
+ else
+ aLine.Color = aLine.InnerLineWidth = aLine.OuterLineWidth = aLine.LineDistance = 0;
+ return aLine;
+}
+
+bool SvxBoxItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
+ table::BorderLine2 aRetLine;
+ sal_uInt16 nDist = 0;
+ bool bDistMember = false;
+ nMemberId &= ~CONVERT_TWIPS;
+ switch(nMemberId)
+ {
+ case 0:
+ {
+ // 4 Borders and 5 distances
+ uno::Sequence< uno::Any > aSeq( 9 );
+ aSeq[0] <<= SvxBoxItem::SvxLineToLine(GetLeft(), bConvert);
+ aSeq[1] <<= SvxBoxItem::SvxLineToLine(GetRight(), bConvert);
+ aSeq[2] <<= SvxBoxItem::SvxLineToLine(GetBottom(), bConvert);
+ aSeq[3] <<= SvxBoxItem::SvxLineToLine(GetTop(), bConvert);
+ aSeq[4] <<= static_cast<sal_Int32>(bConvert ? convertTwipToMm100( GetSmallestDistance()) : GetSmallestDistance());
+ aSeq[5] <<= static_cast<sal_Int32>(bConvert ? convertTwipToMm100( nTopDist ) : nTopDist );
+ aSeq[6] <<= static_cast<sal_Int32>(bConvert ? convertTwipToMm100( nBottomDist ) : nBottomDist );
+ aSeq[7] <<= static_cast<sal_Int32>(bConvert ? convertTwipToMm100( nLeftDist ) : nLeftDist );
+ aSeq[8] <<= static_cast<sal_Int32>(bConvert ? convertTwipToMm100( nRightDist ) : nRightDist );
+ rVal <<= aSeq;
+ return true;
+ }
+ case MID_LEFT_BORDER:
+ case LEFT_BORDER:
+ aRetLine = SvxBoxItem::SvxLineToLine(GetLeft(), bConvert);
+ break;
+ case MID_RIGHT_BORDER:
+ case RIGHT_BORDER:
+ aRetLine = SvxBoxItem::SvxLineToLine(GetRight(), bConvert);
+ break;
+ case MID_BOTTOM_BORDER:
+ case BOTTOM_BORDER:
+ aRetLine = SvxBoxItem::SvxLineToLine(GetBottom(), bConvert);
+ break;
+ case MID_TOP_BORDER:
+ case TOP_BORDER:
+ aRetLine = SvxBoxItem::SvxLineToLine(GetTop(), bConvert);
+ break;
+ case BORDER_DISTANCE:
+ nDist = GetSmallestDistance();
+ bDistMember = true;
+ break;
+ case TOP_BORDER_DISTANCE:
+ nDist = nTopDist;
+ bDistMember = true;
+ break;
+ case BOTTOM_BORDER_DISTANCE:
+ nDist = nBottomDist;
+ bDistMember = true;
+ break;
+ case LEFT_BORDER_DISTANCE:
+ nDist = nLeftDist;
+ bDistMember = true;
+ break;
+ case RIGHT_BORDER_DISTANCE:
+ nDist = nRightDist;
+ bDistMember = true;
+ break;
+ case LINE_STYLE:
+ case LINE_WIDTH:
+ // it doesn't make sense to return a value for these since it's
+ // probably ambiguous
+ return true;
+ break;
+ }
+
+ if( bDistMember )
+ rVal <<= static_cast<sal_Int32>(bConvert ? convertTwipToMm100(nDist) : nDist);
+ else
+ rVal <<= aRetLine;
+
+ return true;
+}
+
+namespace
+{
+
+bool
+lcl_lineToSvxLine(const table::BorderLine& rLine, SvxBorderLine& rSvxLine, bool bConvert, bool bGuessWidth)
+{
+ rSvxLine.SetColor( Color(rLine.Color));
+ if ( bGuessWidth )
+ {
+ rSvxLine.GuessLinesWidths( rSvxLine.GetBorderLineStyle(),
+ sal_uInt16( bConvert ? convertMm100ToTwip(rLine.OuterLineWidth) : rLine.OuterLineWidth ),
+ sal_uInt16( bConvert ? convertMm100ToTwip(rLine.InnerLineWidth) : rLine.InnerLineWidth ),
+ sal_uInt16( bConvert ? convertMm100ToTwip(rLine.LineDistance ) : rLine.LineDistance ));
+ }
+
+ bool bRet = !rSvxLine.isEmpty();
+ return bRet;
+}
+
+}
+
+
+bool SvxBoxItem::LineToSvxLine(const css::table::BorderLine& rLine, SvxBorderLine& rSvxLine, bool bConvert)
+{
+ return lcl_lineToSvxLine(rLine, rSvxLine, bConvert, true);
+}
+
+bool
+SvxBoxItem::LineToSvxLine(const css::table::BorderLine2& rLine, SvxBorderLine& rSvxLine, bool bConvert)
+{
+ SvxBorderLineStyle const nStyle =
+ (rLine.LineStyle < 0 || BORDER_LINE_STYLE_MAX < rLine.LineStyle)
+ ? SvxBorderLineStyle::SOLID // default
+ : static_cast<SvxBorderLineStyle>(rLine.LineStyle);
+
+ rSvxLine.SetBorderLineStyle( nStyle );
+
+ bool bGuessWidth = true;
+ if ( rLine.LineWidth )
+ {
+ rSvxLine.SetWidth( bConvert? convertMm100ToTwip( rLine.LineWidth ) : rLine.LineWidth );
+ // fdo#46112: double does not necessarily mean symmetric
+ // for backwards compatibility
+ bGuessWidth = (SvxBorderLineStyle::DOUBLE == nStyle || SvxBorderLineStyle::DOUBLE_THIN == nStyle) &&
+ (rLine.InnerLineWidth > 0) && (rLine.OuterLineWidth > 0);
+ }
+
+ return lcl_lineToSvxLine(rLine, rSvxLine, bConvert, bGuessWidth);
+}
+
+
+namespace
+{
+
+bool
+lcl_extractBorderLine(const uno::Any& rAny, table::BorderLine2& rLine)
+{
+ if (rAny >>= rLine)
+ return true;
+
+ table::BorderLine aBorderLine;
+ if (rAny >>= aBorderLine)
+ {
+ rLine.Color = aBorderLine.Color;
+ rLine.InnerLineWidth = aBorderLine.InnerLineWidth;
+ rLine.OuterLineWidth = aBorderLine.OuterLineWidth;
+ rLine.LineDistance = aBorderLine.LineDistance;
+ rLine.LineStyle = table::BorderLineStyle::SOLID;
+ return true;
+ }
+
+ return false;
+}
+
+template<typename Item, typename Line>
+bool
+lcl_setLine(const uno::Any& rAny, Item& rItem, Line nLine, const bool bConvert)
+{
+ bool bDone = false;
+ table::BorderLine2 aBorderLine;
+ if (lcl_extractBorderLine(rAny, aBorderLine))
+ {
+ SvxBorderLine aLine;
+ bool bSet = SvxBoxItem::LineToSvxLine(aBorderLine, aLine, bConvert);
+ rItem.SetLine( bSet ? &aLine : nullptr, nLine);
+ bDone = true;
+ }
+ return bDone;
+}
+
+}
+
+bool SvxBoxItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
+ SvxBoxItemLine nLine = SvxBoxItemLine::TOP;
+ bool bDistMember = false;
+ nMemberId &= ~CONVERT_TWIPS;
+ switch(nMemberId)
+ {
+ case 0:
+ {
+ uno::Sequence< uno::Any > aSeq;
+ if (( rVal >>= aSeq ) && ( aSeq.getLength() == 9 ))
+ {
+ // 4 Borders and 5 distances
+ const SvxBoxItemLine aBorders[] = { SvxBoxItemLine::LEFT, SvxBoxItemLine::RIGHT, SvxBoxItemLine::BOTTOM, SvxBoxItemLine::TOP };
+ for (int n(0); n != SAL_N_ELEMENTS(aBorders); ++n)
+ {
+ if (!lcl_setLine(aSeq[n], *this, aBorders[n], bConvert))
+ return false;
+ }
+
+ // WTH are the borders and the distances saved in different order?
+ SvxBoxItemLine const nLines[4] = { SvxBoxItemLine::TOP, SvxBoxItemLine::BOTTOM, SvxBoxItemLine::LEFT, SvxBoxItemLine::RIGHT };
+ for ( sal_Int32 n = 4; n < 9; n++ )
+ {
+ sal_Int32 nDist = 0;
+ if ( aSeq[n] >>= nDist )
+ {
+ if( bConvert )
+ nDist = convertMm100ToTwip(nDist);
+ if ( n == 4 )
+ SetAllDistances(sal_uInt16(nDist));
+ else
+ SetDistance( sal_uInt16( nDist ), nLines[n-5] );
+ }
+ else
+ return false;
+ }
+
+ return true;
+ }
+ else
+ return false;
+ }
+ case LEFT_BORDER_DISTANCE:
+ bDistMember = true;
+ [[fallthrough]];
+ case LEFT_BORDER:
+ case MID_LEFT_BORDER:
+ nLine = SvxBoxItemLine::LEFT;
+ break;
+ case RIGHT_BORDER_DISTANCE:
+ bDistMember = true;
+ [[fallthrough]];
+ case RIGHT_BORDER:
+ case MID_RIGHT_BORDER:
+ nLine = SvxBoxItemLine::RIGHT;
+ break;
+ case BOTTOM_BORDER_DISTANCE:
+ bDistMember = true;
+ [[fallthrough]];
+ case BOTTOM_BORDER:
+ case MID_BOTTOM_BORDER:
+ nLine = SvxBoxItemLine::BOTTOM;
+ break;
+ case TOP_BORDER_DISTANCE:
+ bDistMember = true;
+ [[fallthrough]];
+ case TOP_BORDER:
+ case MID_TOP_BORDER:
+ nLine = SvxBoxItemLine::TOP;
+ break;
+ case LINE_STYLE:
+ {
+ drawing::LineStyle eDrawingStyle;
+ rVal >>= eDrawingStyle;
+ SvxBorderLineStyle eBorderStyle = SvxBorderLineStyle::NONE;
+ switch ( eDrawingStyle )
+ {
+ default:
+ case drawing::LineStyle_NONE:
+ break;
+ case drawing::LineStyle_SOLID:
+ eBorderStyle = SvxBorderLineStyle::SOLID;
+ break;
+ case drawing::LineStyle_DASH:
+ eBorderStyle = SvxBorderLineStyle::DASHED;
+ break;
+ }
+
+ // Set the line style on all borders
+ for( SvxBoxItemLine n : o3tl::enumrange<SvxBoxItemLine>() )
+ {
+ editeng::SvxBorderLine* pLine = const_cast< editeng::SvxBorderLine* >( GetLine( n ) );
+ if( pLine )
+ pLine->SetBorderLineStyle( eBorderStyle );
+ }
+ return true;
+ }
+ break;
+ case LINE_WIDTH:
+ {
+ // Set the line width on all borders
+ long nWidth(0);
+ rVal >>= nWidth;
+ if( bConvert )
+ nWidth = convertMm100ToTwip( nWidth );
+
+ // Set the line Width on all borders
+ for( SvxBoxItemLine n : o3tl::enumrange<SvxBoxItemLine>() )
+ {
+ editeng::SvxBorderLine* pLine = const_cast< editeng::SvxBorderLine* >( GetLine( n ) );
+ if( pLine )
+ pLine->SetWidth( nWidth );
+ }
+ }
+ return true;
+ }
+
+ if( bDistMember || nMemberId == BORDER_DISTANCE )
+ {
+ sal_Int32 nDist = 0;
+ if(!(rVal >>= nDist))
+ return false;
+
+ if(nDist >= 0)
+ {
+ if( bConvert )
+ nDist = convertMm100ToTwip(nDist);
+ if( nMemberId == BORDER_DISTANCE )
+ SetAllDistances(sal_uInt16(nDist));
+ else
+ SetDistance( sal_uInt16( nDist ), nLine );
+ }
+ }
+ else
+ {
+ SvxBorderLine aLine;
+ if( !rVal.hasValue() )
+ return false;
+
+ table::BorderLine2 aBorderLine;
+ if( lcl_extractBorderLine(rVal, aBorderLine) )
+ {
+ // usual struct
+ }
+ else if (rVal.getValueTypeClass() == uno::TypeClass_SEQUENCE )
+ {
+ // serialization for basic macro recording
+ uno::Reference < script::XTypeConverter > xConverter
+ ( script::Converter::create(::comphelper::getProcessComponentContext()) );
+ uno::Sequence < uno::Any > aSeq;
+ uno::Any aNew;
+ try { aNew = xConverter->convertTo( rVal, cppu::UnoType<uno::Sequence < uno::Any >>::get() ); }
+ catch (const uno::Exception&) {}
+
+ aNew >>= aSeq;
+ if (aSeq.getLength() >= 4 && aSeq.getLength() <= 6)
+ {
+ sal_Int32 nVal = 0;
+ if ( aSeq[0] >>= nVal )
+ aBorderLine.Color = nVal;
+ if ( aSeq[1] >>= nVal )
+ aBorderLine.InnerLineWidth = static_cast<sal_Int16>(nVal);
+ if ( aSeq[2] >>= nVal )
+ aBorderLine.OuterLineWidth = static_cast<sal_Int16>(nVal);
+ if ( aSeq[3] >>= nVal )
+ aBorderLine.LineDistance = static_cast<sal_Int16>(nVal);
+ if (aSeq.getLength() >= 5) // fdo#40874 added fields
+ {
+ if (aSeq[4] >>= nVal)
+ {
+ aBorderLine.LineStyle = nVal;
+ }
+ if (aSeq.getLength() >= 6)
+ {
+ if (aSeq[5] >>= nVal)
+ {
+ aBorderLine.LineWidth = nVal;
+ }
+ }
+ }
+ }
+ else
+ return false;
+ }
+ else
+ return false;
+
+ bool bSet = SvxBoxItem::LineToSvxLine(aBorderLine, aLine, bConvert);
+ SetLine(bSet ? &aLine : nullptr, nLine);
+ }
+
+ return true;
+}
+
+SvxBoxItem* SvxBoxItem::Clone( SfxItemPool* ) const
+{
+ return new SvxBoxItem( *this );
+}
+
+bool SvxBoxItem::GetPresentation
+(
+ SfxItemPresentation ePres,
+ MapUnit eCoreUnit,
+ MapUnit ePresUnit,
+ OUString& rText, const IntlWrapper& rIntl
+) const
+{
+ OUString cpDelimTmp(cpDelim);
+ switch ( ePres )
+ {
+ case SfxItemPresentation::Nameless:
+ {
+ rText.clear();
+
+ if ( pTop )
+ {
+ rText = pTop->GetValueString( eCoreUnit, ePresUnit, &rIntl ) + cpDelimTmp;
+ }
+ if( !(pTop && pBottom && pLeft && pRight &&
+ *pTop == *pBottom && *pTop == *pLeft && *pTop == *pRight) )
+ {
+ if ( pBottom )
+ {
+ rText += pBottom->GetValueString( eCoreUnit, ePresUnit, &rIntl ) + cpDelimTmp;
+ }
+ if ( pLeft )
+ {
+ rText += pLeft->GetValueString( eCoreUnit, ePresUnit, &rIntl ) + cpDelimTmp;
+ }
+ if ( pRight )
+ {
+ rText += pRight->GetValueString( eCoreUnit, ePresUnit, &rIntl ) + cpDelimTmp;
+ }
+ }
+ rText += GetMetricText( static_cast<long>(nTopDist), eCoreUnit, ePresUnit, &rIntl );
+ if( nTopDist != nBottomDist || nTopDist != nLeftDist ||
+ nTopDist != nRightDist )
+ {
+ rText += cpDelimTmp +
+ GetMetricText( static_cast<long>(nBottomDist), eCoreUnit,
+ ePresUnit, &rIntl ) +
+ cpDelimTmp +
+ GetMetricText( static_cast<long>(nLeftDist), eCoreUnit, ePresUnit, &rIntl ) +
+ cpDelimTmp +
+ GetMetricText( static_cast<long>(nRightDist), eCoreUnit,
+ ePresUnit, &rIntl );
+ }
+ return true;
+ }
+ case SfxItemPresentation::Complete:
+ {
+ if( !(pTop || pBottom || pLeft || pRight) )
+ {
+ rText = EditResId(RID_SVXITEMS_BORDER_NONE) + cpDelimTmp;
+ }
+ else
+ {
+ rText = EditResId(RID_SVXITEMS_BORDER_COMPLETE);
+ if( pTop && pBottom && pLeft && pRight &&
+ *pTop == *pBottom && *pTop == *pLeft && *pTop == *pRight )
+ {
+ rText += pTop->GetValueString( eCoreUnit, ePresUnit, &rIntl, true ) + cpDelimTmp;
+ }
+ else
+ {
+ if ( pTop )
+ {
+ rText += EditResId(RID_SVXITEMS_BORDER_TOP) +
+ pTop->GetValueString( eCoreUnit, ePresUnit, &rIntl, true ) +
+ cpDelimTmp;
+ }
+ if ( pBottom )
+ {
+ rText += EditResId(RID_SVXITEMS_BORDER_BOTTOM) +
+ pBottom->GetValueString( eCoreUnit, ePresUnit, &rIntl, true ) +
+ cpDelimTmp;
+ }
+ if ( pLeft )
+ {
+ rText += EditResId(RID_SVXITEMS_BORDER_LEFT) +
+ pLeft->GetValueString( eCoreUnit, ePresUnit, &rIntl, true ) +
+ cpDelimTmp;
+ }
+ if ( pRight )
+ {
+ rText += EditResId(RID_SVXITEMS_BORDER_RIGHT) +
+ pRight->GetValueString( eCoreUnit, ePresUnit, &rIntl, true ) +
+ cpDelimTmp;
+ }
+ }
+ }
+
+ rText += EditResId(RID_SVXITEMS_BORDER_DISTANCE);
+ if( nTopDist == nBottomDist && nTopDist == nLeftDist &&
+ nTopDist == nRightDist )
+ {
+ rText += GetMetricText( static_cast<long>(nTopDist), eCoreUnit,
+ ePresUnit, &rIntl ) +
+ " " + EditResId(GetMetricId(ePresUnit));
+ }
+ else
+ {
+ rText += EditResId(RID_SVXITEMS_BORDER_TOP) +
+ GetMetricText( static_cast<long>(nTopDist), eCoreUnit,
+ ePresUnit, &rIntl ) +
+ " " + EditResId(GetMetricId(ePresUnit)) +
+ cpDelimTmp +
+ EditResId(RID_SVXITEMS_BORDER_BOTTOM) +
+ GetMetricText( static_cast<long>(nBottomDist), eCoreUnit,
+ ePresUnit, &rIntl ) +
+ " " + EditResId(GetMetricId(ePresUnit)) +
+ cpDelimTmp +
+ EditResId(RID_SVXITEMS_BORDER_LEFT) +
+ GetMetricText( static_cast<long>(nLeftDist), eCoreUnit,
+ ePresUnit, &rIntl ) +
+ " " + EditResId(GetMetricId(ePresUnit)) +
+ cpDelimTmp +
+ EditResId(RID_SVXITEMS_BORDER_RIGHT) +
+ GetMetricText( static_cast<long>(nRightDist), eCoreUnit,
+ ePresUnit, &rIntl ) +
+ " " + EditResId(GetMetricId(ePresUnit));
+ }
+ return true;
+ }
+ default: ; // prevent warning
+ }
+ return false;
+}
+
+
+void SvxBoxItem::ScaleMetrics( long nMult, long nDiv )
+{
+ if ( pTop ) pTop->ScaleMetrics( nMult, nDiv );
+ if ( pBottom ) pBottom->ScaleMetrics( nMult, nDiv );
+ if ( pLeft ) pLeft->ScaleMetrics( nMult, nDiv );
+ if ( pRight ) pRight->ScaleMetrics( nMult, nDiv );
+ nTopDist = static_cast<sal_uInt16>(Scale( nTopDist, nMult, nDiv ));
+ nBottomDist = static_cast<sal_uInt16>(Scale( nBottomDist, nMult, nDiv ));
+ nLeftDist = static_cast<sal_uInt16>(Scale( nLeftDist, nMult, nDiv ));
+ nRightDist = static_cast<sal_uInt16>(Scale( nRightDist, nMult, nDiv ));
+}
+
+
+bool SvxBoxItem::HasMetrics() const
+{
+ return true;
+}
+
+
+const SvxBorderLine *SvxBoxItem::GetLine( SvxBoxItemLine nLine ) const
+{
+ const SvxBorderLine *pRet = nullptr;
+
+ switch ( nLine )
+ {
+ case SvxBoxItemLine::TOP:
+ pRet = pTop.get();
+ break;
+ case SvxBoxItemLine::BOTTOM:
+ pRet = pBottom.get();
+ break;
+ case SvxBoxItemLine::LEFT:
+ pRet = pLeft.get();
+ break;
+ case SvxBoxItemLine::RIGHT:
+ pRet = pRight.get();
+ break;
+ default:
+ OSL_FAIL( "wrong line" );
+ break;
+ }
+
+ return pRet;
+}
+
+
+void SvxBoxItem::SetLine( const SvxBorderLine* pNew, SvxBoxItemLine nLine )
+{
+ std::unique_ptr<SvxBorderLine> pTmp( pNew ? new SvxBorderLine( *pNew ) : nullptr );
+
+ switch ( nLine )
+ {
+ case SvxBoxItemLine::TOP:
+ pTop = std::move( pTmp );
+ break;
+ case SvxBoxItemLine::BOTTOM:
+ pBottom = std::move( pTmp );
+ break;
+ case SvxBoxItemLine::LEFT:
+ pLeft = std::move( pTmp );
+ break;
+ case SvxBoxItemLine::RIGHT:
+ pRight = std::move( pTmp );
+ break;
+ default:
+ OSL_FAIL( "wrong line" );
+ }
+}
+
+
+sal_uInt16 SvxBoxItem::GetSmallestDistance() const
+{
+ // The smallest distance that is not 0 will be returned.
+ sal_uInt16 nDist = nTopDist;
+ if( nBottomDist && (!nDist || nBottomDist < nDist) )
+ nDist = nBottomDist;
+ if( nLeftDist && (!nDist || nLeftDist < nDist) )
+ nDist = nLeftDist;
+ if( nRightDist && (!nDist || nRightDist < nDist) )
+ nDist = nRightDist;
+
+ return nDist;
+}
+
+
+sal_uInt16 SvxBoxItem::GetDistance( SvxBoxItemLine nLine ) const
+{
+ sal_uInt16 nDist = 0;
+ switch ( nLine )
+ {
+ case SvxBoxItemLine::TOP:
+ nDist = nTopDist;
+ break;
+ case SvxBoxItemLine::BOTTOM:
+ nDist = nBottomDist;
+ break;
+ case SvxBoxItemLine::LEFT:
+ nDist = nLeftDist;
+ break;
+ case SvxBoxItemLine::RIGHT:
+ nDist = nRightDist;
+ break;
+ default:
+ OSL_FAIL( "wrong line" );
+ }
+
+ return nDist;
+}
+
+
+void SvxBoxItem::SetDistance( sal_uInt16 nNew, SvxBoxItemLine nLine )
+{
+ switch ( nLine )
+ {
+ case SvxBoxItemLine::TOP:
+ nTopDist = nNew;
+ break;
+ case SvxBoxItemLine::BOTTOM:
+ nBottomDist = nNew;
+ break;
+ case SvxBoxItemLine::LEFT:
+ nLeftDist = nNew;
+ break;
+ case SvxBoxItemLine::RIGHT:
+ nRightDist = nNew;
+ break;
+ default:
+ OSL_FAIL( "wrong line" );
+ }
+}
+
+sal_uInt16 SvxBoxItem::CalcLineWidth( SvxBoxItemLine nLine ) const
+{
+ SvxBorderLine* pTmp = nullptr;
+ sal_uInt16 nWidth = 0;
+ switch ( nLine )
+ {
+ case SvxBoxItemLine::TOP:
+ pTmp = pTop.get();
+ break;
+ case SvxBoxItemLine::BOTTOM:
+ pTmp = pBottom.get();
+ break;
+ case SvxBoxItemLine::LEFT:
+ pTmp = pLeft.get();
+ break;
+ case SvxBoxItemLine::RIGHT:
+ pTmp = pRight.get();
+ break;
+ default:
+ OSL_FAIL( "wrong line" );
+ }
+
+ if( pTmp )
+ nWidth = pTmp->GetScaledWidth();
+
+ return nWidth;
+}
+
+sal_uInt16 SvxBoxItem::CalcLineSpace( SvxBoxItemLine nLine, bool bEvenIfNoLine ) const
+{
+ SvxBorderLine* pTmp = nullptr;
+ sal_uInt16 nDist = 0;
+ switch ( nLine )
+ {
+ case SvxBoxItemLine::TOP:
+ pTmp = pTop.get();
+ nDist = nTopDist;
+ break;
+ case SvxBoxItemLine::BOTTOM:
+ pTmp = pBottom.get();
+ nDist = nBottomDist;
+ break;
+ case SvxBoxItemLine::LEFT:
+ pTmp = pLeft.get();
+ nDist = nLeftDist;
+ break;
+ case SvxBoxItemLine::RIGHT:
+ pTmp = pRight.get();
+ nDist = nRightDist;
+ break;
+ default:
+ OSL_FAIL( "wrong line" );
+ }
+
+ if( pTmp )
+ {
+ nDist = nDist + pTmp->GetScaledWidth();
+ }
+ else if( !bEvenIfNoLine )
+ nDist = 0;
+ return nDist;
+}
+
+bool SvxBoxItem::HasBorder( bool bTreatPaddingAsBorder ) const
+{
+ return CalcLineSpace( SvxBoxItemLine::BOTTOM, bTreatPaddingAsBorder )
+ || CalcLineSpace( SvxBoxItemLine::RIGHT, bTreatPaddingAsBorder )
+ || CalcLineSpace( SvxBoxItemLine::TOP, bTreatPaddingAsBorder )
+ || CalcLineSpace( SvxBoxItemLine::LEFT, bTreatPaddingAsBorder );
+}
+
+// class SvxBoxInfoItem --------------------------------------------------
+
+SvxBoxInfoItem::SvxBoxInfoItem( const sal_uInt16 nId ) :
+ SfxPoolItem( nId ),
+ mbEnableHor( false ),
+ mbEnableVer( false ),
+ nDefDist( 0 )
+{
+ bDist = bMinDist = false;
+ ResetFlags();
+}
+
+
+SvxBoxInfoItem::SvxBoxInfoItem( const SvxBoxInfoItem& rCpy ) :
+ SfxPoolItem( rCpy ),
+ pHori( rCpy.pHori ? new SvxBorderLine( *rCpy.pHori ) : nullptr ),
+ pVert( rCpy.pVert ? new SvxBorderLine( *rCpy.pVert ) : nullptr ),
+ mbEnableHor( rCpy.mbEnableHor ),
+ mbEnableVer( rCpy.mbEnableVer ),
+ bDist( rCpy.bDist ),
+ bMinDist ( rCpy.bMinDist ),
+ nValidFlags( rCpy.nValidFlags ),
+ nDefDist( rCpy.nDefDist )
+{
+}
+
+SvxBoxInfoItem::~SvxBoxInfoItem()
+{
+}
+
+bool SvxBoxInfoItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ assert(SfxPoolItem::operator==(rAttr));
+
+ const SvxBoxInfoItem& rBoxInfo = static_cast<const SvxBoxInfoItem&>(rAttr);
+
+ return ( mbEnableHor == rBoxInfo.mbEnableHor
+ && mbEnableVer == rBoxInfo.mbEnableVer
+ && bDist == rBoxInfo.IsDist()
+ && bMinDist == rBoxInfo.IsMinDist()
+ && nValidFlags == rBoxInfo.nValidFlags
+ && nDefDist == rBoxInfo.GetDefDist()
+ && CmpBrdLn( pHori, rBoxInfo.GetHori() )
+ && CmpBrdLn( pVert, rBoxInfo.GetVert() )
+ );
+}
+
+
+void SvxBoxInfoItem::SetLine( const SvxBorderLine* pNew, SvxBoxInfoItemLine nLine )
+{
+ std::unique_ptr<SvxBorderLine> pTmp( pNew ? new SvxBorderLine( *pNew ) : nullptr );
+
+ if ( SvxBoxInfoItemLine::HORI == nLine )
+ {
+ pHori = std::move(pTmp);
+ }
+ else if ( SvxBoxInfoItemLine::VERT == nLine )
+ {
+ pVert = std::move(pTmp);
+ }
+ else
+ {
+ OSL_FAIL( "wrong line" );
+ }
+}
+
+SvxBoxInfoItem* SvxBoxInfoItem::Clone( SfxItemPool* ) const
+{
+ return new SvxBoxInfoItem( *this );
+}
+
+bool SvxBoxInfoItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper&
+) const
+{
+ rText.clear();
+ return false;
+}
+
+
+void SvxBoxInfoItem::ScaleMetrics( long nMult, long nDiv )
+{
+ if ( pHori ) pHori->ScaleMetrics( nMult, nDiv );
+ if ( pVert ) pVert->ScaleMetrics( nMult, nDiv );
+ nDefDist = static_cast<sal_uInt16>(Scale( nDefDist, nMult, nDiv ));
+}
+
+
+bool SvxBoxInfoItem::HasMetrics() const
+{
+ return true;
+}
+
+
+void SvxBoxInfoItem::ResetFlags()
+{
+ nValidFlags = static_cast<SvxBoxInfoItemValidFlags>(0x7F); // all valid except Disable
+}
+
+bool SvxBoxInfoItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ bool bConvert = 0 != (nMemberId & CONVERT_TWIPS);
+ table::BorderLine2 aRetLine;
+ sal_Int16 nVal=0;
+ bool bIntMember = false;
+ nMemberId &= ~CONVERT_TWIPS;
+ switch(nMemberId)
+ {
+ case 0:
+ {
+ // 2 BorderLines, flags, valid flags and distance
+ css::uno::Sequence< css::uno::Any > aSeq( 5 );
+ aSeq[0] <<= SvxBoxItem::SvxLineToLine( pHori.get(), bConvert);
+ aSeq[1] <<= SvxBoxItem::SvxLineToLine( pVert.get(), bConvert);
+ if ( IsTable() )
+ nVal |= 0x01;
+ if ( IsDist() )
+ nVal |= 0x02;
+ if ( IsMinDist() )
+ nVal |= 0x04;
+ aSeq[2] <<= nVal;
+ aSeq[3] <<= static_cast<sal_Int16>(nValidFlags);
+ aSeq[4] <<= static_cast<sal_Int32>(bConvert ? convertTwipToMm100(GetDefDist()) : GetDefDist());
+ rVal <<= aSeq;
+ return true;
+ }
+
+ case MID_HORIZONTAL:
+ aRetLine = SvxBoxItem::SvxLineToLine( pHori.get(), bConvert);
+ break;
+ case MID_VERTICAL:
+ aRetLine = SvxBoxItem::SvxLineToLine( pVert.get(), bConvert);
+ break;
+ case MID_FLAGS:
+ bIntMember = true;
+ if ( IsTable() )
+ nVal |= 0x01;
+ if ( IsDist() )
+ nVal |= 0x02;
+ if ( IsMinDist() )
+ nVal |= 0x04;
+ rVal <<= nVal;
+ break;
+ case MID_VALIDFLAGS:
+ bIntMember = true;
+ rVal <<= static_cast<sal_Int16>(nValidFlags);
+ break;
+ case MID_DISTANCE:
+ bIntMember = true;
+ rVal <<= static_cast<sal_Int32>(bConvert ? convertTwipToMm100(GetDefDist()) : GetDefDist());
+ break;
+ default: OSL_FAIL("Wrong MemberId!"); return false;
+ }
+
+ if( !bIntMember )
+ rVal <<= aRetLine;
+
+ return true;
+}
+
+
+bool SvxBoxInfoItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
+ nMemberId &= ~CONVERT_TWIPS;
+ bool bRet;
+ switch(nMemberId)
+ {
+ case 0:
+ {
+ css::uno::Sequence< css::uno::Any > aSeq;
+ if (( rVal >>= aSeq ) && ( aSeq.getLength() == 5 ))
+ {
+ // 2 BorderLines, flags, valid flags and distance
+ if (!lcl_setLine(aSeq[0], *this, SvxBoxInfoItemLine::HORI, bConvert))
+ return false;
+ if (!lcl_setLine(aSeq[1], *this, SvxBoxInfoItemLine::VERT, bConvert))
+ return false;
+
+ sal_Int16 nFlags( 0 );
+ sal_Int32 nVal( 0 );
+ if ( aSeq[2] >>= nFlags )
+ {
+ SetTable ( ( nFlags & 0x01 ) != 0 );
+ SetDist ( ( nFlags & 0x02 ) != 0 );
+ SetMinDist( ( nFlags & 0x04 ) != 0 );
+ }
+ else
+ return false;
+ if ( aSeq[3] >>= nFlags )
+ nValidFlags = static_cast<SvxBoxInfoItemValidFlags>(nFlags);
+ else
+ return false;
+ if (( aSeq[4] >>= nVal ) && ( nVal >= 0 ))
+ {
+ if( bConvert )
+ nVal = convertMm100ToTwip(nVal);
+ SetDefDist( static_cast<sal_uInt16>(nVal) );
+ }
+ }
+ return true;
+ }
+
+ case MID_HORIZONTAL:
+ case MID_VERTICAL:
+ {
+ if( !rVal.hasValue() )
+ return false;
+
+ table::BorderLine2 aBorderLine;
+ if( lcl_extractBorderLine(rVal, aBorderLine) )
+ {
+ // usual struct
+ }
+ else if (rVal.getValueTypeClass() == uno::TypeClass_SEQUENCE )
+ {
+ // serialization for basic macro recording
+ uno::Reference < script::XTypeConverter > xConverter( script::Converter::create(::comphelper::getProcessComponentContext()) );
+ uno::Any aNew;
+ uno::Sequence < uno::Any > aSeq;
+ try { aNew = xConverter->convertTo( rVal, cppu::UnoType<uno::Sequence < uno::Any >>::get() ); }
+ catch (const uno::Exception&) {}
+
+ if ((aNew >>= aSeq) &&
+ aSeq.getLength() >= 4 && aSeq.getLength() <= 6)
+ {
+ sal_Int32 nVal = 0;
+ if ( aSeq[0] >>= nVal )
+ aBorderLine.Color = nVal;
+ if ( aSeq[1] >>= nVal )
+ aBorderLine.InnerLineWidth = static_cast<sal_Int16>(nVal);
+ if ( aSeq[2] >>= nVal )
+ aBorderLine.OuterLineWidth = static_cast<sal_Int16>(nVal);
+ if ( aSeq[3] >>= nVal )
+ aBorderLine.LineDistance = static_cast<sal_Int16>(nVal);
+ if (aSeq.getLength() >= 5) // fdo#40874 added fields
+ {
+ if (aSeq[4] >>= nVal)
+ {
+ aBorderLine.LineStyle = nVal;
+ }
+ if (aSeq.getLength() >= 6)
+ {
+ if (aSeq[5] >>= nVal)
+ {
+ aBorderLine.LineWidth = nVal;
+ }
+ }
+ }
+ }
+ else
+ return false;
+ }
+ else if (rVal.getValueType() == cppu::UnoType<css::uno::Sequence < sal_Int16 >>::get() )
+ {
+ // serialization for basic macro recording
+ css::uno::Sequence < sal_Int16 > aSeq;
+ rVal >>= aSeq;
+ if (aSeq.getLength() >= 4 && aSeq.getLength() <= 6)
+ {
+ aBorderLine.Color = aSeq[0];
+ aBorderLine.InnerLineWidth = aSeq[1];
+ aBorderLine.OuterLineWidth = aSeq[2];
+ aBorderLine.LineDistance = aSeq[3];
+ if (aSeq.getLength() >= 5) // fdo#40874 added fields
+ {
+ aBorderLine.LineStyle = aSeq[4];
+ if (aSeq.getLength() >= 6)
+ {
+ aBorderLine.LineWidth = aSeq[5];
+ }
+ }
+ }
+ else
+ return false;
+ }
+ else
+ return false;
+
+ SvxBorderLine aLine;
+ bool bSet = SvxBoxItem::LineToSvxLine(aBorderLine, aLine, bConvert);
+ if ( bSet )
+ SetLine( &aLine, nMemberId == MID_HORIZONTAL ? SvxBoxInfoItemLine::HORI : SvxBoxInfoItemLine::VERT );
+ break;
+ }
+ case MID_FLAGS:
+ {
+ sal_Int16 nFlags = sal_Int16();
+ bRet = (rVal >>= nFlags);
+ if ( bRet )
+ {
+ SetTable ( ( nFlags & 0x01 ) != 0 );
+ SetDist ( ( nFlags & 0x02 ) != 0 );
+ SetMinDist( ( nFlags & 0x04 ) != 0 );
+ }
+
+ break;
+ }
+ case MID_VALIDFLAGS:
+ {
+ sal_Int16 nFlags = sal_Int16();
+ bRet = (rVal >>= nFlags);
+ if ( bRet )
+ nValidFlags = static_cast<SvxBoxInfoItemValidFlags>(nFlags);
+ break;
+ }
+ case MID_DISTANCE:
+ {
+ sal_Int32 nVal = 0;
+ bRet = (rVal >>= nVal);
+ if ( bRet && nVal>=0 )
+ {
+ if( bConvert )
+ nVal = convertMm100ToTwip(nVal);
+ SetDefDist( static_cast<sal_uInt16>(nVal) );
+ }
+ break;
+ }
+ default: OSL_FAIL("Wrong MemberId!"); return false;
+ }
+
+ return true;
+}
+
+
+namespace editeng
+{
+
+void BorderDistanceFromWord(bool bFromEdge, sal_Int32& nMargin, sal_Int32& nBorderDistance,
+ sal_Int32 nBorderWidth)
+{
+ // See https://wiki.openoffice.org/wiki/Writer/MSInteroperability/PageBorder
+
+ sal_Int32 nNewMargin = nMargin;
+ sal_Int32 nNewBorderDistance = nBorderDistance;
+
+ if (bFromEdge)
+ {
+ nNewMargin = nBorderDistance;
+ nNewBorderDistance = nMargin - nBorderDistance - nBorderWidth;
+ }
+ else
+ {
+ nNewMargin -= nBorderDistance + nBorderWidth;
+ }
+
+ // Ensure correct distance from page edge to text in cases not supported by us:
+ // when border is outside entire page area (!bFromEdge && BorderDistance > Margin),
+ // and when border is inside page body area (bFromEdge && BorderDistance > Margin)
+ if (nNewMargin < 0)
+ {
+ nNewMargin = 0;
+ nNewBorderDistance = std::max<sal_Int32>(nMargin - nBorderWidth, 0);
+ }
+ else if (nNewBorderDistance < 0)
+ {
+ nNewMargin = std::max<sal_Int32>(nMargin - nBorderWidth, 0);
+ nNewBorderDistance = 0;
+ }
+
+ nMargin = nNewMargin;
+ nBorderDistance = nNewBorderDistance;
+}
+
+// Heuristics to decide if we need to use "from edge" offset of borders
+//
+// There are two cases when we can safely use "from text" or "from edge" offset without distorting
+// border position (modulo rounding errors):
+// 1. When distance of all borders from text is no greater than 31 pt, we use "from text"
+// 2. Otherwise, if distance of all borders from edge is no greater than 31 pt, we use "from edge"
+// In all other cases, the position of borders would be distorted on export, because Word doesn't
+// support the offset of >31 pts (https://msdn.microsoft.com/en-us/library/ff533820), and we need
+// to decide which type of offset would provide less wrong result (i.e., the result would look
+// closer to original). Here, we just check sum of distances from text to borders, and if it is
+// less than sum of distances from borders to edges. The alternative would be to compare total areas
+// between text-and-borders and between borders-and-edges (taking into account different lengths of
+// borders, and visual impact of that).
+void BorderDistancesToWord(const SvxBoxItem& rBox, const WordPageMargins& rMargins,
+ WordBorderDistances& rDistances)
+{
+ // Use signed sal_Int32 that can hold sal_uInt16, to prevent overflow at subtraction below
+ const sal_Int32 nT = rBox.GetDistance(SvxBoxItemLine::TOP);
+ const sal_Int32 nL = rBox.GetDistance(SvxBoxItemLine::LEFT);
+ const sal_Int32 nB = rBox.GetDistance(SvxBoxItemLine::BOTTOM);
+ const sal_Int32 nR = rBox.GetDistance(SvxBoxItemLine::RIGHT);
+
+ // Only take into account existing borders
+ const SvxBorderLine* pLnT = rBox.GetLine(SvxBoxItemLine::TOP);
+ const SvxBorderLine* pLnL = rBox.GetLine(SvxBoxItemLine::LEFT);
+ const SvxBorderLine* pLnB = rBox.GetLine(SvxBoxItemLine::BOTTOM);
+ const SvxBorderLine* pLnR = rBox.GetLine(SvxBoxItemLine::RIGHT);
+
+ // We need to take border widths into account
+ const long nWidthT = pLnT ? pLnT->GetScaledWidth() : 0;
+ const long nWidthL = pLnL ? pLnL->GetScaledWidth() : 0;
+ const long nWidthB = pLnB ? pLnB->GetScaledWidth() : 0;
+ const long nWidthR = pLnR ? pLnR->GetScaledWidth() : 0;
+
+ // Resulting distances from text to borders
+ const sal_Int32 nT2BT = pLnT ? nT : 0;
+ const sal_Int32 nT2BL = pLnL ? nL : 0;
+ const sal_Int32 nT2BB = pLnB ? nB : 0;
+ const sal_Int32 nT2BR = pLnR ? nR : 0;
+
+ // Resulting distances from edge to borders
+ const sal_Int32 nE2BT = pLnT ? std::max<sal_Int32>(rMargins.nTop - nT - nWidthT, 0) : 0;
+ const sal_Int32 nE2BL = pLnL ? std::max<sal_Int32>(rMargins.nLeft - nL - nWidthL, 0) : 0;
+ const sal_Int32 nE2BB = pLnB ? std::max<sal_Int32>(rMargins.nBottom - nB - nWidthB, 0) : 0;
+ const sal_Int32 nE2BR = pLnR ? std::max<sal_Int32>(rMargins.nRight - nR - nWidthR, 0) : 0;
+
+ const sal_Int32 n32pt = 32 * 20;
+ // 1. If all borders are in range of 31 pts from text
+ if (nT2BT < n32pt && nT2BL < n32pt && nT2BB < n32pt && nT2BR < n32pt)
+ {
+ rDistances.bFromEdge = false;
+ }
+ else
+ {
+ // 2. If all borders are in range of 31 pts from edge
+ if (nE2BT < n32pt && nE2BL < n32pt && nE2BB < n32pt && nE2BR < n32pt)
+ {
+ rDistances.bFromEdge = true;
+ }
+ else
+ {
+ // Let's try to guess which would be the best approximation
+ rDistances.bFromEdge =
+ (nT2BT + nT2BL + nT2BB + nT2BR) > (nE2BT + nE2BL + nE2BB + nE2BR);
+ }
+ }
+
+ if (rDistances.bFromEdge)
+ {
+ rDistances.nTop = sal::static_int_cast<sal_uInt16>(nE2BT);
+ rDistances.nLeft = sal::static_int_cast<sal_uInt16>(nE2BL);
+ rDistances.nBottom = sal::static_int_cast<sal_uInt16>(nE2BB);
+ rDistances.nRight = sal::static_int_cast<sal_uInt16>(nE2BR);
+ }
+ else
+ {
+ rDistances.nTop = sal::static_int_cast<sal_uInt16>(nT2BT);
+ rDistances.nLeft = sal::static_int_cast<sal_uInt16>(nT2BL);
+ rDistances.nBottom = sal::static_int_cast<sal_uInt16>(nT2BB);
+ rDistances.nRight = sal::static_int_cast<sal_uInt16>(nT2BR);
+ }
+}
+
+}
+
+// class SvxFormatBreakItem -------------------------------------------------
+
+bool SvxFormatBreakItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ assert(SfxPoolItem::operator==(rAttr));
+
+ return GetValue() == static_cast<const SvxFormatBreakItem&>( rAttr ).GetValue();
+}
+
+
+bool SvxFormatBreakItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper&
+) const
+{
+ rText = GetValueTextByPos( GetEnumValue() );
+ return true;
+}
+
+OUString SvxFormatBreakItem::GetValueTextByPos( sal_uInt16 nPos )
+{
+ static const char* RID_SVXITEMS_BREAK[] =
+ {
+ RID_SVXITEMS_BREAK_NONE,
+ RID_SVXITEMS_BREAK_COLUMN_BEFORE,
+ RID_SVXITEMS_BREAK_COLUMN_AFTER,
+ RID_SVXITEMS_BREAK_COLUMN_BOTH,
+ RID_SVXITEMS_BREAK_PAGE_BEFORE,
+ RID_SVXITEMS_BREAK_PAGE_AFTER,
+ RID_SVXITEMS_BREAK_PAGE_BOTH
+ };
+ static_assert(SAL_N_ELEMENTS(RID_SVXITEMS_BREAK) == size_t(SvxBreak::End), "unexpected size");
+ assert(nPos < sal_uInt16(SvxBreak::End) && "enum overflow!");
+ return EditResId(RID_SVXITEMS_BREAK[nPos]);
+}
+
+bool SvxFormatBreakItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
+{
+ style::BreakType eBreak = style::BreakType_NONE;
+ switch ( GetBreak() )
+ {
+ case SvxBreak::ColumnBefore: eBreak = style::BreakType_COLUMN_BEFORE; break;
+ case SvxBreak::ColumnAfter: eBreak = style::BreakType_COLUMN_AFTER ; break;
+ case SvxBreak::ColumnBoth: eBreak = style::BreakType_COLUMN_BOTH ; break;
+ case SvxBreak::PageBefore: eBreak = style::BreakType_PAGE_BEFORE ; break;
+ case SvxBreak::PageAfter: eBreak = style::BreakType_PAGE_AFTER ; break;
+ case SvxBreak::PageBoth: eBreak = style::BreakType_PAGE_BOTH ; break;
+ default: ; // prevent warning
+ }
+ rVal <<= eBreak;
+ return true;
+}
+
+bool SvxFormatBreakItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
+{
+ style::BreakType nBreak;
+
+ if(!(rVal >>= nBreak))
+ {
+ sal_Int32 nValue = 0;
+ if(!(rVal >>= nValue))
+ return false;
+
+ nBreak = static_cast<style::BreakType>(nValue);
+ }
+
+ SvxBreak eBreak = SvxBreak::NONE;
+ switch( nBreak )
+ {
+ case style::BreakType_COLUMN_BEFORE: eBreak = SvxBreak::ColumnBefore; break;
+ case style::BreakType_COLUMN_AFTER: eBreak = SvxBreak::ColumnAfter; break;
+ case style::BreakType_COLUMN_BOTH: eBreak = SvxBreak::ColumnBoth; break;
+ case style::BreakType_PAGE_BEFORE: eBreak = SvxBreak::PageBefore; break;
+ case style::BreakType_PAGE_AFTER: eBreak = SvxBreak::PageAfter; break;
+ case style::BreakType_PAGE_BOTH: eBreak = SvxBreak::PageBoth; break;
+ default: ; // prevent warning
+ }
+ SetValue(eBreak);
+
+ return true;
+}
+
+SvxFormatBreakItem* SvxFormatBreakItem::Clone( SfxItemPool* ) const
+{
+ return new SvxFormatBreakItem( *this );
+}
+
+sal_uInt16 SvxFormatBreakItem::GetValueCount() const
+{
+ return sal_uInt16(SvxBreak::End); // SvxBreak::PageBoth + 1
+}
+
+SvxFormatKeepItem* SvxFormatKeepItem::Clone( SfxItemPool* ) const
+{
+ return new SvxFormatKeepItem( *this );
+}
+
+bool SvxFormatKeepItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper&
+ ) const
+{
+ const char* pId = RID_SVXITEMS_FMTKEEP_FALSE;
+
+ if ( GetValue() )
+ pId = RID_SVXITEMS_FMTKEEP_TRUE;
+ rText = EditResId(pId);
+ return true;
+}
+
+
+SvxLineItem::SvxLineItem( const sal_uInt16 nId ) :
+ SfxPoolItem ( nId )
+{
+}
+
+
+SvxLineItem::SvxLineItem( const SvxLineItem& rCpy ) :
+ SfxPoolItem ( rCpy ),
+ pLine(rCpy.pLine ? new SvxBorderLine( *rCpy.pLine ) : nullptr)
+{
+}
+
+
+SvxLineItem::~SvxLineItem()
+{
+}
+
+
+bool SvxLineItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ assert(SfxPoolItem::operator==(rAttr));
+
+ return CmpBrdLn( pLine, static_cast<const SvxLineItem&>(rAttr).GetLine() );
+}
+
+SvxLineItem* SvxLineItem::Clone( SfxItemPool* ) const
+{
+ return new SvxLineItem( *this );
+}
+
+bool SvxLineItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemId ) const
+{
+ bool bConvert = 0!=(nMemId&CONVERT_TWIPS);
+ nMemId &= ~CONVERT_TWIPS;
+ if ( nMemId == 0 )
+ {
+ rVal <<= SvxBoxItem::SvxLineToLine(pLine.get(), bConvert);
+ return true;
+ }
+ else if ( pLine )
+ {
+ switch ( nMemId )
+ {
+ case MID_FG_COLOR: rVal <<= pLine->GetColor(); break;
+ case MID_OUTER_WIDTH: rVal <<= sal_Int32(pLine->GetOutWidth()); break;
+ case MID_INNER_WIDTH: rVal <<= sal_Int32(pLine->GetInWidth( )); break;
+ case MID_DISTANCE: rVal <<= sal_Int32(pLine->GetDistance()); break;
+ default:
+ OSL_FAIL( "Wrong MemberId" );
+ return false;
+ }
+ }
+
+ return true;
+}
+
+
+bool SvxLineItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemId )
+{
+ bool bConvert = 0!=(nMemId&CONVERT_TWIPS);
+ nMemId &= ~CONVERT_TWIPS;
+ sal_Int32 nVal = 0;
+ if ( nMemId == 0 )
+ {
+ table::BorderLine2 aLine;
+ if ( lcl_extractBorderLine(rVal, aLine) )
+ {
+ if ( !pLine )
+ pLine.reset( new SvxBorderLine );
+ if( !SvxBoxItem::LineToSvxLine(aLine, *pLine, bConvert) )
+ pLine.reset();
+ return true;
+ }
+ return false;
+ }
+ else if ( rVal >>= nVal )
+ {
+ if ( !pLine )
+ pLine.reset( new SvxBorderLine );
+
+ switch ( nMemId )
+ {
+ case MID_FG_COLOR: pLine->SetColor( Color(nVal) ); break;
+ case MID_LINE_STYLE:
+ pLine->SetBorderLineStyle(static_cast<SvxBorderLineStyle>(nVal));
+ break;
+ default:
+ OSL_FAIL( "Wrong MemberId" );
+ return false;
+ }
+
+ return true;
+ }
+
+ return false;
+}
+
+
+bool SvxLineItem::GetPresentation
+(
+ SfxItemPresentation ePres,
+ MapUnit eCoreUnit,
+ MapUnit ePresUnit,
+ OUString& rText, const IntlWrapper& rIntl
+) const
+{
+ rText.clear();
+
+ if ( pLine )
+ rText = pLine->GetValueString( eCoreUnit, ePresUnit, &rIntl,
+ (SfxItemPresentation::Complete == ePres) );
+ return true;
+}
+
+
+void SvxLineItem::ScaleMetrics( long nMult, long nDiv )
+{
+ if ( pLine ) pLine->ScaleMetrics( nMult, nDiv );
+}
+
+
+bool SvxLineItem::HasMetrics() const
+{
+ return true;
+}
+
+
+void SvxLineItem::SetLine( const SvxBorderLine* pNew )
+{
+ pLine.reset( pNew ? new SvxBorderLine( *pNew ) : nullptr );
+}
+
+SvxBrushItem::SvxBrushItem(sal_uInt16 _nWhich)
+ : SfxPoolItem(_nWhich)
+ , aColor(COL_TRANSPARENT)
+ , nShadingValue(ShadingPattern::CLEAR)
+ , nGraphicTransparency(0)
+ , eGraphicPos(GPOS_NONE)
+ , bLoadAgain(true)
+{
+}
+
+SvxBrushItem::SvxBrushItem(const Color& rColor, sal_uInt16 _nWhich)
+ : SfxPoolItem(_nWhich)
+ , aColor(rColor)
+ , nShadingValue(ShadingPattern::CLEAR)
+ , nGraphicTransparency(0)
+ , eGraphicPos(GPOS_NONE)
+ , bLoadAgain(true)
+{
+}
+
+SvxBrushItem::SvxBrushItem(const Graphic& rGraphic, SvxGraphicPosition ePos, sal_uInt16 _nWhich)
+ : SfxPoolItem(_nWhich)
+ , aColor(COL_TRANSPARENT)
+ , nShadingValue(ShadingPattern::CLEAR)
+ , xGraphicObject(new GraphicObject(rGraphic))
+ , nGraphicTransparency(0)
+ , eGraphicPos((GPOS_NONE != ePos) ? ePos : GPOS_MM)
+ , bLoadAgain(true)
+{
+ DBG_ASSERT( GPOS_NONE != ePos, "SvxBrushItem-Ctor with GPOS_NONE == ePos" );
+}
+
+SvxBrushItem::SvxBrushItem(const GraphicObject& rGraphicObj, SvxGraphicPosition ePos, sal_uInt16 _nWhich)
+ : SfxPoolItem(_nWhich)
+ , aColor(COL_TRANSPARENT)
+ , nShadingValue(ShadingPattern::CLEAR)
+ , xGraphicObject(new GraphicObject(rGraphicObj))
+ , nGraphicTransparency(0)
+ , eGraphicPos((GPOS_NONE != ePos) ? ePos : GPOS_MM)
+ , bLoadAgain(true)
+{
+ DBG_ASSERT( GPOS_NONE != ePos, "SvxBrushItem-Ctor with GPOS_NONE == ePos" );
+}
+
+SvxBrushItem::SvxBrushItem(const OUString& rLink, const OUString& rFilter,
+ SvxGraphicPosition ePos, sal_uInt16 _nWhich)
+ : SfxPoolItem(_nWhich)
+ , aColor(COL_TRANSPARENT)
+ , nShadingValue(ShadingPattern::CLEAR)
+ , nGraphicTransparency(0)
+ , maStrLink(rLink)
+ , maStrFilter(rFilter)
+ , eGraphicPos((GPOS_NONE != ePos) ? ePos : GPOS_MM)
+ , bLoadAgain(true)
+{
+ DBG_ASSERT( GPOS_NONE != ePos, "SvxBrushItem-Ctor with GPOS_NONE == ePos" );
+}
+
+SvxBrushItem::SvxBrushItem(const SvxBrushItem& rItem)
+ : SfxPoolItem(rItem)
+ , aColor(rItem.aColor)
+ , nShadingValue(rItem.nShadingValue)
+ , xGraphicObject(rItem.xGraphicObject ? new GraphicObject(*rItem.xGraphicObject) : nullptr)
+ , nGraphicTransparency(rItem.nGraphicTransparency)
+ , maStrLink(rItem.maStrLink)
+ , maStrFilter(rItem.maStrFilter)
+ , eGraphicPos(rItem.eGraphicPos)
+ , bLoadAgain(rItem.bLoadAgain)
+{
+}
+
+SvxBrushItem::SvxBrushItem(SvxBrushItem&& rItem)
+ : SfxPoolItem(std::move(rItem))
+ , aColor(std::move(rItem.aColor))
+ , nShadingValue(std::move(rItem.nShadingValue))
+ , xGraphicObject(std::move(rItem.xGraphicObject))
+ , nGraphicTransparency(std::move(rItem.nGraphicTransparency))
+ , maStrLink(std::move(rItem.maStrLink))
+ , maStrFilter(std::move(rItem.maStrFilter))
+ , eGraphicPos(std::move(rItem.eGraphicPos))
+ , bLoadAgain(std::move(rItem.bLoadAgain))
+{
+}
+
+SvxBrushItem::~SvxBrushItem()
+{
+}
+
+bool SvxBrushItem::isUsed() const
+{
+ if (GPOS_NONE != GetGraphicPos())
+ {
+ // graphic used
+ return true;
+ }
+ else if (0xff != GetColor().GetTransparency())
+ {
+ // color used
+ return true;
+ }
+
+ return false;
+}
+
+
+static sal_Int8 lcl_PercentToTransparency(long nPercent)
+{
+ // 0xff must not be returned!
+ return sal_Int8(nPercent ? (50 + 0xfe * nPercent) / 100 : 0);
+}
+
+
+sal_Int8 SvxBrushItem::TransparencyToPercent(sal_Int32 nTrans)
+{
+ return static_cast<sal_Int8>((nTrans * 100 + 127) / 254);
+}
+
+
+bool SvxBrushItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch( nMemberId)
+ {
+ case MID_BACK_COLOR:
+ rVal <<= aColor;
+ break;
+ case MID_BACK_COLOR_R_G_B:
+ rVal <<= aColor.GetRGBColor();
+ break;
+ case MID_BACK_COLOR_TRANSPARENCY:
+ rVal <<= SvxBrushItem::TransparencyToPercent(aColor.GetTransparency());
+ break;
+ case MID_GRAPHIC_POSITION:
+ rVal <<= static_cast<style::GraphicLocation>(static_cast<sal_Int16>(eGraphicPos));
+ break;
+
+ case MID_GRAPHIC_TRANSPARENT:
+ rVal <<= ( aColor.GetTransparency() == 0xff );
+ break;
+
+ case MID_GRAPHIC_URL:
+ case MID_GRAPHIC:
+ {
+ uno::Reference<graphic::XGraphic> xGraphic;
+ if (!maStrLink.isEmpty())
+ {
+ Graphic aGraphic(vcl::graphic::loadFromURL(maStrLink));
+ xGraphic = aGraphic.GetXGraphic();
+ }
+ else if (xGraphicObject)
+ {
+ xGraphic = xGraphicObject->GetGraphic().GetXGraphic();
+ }
+ rVal <<= xGraphic;
+ }
+ break;
+
+ case MID_GRAPHIC_FILTER:
+ {
+ rVal <<= maStrFilter;
+ }
+ break;
+
+ case MID_GRAPHIC_TRANSPARENCY:
+ rVal <<= nGraphicTransparency;
+ break;
+
+ case MID_SHADING_VALUE:
+ {
+ rVal <<= nShadingValue;
+ }
+ break;
+ }
+
+ return true;
+}
+
+
+bool SvxBrushItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch( nMemberId)
+ {
+ case MID_BACK_COLOR:
+ case MID_BACK_COLOR_R_G_B:
+ {
+ Color aNewCol;
+ if ( !( rVal >>= aNewCol ) )
+ return false;
+ if(MID_BACK_COLOR_R_G_B == nMemberId)
+ {
+ aNewCol.SetTransparency(aColor.GetTransparency());
+ }
+ aColor = aNewCol;
+ }
+ break;
+ case MID_BACK_COLOR_TRANSPARENCY:
+ {
+ sal_Int32 nTrans = 0;
+ if ( !( rVal >>= nTrans ) || nTrans < 0 || nTrans > 100 )
+ return false;
+ aColor.SetTransparency(lcl_PercentToTransparency(nTrans));
+ }
+ break;
+
+ case MID_GRAPHIC_POSITION:
+ {
+ style::GraphicLocation eLocation;
+ if ( !( rVal>>=eLocation ) )
+ {
+ sal_Int32 nValue = 0;
+ if ( !( rVal >>= nValue ) )
+ return false;
+ eLocation = static_cast<style::GraphicLocation>(nValue);
+ }
+ SetGraphicPos( static_cast<SvxGraphicPosition>(static_cast<sal_uInt16>(eLocation)) );
+ }
+ break;
+
+ case MID_GRAPHIC_TRANSPARENT:
+ aColor.SetTransparency( Any2Bool( rVal ) ? 0xff : 0 );
+ break;
+
+ case MID_GRAPHIC_URL:
+ case MID_GRAPHIC:
+ {
+ Graphic aGraphic;
+
+ if (rVal.getValueType() == ::cppu::UnoType<OUString>::get())
+ {
+ OUString aURL = rVal.get<OUString>();
+ aGraphic = vcl::graphic::loadFromURL(aURL);
+ }
+ else if (rVal.getValueType() == cppu::UnoType<graphic::XGraphic>::get())
+ {
+ auto xGraphic = rVal.get<uno::Reference<graphic::XGraphic>>();
+ aGraphic = Graphic(xGraphic);
+ }
+
+ if (!aGraphic.IsNone())
+ {
+ maStrLink.clear();
+
+ std::unique_ptr<GraphicObject> xOldGrfObj(std::move(xGraphicObject));
+ xGraphicObject.reset(new GraphicObject(aGraphic));
+ ApplyGraphicTransparency_Impl();
+ xOldGrfObj.reset();
+
+ if (!aGraphic.IsNone() && eGraphicPos == GPOS_NONE)
+ {
+ eGraphicPos = GPOS_MM;
+ }
+ else if (aGraphic.IsNone())
+ {
+ eGraphicPos = GPOS_NONE;
+ }
+ }
+ }
+ break;
+
+ case MID_GRAPHIC_FILTER:
+ {
+ if( rVal.getValueType() == ::cppu::UnoType<OUString>::get() )
+ {
+ OUString sLink;
+ rVal >>= sLink;
+ SetGraphicFilter( sLink );
+ }
+ }
+ break;
+ case MID_GRAPHIC_TRANSPARENCY :
+ {
+ sal_Int32 nTmp = 0;
+ rVal >>= nTmp;
+ if(nTmp >= 0 && nTmp <= 100)
+ {
+ nGraphicTransparency = sal_Int8(nTmp);
+ if (xGraphicObject)
+ ApplyGraphicTransparency_Impl();
+ }
+ }
+ break;
+
+ case MID_SHADING_VALUE:
+ {
+ sal_Int32 nVal = 0;
+ if (!(rVal >>= nVal))
+ return false;
+
+ nShadingValue = nVal;
+ }
+ break;
+ }
+
+ return true;
+}
+
+
+bool SvxBrushItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper&
+ ) const
+{
+ if ( GPOS_NONE == eGraphicPos )
+ {
+ rText = ::GetColorString( aColor ) + cpDelim;
+ const char* pId = RID_SVXITEMS_TRANSPARENT_FALSE;
+
+ if ( aColor.GetTransparency() )
+ pId = RID_SVXITEMS_TRANSPARENT_TRUE;
+ rText += EditResId(pId);
+ }
+ else
+ {
+ rText = EditResId(RID_SVXITEMS_GRAPHIC);
+ }
+
+ return true;
+}
+
+bool SvxBrushItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ assert(SfxPoolItem::operator==(rAttr));
+
+ const SvxBrushItem& rCmp = static_cast<const SvxBrushItem&>(rAttr);
+ bool bEqual = ( aColor == rCmp.aColor && eGraphicPos == rCmp.eGraphicPos &&
+ nGraphicTransparency == rCmp.nGraphicTransparency);
+
+ if ( bEqual )
+ {
+ if ( GPOS_NONE != eGraphicPos )
+ {
+ bEqual = maStrLink == rCmp.maStrLink;
+
+ if ( bEqual )
+ {
+ bEqual = maStrFilter == rCmp.maStrFilter;
+ }
+
+ if ( bEqual )
+ {
+ if (!rCmp.xGraphicObject)
+ bEqual = !xGraphicObject;
+ else
+ bEqual = xGraphicObject &&
+ (*xGraphicObject == *rCmp.xGraphicObject);
+ }
+ }
+
+ if (bEqual)
+ {
+ bEqual = nShadingValue == rCmp.nShadingValue;
+ }
+ }
+
+ return bEqual;
+}
+
+SvxBrushItem* SvxBrushItem::Clone( SfxItemPool* ) const
+{
+ return new SvxBrushItem( *this );
+}
+
+const GraphicObject* SvxBrushItem::GetGraphicObject(OUString const & referer) const
+{
+ if (bLoadAgain && !maStrLink.isEmpty() && !xGraphicObject)
+ // when graphics already loaded, use as a cache
+ {
+ if (maSecOptions.isUntrustedReferer(referer)) {
+ return nullptr;
+ }
+
+ // tdf#94088 prepare graphic and state
+ Graphic aGraphic;
+ bool bGraphicLoaded = false;
+
+ // try to create stream directly from given URL
+ std::unique_ptr<SvStream> xStream(utl::UcbStreamHelper::CreateStream(maStrLink, StreamMode::STD_READ));
+ // tdf#94088 if we have a stream, try to load it directly as graphic
+ if (xStream && !xStream->GetError())
+ {
+ if (ERRCODE_NONE == GraphicFilter::GetGraphicFilter().ImportGraphic(aGraphic, maStrLink, *xStream,
+ GRFILTER_FORMAT_DONTKNOW, nullptr, GraphicFilterImportFlags::DontSetLogsizeForJpeg))
+ {
+ bGraphicLoaded = true;
+ }
+ }
+
+ // tdf#94088 if no succeeded, try if the string (which is not empty) contains
+ // a 'data:' scheme url and try to load that (embedded graphics)
+ if(!bGraphicLoaded)
+ {
+ INetURLObject aGraphicURL( maStrLink );
+
+ if( INetProtocol::Data == aGraphicURL.GetProtocol() )
+ {
+ std::unique_ptr<SvMemoryStream> const xMemStream(aGraphicURL.getData());
+ if (xMemStream)
+ {
+ if (ERRCODE_NONE == GraphicFilter::GetGraphicFilter().ImportGraphic(aGraphic, "", *xMemStream))
+ {
+ bGraphicLoaded = true;
+
+ // tdf#94088 delete the no longer needed data scheme URL which
+ // is potentially pretty // large, containing a base64 encoded copy of the graphic
+ const_cast< SvxBrushItem* >(this)->maStrLink.clear();
+ }
+ }
+ }
+ }
+
+ // tdf#94088 when we got a graphic, set it
+ if(bGraphicLoaded && GraphicType::NONE != aGraphic.GetType())
+ {
+ xGraphicObject.reset(new GraphicObject);
+ xGraphicObject->SetGraphic(aGraphic);
+ const_cast < SvxBrushItem*> (this)->ApplyGraphicTransparency_Impl();
+ }
+ else
+ {
+ bLoadAgain = false;
+ }
+ }
+
+ return xGraphicObject.get();
+}
+
+void SvxBrushItem::setGraphicTransparency(sal_Int8 nNew)
+{
+ if (nNew != nGraphicTransparency)
+ {
+ nGraphicTransparency = nNew;
+ ApplyGraphicTransparency_Impl();
+ }
+}
+
+const Graphic* SvxBrushItem::GetGraphic(OUString const & referer) const
+{
+ const GraphicObject* pGrafObj = GetGraphicObject(referer);
+ return( pGrafObj ? &( pGrafObj->GetGraphic() ) : nullptr );
+}
+
+void SvxBrushItem::SetGraphicPos( SvxGraphicPosition eNew )
+{
+ eGraphicPos = eNew;
+
+ if ( GPOS_NONE == eGraphicPos )
+ {
+ xGraphicObject.reset();
+ maStrLink.clear();
+ maStrFilter.clear();
+ }
+ else
+ {
+ if (!xGraphicObject && maStrLink.isEmpty())
+ {
+ xGraphicObject.reset(new GraphicObject); // Creating a dummy
+ }
+ }
+}
+
+void SvxBrushItem::SetGraphic( const Graphic& rNew )
+{
+ if ( maStrLink.isEmpty() )
+ {
+ if (xGraphicObject)
+ xGraphicObject->SetGraphic(rNew);
+ else
+ xGraphicObject.reset(new GraphicObject(rNew));
+
+ ApplyGraphicTransparency_Impl();
+
+ if ( GPOS_NONE == eGraphicPos )
+ eGraphicPos = GPOS_MM; // None would be brush, then Default: middle
+ }
+ else
+ {
+ OSL_FAIL( "SetGraphic() on linked graphic! :-/" );
+ }
+}
+
+void SvxBrushItem::SetGraphicObject( const GraphicObject& rNewObj )
+{
+ if ( maStrLink.isEmpty() )
+ {
+ if (xGraphicObject)
+ *xGraphicObject = rNewObj;
+ else
+ xGraphicObject.reset(new GraphicObject(rNewObj));
+
+ ApplyGraphicTransparency_Impl();
+
+ if ( GPOS_NONE == eGraphicPos )
+ eGraphicPos = GPOS_MM; // None would be brush, then Default: middle
+ }
+ else
+ {
+ OSL_FAIL( "SetGraphic() on linked graphic! :-/" );
+ }
+}
+
+void SvxBrushItem::SetGraphicLink( const OUString& rNew )
+{
+ if ( rNew.isEmpty() )
+ maStrLink.clear();
+ else
+ {
+ maStrLink = rNew;
+ xGraphicObject.reset();
+ }
+}
+
+void SvxBrushItem::SetGraphicFilter( const OUString& rNew )
+{
+ maStrFilter = rNew;
+}
+
+void SvxBrushItem::ApplyGraphicTransparency_Impl()
+{
+ DBG_ASSERT(xGraphicObject, "no GraphicObject available" );
+ if (xGraphicObject)
+ {
+ GraphicAttr aAttr(xGraphicObject->GetAttr());
+ aAttr.SetTransparency(lcl_PercentToTransparency(
+ nGraphicTransparency));
+ xGraphicObject->SetAttr(aAttr);
+ }
+}
+
+void SvxBrushItem::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+ xmlTextWriterStartElement(pWriter, BAD_CAST("SvxBrushItem"));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("color"), BAD_CAST(aColor.AsRGBHexString().toUtf8().getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("shadingValue"), BAD_CAST(OString::number(nShadingValue).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("link"), BAD_CAST(maStrLink.toUtf8().getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("filter"), BAD_CAST(maStrFilter.toUtf8().getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("graphicPos"), BAD_CAST(OString::number(eGraphicPos).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("loadAgain"), BAD_CAST(OString::boolean(bLoadAgain).getStr()));
+ xmlTextWriterEndElement(pWriter);
+}
+
+
+SvxFrameDirectionItem::SvxFrameDirectionItem( SvxFrameDirection nValue ,
+ sal_uInt16 _nWhich )
+ : SfxEnumItem<SvxFrameDirection>( _nWhich, nValue )
+{
+}
+
+
+SvxFrameDirectionItem::~SvxFrameDirectionItem()
+{
+}
+
+SvxFrameDirectionItem* SvxFrameDirectionItem::Clone( SfxItemPool * ) const
+{
+ return new SvxFrameDirectionItem( *this );
+}
+
+const char* getFrmDirResId(size_t nIndex)
+{
+ const char* const RID_SVXITEMS_FRMDIR[] =
+ {
+ RID_SVXITEMS_FRMDIR_HORI_LEFT_TOP,
+ RID_SVXITEMS_FRMDIR_HORI_RIGHT_TOP,
+ RID_SVXITEMS_FRMDIR_VERT_TOP_RIGHT,
+ RID_SVXITEMS_FRMDIR_VERT_TOP_LEFT,
+ RID_SVXITEMS_FRMDIR_ENVIRONMENT,
+ RID_SVXITEMS_FRMDIR_VERT_BOT_LEFT
+ };
+ return RID_SVXITEMS_FRMDIR[nIndex];
+}
+
+bool SvxFrameDirectionItem::GetPresentation(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper&) const
+{
+ rText = EditResId(getFrmDirResId(GetEnumValue()));
+ return true;
+}
+
+bool SvxFrameDirectionItem::PutValue( const css::uno::Any& rVal,
+ sal_uInt8 )
+{
+ sal_Int16 nVal = sal_Int16();
+ bool bRet = ( rVal >>= nVal );
+ if( bRet )
+ {
+ // translate WritingDirection2 constants into SvxFrameDirection
+ switch( nVal )
+ {
+ case text::WritingMode2::LR_TB:
+ SetValue( SvxFrameDirection::Horizontal_LR_TB );
+ break;
+ case text::WritingMode2::RL_TB:
+ SetValue( SvxFrameDirection::Horizontal_RL_TB );
+ break;
+ case text::WritingMode2::TB_RL:
+ SetValue( SvxFrameDirection::Vertical_RL_TB );
+ break;
+ case text::WritingMode2::TB_LR:
+ SetValue( SvxFrameDirection::Vertical_LR_TB );
+ break;
+ case text::WritingMode2::BT_LR:
+ SetValue( SvxFrameDirection::Vertical_LR_BT );
+ break;
+ case text::WritingMode2::PAGE:
+ SetValue( SvxFrameDirection::Environment );
+ break;
+ default:
+ bRet = false;
+ break;
+ }
+ }
+
+ return bRet;
+}
+
+
+bool SvxFrameDirectionItem::QueryValue( css::uno::Any& rVal,
+ sal_uInt8 ) const
+{
+ // translate SvxFrameDirection into WritingDirection2
+ sal_Int16 nVal;
+ bool bRet = true;
+ switch( GetValue() )
+ {
+ case SvxFrameDirection::Horizontal_LR_TB:
+ nVal = text::WritingMode2::LR_TB;
+ break;
+ case SvxFrameDirection::Horizontal_RL_TB:
+ nVal = text::WritingMode2::RL_TB;
+ break;
+ case SvxFrameDirection::Vertical_RL_TB:
+ nVal = text::WritingMode2::TB_RL;
+ break;
+ case SvxFrameDirection::Vertical_LR_TB:
+ nVal = text::WritingMode2::TB_LR;
+ break;
+ case SvxFrameDirection::Vertical_LR_BT:
+ nVal = text::WritingMode2::BT_LR;
+ break;
+ case SvxFrameDirection::Environment:
+ nVal = text::WritingMode2::PAGE;
+ break;
+ default:
+ OSL_FAIL("Unknown SvxFrameDirection value!");
+ bRet = false;
+ break;
+ }
+
+ // return value + error state
+ if( bRet )
+ {
+ rVal <<= nVal;
+ }
+ return bRet;
+}
+
+void SvxFrameDirectionItem::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+ xmlTextWriterStartElement(pWriter, BAD_CAST("SvxFrameDirectionItem"));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("m_nWhich"),
+ BAD_CAST(OString::number(Which()).getStr()));
+ xmlTextWriterWriteAttribute(
+ pWriter, BAD_CAST("m_nValue"),
+ BAD_CAST(OString::number(static_cast<sal_Int16>(GetValue())).getStr()));
+ xmlTextWriterEndElement(pWriter);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/items/itemtype.cxx b/editeng/source/items/itemtype.cxx
new file mode 100644
index 000000000..9b3996e79
--- /dev/null
+++ b/editeng/source/items/itemtype.cxx
@@ -0,0 +1,232 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <osl/diagnose.h>
+#include <vcl/outdev.hxx>
+#include <editeng/editrids.hrc>
+#include <unotools/intlwrapper.hxx>
+#include <unotools/localedatawrapper.hxx>
+#include <editeng/itemtype.hxx>
+#include <editeng/eerdll.hxx>
+#include <rtl/ustrbuf.hxx>
+
+
+OUString GetMetricText( long nVal, MapUnit eSrcUnit, MapUnit eDestUnit, const IntlWrapper* pIntl )
+{
+ bool bNeg = false;
+ bool bShowAtLeastOneDecimalDigit = true;
+ sal_Int32 nRet = 0;
+
+ if ( nVal < 0 )
+ {
+ bNeg = true;
+ nVal *= -1;
+ }
+
+ switch ( eDestUnit )
+ {
+ case MapUnit::Map100thMM:
+ case MapUnit::Map10thMM:
+ case MapUnit::MapMM:
+ case MapUnit::MapCM:
+ {
+ nRet = OutputDevice::LogicToLogic( nVal, eSrcUnit, MapUnit::Map100thMM );
+
+ switch ( eDestUnit )
+ {
+ case MapUnit::Map100thMM: nRet *= 1000; break;
+ case MapUnit::Map10thMM: nRet *= 100; break;
+ case MapUnit::MapMM: nRet *= 10; break;
+ default: ;//prevent warning
+ }
+ break;
+ }
+
+ case MapUnit::Map1000thInch:
+ case MapUnit::Map100thInch:
+ case MapUnit::Map10thInch:
+ case MapUnit::MapInch:
+ {
+ nRet = OutputDevice::LogicToLogic( nVal, eSrcUnit, MapUnit::Map1000thInch );
+
+ switch ( eDestUnit )
+ {
+ case MapUnit::Map1000thInch: nRet *= 1000; break;
+ case MapUnit::Map100thInch: nRet *= 100; break;
+ case MapUnit::Map10thInch: nRet *= 10; break;
+ default: ;//prevent warning
+ }
+ break;
+ }
+
+ case MapUnit::MapPoint:
+ // fractions of a point are used, e.g., for font size
+ nRet = OutputDevice::LogicToLogic(nVal, eSrcUnit, MapUnit::MapTwip) * 50;
+ bShowAtLeastOneDecimalDigit = false;
+ break;
+
+ case MapUnit::MapTwip:
+ case MapUnit::MapPixel:
+ return OUString::number( OutputDevice::LogicToLogic(
+ nVal, eSrcUnit, eDestUnit ));
+
+ default:
+ OSL_FAIL( "not supported mapunit" );
+ return OUString();
+ }
+
+ if ( MapUnit::MapCM == eDestUnit || MapUnit::MapInch == eDestUnit )
+ {
+ sal_Int32 nMod = nRet % 10;
+
+ if ( nMod > 4 )
+ nRet += 10 - nMod;
+ else if ( nMod > 0 )
+ nRet -= nMod;
+ }
+
+ OUStringBuffer sRet;
+
+ if ( bNeg )
+ sRet.append('-');
+
+ long nDiff = 1000;
+ for( int nDigits = 4; nDigits; --nDigits, nDiff /= 10 )
+ {
+ if ( nRet < nDiff )
+ sRet.append('0');
+ else
+ sRet.append(nRet / nDiff);
+ nRet %= nDiff;
+ if( 4 == nDigits && (bShowAtLeastOneDecimalDigit || nRet) )
+ {
+ if(pIntl)
+ sRet.append(pIntl->getLocaleData()->getNumDecimalSep());
+ else
+ sRet.append(',');
+ if( !nRet )
+ {
+ sRet.append('0');
+ break;
+ }
+ }
+ else if( !nRet )
+ break;
+ }
+ return sRet.makeStringAndClear();
+}
+
+OUString GetColorString( const Color& rCol )
+{
+ if (rCol == COL_AUTO)
+ return EditResId(RID_SVXSTR_AUTOMATIC);
+
+ static const Color aColAry[] = {
+ COL_BLACK, COL_BLUE, COL_GREEN, COL_CYAN,
+ COL_RED, COL_MAGENTA, COL_BROWN, COL_GRAY,
+ COL_LIGHTGRAY, COL_LIGHTBLUE, COL_LIGHTGREEN, COL_LIGHTCYAN,
+ COL_LIGHTRED, COL_LIGHTMAGENTA, COL_YELLOW, COL_WHITE };
+
+ sal_uInt16 nColor = 0;
+ while ( nColor < SAL_N_ELEMENTS(aColAry) &&
+ aColAry[nColor] != rCol.GetRGBColor() )
+ {
+ nColor += 1;
+ }
+
+ static const char* RID_SVXITEMS_COLORS[] =
+ {
+ RID_SVXITEMS_COLOR_BLACK,
+ RID_SVXITEMS_COLOR_BLUE,
+ RID_SVXITEMS_COLOR_GREEN,
+ RID_SVXITEMS_COLOR_CYAN,
+ RID_SVXITEMS_COLOR_RED,
+ RID_SVXITEMS_COLOR_MAGENTA,
+ RID_SVXITEMS_COLOR_BROWN,
+ RID_SVXITEMS_COLOR_GRAY,
+ RID_SVXITEMS_COLOR_LIGHTGRAY,
+ RID_SVXITEMS_COLOR_LIGHTBLUE,
+ RID_SVXITEMS_COLOR_LIGHTGREEN,
+ RID_SVXITEMS_COLOR_LIGHTCYAN,
+ RID_SVXITEMS_COLOR_LIGHTRED,
+ RID_SVXITEMS_COLOR_LIGHTMAGENTA,
+ RID_SVXITEMS_COLOR_YELLOW,
+ RID_SVXITEMS_COLOR_WHITE
+ };
+
+ static_assert(SAL_N_ELEMENTS(aColAry) == SAL_N_ELEMENTS(RID_SVXITEMS_COLORS), "must match");
+
+ OUString sStr;
+ if ( nColor < SAL_N_ELEMENTS(aColAry) )
+ sStr = EditResId(RID_SVXITEMS_COLORS[nColor]);
+
+ if ( sStr.isEmpty() )
+ {
+ sStr += "RGB(" +
+ OUString::number( rCol.GetRed() ) + cpDelim +
+ OUString::number( rCol.GetGreen() ) + cpDelim +
+ OUString::number( rCol.GetBlue() ) + ")";
+ }
+ return sStr;
+}
+
+const char* GetMetricId( MapUnit eUnit )
+{
+ const char* pId = RID_SVXITEMS_METRIC_MM;
+
+ switch ( eUnit )
+ {
+ case MapUnit::Map100thMM:
+ case MapUnit::Map10thMM:
+ case MapUnit::MapMM:
+ pId = RID_SVXITEMS_METRIC_MM;
+ break;
+
+ case MapUnit::MapCM:
+ pId = RID_SVXITEMS_METRIC_CM;
+ break;
+
+ case MapUnit::Map1000thInch:
+ case MapUnit::Map100thInch:
+ case MapUnit::Map10thInch:
+ case MapUnit::MapInch:
+ pId = RID_SVXITEMS_METRIC_INCH;
+ break;
+
+ case MapUnit::MapPoint:
+ pId = RID_SVXITEMS_METRIC_POINT;
+ break;
+
+ case MapUnit::MapTwip:
+ pId = RID_SVXITEMS_METRIC_TWIP;
+ break;
+
+ case MapUnit::MapPixel:
+ pId = RID_SVXITEMS_METRIC_PIXEL;
+ break;
+
+ default:
+ OSL_FAIL( "not supported mapunit" );
+ }
+ return pId;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/items/justifyitem.cxx b/editeng/source/items/justifyitem.cxx
new file mode 100644
index 000000000..7fe699cb2
--- /dev/null
+++ b/editeng/source/items/justifyitem.cxx
@@ -0,0 +1,368 @@
+/* -*- 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 <editeng/justifyitem.hxx>
+#include <editeng/memberids.h>
+#include <editeng/eerdll.hxx>
+
+#include <com/sun/star/table/CellHoriJustify.hpp>
+#include <com/sun/star/style/ParagraphAdjust.hpp>
+#include <com/sun/star/table/CellJustifyMethod.hpp>
+#include <com/sun/star/table/CellVertJustify2.hpp>
+#include <com/sun/star/style/VerticalAlignment.hpp>
+
+#include <strings.hrc>
+
+SfxPoolItem* SvxHorJustifyItem::CreateDefault() { return new SvxHorJustifyItem(SvxCellHorJustify::Standard, 0) ;}
+SfxPoolItem* SvxVerJustifyItem::CreateDefault() { return new SvxVerJustifyItem(SvxCellVerJustify::Standard, 0) ;}
+
+using namespace ::com::sun::star;
+
+
+SvxHorJustifyItem::SvxHorJustifyItem( const sal_uInt16 nId ) :
+ SfxEnumItem( nId, SvxCellHorJustify::Standard )
+{
+}
+
+SvxHorJustifyItem::SvxHorJustifyItem( const SvxCellHorJustify eJustify,
+ const sal_uInt16 nId ) :
+ SfxEnumItem( nId, eJustify )
+{
+}
+
+
+bool SvxHorJustifyItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper&) const
+{
+ rText = GetValueText(GetValue());
+ return true;
+}
+
+
+bool SvxHorJustifyItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch ( nMemberId )
+ {
+ case MID_HORJUST_HORJUST:
+ {
+ table::CellHoriJustify eUno = table::CellHoriJustify_STANDARD;
+ switch ( GetValue() )
+ {
+ case SvxCellHorJustify::Standard: eUno = table::CellHoriJustify_STANDARD; break;
+ case SvxCellHorJustify::Left: eUno = table::CellHoriJustify_LEFT; break;
+ case SvxCellHorJustify::Center: eUno = table::CellHoriJustify_CENTER; break;
+ case SvxCellHorJustify::Right: eUno = table::CellHoriJustify_RIGHT; break;
+ case SvxCellHorJustify::Block: eUno = table::CellHoriJustify_BLOCK; break;
+ case SvxCellHorJustify::Repeat: eUno = table::CellHoriJustify_REPEAT; break;
+ }
+ rVal <<= eUno;
+ }
+ break;
+ case MID_HORJUST_ADJUST:
+ {
+ // ParagraphAdjust values, as in SvxAdjustItem
+ // (same value for ParaAdjust and ParaLastLineAdjust)
+
+ style::ParagraphAdjust nAdjust = style::ParagraphAdjust_LEFT;
+ switch ( GetValue() )
+ {
+ // ParagraphAdjust_LEFT is used for STANDARD and REPEAT
+ case SvxCellHorJustify::Standard:
+ case SvxCellHorJustify::Repeat:
+ case SvxCellHorJustify::Left: nAdjust = style::ParagraphAdjust_LEFT; break;
+ case SvxCellHorJustify::Center: nAdjust = style::ParagraphAdjust_CENTER; break;
+ case SvxCellHorJustify::Right: nAdjust = style::ParagraphAdjust_RIGHT; break;
+ case SvxCellHorJustify::Block: nAdjust = style::ParagraphAdjust_BLOCK; break;
+ }
+ rVal <<= static_cast<sal_Int16>(nAdjust); // as sal_Int16
+ }
+ break;
+ }
+ return true;
+}
+
+bool SvxHorJustifyItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch ( nMemberId )
+ {
+ case MID_HORJUST_HORJUST:
+ {
+ table::CellHoriJustify eUno;
+ if(!(rVal >>= eUno))
+ {
+ sal_Int32 nValue = 0;
+ if(!(rVal >>= nValue))
+ return false;
+ eUno = static_cast<table::CellHoriJustify>(nValue);
+ }
+ SvxCellHorJustify eSvx = SvxCellHorJustify::Standard;
+ switch (eUno)
+ {
+ case table::CellHoriJustify_STANDARD: eSvx = SvxCellHorJustify::Standard; break;
+ case table::CellHoriJustify_LEFT: eSvx = SvxCellHorJustify::Left; break;
+ case table::CellHoriJustify_CENTER: eSvx = SvxCellHorJustify::Center; break;
+ case table::CellHoriJustify_RIGHT: eSvx = SvxCellHorJustify::Right; break;
+ case table::CellHoriJustify_BLOCK: eSvx = SvxCellHorJustify::Block; break;
+ case table::CellHoriJustify_REPEAT: eSvx = SvxCellHorJustify::Repeat; break;
+ default: ; //prevent warning
+ }
+ SetValue( eSvx );
+ }
+ break;
+ case MID_HORJUST_ADJUST:
+ {
+ // property contains ParagraphAdjust values as sal_Int16
+ sal_Int16 nVal = sal_Int16();
+ if(!(rVal >>= nVal))
+ return false;
+
+ SvxCellHorJustify eSvx = SvxCellHorJustify::Standard;
+ switch (static_cast<style::ParagraphAdjust>(nVal))
+ {
+ // STRETCH is treated as BLOCK
+ case style::ParagraphAdjust_LEFT: eSvx = SvxCellHorJustify::Left; break;
+ case style::ParagraphAdjust_RIGHT: eSvx = SvxCellHorJustify::Right; break;
+ case style::ParagraphAdjust_STRETCH:
+ case style::ParagraphAdjust_BLOCK: eSvx = SvxCellHorJustify::Block; break;
+ case style::ParagraphAdjust_CENTER: eSvx = SvxCellHorJustify::Center; break;
+ default: break;
+ }
+ SetValue( eSvx );
+ }
+ }
+ return true;
+}
+
+OUString SvxHorJustifyItem::GetValueText(SvxCellHorJustify nVal)
+{
+ assert(nVal <= SvxCellHorJustify::Repeat && "enum overflow!");
+ return EditResId(RID_SVXITEMS_HORJUST[static_cast<size_t>(nVal)]);
+}
+
+SvxHorJustifyItem* SvxHorJustifyItem::Clone( SfxItemPool* ) const
+{
+ return new SvxHorJustifyItem( *this );
+}
+
+sal_uInt16 SvxHorJustifyItem::GetValueCount() const
+{
+ return sal_uInt16(SvxCellHorJustify::Repeat) + 1; // Last Enum value + 1
+}
+
+
+SvxVerJustifyItem::SvxVerJustifyItem( const sal_uInt16 nId ) :
+ SfxEnumItem( nId, SvxCellVerJustify::Standard )
+{
+}
+
+SvxVerJustifyItem::SvxVerJustifyItem( const SvxCellVerJustify eJustify,
+ const sal_uInt16 nId ) :
+ SfxEnumItem( nId, eJustify )
+{
+}
+
+
+bool SvxVerJustifyItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText,
+ const IntlWrapper& ) const
+{
+ rText = GetValueText( GetValue() );
+ return true;
+}
+
+
+bool SvxVerJustifyItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch ( nMemberId )
+ {
+ case MID_HORJUST_ADJUST:
+ {
+ style::VerticalAlignment eUno = style::VerticalAlignment_TOP;
+ switch ( GetValue() )
+ {
+ case SvxCellVerJustify::Top: eUno = style::VerticalAlignment_TOP; break;
+ case SvxCellVerJustify::Center: eUno = style::VerticalAlignment_MIDDLE; break;
+ case SvxCellVerJustify::Bottom: eUno = style::VerticalAlignment_BOTTOM; break;
+ default: ; //prevent warning
+ }
+ rVal <<= eUno;
+ break;
+ }
+ default:
+ {
+ sal_Int32 nUno = table::CellVertJustify2::STANDARD;
+ switch ( GetValue() )
+ {
+ case SvxCellVerJustify::Standard: nUno = table::CellVertJustify2::STANDARD; break;
+ case SvxCellVerJustify::Top: nUno = table::CellVertJustify2::TOP; break;
+ case SvxCellVerJustify::Center: nUno = table::CellVertJustify2::CENTER; break;
+ case SvxCellVerJustify::Bottom: nUno = table::CellVertJustify2::BOTTOM; break;
+ case SvxCellVerJustify::Block: nUno = table::CellVertJustify2::BLOCK; break;
+ default: ; //prevent warning
+ }
+ rVal <<= nUno;
+ break;
+ }
+ }
+ return true;
+}
+
+bool SvxVerJustifyItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch ( nMemberId )
+ {
+ case MID_HORJUST_ADJUST:
+ {
+ // property contains ParagraphAdjust values as sal_Int16
+ style::VerticalAlignment nVal = style::VerticalAlignment_TOP;
+ if(!(rVal >>= nVal))
+ return false;
+
+ SvxCellVerJustify eSvx = SvxCellVerJustify::Standard;
+ switch (nVal)
+ {
+ case style::VerticalAlignment_TOP: eSvx = SvxCellVerJustify::Top; break;
+ case style::VerticalAlignment_MIDDLE: eSvx = SvxCellVerJustify::Center; break;
+ case style::VerticalAlignment_BOTTOM: eSvx = SvxCellVerJustify::Bottom; break;
+ default:;
+ }
+ SetValue( eSvx );
+ break;
+ }
+ default:
+ {
+ sal_Int32 eUno = table::CellVertJustify2::STANDARD;
+ rVal >>= eUno;
+
+ SvxCellVerJustify eSvx = SvxCellVerJustify::Standard;
+ switch (eUno)
+ {
+ case table::CellVertJustify2::STANDARD: eSvx = SvxCellVerJustify::Standard; break;
+ case table::CellVertJustify2::TOP: eSvx = SvxCellVerJustify::Top; break;
+ case table::CellVertJustify2::CENTER: eSvx = SvxCellVerJustify::Center; break;
+ case table::CellVertJustify2::BOTTOM: eSvx = SvxCellVerJustify::Bottom; break;
+ case table::CellVertJustify2::BLOCK: eSvx = SvxCellVerJustify::Block; break;
+ default: ; //prevent warning
+ }
+ SetValue( eSvx );
+ break;
+ }
+ }
+
+ return true;
+}
+
+OUString SvxVerJustifyItem::GetValueText( SvxCellVerJustify nVal )
+{
+ assert(nVal <= SvxCellVerJustify::Block && "enum overflow!");
+ return EditResId(RID_SVXITEMS_VERJUST[static_cast<size_t>(nVal)]);
+}
+
+SvxVerJustifyItem* SvxVerJustifyItem::Clone( SfxItemPool* ) const
+{
+ return new SvxVerJustifyItem( *this );
+}
+
+sal_uInt16 SvxVerJustifyItem::GetValueCount() const
+{
+ return static_cast<sal_uInt16>(SvxCellVerJustify::Bottom) + 1; // Last Enum value + 1
+}
+
+SvxJustifyMethodItem::SvxJustifyMethodItem( const SvxCellJustifyMethod eJustify,
+ const sal_uInt16 nId ) :
+ SfxEnumItem( nId, eJustify )
+{
+}
+
+bool SvxJustifyMethodItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText,
+ const IntlWrapper& ) const
+{
+ rText = GetValueText( GetValue() );
+ return true;
+}
+
+
+bool SvxJustifyMethodItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
+{
+ sal_Int32 nUno = table::CellJustifyMethod::AUTO;
+ switch (GetValue())
+ {
+ case SvxCellJustifyMethod::Auto: nUno = table::CellJustifyMethod::AUTO; break;
+ case SvxCellJustifyMethod::Distribute: nUno = table::CellJustifyMethod::DISTRIBUTE; break;
+ default:;
+ }
+ rVal <<= nUno;
+ return true;
+}
+
+bool SvxJustifyMethodItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
+{
+ sal_Int32 nVal = table::CellJustifyMethod::AUTO;
+ if (!(rVal >>= nVal))
+ return false;
+
+ SvxCellJustifyMethod eSvx = SvxCellJustifyMethod::Auto;
+ switch (nVal)
+ {
+ case table::CellJustifyMethod::AUTO:
+ eSvx = SvxCellJustifyMethod::Auto;
+ break;
+ case table::CellJustifyMethod::DISTRIBUTE:
+ eSvx = SvxCellJustifyMethod::Distribute;
+ break;
+ default:;
+ }
+ SetValue(eSvx);
+ return true;
+}
+
+OUString SvxJustifyMethodItem::GetValueText( SvxCellJustifyMethod nVal )
+{
+ assert(nVal <= SvxCellJustifyMethod::Distribute && "enum overflow!");
+ return EditResId(RID_SVXITEMS_JUSTMETHOD[static_cast<size_t>(nVal)]);
+}
+
+SvxJustifyMethodItem* SvxJustifyMethodItem::Clone( SfxItemPool* ) const
+{
+ return new SvxJustifyMethodItem( *this );
+}
+
+sal_uInt16 SvxJustifyMethodItem::GetValueCount() const
+{
+ return static_cast<sal_uInt16>(SvxCellJustifyMethod::Distribute) + 1; // Last Enum value + 1
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/items/legacyitem.cxx b/editeng/source/items/legacyitem.cxx
new file mode 100644
index 000000000..af41980b2
--- /dev/null
+++ b/editeng/source/items/legacyitem.cxx
@@ -0,0 +1,824 @@
+/* -*- 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 <editeng/legacyitem.hxx>
+#include <unotools/fontdefs.hxx>
+#include <tools/tenccvt.hxx>
+#include <tools/stream.hxx>
+#include <comphelper/fileformat.h>
+#include <vcl/graph.hxx>
+#include <vcl/GraphicObject.hxx>
+#include <osl/diagnose.h>
+#include <tools/urlobj.hxx>
+#include <editeng/fontitem.hxx>
+#include <editeng/fhgtitem.hxx>
+#include <editeng/wghtitem.hxx>
+#include <editeng/postitem.hxx>
+#include <editeng/udlnitem.hxx>
+#include <editeng/crossedoutitem.hxx>
+#include <editeng/colritem.hxx>
+#include <editeng/boxitem.hxx>
+#include <editeng/borderline.hxx>
+#include <editeng/lineitem.hxx>
+#include <editeng/brushitem.hxx>
+#include <editeng/editerr.hxx>
+#include <editeng/adjustitem.hxx>
+#include <editeng/justifyitem.hxx>
+#include <editeng/frmdiritem.hxx>
+#include <editeng/formatbreakitem.hxx>
+#include <editeng/keepitem.hxx>
+#include <editeng/shaditem.hxx>
+#include <tools/GenericTypeSerializer.hxx>
+
+
+void Create_legacy_direct_set(SvxFontHeightItem& rItem, sal_uInt32 nH, sal_uInt16 nP, MapUnit eP)
+{
+ rItem.legacy_direct_set(nH, nP, eP);
+}
+
+namespace legacy
+{
+ namespace SvxFont
+ {
+ sal_uInt16 GetVersion(sal_uInt16)
+ {
+ return 0;
+ }
+
+ void Create(SvxFontItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ sal_uInt8 _eFamily, eFontPitch, eFontTextEncoding;
+ OUString aName, aStyle;
+ rStrm.ReadUChar( _eFamily );
+ rStrm.ReadUChar( eFontPitch );
+ rStrm.ReadUChar( eFontTextEncoding );
+
+ // UNICODE: rStrm >> aName;
+ aName = rStrm.ReadUniOrByteString(rStrm.GetStreamCharSet());
+
+ // UNICODE: rStrm >> aStyle;
+ aStyle = rStrm.ReadUniOrByteString(rStrm.GetStreamCharSet());
+
+ // Set the "correct" textencoding
+ eFontTextEncoding = static_cast<sal_uInt8>(GetSOLoadTextEncoding( eFontTextEncoding ));
+
+ // at some point, the StarBats changes from ANSI font to SYMBOL font
+ if ( RTL_TEXTENCODING_SYMBOL != eFontTextEncoding && aName == "StarBats" )
+ eFontTextEncoding = RTL_TEXTENCODING_SYMBOL;
+
+ // Check if we have stored unicode
+ sal_uInt64 const nStreamPos = rStrm.Tell();
+ // #define STORE_UNICODE_MAGIC_MARKER 0xFE331188
+ sal_uInt32 nMagic = 0xFE331188;
+ rStrm.ReadUInt32( nMagic );
+ if ( nMagic == 0xFE331188 )
+ {
+ aName = rStrm.ReadUniOrByteString( RTL_TEXTENCODING_UNICODE );
+ aStyle = rStrm.ReadUniOrByteString( RTL_TEXTENCODING_UNICODE );
+ }
+ else
+ {
+ rStrm.Seek( nStreamPos );
+ }
+
+ rItem.SetFamilyName(aName);
+ rItem.SetStyleName(aStyle);
+ rItem.SetFamily(static_cast<FontFamily>(_eFamily));
+ rItem.SetPitch(static_cast<FontPitch>(eFontPitch));
+ rItem.SetCharSet(static_cast<rtl_TextEncoding>(eFontTextEncoding));
+ }
+
+ SvStream& Store(const SvxFontItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ const bool bToBats(IsStarSymbol(rItem.GetFamilyName()));
+
+ rStrm.WriteUChar(rItem.GetFamily()).WriteUChar(rItem.GetPitch()).WriteUChar(bToBats ?
+ RTL_TEXTENCODING_SYMBOL :
+ GetSOStoreTextEncoding(rItem.GetCharSet()));
+
+ const OUString aStoreFamilyName(bToBats ? "StarBats" : rItem.GetFamilyName());
+
+ rStrm.WriteUniOrByteString(aStoreFamilyName, rStrm.GetStreamCharSet());
+ rStrm.WriteUniOrByteString(rItem.GetStyleName(), rStrm.GetStreamCharSet());
+
+ return rStrm;
+ }
+ }
+
+ namespace SvxFontHeight
+ {
+ sal_uInt16 GetVersion(sal_uInt16 nFileFormatVersion)
+ {
+ return (nFileFormatVersion <= SOFFICE_FILEFORMAT_40)
+ ? FONTHEIGHT_16_VERSION
+ : FONTHEIGHT_UNIT_VERSION;
+ }
+
+ void Create(SvxFontHeightItem& rItem, SvStream& rStrm, sal_uInt16 nItemVersion)
+ {
+ sal_uInt16 nsize, nprop = 0;
+ MapUnit nPropUnit = MapUnit::MapRelative;
+
+ rStrm.ReadUInt16( nsize );
+
+ if( FONTHEIGHT_16_VERSION <= nItemVersion )
+ rStrm.ReadUInt16( nprop );
+ else
+ {
+ sal_uInt8 nP;
+ rStrm .ReadUChar( nP );
+ nprop = static_cast<sal_uInt16>(nP);
+ }
+
+ if( FONTHEIGHT_UNIT_VERSION <= nItemVersion )
+ {
+ sal_uInt16 nTmp;
+ rStrm.ReadUInt16( nTmp );
+ nPropUnit = static_cast<MapUnit>(nTmp);
+ }
+
+ Create_legacy_direct_set(rItem, nsize, nprop, nPropUnit);
+ }
+
+ SvStream& Store(const SvxFontHeightItem& rItem, SvStream& rStrm, sal_uInt16 nItemVersion)
+ {
+ rStrm.WriteUInt16( rItem.GetHeight() );
+
+ if( FONTHEIGHT_UNIT_VERSION <= nItemVersion )
+ rStrm.WriteUInt16( rItem.GetProp() ).WriteUInt16( static_cast<sal_uInt16>(rItem.GetPropUnit()) );
+ else
+ {
+ // When exporting to the old versions the relative information is lost
+ // when there is no percentage
+ sal_uInt16 _nProp = rItem.GetProp();
+ if( MapUnit::MapRelative != rItem.GetPropUnit() )
+ _nProp = 100;
+ rStrm.WriteUInt16( _nProp );
+ }
+ return rStrm;
+ }
+ }
+
+ namespace SvxWeight
+ {
+ sal_uInt16 GetVersion(sal_uInt16)
+ {
+ return 0;
+ }
+
+ void Create(SvxWeightItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ sal_uInt8 nWeight(0);
+ rStrm.ReadUChar(nWeight);
+ rItem.SetValue(static_cast<FontWeight>(nWeight));
+ }
+
+ SvStream& Store(const SvxWeightItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ rStrm.WriteUChar(rItem.GetValue());
+ return rStrm;
+ }
+ }
+
+ namespace SvxPosture
+ {
+ sal_uInt16 GetVersion(sal_uInt16)
+ {
+ return 0;
+ }
+
+ void Create(SvxPostureItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ sal_uInt8 nPosture(0);
+ rStrm.ReadUChar(nPosture);
+ rItem.SetValue(static_cast<FontItalic>(nPosture));
+ }
+
+ SvStream& Store(const SvxPostureItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ rStrm.WriteUChar( rItem.GetValue() );
+ return rStrm;
+ }
+ }
+
+ namespace SvxTextLine // SvxUnderlineItem, SvxOverlineItem -> SvxTextLineItem
+ {
+ sal_uInt16 GetVersion(sal_uInt16)
+ {
+ return 0;
+ }
+
+ void Create(SvxTextLineItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ sal_uInt8 nState(0);
+ rStrm.ReadUChar(nState);
+ rItem.SetValue(static_cast<FontLineStyle>(nState));
+ // GetColor() is *not* saved/loaded ?!?
+ }
+
+ SvStream& Store(const SvxTextLineItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ rStrm.WriteUChar(rItem.GetValue());
+ // GetColor() is *not* saved/loaded ?!?
+ return rStrm;
+ }
+ }
+
+ namespace SvxCrossedOut
+ {
+ sal_uInt16 GetVersion(sal_uInt16)
+ {
+ return 0;
+ }
+
+ void Create(SvxCrossedOutItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ sal_uInt8 eCross(0);
+ rStrm.ReadUChar(eCross);
+ rItem.SetValue(static_cast<FontStrikeout>(eCross));
+ }
+
+ SvStream& Store(const SvxCrossedOutItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ rStrm.WriteUChar(rItem.GetValue());
+ return rStrm;
+ }
+ }
+
+ namespace SvxColor
+ {
+ sal_uInt16 GetVersion(sal_uInt16 nFileFormatVersion)
+ {
+ DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFileFormatVersion ||
+ SOFFICE_FILEFORMAT_40==nFileFormatVersion ||
+ SOFFICE_FILEFORMAT_50==nFileFormatVersion,
+ "SvxColorItem: Is there a new file format? ");
+ return SOFFICE_FILEFORMAT_50 >= nFileFormatVersion ? VERSION_USEAUTOCOLOR : 0;
+ }
+
+ void Create(SvxColorItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ Color aColor(COL_AUTO);
+ tools::GenericTypeSerializer aSerializer(rStrm);
+ aSerializer.readColor(aColor);
+ rItem.SetValue(aColor);
+ }
+
+ SvStream& Store(const SvxColorItem& rItem, SvStream& rStrm, sal_uInt16 nItemVersion)
+ {
+ tools::GenericTypeSerializer aSerializer(rStrm);
+ if( VERSION_USEAUTOCOLOR == nItemVersion && COL_AUTO == rItem.GetValue() )
+ aSerializer.writeColor(COL_BLACK);
+ else
+ aSerializer.writeColor(rItem.GetValue());
+ return rStrm;
+ }
+ }
+
+ namespace SvxBox
+ {
+ sal_uInt16 GetVersion(sal_uInt16 nFileFormatVersion)
+ {
+ DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFileFormatVersion ||
+ SOFFICE_FILEFORMAT_40==nFileFormatVersion ||
+ SOFFICE_FILEFORMAT_50==nFileFormatVersion,
+ "SvxBoxItem: Is there a new file format?" );
+ return SOFFICE_FILEFORMAT_31==nFileFormatVersion ||
+ SOFFICE_FILEFORMAT_40==nFileFormatVersion ? 0 : BOX_BORDER_STYLE_VERSION;
+ }
+
+ /// Item version for saved border lines. The old version saves the line without style information.
+ const int BORDER_LINE_OLD_VERSION = 0;
+ /// Item version for saved border lies. The new version includes line style.
+ const int BORDER_LINE_WITH_STYLE_VERSION = 1;
+
+ /// Creates a border line from a stream.
+ static ::editeng::SvxBorderLine CreateBorderLine(SvStream &stream, sal_uInt16 version)
+ {
+ sal_uInt16 nOutline, nInline, nDistance;
+ sal_uInt16 nStyle = css::table::BorderLineStyle::NONE;
+ Color aColor;
+ tools::GenericTypeSerializer aSerializer(stream);
+ aSerializer.readColor(aColor);
+ stream.ReadUInt16( nOutline ).ReadUInt16( nInline ).ReadUInt16( nDistance );
+
+ if (version >= BORDER_LINE_WITH_STYLE_VERSION)
+ stream.ReadUInt16( nStyle );
+
+ ::editeng::SvxBorderLine border(&aColor);
+ border.GuessLinesWidths(static_cast<SvxBorderLineStyle>(nStyle), nOutline, nInline, nDistance);
+ return border;
+ }
+
+ /// Retrieves a BORDER_LINE_* version from a BOX_BORDER_* version.
+ static sal_uInt16 BorderLineVersionFromBoxVersion(sal_uInt16 boxVersion)
+ {
+ return (boxVersion >= BOX_BORDER_STYLE_VERSION)? BORDER_LINE_WITH_STYLE_VERSION : BORDER_LINE_OLD_VERSION;
+ }
+
+ void Create(SvxBoxItem& rItem, SvStream& rStrm, sal_uInt16 nItemVersion)
+ {
+ sal_uInt16 nDistance(0);
+ rStrm.ReadUInt16( nDistance );
+ SvxBoxItemLine aLineMap[4] = { SvxBoxItemLine::TOP, SvxBoxItemLine::LEFT,
+ SvxBoxItemLine::RIGHT, SvxBoxItemLine::BOTTOM };
+ sal_Int8 cLine(0);
+
+ while (rStrm.good())
+ {
+ rStrm.ReadSChar( cLine );
+
+ if( cLine > 3 )
+ break;
+
+ ::editeng::SvxBorderLine aBorder = CreateBorderLine(rStrm, BorderLineVersionFromBoxVersion(nItemVersion));
+ rItem.SetLine( &aBorder, aLineMap[cLine] );
+ }
+
+ if( nItemVersion >= BOX_4DISTS_VERSION && (cLine&0x10) != 0 )
+ {
+ for(const SvxBoxItemLine & i : aLineMap)
+ {
+ sal_uInt16 nDist;
+ rStrm.ReadUInt16( nDist );
+ rItem.SetDistance( nDist, i );
+ }
+ }
+ else
+ {
+ rItem.SetAllDistances(nDistance);
+ }
+ }
+
+ /// Store a border line to a stream.
+ static SvStream& StoreBorderLine(SvStream &stream, const ::editeng::SvxBorderLine &l, sal_uInt16 version)
+ {
+ tools::GenericTypeSerializer aSerializer(stream);
+ aSerializer.writeColor(l.GetColor());
+
+ stream.WriteUInt16( l.GetOutWidth() )
+ .WriteUInt16( l.GetInWidth() )
+ .WriteUInt16( l.GetDistance() );
+
+ if (version >= BORDER_LINE_WITH_STYLE_VERSION)
+ stream.WriteUInt16( static_cast<sal_uInt16>(l.GetBorderLineStyle()) );
+
+ return stream;
+ }
+
+ SvStream& Store(const SvxBoxItem& rItem, SvStream& rStrm, sal_uInt16 nItemVersion)
+ {
+ rStrm.WriteUInt16( rItem.GetSmallestDistance() );
+ const ::editeng::SvxBorderLine* pLine[ 4 ]; // top, left, right, bottom
+ pLine[ 0 ] = rItem.GetTop();
+ pLine[ 1 ] = rItem.GetLeft();
+ pLine[ 2 ] = rItem.GetRight();
+ pLine[ 3 ] = rItem.GetBottom();
+
+ for( int i = 0; i < 4; i++ )
+ {
+ const ::editeng::SvxBorderLine* l = pLine[ i ];
+ if( l )
+ {
+ rStrm.WriteSChar(i);
+ StoreBorderLine(rStrm, *l, BorderLineVersionFromBoxVersion(nItemVersion));
+ }
+ }
+ sal_Int8 cLine = 4;
+ const sal_uInt16 nTopDist(rItem.GetDistance(SvxBoxItemLine::TOP));
+ const sal_uInt16 nLeftDist(rItem.GetDistance(SvxBoxItemLine::LEFT));
+ const sal_uInt16 nRightDist(rItem.GetDistance(SvxBoxItemLine::RIGHT));
+ const sal_uInt16 nBottomDist(rItem.GetDistance(SvxBoxItemLine::BOTTOM));
+
+ if( nItemVersion >= BOX_4DISTS_VERSION &&
+ !(nTopDist == nLeftDist &&
+ nTopDist == nRightDist &&
+ nTopDist == nBottomDist) )
+ {
+ cLine |= 0x10;
+ }
+
+ rStrm.WriteSChar( cLine );
+
+ if( nItemVersion >= BOX_4DISTS_VERSION && (cLine & 0x10) != 0 )
+ {
+ rStrm.WriteUInt16( nTopDist )
+ .WriteUInt16( nLeftDist )
+ .WriteUInt16( nRightDist )
+ .WriteUInt16( nBottomDist );
+ }
+
+ return rStrm;
+ }
+ }
+
+ namespace SvxLine
+ {
+ sal_uInt16 GetVersion(sal_uInt16)
+ {
+ return 0;
+ }
+
+ void Create(SvxLineItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ short nOutline, nInline, nDistance;
+ Color aColor;
+
+ tools::GenericTypeSerializer aSerializer(rStrm);
+ aSerializer.readColor(aColor);
+ rStrm.ReadInt16( nOutline ).ReadInt16( nInline ).ReadInt16( nDistance );
+ if( nOutline )
+ {
+ ::editeng::SvxBorderLine aLine( &aColor );
+ aLine.GuessLinesWidths(SvxBorderLineStyle::NONE, nOutline, nInline, nDistance);
+ rItem.SetLine( &aLine );
+ }
+ }
+
+ SvStream& Store(const SvxLineItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ const ::editeng::SvxBorderLine* pLine(rItem.GetLine());
+
+ if(nullptr != pLine)
+ {
+ tools::GenericTypeSerializer aSerializer(rStrm);
+ aSerializer.writeColor(pLine->GetColor());
+ rStrm.WriteInt16( pLine->GetOutWidth() )
+ .WriteInt16( pLine->GetInWidth() )
+ .WriteInt16( pLine->GetDistance() );
+ }
+ else
+ {
+ tools::GenericTypeSerializer aSerializer(rStrm);
+ aSerializer.writeColor(Color());
+ rStrm.WriteInt16( 0 ).WriteInt16( 0 ).WriteInt16( 0 );
+ }
+
+ return rStrm;
+ }
+ }
+
+ namespace SvxBrush
+ {
+ sal_uInt16 GetVersion(sal_uInt16)
+ {
+ return BRUSH_GRAPHIC_VERSION;
+ }
+
+ const sal_uInt16 LOAD_GRAPHIC = (sal_uInt16(0x0001));
+ const sal_uInt16 LOAD_LINK = (sal_uInt16(0x0002));
+ const sal_uInt16 LOAD_FILTER = (sal_uInt16(0x0004));
+
+ void Create(SvxBrushItem& rItem, SvStream& rStrm, sal_uInt16 nItemVersion)
+ {
+ bool bTrans;
+ Color aTempColor;
+ Color aTempFillColor;
+ sal_Int8 nStyle;
+
+ rStrm.ReadCharAsBool( bTrans );
+ tools::GenericTypeSerializer aSerializer(rStrm);
+ aSerializer.readColor(aTempColor);
+ aSerializer.readColor(aTempFillColor);
+ rStrm.ReadSChar( nStyle );
+
+ switch ( nStyle )
+ {
+ case 8: // BRUSH_25:
+ {
+ sal_uInt32 nRed = aTempColor.GetRed();
+ sal_uInt32 nGreen = aTempColor.GetGreen();
+ sal_uInt32 nBlue = aTempColor.GetBlue();
+ nRed += static_cast<sal_uInt32>(aTempFillColor.GetRed())*2;
+ nGreen += static_cast<sal_uInt32>(aTempFillColor.GetGreen())*2;
+ nBlue += static_cast<sal_uInt32>(aTempFillColor.GetBlue())*2;
+ rItem.SetColor(Color( static_cast<sal_Int8>(nRed/3), static_cast<sal_Int8>(nGreen/3), static_cast<sal_Int8>(nBlue/3) ));
+ }
+ break;
+
+ case 9: // BRUSH_50:
+ {
+ sal_uInt32 nRed = aTempColor.GetRed();
+ sal_uInt32 nGreen = aTempColor.GetGreen();
+ sal_uInt32 nBlue = aTempColor.GetBlue();
+ nRed += static_cast<sal_uInt32>(aTempFillColor.GetRed());
+ nGreen += static_cast<sal_uInt32>(aTempFillColor.GetGreen());
+ nBlue += static_cast<sal_uInt32>(aTempFillColor.GetBlue());
+ rItem.SetColor(Color( static_cast<sal_Int8>(nRed/2), static_cast<sal_Int8>(nGreen/2), static_cast<sal_Int8>(nBlue/2) ));
+ }
+ break;
+
+ case 10: // BRUSH_75:
+ {
+ sal_uInt32 nRed = aTempColor.GetRed()*2;
+ sal_uInt32 nGreen = aTempColor.GetGreen()*2;
+ sal_uInt32 nBlue = aTempColor.GetBlue()*2;
+ nRed += static_cast<sal_uInt32>(aTempFillColor.GetRed());
+ nGreen += static_cast<sal_uInt32>(aTempFillColor.GetGreen());
+ nBlue += static_cast<sal_uInt32>(aTempFillColor.GetBlue());
+ rItem.SetColor(Color( static_cast<sal_Int8>(nRed/3), static_cast<sal_Int8>(nGreen/3), static_cast<sal_Int8>(nBlue/3) ));
+ }
+ break;
+
+ case 0: // BRUSH_NULL:
+ rItem.SetColor(COL_TRANSPARENT);
+ break;
+
+ default:
+ rItem.SetColor(aTempColor);
+ }
+
+ if ( nItemVersion < BRUSH_GRAPHIC_VERSION )
+ return;
+
+ sal_uInt16 nDoLoad = 0;
+ sal_Int8 nPos;
+
+ rStrm.ReadUInt16( nDoLoad );
+
+ if ( nDoLoad & LOAD_GRAPHIC )
+ {
+ Graphic aGraphic;
+
+ ReadGraphic( rStrm, aGraphic );
+ rItem.SetGraphicObject(GraphicObject(aGraphic));
+
+ if( SVSTREAM_FILEFORMAT_ERROR == rStrm.GetError() )
+ {
+ rStrm.ResetError();
+ rStrm.SetError( ERRCODE_SVX_GRAPHIC_WRONG_FILEFORMAT.MakeWarning() );
+ }
+ }
+
+ if ( nDoLoad & LOAD_LINK )
+ {
+ // UNICODE: rStrm >> aRel;
+ OUString aRel = rStrm.ReadUniOrByteString(rStrm.GetStreamCharSet());
+
+ // TODO/MBA: how can we get a BaseURL here?!
+ OSL_FAIL("No BaseURL!");
+ OUString aAbs = INetURLObject::GetAbsURL( "", aRel );
+ DBG_ASSERT( !aAbs.isEmpty(), "Invalid URL!" );
+ rItem.SetGraphicLink(aAbs);
+ }
+
+ if ( nDoLoad & LOAD_FILTER )
+ {
+ // UNICODE: rStrm >> maStrFilter;
+ rItem.SetGraphicFilter(rStrm.ReadUniOrByteString(rStrm.GetStreamCharSet()));
+ }
+
+ rStrm.ReadSChar( nPos );
+
+ rItem.SetGraphicPos(static_cast<SvxGraphicPosition>(nPos));
+ }
+
+ SvStream& Store(const SvxBrushItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ rStrm.WriteBool( false );
+ tools::GenericTypeSerializer aSerializer(rStrm);
+ aSerializer.writeColor(rItem.GetColor());
+ aSerializer.writeColor(rItem.GetColor());
+ rStrm.WriteSChar( rItem.GetColor().GetTransparency() > 0 ? 0 : 1 ); //BRUSH_NULL : BRUSH_SOLID
+
+ sal_uInt16 nDoLoad = 0;
+ const GraphicObject* pGraphicObject(rItem.GetGraphicObject());
+
+ if (nullptr != pGraphicObject && rItem.GetGraphicLink().isEmpty())
+ nDoLoad |= LOAD_GRAPHIC;
+ if ( !rItem.GetGraphicLink().isEmpty() )
+ nDoLoad |= LOAD_LINK;
+ if ( !rItem.GetGraphicFilter().isEmpty() )
+ nDoLoad |= LOAD_FILTER;
+ rStrm.WriteUInt16( nDoLoad );
+
+ if (nullptr != pGraphicObject && rItem.GetGraphicLink().isEmpty())
+ WriteGraphic(rStrm, pGraphicObject->GetGraphic());
+ if ( !rItem.GetGraphicLink().isEmpty() )
+ {
+ OSL_FAIL("No BaseURL!");
+ // TODO/MBA: how to get a BaseURL?!
+ OUString aRel = INetURLObject::GetRelURL( "", rItem.GetGraphicLink() );
+ // UNICODE: rStrm << aRel;
+ rStrm.WriteUniOrByteString(aRel, rStrm.GetStreamCharSet());
+ }
+ if ( !rItem.GetGraphicFilter().isEmpty() )
+ {
+ // UNICODE: rStrm << rItem.GetGraphicFilter();
+ rStrm.WriteUniOrByteString(rItem.GetGraphicFilter(), rStrm.GetStreamCharSet());
+ }
+ rStrm.WriteSChar( rItem.GetGraphicPos() );
+ return rStrm;
+ }
+ }
+
+ namespace SvxAdjust
+ {
+ sal_uInt16 GetVersion(sal_uInt16 nFileFormatVersion)
+ {
+ return (nFileFormatVersion == SOFFICE_FILEFORMAT_31)
+ ? 0 : ADJUST_LASTBLOCK_VERSION;
+ }
+
+ void Create(SvxAdjustItem& rItem, SvStream& rStrm, sal_uInt16 nItemVersion)
+ {
+ char eAdjustment;
+ rStrm.ReadChar(eAdjustment);
+ rItem.SetAdjust(static_cast<::SvxAdjust>(eAdjustment));
+
+ if( nItemVersion >= ADJUST_LASTBLOCK_VERSION )
+ {
+ sal_Int8 nFlags;
+ rStrm.ReadSChar( nFlags );
+ rItem.SetAsFlags(nFlags);
+ }
+ }
+
+ SvStream& Store(const SvxAdjustItem& rItem, SvStream& rStrm, sal_uInt16 nItemVersion)
+ {
+ rStrm.WriteChar( static_cast<char>(rItem.GetAdjust()) );
+ if ( nItemVersion >= ADJUST_LASTBLOCK_VERSION )
+ {
+ const sal_Int8 nFlags(rItem.GetAsFlags());
+ rStrm.WriteSChar( nFlags );
+ }
+ return rStrm;
+ }
+ }
+
+ namespace SvxHorJustify
+ {
+ sal_uInt16 GetVersion(sal_uInt16)
+ {
+ return 0;
+ }
+
+ void Create(SvxHorJustifyItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ sal_uInt16 nVal(0);
+ rStrm.ReadUInt16( nVal );
+ rItem.SetValue(static_cast<::SvxCellHorJustify>(nVal));
+ }
+
+ SvStream& Store(const SvxHorJustifyItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ rStrm.WriteUInt16( static_cast<sal_uInt16>(rItem.GetValue()) );
+ return rStrm;
+ }
+ }
+
+ namespace SvxVerJustify
+ {
+ sal_uInt16 GetVersion(sal_uInt16)
+ {
+ return 0;
+ }
+
+ void Create(SvxVerJustifyItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ sal_uInt16 nVal(0);
+ rStrm.ReadUInt16( nVal );
+ rItem.SetValue(static_cast<::SvxCellVerJustify>(nVal));
+ }
+
+ SvStream& Store(const SvxVerJustifyItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ rStrm.WriteUInt16( static_cast<sal_uInt16>(rItem.GetValue()) );
+ return rStrm;
+ }
+ }
+
+ namespace SvxFrameDirection
+ {
+ sal_uInt16 GetVersion(sal_uInt16 nFileFormatVersion)
+ {
+ return SOFFICE_FILEFORMAT_50 > nFileFormatVersion ? USHRT_MAX : 0;
+ }
+
+ void Create(SvxFrameDirectionItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ sal_uInt16 nVal(0);
+ rStrm.ReadUInt16( nVal );
+ rItem.SetValue(static_cast<::SvxFrameDirection>(nVal));
+ }
+
+ SvStream& Store(const SvxFrameDirectionItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ rStrm.WriteUInt16( static_cast<sal_uInt16>(rItem.GetValue()) );
+ return rStrm;
+ }
+ }
+
+ namespace SvxFormatBreak
+ {
+ sal_uInt16 GetVersion(sal_uInt16 nFileFormatVersion)
+ {
+ DBG_ASSERT( SOFFICE_FILEFORMAT_31==nFileFormatVersion ||
+ SOFFICE_FILEFORMAT_40==nFileFormatVersion ||
+ SOFFICE_FILEFORMAT_50==nFileFormatVersion,
+ "SvxFormatBreakItem: Is there a new file format? ");
+ return SOFFICE_FILEFORMAT_31==nFileFormatVersion ||
+ SOFFICE_FILEFORMAT_40==nFileFormatVersion ? 0 : FMTBREAK_NOAUTO;
+ }
+
+ void Create(SvxFormatBreakItem& rItem, SvStream& rStrm, sal_uInt16 nItemVersion)
+ {
+ sal_Int8 eBreak, bDummy;
+ rStrm.ReadSChar( eBreak );
+ if( FMTBREAK_NOAUTO > nItemVersion )
+ rStrm.ReadSChar( bDummy );
+ rItem.SetValue(static_cast<::SvxBreak>(eBreak));
+ }
+
+ SvStream& Store(const SvxFormatBreakItem& rItem, SvStream& rStrm, sal_uInt16 nItemVersion)
+ {
+ rStrm.WriteSChar( rItem.GetEnumValue() );
+ if( FMTBREAK_NOAUTO > nItemVersion )
+ rStrm.WriteSChar( 0x01 );
+ return rStrm;
+ }
+ }
+
+ namespace SvxFormatKeep
+ {
+ sal_uInt16 GetVersion(sal_uInt16)
+ {
+ return 0;
+ }
+
+ void Create(SvxFormatKeepItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ // derived from SfxBoolItem, but that uses
+ // rStream.ReadCharAsBool( tmp );
+ sal_Int8 bIsKeep;
+ rStrm.ReadSChar( bIsKeep );
+ rItem.SetValue(static_cast<bool>(bIsKeep));
+ }
+
+ SvStream& Store(const SvxFormatKeepItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ // derived from SfxBoolItem, but that uses
+ // rStream.WriteBool( m_bValue ); // not bool for serialization!
+ rStrm.WriteSChar( static_cast<sal_Int8>(rItem.GetValue()) );
+ return rStrm;
+ }
+ }
+
+ namespace SvxShadow
+ {
+ sal_uInt16 GetVersion(sal_uInt16)
+ {
+ return 0;
+ }
+
+ void Create(SvxShadowItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ sal_Int8 cLoc;
+ sal_uInt16 _nWidth;
+ bool bTrans;
+ Color aColor;
+ Color aFillColor;
+ sal_Int8 nStyle;
+ rStrm.ReadSChar( cLoc ).ReadUInt16( _nWidth ).ReadCharAsBool( bTrans );
+ tools::GenericTypeSerializer aSerializer(rStrm);
+ aSerializer.readColor(aColor);
+ aSerializer.readColor(aFillColor);
+ rStrm.ReadSChar(nStyle);
+ aColor.SetTransparency(bTrans ? 0xff : 0);
+
+ rItem.SetLocation(static_cast<SvxShadowLocation>(cLoc));
+ rItem.SetWidth(_nWidth);
+ rItem.SetColor(aColor);
+ }
+
+ SvStream& Store(const SvxShadowItem& rItem, SvStream& rStrm, sal_uInt16)
+ {
+ rStrm.WriteSChar( static_cast<sal_uInt8>(rItem.GetLocation()) )
+ .WriteUInt16( rItem.GetWidth() )
+ .WriteBool( rItem.GetColor().GetTransparency() > 0 );
+ tools::GenericTypeSerializer aSerializer(rStrm);
+ aSerializer.writeColor(rItem.GetColor());
+ aSerializer.writeColor(rItem.GetColor());
+ rStrm.WriteSChar( rItem.GetColor().GetTransparency() > 0 ? 0 : 1 ); //BRUSH_NULL : BRUSH_SOLID
+ return rStrm;
+ }
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/items/numitem.cxx b/editeng/source/items/numitem.cxx
new file mode 100644
index 000000000..d6f1769d1
--- /dev/null
+++ b/editeng/source/items/numitem.cxx
@@ -0,0 +1,1001 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <algorithm>
+
+#include <editeng/numitem.hxx>
+
+#include <com/sun/star/text/VertOrientation.hpp>
+#include <editeng/brushitem.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <vcl/font.hxx>
+#include <vcl/settings.hxx>
+#include <editeng/editids.hrc>
+#include <editeng/numdef.hxx>
+#include <vcl/graph.hxx>
+#include <vcl/outdev.hxx>
+#include <vcl/svapp.hxx>
+#include <com/sun/star/text/XNumberingFormatter.hpp>
+#include <com/sun/star/text/DefaultNumberingProvider.hpp>
+#include <com/sun/star/text/XDefaultNumberingProvider.hpp>
+#include <com/sun/star/style/NumberingType.hpp>
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <comphelper/fileformat.h>
+#include <comphelper/processfactory.hxx>
+#include <tools/mapunit.hxx>
+#include <tools/stream.hxx>
+#include <tools/debug.hxx>
+#include <tools/GenericTypeSerializer.hxx>
+#include <unotools/configmgr.hxx>
+#include <libxml/xmlwriter.h>
+#include <editeng/unonrule.hxx>
+#include <sal/log.hxx>
+#include <i18nlangtag/languagetag.hxx>
+#include <editeng/legacyitem.hxx>
+
+#define DEF_WRITER_LSPACE 500 //Standard Indentation
+#define DEF_DRAW_LSPACE 800 //Standard Indentation
+
+#define NUMITEM_VERSION_03 0x03
+#define NUMITEM_VERSION_04 0x04
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::text;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::style;
+
+sal_Int32 SvxNumberType::nRefCount = 0;
+css::uno::Reference<css::text::XNumberingFormatter> SvxNumberType::xFormatter;
+static void lcl_getFormatter(css::uno::Reference<css::text::XNumberingFormatter>& _xFormatter)
+{
+ if(_xFormatter.is())
+ return;
+
+ try
+ {
+ Reference<XComponentContext> xContext( ::comphelper::getProcessComponentContext() );
+ Reference<XDefaultNumberingProvider> xRet = text::DefaultNumberingProvider::create(xContext);
+ _xFormatter.set(xRet, UNO_QUERY);
+ }
+ catch(const Exception&)
+ {
+ SAL_WARN("editeng", "service missing: \"com.sun.star.text.DefaultNumberingProvider\"");
+ }
+}
+
+SvxNumberType::SvxNumberType(SvxNumType nType) :
+ nNumType(nType),
+ bShowSymbol(true)
+{
+ nRefCount++;
+}
+
+SvxNumberType::SvxNumberType(const SvxNumberType& rType) :
+ nNumType(rType.nNumType),
+ bShowSymbol(rType.bShowSymbol)
+{
+ nRefCount++;
+}
+
+SvxNumberType::~SvxNumberType()
+{
+ if(!--nRefCount)
+ xFormatter = nullptr;
+}
+
+OUString SvxNumberType::GetNumStr( sal_Int32 nNo ) const
+{
+ LanguageTag aLang = utl::ConfigManager::IsFuzzing() ?
+ LanguageTag("en-US") :
+ Application::GetSettings().GetLanguageTag();
+ return GetNumStr( nNo, aLang.getLocale() );
+}
+
+OUString SvxNumberType::GetNumStr( sal_Int32 nNo, const css::lang::Locale& rLocale ) const
+{
+ lcl_getFormatter(xFormatter);
+ if(!xFormatter.is())
+ return OUString();
+
+ if(bShowSymbol)
+ {
+ switch(nNumType)
+ {
+ case NumberingType::CHAR_SPECIAL:
+ case NumberingType::BITMAP:
+ break;
+ default:
+ {
+ // '0' allowed for ARABIC numberings
+ if(NumberingType::ARABIC == nNumType && 0 == nNo )
+ return OUString('0');
+ else
+ {
+ Sequence< PropertyValue > aProperties(2);
+ PropertyValue* pValues = aProperties.getArray();
+ pValues[0].Name = "NumberingType";
+ pValues[0].Value <<= static_cast<sal_uInt16>(nNumType);
+ pValues[1].Name = "Value";
+ pValues[1].Value <<= nNo;
+
+ try
+ {
+ return xFormatter->makeNumberingString( aProperties, rLocale );
+ }
+ catch(const Exception&)
+ {
+ }
+ }
+ }
+ }
+ }
+ return OUString();
+}
+
+void SvxNumberType::dumpAsXml( xmlTextWriterPtr pWriter ) const
+{
+ xmlTextWriterStartElement(pWriter, BAD_CAST("SvxNumberType"));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("NumType"), BAD_CAST(OString::number(nNumType).getStr()));
+ xmlTextWriterEndElement(pWriter);
+}
+
+SvxNumberFormat::SvxNumberFormat( SvxNumType eType )
+ : SvxNumberType(eType),
+ eNumAdjust(SvxAdjust::Left),
+ nInclUpperLevels(0),
+ nStart(1),
+ cBullet(SVX_DEF_BULLET),
+ nBulletRelSize(100),
+ nBulletColor(COL_BLACK),
+ mePositionAndSpaceMode( LABEL_WIDTH_AND_POSITION ),
+ nFirstLineOffset(0),
+ nAbsLSpace(0),
+ nCharTextDistance(0),
+ meLabelFollowedBy( LISTTAB ),
+ mnListtabPos( 0 ),
+ mnFirstLineIndent( 0 ),
+ mnIndentAt( 0 ),
+ eVertOrient(text::VertOrientation::NONE)
+{
+}
+
+SvxNumberFormat::SvxNumberFormat(const SvxNumberFormat& rFormat) :
+ SvxNumberType(rFormat),
+ mePositionAndSpaceMode( rFormat.mePositionAndSpaceMode )
+{
+ *this = rFormat;
+}
+
+SvxNumberFormat::SvxNumberFormat( SvStream &rStream )
+ : nStart(0)
+ , nBulletRelSize(100)
+ , nFirstLineOffset(0)
+ , nAbsLSpace(0)
+ , nCharTextDistance(0)
+{
+ sal_uInt16 nTmp16(0);
+ sal_Int32 nTmp32(0);
+ rStream.ReadUInt16( nTmp16 ); // Version number
+
+ rStream.ReadUInt16( nTmp16 ); SetNumberingType( static_cast<SvxNumType>(nTmp16) );
+ rStream.ReadUInt16( nTmp16 ); eNumAdjust = static_cast<SvxAdjust>(nTmp16);
+ rStream.ReadUInt16( nTmp16 ); nInclUpperLevels = nTmp16;
+ rStream.ReadUInt16( nStart );
+ rStream.ReadUInt16( nTmp16 ); cBullet = static_cast<sal_Unicode>(nTmp16);
+
+ sal_Int16 temp = 0;
+ rStream.ReadInt16( temp );
+ nFirstLineOffset = temp;
+ temp = 0;
+ rStream.ReadInt16( temp );
+ nAbsLSpace = temp;
+ rStream.SeekRel(2); //skip old now unused nLSpace;
+
+ rStream.ReadInt16( nCharTextDistance );
+
+ sPrefix = rStream.ReadUniOrByteString( rStream.GetStreamCharSet() );
+ sSuffix = rStream.ReadUniOrByteString( rStream.GetStreamCharSet() );
+ sCharStyleName = rStream.ReadUniOrByteString( rStream.GetStreamCharSet() );
+
+ sal_uInt16 hasGraphicBrush = 0;
+ rStream.ReadUInt16( hasGraphicBrush );
+ if ( hasGraphicBrush )
+ {
+ pGraphicBrush.reset(new SvxBrushItem(SID_ATTR_BRUSH));
+ legacy::SvxBrush::Create(*pGraphicBrush, rStream, BRUSH_GRAPHIC_VERSION);
+ }
+ else pGraphicBrush = nullptr;
+ rStream.ReadUInt16( nTmp16 ); eVertOrient = nTmp16;
+
+ sal_uInt16 hasBulletFont = 0;
+ rStream.ReadUInt16( hasBulletFont );
+ if ( hasBulletFont )
+ {
+ pBulletFont.reset( new vcl::Font() );
+ ReadFont( rStream, *pBulletFont );
+ }
+ else pBulletFont = nullptr;
+
+ tools::GenericTypeSerializer aSerializer(rStream);
+ aSerializer.readSize(aGraphicSize);
+ aSerializer.readColor(nBulletColor);
+
+ rStream.ReadUInt16( nBulletRelSize );
+ rStream.ReadUInt16( nTmp16 ); SetShowSymbol( nTmp16 != 0 );
+
+ rStream.ReadUInt16( nTmp16 ); mePositionAndSpaceMode = static_cast<SvxNumPositionAndSpaceMode>(nTmp16);
+ rStream.ReadUInt16( nTmp16 ); meLabelFollowedBy = static_cast<LabelFollowedBy>(nTmp16);
+ rStream.ReadInt32( nTmp32 ); mnListtabPos = nTmp32;
+ rStream.ReadInt32( nTmp32 ); mnFirstLineIndent = nTmp32;
+ rStream.ReadInt32( nTmp32 ); mnIndentAt = nTmp32;
+}
+
+SvxNumberFormat::~SvxNumberFormat()
+{
+}
+
+void SvxNumberFormat::Store(SvStream &rStream, FontToSubsFontConverter pConverter)
+{
+ if(pConverter && pBulletFont)
+ {
+ cBullet = ConvertFontToSubsFontChar(pConverter, cBullet);
+ OUString sFontName = GetFontToSubsFontName(pConverter);
+ pBulletFont->SetFamilyName(sFontName);
+ }
+
+ tools::GenericTypeSerializer aSerializer(rStream);
+
+ rStream.WriteUInt16( NUMITEM_VERSION_04 );
+
+ rStream.WriteUInt16( GetNumberingType() );
+ rStream.WriteUInt16( static_cast<sal_uInt16>(eNumAdjust) );
+ rStream.WriteUInt16( nInclUpperLevels );
+ rStream.WriteUInt16( nStart );
+ rStream.WriteUInt16( cBullet );
+
+ rStream.WriteInt16(
+ sal_Int16(std::clamp<sal_Int32>(nFirstLineOffset, SAL_MIN_INT16, SAL_MAX_INT16)) );
+ //TODO: better way to handle out-of-bounds value?
+ rStream.WriteInt16(
+ sal_Int16(std::clamp<sal_Int32>(nAbsLSpace, SAL_MIN_INT16, SAL_MAX_INT16)) );
+ //TODO: better way to handle out-of-bounds value?
+ rStream.WriteInt16( 0 ); // write a dummy for old now unused nLSpace
+
+ rStream.WriteInt16( nCharTextDistance );
+ rtl_TextEncoding eEnc = osl_getThreadTextEncoding();
+ rStream.WriteUniOrByteString(sPrefix, eEnc);
+ rStream.WriteUniOrByteString(sSuffix, eEnc);
+ rStream.WriteUniOrByteString(sCharStyleName, eEnc);
+ if(pGraphicBrush)
+ {
+ rStream.WriteUInt16( 1 );
+
+ // in SD or SI force bullet itself to be stored,
+ // for that purpose throw away link when link and graphic
+ // are present, so Brush save is forced
+ if(!pGraphicBrush->GetGraphicLink().isEmpty() && pGraphicBrush->GetGraphic())
+ {
+ pGraphicBrush->SetGraphicLink("");
+ }
+
+ legacy::SvxBrush::Store(*pGraphicBrush, rStream, BRUSH_GRAPHIC_VERSION);
+ }
+ else
+ rStream.WriteUInt16( 0 );
+
+ rStream.WriteUInt16( eVertOrient );
+ if(pBulletFont)
+ {
+ rStream.WriteUInt16( 1 );
+ WriteFont( rStream, *pBulletFont );
+ }
+ else
+ rStream.WriteUInt16( 0 );
+
+ aSerializer.writeSize(aGraphicSize);
+
+ Color nTempColor = nBulletColor;
+ if(COL_AUTO == nBulletColor)
+ nTempColor = COL_BLACK;
+
+ aSerializer.writeColor(nTempColor);
+ rStream.WriteUInt16( nBulletRelSize );
+ rStream.WriteUInt16( sal_uInt16(IsShowSymbol()) );
+
+ rStream.WriteUInt16( mePositionAndSpaceMode );
+ rStream.WriteUInt16( meLabelFollowedBy );
+ rStream.WriteInt32( mnListtabPos );
+ rStream.WriteInt32( mnFirstLineIndent );
+ rStream.WriteInt32( mnIndentAt );
+}
+
+SvxNumberFormat& SvxNumberFormat::operator=( const SvxNumberFormat& rFormat )
+{
+ if (& rFormat == this) { return *this; }
+
+ SvxNumberType::SetNumberingType(rFormat.GetNumberingType());
+ eNumAdjust = rFormat.eNumAdjust ;
+ nInclUpperLevels = rFormat.nInclUpperLevels ;
+ nStart = rFormat.nStart ;
+ cBullet = rFormat.cBullet ;
+ mePositionAndSpaceMode = rFormat.mePositionAndSpaceMode;
+ nFirstLineOffset = rFormat.nFirstLineOffset;
+ nAbsLSpace = rFormat.nAbsLSpace ;
+ nCharTextDistance = rFormat.nCharTextDistance ;
+ meLabelFollowedBy = rFormat.meLabelFollowedBy;
+ mnListtabPos = rFormat.mnListtabPos;
+ mnFirstLineIndent = rFormat.mnFirstLineIndent;
+ mnIndentAt = rFormat.mnIndentAt;
+ eVertOrient = rFormat.eVertOrient;
+ sPrefix = rFormat.sPrefix;
+ sSuffix = rFormat.sSuffix;
+ sListFormat = rFormat.sListFormat;
+ aGraphicSize = rFormat.aGraphicSize ;
+ nBulletColor = rFormat.nBulletColor ;
+ nBulletRelSize = rFormat.nBulletRelSize;
+ SetShowSymbol(rFormat.IsShowSymbol());
+ sCharStyleName = rFormat.sCharStyleName;
+ pGraphicBrush.reset();
+ if(rFormat.pGraphicBrush)
+ {
+ pGraphicBrush.reset( new SvxBrushItem(*rFormat.pGraphicBrush) );
+ }
+ pBulletFont.reset();
+ if(rFormat.pBulletFont)
+ pBulletFont.reset( new vcl::Font(*rFormat.pBulletFont) );
+ return *this;
+}
+
+bool SvxNumberFormat::operator==( const SvxNumberFormat& rFormat) const
+{
+ if( GetNumberingType() != rFormat.GetNumberingType() ||
+ eNumAdjust != rFormat.eNumAdjust ||
+ nInclUpperLevels != rFormat.nInclUpperLevels ||
+ nStart != rFormat.nStart ||
+ cBullet != rFormat.cBullet ||
+ mePositionAndSpaceMode != rFormat.mePositionAndSpaceMode ||
+ nFirstLineOffset != rFormat.nFirstLineOffset ||
+ nAbsLSpace != rFormat.nAbsLSpace ||
+ nCharTextDistance != rFormat.nCharTextDistance ||
+ meLabelFollowedBy != rFormat.meLabelFollowedBy ||
+ mnListtabPos != rFormat.mnListtabPos ||
+ mnFirstLineIndent != rFormat.mnFirstLineIndent ||
+ mnIndentAt != rFormat.mnIndentAt ||
+ eVertOrient != rFormat.eVertOrient ||
+ sPrefix != rFormat.sPrefix ||
+ sSuffix != rFormat.sSuffix ||
+ sListFormat != rFormat.sListFormat ||
+ aGraphicSize != rFormat.aGraphicSize ||
+ nBulletColor != rFormat.nBulletColor ||
+ nBulletRelSize != rFormat.nBulletRelSize ||
+ IsShowSymbol() != rFormat.IsShowSymbol() ||
+ sCharStyleName != rFormat.sCharStyleName
+ )
+ return false;
+ if (
+ (pGraphicBrush && !rFormat.pGraphicBrush) ||
+ (!pGraphicBrush && rFormat.pGraphicBrush) ||
+ (pGraphicBrush && *pGraphicBrush != *rFormat.pGraphicBrush)
+ )
+ {
+ return false;
+ }
+ if (
+ (pBulletFont && !rFormat.pBulletFont) ||
+ (!pBulletFont && rFormat.pBulletFont) ||
+ (pBulletFont && *pBulletFont != *rFormat.pBulletFont)
+ )
+ {
+ return false;
+ }
+ return true;
+}
+
+void SvxNumberFormat::SetGraphicBrush( const SvxBrushItem* pBrushItem,
+ const Size* pSize, const sal_Int16* pOrient)
+{
+ if (!pBrushItem)
+ pGraphicBrush.reset();
+ else if ( !pGraphicBrush || (*pBrushItem != *pGraphicBrush) )
+ pGraphicBrush.reset(pBrushItem->Clone());
+
+ if(pOrient)
+ eVertOrient = *pOrient;
+ else
+ eVertOrient = text::VertOrientation::NONE;
+ if(pSize)
+ aGraphicSize = *pSize;
+ else
+ {
+ aGraphicSize.setWidth(0);
+ aGraphicSize.setHeight(0);
+ }
+}
+
+void SvxNumberFormat::SetGraphic( const OUString& rName )
+{
+ if( pGraphicBrush && pGraphicBrush->GetGraphicLink() == rName )
+ return ;
+
+ pGraphicBrush.reset( new SvxBrushItem( rName, "", GPOS_AREA, 0 ) );
+ if( eVertOrient == text::VertOrientation::NONE )
+ eVertOrient = text::VertOrientation::TOP;
+
+ aGraphicSize.setWidth(0);
+ aGraphicSize.setHeight(0);
+}
+
+sal_Int16 SvxNumberFormat::GetVertOrient() const
+{
+ return eVertOrient;
+}
+
+void SvxNumberFormat::SetBulletFont(const vcl::Font* pFont)
+{
+ pBulletFont.reset( pFont ? new vcl::Font(*pFont): nullptr );
+}
+
+void SvxNumberFormat::SetPositionAndSpaceMode( SvxNumPositionAndSpaceMode ePositionAndSpaceMode )
+{
+ mePositionAndSpaceMode = ePositionAndSpaceMode;
+}
+
+sal_Int32 SvxNumberFormat::GetAbsLSpace() const
+{
+ return mePositionAndSpaceMode == LABEL_WIDTH_AND_POSITION
+ ? nAbsLSpace
+ : static_cast<sal_Int32>( GetFirstLineIndent() + GetIndentAt() );
+}
+sal_Int32 SvxNumberFormat::GetFirstLineOffset() const
+{
+ return mePositionAndSpaceMode == LABEL_WIDTH_AND_POSITION
+ ? nFirstLineOffset
+ : static_cast<sal_Int32>( GetFirstLineIndent() );
+}
+short SvxNumberFormat::GetCharTextDistance() const
+{
+ return mePositionAndSpaceMode == LABEL_WIDTH_AND_POSITION ? nCharTextDistance : 0;
+}
+
+void SvxNumberFormat::SetLabelFollowedBy( const LabelFollowedBy eLabelFollowedBy )
+{
+ meLabelFollowedBy = eLabelFollowedBy;
+}
+void SvxNumberFormat::SetListtabPos( const long nListtabPos )
+{
+ mnListtabPos = nListtabPos;
+}
+void SvxNumberFormat::SetFirstLineIndent( const long nFirstLineIndent )
+{
+ mnFirstLineIndent = nFirstLineIndent;
+}
+void SvxNumberFormat::SetIndentAt( const long nIndentAt )
+{
+ mnIndentAt = nIndentAt;
+}
+
+Size SvxNumberFormat::GetGraphicSizeMM100(const Graphic* pGraphic)
+{
+ const MapMode aMapMM100( MapUnit::Map100thMM );
+ const Size& rSize = pGraphic->GetPrefSize();
+ Size aRetSize;
+ if ( pGraphic->GetPrefMapMode().GetMapUnit() == MapUnit::MapPixel )
+ {
+ OutputDevice* pOutDev = Application::GetDefaultDevice();
+ MapMode aOldMap( pOutDev->GetMapMode() );
+ pOutDev->SetMapMode( aMapMM100 );
+ aRetSize = pOutDev->PixelToLogic( rSize );
+ pOutDev->SetMapMode( aOldMap );
+ }
+ else
+ aRetSize = OutputDevice::LogicToLogic( rSize, pGraphic->GetPrefMapMode(), aMapMM100 );
+ return aRetSize;
+}
+
+OUString SvxNumberFormat::CreateRomanString( sal_uLong nNo, bool bUpper )
+{
+ nNo %= 4000; // more can not be displayed
+// i, ii, iii, iv, v, vi, vii, vii, viii, ix
+// (Dummy),1000,500,100,50,10,5,1
+ const char *cRomanArr = bUpper
+ ? "MDCLXVI--" // +2 Dummy entries!
+ : "mdclxvi--"; // +2 Dummy entries!
+
+ OUStringBuffer sRet;
+ sal_uInt16 nMask = 1000;
+ while( nMask )
+ {
+ sal_uInt8 nNumber = sal_uInt8(nNo / nMask);
+ sal_uInt8 nDiff = 1;
+ nNo %= nMask;
+
+ if( 5 < nNumber )
+ {
+ if( nNumber < 9 )
+ sRet.append(*(cRomanArr-1));
+ ++nDiff;
+ nNumber -= 5;
+ }
+ switch( nNumber )
+ {
+ case 3: { sRet.append(*cRomanArr); [[fallthrough]]; }
+ case 2: { sRet.append(*cRomanArr); [[fallthrough]]; }
+ case 1: { sRet.append(*cRomanArr); }
+ break;
+
+ case 4: {
+ sRet.append(*cRomanArr);
+ sRet.append(*(cRomanArr-nDiff));
+ }
+ break;
+ case 5: { sRet.append(*(cRomanArr-nDiff)); }
+ break;
+ }
+
+ nMask /= 10; // for the next decade
+ cRomanArr += 2;
+ }
+ return sRet.makeStringAndClear();
+}
+
+OUString SvxNumberFormat::GetCharFormatName()const
+{
+ return sCharStyleName;
+}
+
+sal_Int32 SvxNumRule::nRefCount = 0;
+static SvxNumberFormat* pStdNumFmt = nullptr;
+static SvxNumberFormat* pStdOutlineNumFmt = nullptr;
+SvxNumRule::SvxNumRule( SvxNumRuleFlags nFeatures,
+ sal_uInt16 nLevels,
+ bool bCont,
+ SvxNumRuleType eType,
+ SvxNumberFormat::SvxNumPositionAndSpaceMode
+ eDefaultNumberFormatPositionAndSpaceMode )
+ : nLevelCount(nLevels),
+ nFeatureFlags(nFeatures),
+ eNumberingType(eType),
+ bContinuousNumbering(bCont)
+{
+ ++nRefCount;
+ for(sal_uInt16 i = 0; i < SVX_MAX_NUM; i++)
+ {
+ if(i < nLevels)
+ {
+ aFmts[i].reset( new SvxNumberFormat(SVX_NUM_CHARS_UPPER_LETTER) );
+ // It is a distinction between writer and draw
+ if(nFeatures & SvxNumRuleFlags::CONTINUOUS)
+ {
+ if ( eDefaultNumberFormatPositionAndSpaceMode ==
+ SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
+ {
+ aFmts[i]->SetAbsLSpace( convertMm100ToTwip(DEF_WRITER_LSPACE * (i+1)) );
+ aFmts[i]->SetFirstLineOffset(convertMm100ToTwip(-DEF_WRITER_LSPACE));
+ }
+ else if ( eDefaultNumberFormatPositionAndSpaceMode ==
+ SvxNumberFormat::LABEL_ALIGNMENT )
+ {
+ // first line indent of general numbering in inch: -0,25 inch
+ const long cFirstLineIndent = -1440/4;
+ // indent values of general numbering in inch:
+ // 0,5 0,75 1,0 1,25 1,5
+ // 1,75 2,0 2,25 2,5 2,75
+ const long cIndentAt = 1440/4;
+ aFmts[i]->SetPositionAndSpaceMode( SvxNumberFormat::LABEL_ALIGNMENT );
+ aFmts[i]->SetLabelFollowedBy( SvxNumberFormat::LISTTAB );
+ aFmts[i]->SetListtabPos( cIndentAt * (i+2) );
+ aFmts[i]->SetFirstLineIndent( cFirstLineIndent );
+ aFmts[i]->SetIndentAt( cIndentAt * (i+2) );
+ }
+ }
+ else
+ {
+ aFmts[i]->SetAbsLSpace( DEF_DRAW_LSPACE * i );
+ }
+ }
+ else
+ aFmts[i] = nullptr;
+ aFmtsSet[i] = false;
+ }
+}
+
+SvxNumRule::SvxNumRule(const SvxNumRule& rCopy)
+{
+ ++nRefCount;
+ nLevelCount = rCopy.nLevelCount ;
+ nFeatureFlags = rCopy.nFeatureFlags ;
+ bContinuousNumbering = rCopy.bContinuousNumbering;
+ eNumberingType = rCopy.eNumberingType;
+ for(sal_uInt16 i = 0; i < SVX_MAX_NUM; i++)
+ {
+ if(rCopy.aFmts[i])
+ aFmts[i].reset( new SvxNumberFormat(*rCopy.aFmts[i]) );
+ else
+ aFmts[i].reset();
+ aFmtsSet[i] = rCopy.aFmtsSet[i];
+ }
+}
+
+SvxNumRule::SvxNumRule( SvStream &rStream )
+ : nLevelCount(0)
+{
+ sal_uInt16 nTmp16(0);
+ rStream.ReadUInt16( nTmp16 ); // NUM_ITEM_VERSION
+ rStream.ReadUInt16( nLevelCount );
+
+ // first nFeatureFlags of old Versions
+ rStream.ReadUInt16( nTmp16 ); nFeatureFlags = static_cast<SvxNumRuleFlags>(nTmp16);
+ rStream.ReadUInt16( nTmp16 ); bContinuousNumbering = nTmp16;
+ rStream.ReadUInt16( nTmp16 ); eNumberingType = static_cast<SvxNumRuleType>(nTmp16);
+
+ for (sal_uInt16 i = 0; i < SVX_MAX_NUM; i++)
+ {
+ rStream.ReadUInt16( nTmp16 );
+ bool hasNumberingFormat = nTmp16 & 1;
+ aFmtsSet[i] = nTmp16 & 2; // fdo#68648 reset flag
+ if ( hasNumberingFormat ){
+ aFmts[i].reset( new SvxNumberFormat( rStream ) );
+ }
+ else
+ {
+ aFmts[i].reset();
+ aFmtsSet[i] = false; // actually only false is valid
+ }
+ }
+ //second nFeatureFlags for new versions
+ rStream.ReadUInt16( nTmp16 ); nFeatureFlags = static_cast<SvxNumRuleFlags>(nTmp16);
+}
+
+void SvxNumRule::Store( SvStream &rStream )
+{
+ rStream.WriteUInt16( NUMITEM_VERSION_03 );
+ rStream.WriteUInt16( nLevelCount );
+ //first save of nFeatureFlags for old versions
+ rStream.WriteUInt16( static_cast<sal_uInt16>(nFeatureFlags) );
+ rStream.WriteUInt16( sal_uInt16(bContinuousNumbering) );
+ rStream.WriteUInt16( static_cast<sal_uInt16>(eNumberingType) );
+
+ FontToSubsFontConverter pConverter = nullptr;
+ bool bConvertBulletFont = ( rStream.GetVersion() <= SOFFICE_FILEFORMAT_50 ) && ( rStream.GetVersion() );
+ for(sal_uInt16 i = 0; i < SVX_MAX_NUM; i++)
+ {
+ sal_uInt16 nSetFlag(aFmtsSet[i] ? 2 : 0); // fdo#68648 store that too
+ if(aFmts[i])
+ {
+ rStream.WriteUInt16( 1 | nSetFlag );
+ if(bConvertBulletFont && aFmts[i]->GetBulletFont())
+ {
+ if(!pConverter)
+ pConverter =
+ CreateFontToSubsFontConverter(aFmts[i]->GetBulletFont()->GetFamilyName(),
+ FontToSubsFontFlags::EXPORT);
+ }
+ aFmts[i]->Store(rStream, pConverter);
+ }
+ else
+ rStream.WriteUInt16( 0 | nSetFlag );
+ }
+ //second save of nFeatureFlags for new versions
+ rStream.WriteUInt16( static_cast<sal_uInt16>(nFeatureFlags) );
+}
+
+void SvxNumRule::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+ xmlTextWriterStartElement(pWriter, BAD_CAST("SvxNumRule"));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("levelCount"), BAD_CAST(OString::number(nLevelCount).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("continuousNumbering"), BAD_CAST(OString::boolean(bContinuousNumbering).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("numberingType"), BAD_CAST(OString::number(static_cast<int>(eNumberingType)).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("featureFlags"), BAD_CAST(OString::number(static_cast<int>(nFeatureFlags)).getStr()));
+ for(sal_uInt16 i = 0; i < SVX_MAX_NUM; i++)
+ {
+ if(aFmts[i])
+ {
+ xmlTextWriterStartElement(pWriter, BAD_CAST("aFmts"));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("i"), BAD_CAST(OString::number(i).getStr()));
+ xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("ptr"), "%p", aFmts[i].get());
+ xmlTextWriterEndElement(pWriter);
+ }
+ }
+ xmlTextWriterEndElement(pWriter);
+}
+
+
+SvxNumRule::~SvxNumRule()
+{
+ if(!--nRefCount)
+ {
+ DELETEZ(pStdNumFmt);
+ DELETEZ(pStdOutlineNumFmt);
+ }
+}
+
+SvxNumRule& SvxNumRule::operator=( const SvxNumRule& rCopy )
+{
+ if (this != &rCopy)
+ {
+ nLevelCount = rCopy.nLevelCount;
+ nFeatureFlags = rCopy.nFeatureFlags;
+ bContinuousNumbering = rCopy.bContinuousNumbering;
+ eNumberingType = rCopy.eNumberingType;
+ for(sal_uInt16 i = 0; i < SVX_MAX_NUM; i++)
+ {
+ if(rCopy.aFmts[i])
+ aFmts[i].reset( new SvxNumberFormat(*rCopy.aFmts[i]) );
+ else
+ aFmts[i].reset();
+ aFmtsSet[i] = rCopy.aFmtsSet[i];
+ }
+ }
+ return *this;
+}
+
+bool SvxNumRule::operator==( const SvxNumRule& rCopy) const
+{
+ if(nLevelCount != rCopy.nLevelCount ||
+ nFeatureFlags != rCopy.nFeatureFlags ||
+ bContinuousNumbering != rCopy.bContinuousNumbering ||
+ eNumberingType != rCopy.eNumberingType)
+ return false;
+ for(sal_uInt16 i = 0; i < nLevelCount; i++)
+ {
+ if (
+ (aFmtsSet[i] != rCopy.aFmtsSet[i]) ||
+ (!aFmts[i] && rCopy.aFmts[i]) ||
+ (aFmts[i] && !rCopy.aFmts[i]) ||
+ (aFmts[i] && *aFmts[i] != *rCopy.aFmts[i])
+ )
+ {
+ return false;
+ }
+ }
+ return true;
+}
+
+const SvxNumberFormat* SvxNumRule::Get(sal_uInt16 nLevel)const
+{
+ DBG_ASSERT(nLevel < SVX_MAX_NUM, "Wrong Level" );
+ if( nLevel < SVX_MAX_NUM )
+ return aFmtsSet[nLevel] ? aFmts[nLevel].get() : nullptr;
+ else
+ return nullptr;
+}
+
+const SvxNumberFormat& SvxNumRule::GetLevel(sal_uInt16 nLevel)const
+{
+ if(!pStdNumFmt)
+ {
+ pStdNumFmt = new SvxNumberFormat(SVX_NUM_ARABIC);
+ pStdOutlineNumFmt = new SvxNumberFormat(SVX_NUM_NUMBER_NONE);
+ }
+
+ DBG_ASSERT(nLevel < SVX_MAX_NUM, "Wrong Level" );
+
+ return ( ( nLevel < SVX_MAX_NUM ) && aFmts[nLevel] ) ?
+ *aFmts[nLevel] : eNumberingType == SvxNumRuleType::NUMBERING ?
+ *pStdNumFmt : *pStdOutlineNumFmt;
+}
+
+void SvxNumRule::SetLevel( sal_uInt16 i, const SvxNumberFormat& rNumFmt, bool bIsValid )
+{
+ DBG_ASSERT(i < SVX_MAX_NUM, "Wrong Level" );
+
+ if( i >= SVX_MAX_NUM )
+ return;
+
+ bool bReplace = !aFmtsSet[i];
+ if (!bReplace)
+ {
+ const SvxNumberFormat *pFmt = Get(i);
+ bReplace = pFmt == nullptr || rNumFmt != *pFmt;
+ }
+
+ if (bReplace)
+ {
+ aFmts[i].reset( new SvxNumberFormat(rNumFmt) );
+ aFmtsSet[i] = bIsValid;
+ }
+}
+
+void SvxNumRule::SetLevel(sal_uInt16 nLevel, const SvxNumberFormat* pFmt)
+{
+ DBG_ASSERT(nLevel < SVX_MAX_NUM, "Wrong Level" );
+
+ if( nLevel < SVX_MAX_NUM )
+ {
+ aFmtsSet[nLevel] = nullptr != pFmt;
+ if(pFmt)
+ SetLevel(nLevel, *pFmt);
+ else
+ {
+ aFmts[nLevel].reset();
+ }
+ }
+}
+
+OUString SvxNumRule::MakeNumString( const SvxNodeNum& rNum ) const
+{
+ OUStringBuffer aStr;
+ if( SVX_NO_NUM > rNum.GetLevel() && !( SVX_NO_NUMLEVEL & rNum.GetLevel() ) )
+ {
+ const SvxNumberFormat& rMyNFmt = GetLevel( rNum.GetLevel() );
+ aStr.append(rMyNFmt.GetPrefix());
+ if( SVX_NUM_NUMBER_NONE != rMyNFmt.GetNumberingType() )
+ {
+ sal_uInt8 i = rNum.GetLevel();
+
+ if( !IsContinuousNumbering() &&
+ 1 < rMyNFmt.GetIncludeUpperLevels() ) // only on own level?
+ {
+ sal_uInt8 n = rMyNFmt.GetIncludeUpperLevels();
+ if( 1 < n )
+ {
+ if( i+1 >= n )
+ i -= n - 1;
+ else
+ i = 0;
+ }
+ }
+
+ for( ; i <= rNum.GetLevel(); ++i )
+ {
+ const SvxNumberFormat& rNFmt = GetLevel( i );
+ if( SVX_NUM_NUMBER_NONE == rNFmt.GetNumberingType() )
+ {
+ continue;
+ }
+
+ bool bDot = true;
+ if( rNum.GetLevelVal()[ i ] )
+ {
+ if(SVX_NUM_BITMAP != rNFmt.GetNumberingType())
+ {
+ const LanguageTag& rLang = Application::GetSettings().GetLanguageTag();
+ aStr.append(rNFmt.GetNumStr( rNum.GetLevelVal()[ i ], rLang.getLocale() ));
+ }
+ else
+ bDot = false;
+ }
+ else
+ aStr.append("0"); // all 0-levels are a 0
+ if( i != rNum.GetLevel() && bDot)
+ aStr.append(".");
+ }
+ }
+
+ aStr.append(rMyNFmt.GetSuffix());
+ }
+ return aStr.makeStringAndClear();
+}
+
+// changes linked to embedded bitmaps
+void SvxNumRule::UnLinkGraphics()
+{
+ for(sal_uInt16 i = 0; i < GetLevelCount(); i++)
+ {
+ SvxNumberFormat aFmt(GetLevel(i));
+ const SvxBrushItem* pBrush = aFmt.GetBrush();
+ if(SVX_NUM_BITMAP == aFmt.GetNumberingType())
+ {
+ if(pBrush && !pBrush->GetGraphicLink().isEmpty())
+ {
+ const Graphic* pGraphic = pBrush->GetGraphic();
+ if (pGraphic)
+ {
+ SvxBrushItem aTempItem(*pBrush);
+ aTempItem.SetGraphicLink("");
+ aTempItem.SetGraphic(*pGraphic);
+ sal_Int16 eOrient = aFmt.GetVertOrient();
+ aFmt.SetGraphicBrush( &aTempItem, &aFmt.GetGraphicSize(), &eOrient );
+ }
+ }
+ }
+ else if((SVX_NUM_BITMAP|LINK_TOKEN) == static_cast<int>(aFmt.GetNumberingType()))
+ aFmt.SetNumberingType(SVX_NUM_BITMAP);
+ SetLevel(i, aFmt);
+ }
+}
+
+SvxNumBulletItem::SvxNumBulletItem(SvxNumRule const & rRule) :
+ SfxPoolItem(SID_ATTR_NUMBERING_RULE),
+ pNumRule(new SvxNumRule(rRule))
+{
+}
+
+SvxNumBulletItem::SvxNumBulletItem(SvxNumRule const & rRule, sal_uInt16 _nWhich ) :
+ SfxPoolItem(_nWhich),
+ pNumRule(new SvxNumRule(rRule))
+{
+}
+
+SvxNumBulletItem::SvxNumBulletItem(const SvxNumBulletItem& rCopy) :
+ SfxPoolItem(rCopy),
+ pNumRule(new SvxNumRule(*rCopy.pNumRule))
+{
+}
+
+SvxNumBulletItem::~SvxNumBulletItem()
+{
+}
+
+bool SvxNumBulletItem::operator==( const SfxPoolItem& rCopy) const
+{
+ return SfxPoolItem::operator==(rCopy) &&
+ *pNumRule == *static_cast<const SvxNumBulletItem&>(rCopy).pNumRule;
+}
+
+SvxNumBulletItem* SvxNumBulletItem::Clone( SfxItemPool * ) const
+{
+ return new SvxNumBulletItem(*this);
+}
+
+bool SvxNumBulletItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
+{
+ rVal <<= SvxCreateNumRule( pNumRule.get() );
+ return true;
+}
+
+bool SvxNumBulletItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
+{
+ uno::Reference< container::XIndexReplace > xRule;
+ if( rVal >>= xRule )
+ {
+ try
+ {
+ std::unique_ptr<SvxNumRule> pNewRule(new SvxNumRule( SvxGetNumRule( xRule ) ));
+ if( pNewRule->GetLevelCount() != pNumRule->GetLevelCount() ||
+ pNewRule->GetNumRuleType() != pNumRule->GetNumRuleType() )
+ {
+ std::unique_ptr<SvxNumRule> pConverted = SvxConvertNumRule( pNewRule.get(), pNumRule->GetLevelCount(), pNumRule->GetNumRuleType() );
+ pNewRule = std::move(pConverted);
+ }
+ pNumRule = std::move( pNewRule );
+ return true;
+ }
+ catch(const lang::IllegalArgumentException&)
+ {
+ }
+ }
+ return false;
+}
+
+void SvxNumBulletItem::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+ xmlTextWriterStartElement(pWriter, BAD_CAST("SvxNumBulletItem"));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+ pNumRule->dumpAsXml(pWriter);
+ xmlTextWriterEndElement(pWriter);
+}
+
+std::unique_ptr<SvxNumRule> SvxConvertNumRule( const SvxNumRule* pRule, sal_uInt16 nLevels, SvxNumRuleType eType )
+{
+ const sal_uInt16 nSrcLevels = pRule->GetLevelCount();
+ std::unique_ptr<SvxNumRule> pNewRule(new SvxNumRule( pRule->GetFeatureFlags(), nLevels, pRule->IsContinuousNumbering(), eType ));
+
+ for( sal_uInt16 nLevel = 0; (nLevel < nLevels) && (nLevel < nSrcLevels); nLevel++ )
+ pNewRule->SetLevel( nLevel, pRule->GetLevel( nLevel ) );
+
+ return pNewRule;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/items/optitems.cxx b/editeng/source/items/optitems.cxx
new file mode 100644
index 000000000..254da79d9
--- /dev/null
+++ b/editeng/source/items/optitems.cxx
@@ -0,0 +1,63 @@
+/* -*- 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 <editeng/optitems.hxx>
+#include <editeng/eerdll.hxx>
+#include <editeng/editrids.hrc>
+
+
+// class SfxHyphenRegionItem -----------------------------------------------
+
+SfxHyphenRegionItem::SfxHyphenRegionItem( const sal_uInt16 nId ) :
+
+ SfxPoolItem( nId )
+{
+ nMinLead = nMinTrail = 0;
+}
+
+bool SfxHyphenRegionItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ assert(SfxPoolItem::operator==(rAttr));
+
+ return ( ( static_cast<const SfxHyphenRegionItem&>( rAttr ).nMinLead == nMinLead ) &&
+ ( static_cast<const SfxHyphenRegionItem&>( rAttr ).nMinTrail == nMinTrail ) );
+}
+
+SfxHyphenRegionItem* SfxHyphenRegionItem::Clone( SfxItemPool* ) const
+{
+ return new SfxHyphenRegionItem( *this );
+}
+
+bool SfxHyphenRegionItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit ,
+ MapUnit ,
+ OUString& rText,
+ const IntlWrapper&
+) const
+{
+ rText += EditResId(RID_SVXITEMS_HYPHEN_MINLEAD).replaceAll("%1", OUString::number(nMinLead)) +
+ "," +
+ EditResId(RID_SVXITEMS_HYPHEN_MINTRAIL).replaceAll("%1", OUString::number(nMinTrail));
+ return true;
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/items/paperinf.cxx b/editeng/source/items/paperinf.cxx
new file mode 100644
index 000000000..ebb5aecaf
--- /dev/null
+++ b/editeng/source/items/paperinf.cxx
@@ -0,0 +1,121 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <vcl/print.hxx>
+#include <editeng/paperinf.hxx>
+
+/*--------------------------------------------------------------------
+ Description: Is the printer valid
+ --------------------------------------------------------------------*/
+
+static bool IsValidPrinter( const Printer* pPtr )
+{
+ return !pPtr->GetName().isEmpty();
+}
+
+
+Size SvxPaperInfo::GetPaperSize( Paper ePaper, MapUnit eUnit )
+{
+ PaperInfo aInfo(ePaper);
+ Size aRet(aInfo.getWidth(), aInfo.getHeight()); // in 100thMM
+ return eUnit == MapUnit::Map100thMM
+ ? aRet
+ : OutputDevice::LogicToLogic(aRet, MapMode(MapUnit::Map100thMM), MapMode(eUnit));
+}
+
+/*------------------------------------------------------------------------
+ Description: Return the paper size of the printer, aligned to our
+ own sizes. If no Printer is set in the system, A4 portrait
+ will be delivered as the default paper size.
+------------------------------------------------------------------------*/
+
+//Is this method may be confused about the units it returns ?
+//Always returns TWIPS for known paper sizes or on failure.
+//But in the case of PAPER_USER paper and with a Printer with a mapmode set
+//will return in those printer units ?
+Size SvxPaperInfo::GetPaperSize( const Printer* pPrinter )
+{
+ if ( !IsValidPrinter(pPrinter) )
+ return GetPaperSize( PAPER_A4 );
+ const Paper ePaper = pPrinter->GetPaper();
+
+ if ( ePaper == PAPER_USER )
+ {
+ // Orientation not take into account, as the right size has
+ // been already set by SV
+ Size aPaperSize = pPrinter->GetPaperSize();
+ const Size aInvalidSize;
+
+ if ( aPaperSize == aInvalidSize )
+ return GetPaperSize(PAPER_A4);
+ const MapMode& aMap1 = pPrinter->GetMapMode();
+ MapMode aMap2;
+
+ if ( aMap1 == aMap2 )
+ aPaperSize =
+ pPrinter->PixelToLogic( aPaperSize, MapMode( MapUnit::MapTwip ) );
+ return aPaperSize;
+ }
+
+ const Orientation eOrient = pPrinter->GetOrientation();
+ Size aSize( GetPaperSize( ePaper ) );
+ // for Landscape exchange the pages, has already been done by SV
+ if ( eOrient == Orientation::Landscape )
+ Swap( aSize );
+ return aSize;
+}
+
+
+Paper SvxPaperInfo::GetSvxPaper( const Size &rSize, MapUnit eUnit )
+{
+ Size aSize(eUnit == MapUnit::Map100thMM ? rSize : OutputDevice::LogicToLogic(rSize, MapMode(eUnit), MapMode(MapUnit::Map100thMM)));
+ PaperInfo aInfo(aSize.Width(), aSize.Height());
+ aInfo.doSloppyFit();
+ return aInfo.getPaper();
+}
+
+
+long SvxPaperInfo::GetSloppyPaperDimension( long nSize )
+{
+ nSize = OutputDevice::LogicToLogic(nSize, MapUnit::MapTwip, MapUnit::Map100thMM);
+ nSize = PaperInfo::sloppyFitPageDimension(nSize);
+ return OutputDevice::LogicToLogic(nSize, MapUnit::Map100thMM, MapUnit::MapTwip);
+}
+
+
+Size SvxPaperInfo::GetDefaultPaperSize( MapUnit eUnit )
+{
+ PaperInfo aInfo(PaperInfo::getSystemDefaultPaper());
+ Size aRet(aInfo.getWidth(), aInfo.getHeight());
+ return eUnit == MapUnit::Map100thMM
+ ? aRet
+ : OutputDevice::LogicToLogic(aRet, MapMode(MapUnit::Map100thMM), MapMode(eUnit));
+}
+
+/*------------------------------------------------------------------------
+ Description: String representation for the SV-defines of paper size
+------------------------------------------------------------------------*/
+
+OUString SvxPaperInfo::GetName( Paper ePaper )
+{
+ return Printer::GetPaperName( ePaper );
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/items/paraitem.cxx b/editeng/source/items/paraitem.cxx
new file mode 100644
index 000000000..0e1e94f4d
--- /dev/null
+++ b/editeng/source/items/paraitem.cxx
@@ -0,0 +1,1231 @@
+/* -*- 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/style/TabStop.hpp>
+#include <com/sun/star/style/LineSpacing.hpp>
+#include <com/sun/star/style/LineSpacingMode.hpp>
+#include <com/sun/star/uno/Sequence.hxx>
+#include <libxml/xmlwriter.h>
+#include <comphelper/extract.hxx>
+#include <osl/diagnose.h>
+#include <unotools/localedatawrapper.hxx>
+#include <unotools/syslocale.hxx>
+#include <tools/mapunit.hxx>
+#include <svl/itempool.hxx>
+#include <svl/memberid.h>
+#include <editeng/editrids.hrc>
+#include <editeng/lspcitem.hxx>
+#include <editeng/adjustitem.hxx>
+#include <editeng/orphitem.hxx>
+#include <editeng/widwitem.hxx>
+#include <editeng/tstpitem.hxx>
+#include <editeng/pmdlitem.hxx>
+#include <editeng/spltitem.hxx>
+#include <editeng/hyphenzoneitem.hxx>
+#include <editeng/scriptspaceitem.hxx>
+#include <editeng/hngpnctitem.hxx>
+#include <editeng/forbiddenruleitem.hxx>
+#include <editeng/paravertalignitem.hxx>
+#include <editeng/pgrditem.hxx>
+#include <rtl/ustring.hxx>
+#include <sal/log.hxx>
+#include <editeng/memberids.h>
+#include <editeng/itemtype.hxx>
+#include <editeng/eerdll.hxx>
+
+using namespace ::com::sun::star;
+
+
+SfxPoolItem* SvxLineSpacingItem::CreateDefault() { return new SvxLineSpacingItem(LINE_SPACE_DEFAULT_HEIGHT, 0);}
+SfxPoolItem* SvxAdjustItem::CreateDefault() { return new SvxAdjustItem(SvxAdjust::Left, 0);}
+SfxPoolItem* SvxWidowsItem::CreateDefault() { return new SvxWidowsItem(0, 0);}
+SfxPoolItem* SvxOrphansItem::CreateDefault() { return new SvxOrphansItem(0, 0);}
+SfxPoolItem* SvxHyphenZoneItem::CreateDefault() { return new SvxHyphenZoneItem(false, 0);}
+SfxPoolItem* SvxTabStopItem::CreateDefault() { return new SvxTabStopItem(0);}
+SfxPoolItem* SvxFormatSplitItem::CreateDefault() { return new SvxFormatSplitItem(false, 0);}
+SfxPoolItem* SvxPageModelItem::CreateDefault() { return new SvxPageModelItem(0);}
+SfxPoolItem* SvxParaVertAlignItem::CreateDefault() { return new SvxParaVertAlignItem(Align::Automatic, 0);}
+
+namespace {
+
+enum class SvxSpecialLineSpace
+{
+ User,
+ OneLine,
+ OnePointFiveLines,
+ TwoLines,
+ End
+};
+
+}
+
+SvxLineSpacingItem::SvxLineSpacingItem( sal_uInt16 nHeight, const sal_uInt16 nId )
+ : SfxEnumItemInterface( nId )
+{
+ nPropLineSpace = 100;
+ nInterLineSpace = 0;
+ nLineHeight = nHeight;
+ eLineSpaceRule = SvxLineSpaceRule::Auto;
+ eInterLineSpaceRule = SvxInterLineSpaceRule::Off;
+}
+
+
+bool SvxLineSpacingItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ assert(SfxPoolItem::operator==(rAttr));
+
+ const SvxLineSpacingItem& rLineSpace = static_cast<const SvxLineSpacingItem&>(rAttr);
+ return
+ // Same Linespacing Rule?
+ (eLineSpaceRule == rLineSpace.eLineSpaceRule)
+ // For maximum and minimum Linespacing be the size must coincide.
+ && (eLineSpaceRule == SvxLineSpaceRule::Auto ||
+ nLineHeight == rLineSpace.nLineHeight)
+ // Same Linespacing Rule?
+ && ( eInterLineSpaceRule == rLineSpace.eInterLineSpaceRule )
+ // Either set proportional or additive.
+ && (( eInterLineSpaceRule == SvxInterLineSpaceRule::Off)
+ || (eInterLineSpaceRule == SvxInterLineSpaceRule::Prop
+ && nPropLineSpace == rLineSpace.nPropLineSpace)
+ || (eInterLineSpaceRule == SvxInterLineSpaceRule::Fix
+ && (nInterLineSpace == rLineSpace.nInterLineSpace)));
+}
+
+/* Who does still know why the LineSpacingItem is so complicated?
+ We can not use it for UNO since there are only two values:
+ - a sal_uInt16 for the mode
+ - a sal_uInt32 for all values (distance, height, rel. detail)
+*/
+bool SvxLineSpacingItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
+ nMemberId &= ~CONVERT_TWIPS;
+
+ style::LineSpacing aLSp;
+ switch( eLineSpaceRule )
+ {
+ case SvxLineSpaceRule::Auto:
+ if(eInterLineSpaceRule == SvxInterLineSpaceRule::Fix)
+ {
+ aLSp.Mode = style::LineSpacingMode::LEADING;
+ aLSp.Height = ( bConvert ? static_cast<short>(convertTwipToMm100(nInterLineSpace)) : nInterLineSpace);
+ }
+ else if(eInterLineSpaceRule == SvxInterLineSpaceRule::Off)
+ {
+ aLSp.Mode = style::LineSpacingMode::PROP;
+ aLSp.Height = 100;
+ }
+ else
+ {
+ aLSp.Mode = style::LineSpacingMode::PROP;
+ aLSp.Height = nPropLineSpace;
+ }
+ break;
+ case SvxLineSpaceRule::Fix :
+ case SvxLineSpaceRule::Min :
+ aLSp.Mode = eLineSpaceRule == SvxLineSpaceRule::Fix ? style::LineSpacingMode::FIX : style::LineSpacingMode::MINIMUM;
+ aLSp.Height = ( bConvert ? static_cast<short>(convertTwipToMm100(nLineHeight)) : nLineHeight );
+ break;
+ default:
+ ;//prevent warning about SvxLineSpaceRule::End
+ }
+
+ switch ( nMemberId )
+ {
+ case 0 : rVal <<= aLSp; break;
+ case MID_LINESPACE : rVal <<= aLSp.Mode; break;
+ case MID_HEIGHT : rVal <<= aLSp.Height; break;
+ default: OSL_FAIL("Wrong MemberId!"); break;
+ }
+
+ return true;
+}
+
+bool SvxLineSpacingItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
+ nMemberId &= ~CONVERT_TWIPS;
+
+ // fill with current data
+ style::LineSpacing aLSp;
+ uno::Any aAny;
+ bool bRet = QueryValue( aAny, bConvert ? CONVERT_TWIPS : 0 ) && ( aAny >>= aLSp );
+
+ // get new data
+ switch ( nMemberId )
+ {
+ case 0 : bRet = (rVal >>= aLSp); break;
+ case MID_LINESPACE : bRet = (rVal >>= aLSp.Mode); break;
+ case MID_HEIGHT : bRet = (rVal >>= aLSp.Height); break;
+ default: OSL_FAIL("Wrong MemberId!"); break;
+ }
+
+ if( bRet )
+ {
+ nLineHeight = aLSp.Height;
+ switch( aLSp.Mode )
+ {
+ case style::LineSpacingMode::LEADING:
+ {
+ eInterLineSpaceRule = SvxInterLineSpaceRule::Fix;
+ eLineSpaceRule = SvxLineSpaceRule::Auto;
+ nInterLineSpace = aLSp.Height;
+ if(bConvert)
+ nInterLineSpace = static_cast<short>(convertMm100ToTwip(nInterLineSpace));
+
+ }
+ break;
+ case style::LineSpacingMode::PROP:
+ {
+ eLineSpaceRule = SvxLineSpaceRule::Auto;
+ nPropLineSpace = aLSp.Height;
+ if(100 == aLSp.Height)
+ eInterLineSpaceRule = SvxInterLineSpaceRule::Off;
+ else
+ eInterLineSpaceRule = SvxInterLineSpaceRule::Prop;
+ }
+ break;
+ case style::LineSpacingMode::FIX:
+ case style::LineSpacingMode::MINIMUM:
+ {
+ eInterLineSpaceRule = SvxInterLineSpaceRule::Off;
+ eLineSpaceRule = aLSp.Mode == style::LineSpacingMode::FIX ? SvxLineSpaceRule::Fix : SvxLineSpaceRule::Min;
+ nLineHeight = aLSp.Height;
+ if(bConvert)
+ nLineHeight = static_cast<sal_uInt16>(convertMm100ToTwip(nLineHeight));
+ }
+ break;
+ }
+ }
+
+ return bRet;
+}
+
+SvxLineSpacingItem* SvxLineSpacingItem::Clone( SfxItemPool * ) const
+{
+ return new SvxLineSpacingItem( *this );
+}
+
+bool SvxLineSpacingItem::GetPresentation
+(
+ SfxItemPresentation ePres,
+ MapUnit eCoreUnit,
+ MapUnit ePresUnit,
+ OUString& rText, const IntlWrapper& rIntl
+) const
+{
+ switch ( ePres )
+ {
+ case SfxItemPresentation::Nameless:
+ case SfxItemPresentation::Complete:
+ {
+ switch( GetLineSpaceRule() )
+ {
+ case SvxLineSpaceRule::Auto:
+ {
+ SvxInterLineSpaceRule eInter = GetInterLineSpaceRule();
+
+ switch( eInter )
+ {
+ // Default single line spacing
+ case SvxInterLineSpaceRule::Off:
+ rText = EditResId(RID_SVXITEMS_LINESPACING_SINGLE);
+ break;
+
+ // Default single line spacing
+ case SvxInterLineSpaceRule::Prop:
+ if ( 100 == GetPropLineSpace() )
+ {
+ rText = EditResId(RID_SVXITEMS_LINESPACING_SINGLE);
+ break;
+ }
+ // 1.15 line spacing
+ if ( 115 == GetPropLineSpace() )
+ {
+ rText = EditResId(RID_SVXITEMS_LINESPACING_115);
+ break;
+ }
+ // 1.5 line spacing
+ if ( 150 == GetPropLineSpace() )
+ {
+ rText = EditResId(RID_SVXITEMS_LINESPACING_15);
+ break;
+ }
+ // double line spacing
+ if ( 200 == GetPropLineSpace() )
+ {
+ rText = EditResId(RID_SVXITEMS_LINESPACING_DOUBLE);
+ break;
+ }
+ // the set per cent value
+ rText = EditResId(RID_SVXITEMS_LINESPACING_PROPORTIONAL) + " " + OUString::number(GetPropLineSpace()) + "%";
+ break;
+
+ case SvxInterLineSpaceRule::Fix:
+ rText = EditResId(RID_SVXITEMS_LINESPACING_LEADING) +
+ " " + GetMetricText(GetInterLineSpace(), eCoreUnit, ePresUnit, &rIntl) +
+ " " + EditResId(GetMetricId(ePresUnit));
+ break;
+ default: ;//prevent warning
+ }
+ }
+ break;
+ case SvxLineSpaceRule::Fix:
+ rText = EditResId(RID_SVXITEMS_LINESPACING_FIXED) +
+ " " + GetMetricText(GetLineHeight(), eCoreUnit, ePresUnit, &rIntl) +
+ " " + EditResId(GetMetricId(ePresUnit));
+ break;
+
+ case SvxLineSpaceRule::Min:
+ rText = EditResId(RID_SVXITEMS_LINESPACING_MIN) +
+ " " + GetMetricText(GetLineHeight(), eCoreUnit, ePresUnit, &rIntl) +
+ " " + EditResId(GetMetricId(ePresUnit));
+ break;
+ default: ;//prevent warning
+ }
+ }
+ }
+ return true;
+}
+
+sal_uInt16 SvxLineSpacingItem::GetValueCount() const
+{
+ return sal_uInt16(SvxSpecialLineSpace::End); // SvxSpecialLineSpace::TwoLines + 1
+}
+
+
+sal_uInt16 SvxLineSpacingItem::GetEnumValue() const
+{
+ SvxSpecialLineSpace nVal;
+ switch ( nPropLineSpace )
+ {
+ case 100: nVal = SvxSpecialLineSpace::OneLine; break;
+ case 150: nVal = SvxSpecialLineSpace::OnePointFiveLines; break;
+ case 200: nVal = SvxSpecialLineSpace::TwoLines; break;
+ default: nVal = SvxSpecialLineSpace::User; break;
+ }
+ return static_cast<sal_uInt16>(nVal);
+}
+
+
+void SvxLineSpacingItem::SetEnumValue( sal_uInt16 nVal )
+{
+ switch ( static_cast<SvxSpecialLineSpace>(nVal) )
+ {
+ case SvxSpecialLineSpace::OneLine: nPropLineSpace = 100; break;
+ case SvxSpecialLineSpace::OnePointFiveLines: nPropLineSpace = 150; break;
+ case SvxSpecialLineSpace::TwoLines: nPropLineSpace = 200; break;
+ default: break;
+ }
+}
+
+// class SvxAdjustItem ---------------------------------------------------
+
+SvxAdjustItem::SvxAdjustItem(const SvxAdjust eAdjst, const sal_uInt16 nId )
+ : SfxEnumItemInterface( nId ),
+ bOneBlock( false ), bLastCenter( false ), bLastBlock( false )
+{
+ SetAdjust( eAdjst );
+}
+
+
+bool SvxAdjustItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ assert(SfxPoolItem::operator==(rAttr));
+
+ const SvxAdjustItem& rItem = static_cast<const SvxAdjustItem&>(rAttr);
+ return GetAdjust() == rItem.GetAdjust() &&
+ bOneBlock == rItem.bOneBlock &&
+ bLastCenter == rItem.bLastCenter &&
+ bLastBlock == rItem.bLastBlock;
+}
+
+bool SvxAdjustItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch( nMemberId )
+ {
+ case MID_PARA_ADJUST : rVal <<= static_cast<sal_Int16>(GetAdjust()); break;
+ case MID_LAST_LINE_ADJUST : rVal <<= static_cast<sal_Int16>(GetLastBlock()); break;
+ case MID_EXPAND_SINGLE :
+ {
+ rVal <<= bOneBlock;
+ break;
+ }
+ default: ;//prevent warning
+ }
+ return true;
+}
+
+bool SvxAdjustItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch( nMemberId )
+ {
+ case MID_PARA_ADJUST :
+ case MID_LAST_LINE_ADJUST :
+ {
+ sal_Int32 eVal = - 1;
+ ::cppu::enum2int(eVal,rVal);
+ if(eVal >= 0 && eVal <= 4)
+ {
+ SvxAdjust eAdjust = static_cast<SvxAdjust>(eVal);
+ if(MID_LAST_LINE_ADJUST == nMemberId &&
+ eAdjust != SvxAdjust::Left &&
+ eAdjust != SvxAdjust::Block &&
+ eAdjust != SvxAdjust::Center)
+ return false;
+ nMemberId == MID_PARA_ADJUST ? SetAdjust(eAdjust) : SetLastBlock(eAdjust);
+ }
+ }
+ break;
+ case MID_EXPAND_SINGLE :
+ bOneBlock = Any2Bool(rVal);
+ break;
+ }
+ return true;
+}
+
+SvxAdjustItem* SvxAdjustItem::Clone( SfxItemPool * ) const
+{
+ return new SvxAdjustItem( *this );
+}
+
+bool SvxAdjustItem::GetPresentation
+(
+ SfxItemPresentation ePres,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper&
+) const
+{
+ switch ( ePres )
+ {
+ case SfxItemPresentation::Nameless:
+ case SfxItemPresentation::Complete:
+ rText = GetValueTextByPos( static_cast<sal_uInt16>(GetAdjust()) );
+ return true;
+ default: ;//prevent warning
+ }
+ return false;
+}
+
+
+sal_uInt16 SvxAdjustItem::GetValueCount() const
+{
+ return sal_uInt16(SvxAdjust::End); // SvxAdjust::BlockLine + 1
+}
+
+OUString SvxAdjustItem::GetValueTextByPos( sal_uInt16 nPos )
+{
+ static const char* RID_SVXITEMS_ADJUST[] =
+ {
+ RID_SVXITEMS_ADJUST_LEFT,
+ RID_SVXITEMS_ADJUST_RIGHT,
+ RID_SVXITEMS_ADJUST_BLOCK,
+ RID_SVXITEMS_ADJUST_CENTER,
+ RID_SVXITEMS_ADJUST_BLOCKLINE
+ };
+ static_assert(SAL_N_ELEMENTS(RID_SVXITEMS_ADJUST) - 1 == size_t(SvxAdjust::BlockLine), "unexpected size");
+ assert(nPos <= sal_uInt16(SvxAdjust::BlockLine) && "enum overflow!");
+ return EditResId(RID_SVXITEMS_ADJUST[nPos]);
+}
+
+sal_uInt16 SvxAdjustItem::GetEnumValue() const
+{
+ return static_cast<sal_uInt16>(GetAdjust());
+}
+
+
+void SvxAdjustItem::SetEnumValue( sal_uInt16 nVal )
+{
+ SetAdjust( static_cast<SvxAdjust>(nVal) );
+}
+
+
+// class SvxWidowsItem ---------------------------------------------------
+
+SvxWidowsItem::SvxWidowsItem(const sal_uInt8 nL, const sal_uInt16 nId ) :
+ SfxByteItem( nId, nL )
+{
+}
+
+SvxWidowsItem* SvxWidowsItem::Clone( SfxItemPool * ) const
+{
+ return new SvxWidowsItem( *this );
+}
+
+bool SvxWidowsItem::GetPresentation
+(
+ SfxItemPresentation ePres,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper&
+) const
+{
+ switch ( ePres )
+ {
+ case SfxItemPresentation::Nameless:
+ {
+ rText = EditResId(RID_SVXITEMS_LINES);
+ break;
+ }
+
+ case SfxItemPresentation::Complete:
+ {
+ rText = EditResId(RID_SVXITEMS_WIDOWS_COMPLETE) + " " + EditResId(RID_SVXITEMS_LINES);
+ break;
+ }
+
+ default:
+ {
+ SAL_WARN( "editeng.items", "SvxWidowsItem::GetPresentation(): unknown SfxItemPresentation" );
+ }
+ }
+
+ rText = rText.replaceFirst( "%1", OUString::number( GetValue() ) );
+ return true;
+}
+
+// class SvxOrphansItem --------------------------------------------------
+
+SvxOrphansItem::SvxOrphansItem(const sal_uInt8 nL, const sal_uInt16 nId ) :
+ SfxByteItem( nId, nL )
+{
+}
+
+SvxOrphansItem* SvxOrphansItem::Clone( SfxItemPool * ) const
+{
+ return new SvxOrphansItem( *this );
+}
+
+bool SvxOrphansItem::GetPresentation
+(
+ SfxItemPresentation ePres,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper&
+) const
+{
+ switch ( ePres )
+ {
+ case SfxItemPresentation::Nameless:
+ {
+ rText = EditResId(RID_SVXITEMS_LINES);
+ break;
+ }
+
+ case SfxItemPresentation::Complete:
+ {
+ rText = EditResId(RID_SVXITEMS_ORPHANS_COMPLETE) + " " + EditResId(RID_SVXITEMS_LINES);
+ break;
+ }
+
+ default:
+ {
+ SAL_WARN( "editeng.items", "SvxOrphansItem::GetPresentation(): unknown SfxItemPresentation" );
+ }
+ }
+
+ rText = rText.replaceFirst( "%1", OUString::number( GetValue() ) );
+ return true;
+}
+
+// class SvxHyphenZoneItem -----------------------------------------------
+
+SvxHyphenZoneItem::SvxHyphenZoneItem( const bool bHyph, const sal_uInt16 nId ) :
+ SfxPoolItem( nId ),
+ bHyphen(bHyph),
+ bPageEnd(true),
+ bNoCapsHyphenation(false),
+ nMinLead(0),
+ nMinTrail(0),
+ nMaxHyphens(255)
+{
+}
+
+
+bool SvxHyphenZoneItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch(nMemberId)
+ {
+ case MID_IS_HYPHEN:
+ rVal <<= bHyphen;
+ break;
+ case MID_HYPHEN_MIN_LEAD:
+ rVal <<= static_cast<sal_Int16>(nMinLead);
+ break;
+ case MID_HYPHEN_MIN_TRAIL:
+ rVal <<= static_cast<sal_Int16>(nMinTrail);
+ break;
+ case MID_HYPHEN_MAX_HYPHENS:
+ rVal <<= static_cast<sal_Int16>(nMaxHyphens);
+ break;
+ case MID_HYPHEN_NO_CAPS:
+ rVal <<= bNoCapsHyphenation;
+ break;
+ }
+ return true;
+}
+
+bool SvxHyphenZoneItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ sal_Int16 nNewVal = 0;
+
+ if( nMemberId != MID_IS_HYPHEN && nMemberId != MID_HYPHEN_NO_CAPS )
+ if(!(rVal >>= nNewVal))
+ return false;
+
+ switch(nMemberId)
+ {
+ case MID_IS_HYPHEN:
+ bHyphen = Any2Bool(rVal);
+ break;
+ case MID_HYPHEN_MIN_LEAD:
+ nMinLead = static_cast<sal_uInt8>(nNewVal);
+ break;
+ case MID_HYPHEN_MIN_TRAIL:
+ nMinTrail = static_cast<sal_uInt8>(nNewVal);
+ break;
+ case MID_HYPHEN_MAX_HYPHENS:
+ nMaxHyphens = static_cast<sal_uInt8>(nNewVal);
+ break;
+ case MID_HYPHEN_NO_CAPS:
+ bNoCapsHyphenation = Any2Bool(rVal);
+ break;
+ }
+ return true;
+}
+
+
+bool SvxHyphenZoneItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ assert(SfxPoolItem::operator==(rAttr));
+
+ const SvxHyphenZoneItem& rItem = static_cast<const SvxHyphenZoneItem&>(rAttr);
+ return ( rItem.bHyphen == bHyphen
+ && rItem.bNoCapsHyphenation == bNoCapsHyphenation
+ && rItem.bPageEnd == bPageEnd
+ && rItem.nMinLead == nMinLead
+ && rItem.nMinTrail == nMinTrail
+ && rItem.nMaxHyphens == nMaxHyphens );
+}
+
+SvxHyphenZoneItem* SvxHyphenZoneItem::Clone( SfxItemPool * ) const
+{
+ return new SvxHyphenZoneItem( *this );
+}
+
+bool SvxHyphenZoneItem::GetPresentation
+(
+ SfxItemPresentation ePres,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper&
+) const
+{
+ OUString cpDelimTmp(cpDelim);
+ switch ( ePres )
+ {
+ case SfxItemPresentation::Nameless:
+ {
+ const char* pId = RID_SVXITEMS_HYPHEN_FALSE;
+
+ if ( bHyphen )
+ pId = RID_SVXITEMS_HYPHEN_TRUE;
+ rText = EditResId(pId) + cpDelimTmp;
+ pId = RID_SVXITEMS_PAGE_END_FALSE;
+
+ if ( bPageEnd )
+ pId = RID_SVXITEMS_PAGE_END_TRUE;
+ rText += EditResId(pId) + cpDelimTmp +
+ OUString::number( nMinLead ) + cpDelimTmp +
+ OUString::number( nMinTrail ) + cpDelimTmp +
+ OUString::number( nMaxHyphens );
+ return true;
+ }
+ case SfxItemPresentation::Complete:
+ {
+ const char* pId = RID_SVXITEMS_HYPHEN_FALSE;
+
+ if ( bHyphen )
+ pId = RID_SVXITEMS_HYPHEN_TRUE;
+ rText = EditResId(pId) + cpDelimTmp;
+ pId = RID_SVXITEMS_PAGE_END_FALSE;
+
+ if ( bPageEnd )
+ pId = RID_SVXITEMS_PAGE_END_TRUE;
+ rText += EditResId(pId) +
+ cpDelimTmp +
+ EditResId(RID_SVXITEMS_HYPHEN_MINLEAD).replaceAll("%1", OUString::number(nMinLead)) +
+ cpDelimTmp +
+ EditResId(RID_SVXITEMS_HYPHEN_MINTRAIL).replaceAll("%1", OUString::number(nMinTrail)) +
+ cpDelimTmp +
+ EditResId(RID_SVXITEMS_HYPHEN_MAX).replaceAll("%1", OUString::number(nMaxHyphens));
+ return true;
+ }
+ default: ;//prevent warning
+ }
+ return false;
+}
+
+
+// class SvxTabStop ------------------------------------------------------
+
+SvxTabStop::SvxTabStop()
+{
+ nTabPos = 0;
+ eAdjustment = SvxTabAdjust::Left;
+ m_cDecimal = cDfltDecimalChar;
+ cFill = cDfltFillChar;
+}
+
+
+SvxTabStop::SvxTabStop( const sal_Int32 nPos, const SvxTabAdjust eAdjst,
+ const sal_Unicode cDec, const sal_Unicode cFil )
+{
+ nTabPos = nPos;
+ eAdjustment = eAdjst;
+ m_cDecimal = cDec;
+ cFill = cFil;
+}
+
+void SvxTabStop::fillDecimal() const
+{
+ if ( cDfltDecimalChar == m_cDecimal )
+ m_cDecimal = SvtSysLocale().GetLocaleData().getNumDecimalSep()[0];
+}
+
+void SvxTabStop::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+ xmlTextWriterStartElement(pWriter, BAD_CAST("SvxTabStop"));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("nTabPos"),
+ BAD_CAST(OString::number(nTabPos).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("eAdjustment"),
+ BAD_CAST(OString::number(static_cast<int>(eAdjustment)).getStr()));
+ xmlTextWriterEndElement(pWriter);
+}
+
+// class SvxTabStopItem --------------------------------------------------
+
+SvxTabStopItem::SvxTabStopItem( sal_uInt16 _nWhich ) :
+ SfxPoolItem( _nWhich ),
+ maTabStops()
+{
+ const sal_uInt16 nTabs = SVX_TAB_DEFCOUNT, nDist = SVX_TAB_DEFDIST;
+ const SvxTabAdjust eAdjst= SvxTabAdjust::Default;
+
+ for (sal_uInt16 i = 0; i < nTabs; ++i)
+ {
+ SvxTabStop aTab( (i + 1) * nDist, eAdjst );
+ maTabStops.insert( aTab );
+ }
+}
+
+
+SvxTabStopItem::SvxTabStopItem( const sal_uInt16 nTabs,
+ const sal_uInt16 nDist,
+ const SvxTabAdjust eAdjst,
+ sal_uInt16 _nWhich ) :
+ SfxPoolItem( _nWhich ),
+ maTabStops()
+{
+ for ( sal_uInt16 i = 0; i < nTabs; ++i )
+ {
+ SvxTabStop aTab( (i + 1) * nDist, eAdjst );
+ maTabStops.insert( aTab );
+ }
+}
+
+
+sal_uInt16 SvxTabStopItem::GetPos( const SvxTabStop& rTab ) const
+{
+ SvxTabStopArr::const_iterator it = maTabStops.find( rTab );
+ return it != maTabStops.end() ? it - maTabStops.begin() : SVX_TAB_NOTFOUND;
+}
+
+
+sal_uInt16 SvxTabStopItem::GetPos( const sal_Int32 nPos ) const
+{
+ SvxTabStopArr::const_iterator it = maTabStops.find( SvxTabStop( nPos ) );
+ return it != maTabStops.end() ? it - maTabStops.begin() : SVX_TAB_NOTFOUND;
+}
+
+
+bool SvxTabStopItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
+ nMemberId &= ~CONVERT_TWIPS;
+ switch ( nMemberId )
+ {
+ case MID_TABSTOPS:
+ {
+ sal_uInt16 nCount = Count();
+ uno::Sequence< style::TabStop> aSeq(nCount);
+ style::TabStop* pArr = aSeq.getArray();
+ for(sal_uInt16 i = 0; i < nCount; i++)
+ {
+ const SvxTabStop& rTab = (*this)[i];
+ pArr[i].Position = bConvert ? convertTwipToMm100(rTab.GetTabPos()) : rTab.GetTabPos();
+ switch(rTab.GetAdjustment())
+ {
+ case SvxTabAdjust::Left : pArr[i].Alignment = style::TabAlign_LEFT; break;
+ case SvxTabAdjust::Right : pArr[i].Alignment = style::TabAlign_RIGHT; break;
+ case SvxTabAdjust::Decimal: pArr[i].Alignment = style::TabAlign_DECIMAL; break;
+ case SvxTabAdjust::Center : pArr[i].Alignment = style::TabAlign_CENTER; break;
+ default: //SvxTabAdjust::Default
+ pArr[i].Alignment = style::TabAlign_DEFAULT;
+
+ }
+ pArr[i].DecimalChar = rTab.GetDecimal();
+ pArr[i].FillChar = rTab.GetFill();
+ }
+ rVal <<= aSeq;
+ break;
+ }
+ case MID_STD_TAB:
+ {
+ const SvxTabStop &rTab = maTabStops.front();
+ rVal <<= static_cast<sal_Int32>(bConvert ? convertTwipToMm100(rTab.GetTabPos()) : rTab.GetTabPos());
+ break;
+ }
+ }
+ return true;
+}
+
+bool SvxTabStopItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
+ nMemberId &= ~CONVERT_TWIPS;
+ switch ( nMemberId )
+ {
+ case MID_TABSTOPS:
+ {
+ uno::Sequence< style::TabStop> aSeq;
+ if(!(rVal >>= aSeq))
+ {
+ uno::Sequence < uno::Sequence < uno::Any > > aAnySeq;
+ if (!(rVal >>= aAnySeq))
+ return false;
+ sal_Int32 nLength = aAnySeq.getLength();
+ aSeq.realloc( nLength );
+ for ( sal_Int32 n=0; n<nLength; n++ )
+ {
+ uno::Sequence < uno::Any >& rAnySeq = aAnySeq[n];
+ if ( rAnySeq.getLength() == 4 )
+ {
+ if (!(rAnySeq[0] >>= aSeq[n].Position)) return false;
+ if (!(rAnySeq[1] >>= aSeq[n].Alignment))
+ {
+ sal_Int32 nVal = 0;
+ if (rAnySeq[1] >>= nVal)
+ aSeq[n].Alignment = static_cast<css::style::TabAlign>(nVal);
+ else
+ return false;
+ }
+ if (!(rAnySeq[2] >>= aSeq[n].DecimalChar))
+ {
+ OUString aVal;
+ if ( (rAnySeq[2] >>= aVal) && aVal.getLength() == 1 )
+ aSeq[n].DecimalChar = aVal.toChar();
+ else
+ return false;
+ }
+ if (!(rAnySeq[3] >>= aSeq[n].FillChar))
+ {
+ OUString aVal;
+ if ( (rAnySeq[3] >>= aVal) && aVal.getLength() == 1 )
+ aSeq[n].FillChar = aVal.toChar();
+ else
+ return false;
+ }
+ }
+ else
+ return false;
+ }
+ }
+
+ maTabStops.clear();
+ const style::TabStop* pArr = aSeq.getConstArray();
+ const sal_uInt16 nCount = static_cast<sal_uInt16>(aSeq.getLength());
+ for(sal_uInt16 i = 0; i < nCount ; i++)
+ {
+ SvxTabAdjust eAdjust = SvxTabAdjust::Default;
+ switch(pArr[i].Alignment)
+ {
+ case style::TabAlign_LEFT : eAdjust = SvxTabAdjust::Left; break;
+ case style::TabAlign_CENTER : eAdjust = SvxTabAdjust::Center; break;
+ case style::TabAlign_RIGHT : eAdjust = SvxTabAdjust::Right; break;
+ case style::TabAlign_DECIMAL: eAdjust = SvxTabAdjust::Decimal; break;
+ default: ;//prevent warning
+ }
+ sal_Unicode cFill = pArr[i].FillChar;
+ sal_Unicode cDecimal = pArr[i].DecimalChar;
+ SvxTabStop aTab( bConvert ? convertMm100ToTwip(pArr[i].Position) : pArr[i].Position,
+ eAdjust,
+ cDecimal,
+ cFill );
+ Insert(aTab);
+ }
+ break;
+ }
+ case MID_STD_TAB:
+ {
+ sal_Int32 nNewPos = 0;
+ if (!(rVal >>= nNewPos) )
+ return false;
+ if (bConvert)
+ nNewPos = convertMm100ToTwip ( nNewPos );
+ if (nNewPos <= 0)
+ return false;
+ const SvxTabStop& rTab = maTabStops.front();
+ SvxTabStop aNewTab ( nNewPos, rTab.GetAdjustment(), rTab.GetDecimal(), rTab.GetFill() );
+ Remove( 0 );
+ Insert( aNewTab );
+ break;
+ }
+ }
+ return true;
+}
+
+
+bool SvxTabStopItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ assert(SfxPoolItem::operator==(rAttr));
+
+ const SvxTabStopItem& rTSI = static_cast<const SvxTabStopItem&>(rAttr);
+
+ if ( Count() != rTSI.Count() )
+ return false;
+
+ for ( sal_uInt16 i = 0; i < Count(); ++i )
+ if( (*this)[i] != rTSI[i] )
+ return false;
+ return true;
+}
+
+SvxTabStopItem* SvxTabStopItem::Clone( SfxItemPool * ) const
+{
+ return new SvxTabStopItem( *this );
+}
+
+bool SvxTabStopItem::GetPresentation
+(
+ SfxItemPresentation ePres,
+ MapUnit eCoreUnit,
+ MapUnit ePresUnit,
+ OUString& rText, const IntlWrapper& rIntl
+) const
+{
+ rText.clear();
+
+ bool bComma = false;
+
+ for ( sal_uInt16 i = 0; i < Count(); ++i )
+ {
+ if ( SvxTabAdjust::Default != ((*this)[i]).GetAdjustment() )
+ {
+ if ( bComma )
+ rText += ",";
+ rText += GetMetricText(
+ ((*this)[i]).GetTabPos(), eCoreUnit, ePresUnit, &rIntl );
+ if ( SfxItemPresentation::Complete == ePres )
+ {
+ rText += " " + EditResId(GetMetricId(ePresUnit));
+ }
+ bComma = true;
+ }
+ }
+ return true;
+}
+
+
+bool SvxTabStopItem::Insert( const SvxTabStop& rTab )
+{
+ sal_uInt16 nTabPos = GetPos(rTab);
+ if(SVX_TAB_NOTFOUND != nTabPos )
+ Remove(nTabPos);
+ return maTabStops.insert( rTab ).second;
+}
+
+void SvxTabStopItem::Insert( const SvxTabStopItem* pTabs )
+{
+ for( sal_uInt16 i = 0; i < pTabs->Count(); i++ )
+ {
+ const SvxTabStop& rTab = (*pTabs)[i];
+ sal_uInt16 nTabPos = GetPos(rTab);
+ if(SVX_TAB_NOTFOUND != nTabPos)
+ Remove(nTabPos);
+ }
+ for( sal_uInt16 i = 0; i < pTabs->Count(); i++ )
+ {
+ maTabStops.insert( (*pTabs)[i] );
+ }
+}
+
+void SvxTabStopItem::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+ xmlTextWriterStartElement(pWriter, BAD_CAST("SvxTabStopItem"));
+ for (const auto& rTabStop : maTabStops)
+ rTabStop.dumpAsXml(pWriter);
+ xmlTextWriterEndElement(pWriter);
+}
+
+// class SvxFormatSplitItem -------------------------------------------------
+SvxFormatSplitItem::~SvxFormatSplitItem()
+{
+}
+
+SvxFormatSplitItem* SvxFormatSplitItem::Clone( SfxItemPool * ) const
+{
+ return new SvxFormatSplitItem( *this );
+}
+
+bool SvxFormatSplitItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper&
+) const
+{
+ const char* pId = RID_SVXITEMS_FMTSPLIT_FALSE;
+
+ if ( GetValue() )
+ pId = RID_SVXITEMS_FMTSPLIT_TRUE;
+ rText = EditResId(pId);
+ return true;
+}
+
+SvxPageModelItem* SvxPageModelItem::Clone( SfxItemPool* ) const
+{
+ return new SvxPageModelItem( *this );
+}
+
+bool SvxPageModelItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ nMemberId &= ~CONVERT_TWIPS;
+
+ switch ( nMemberId )
+ {
+ case MID_AUTO: rVal <<= bAuto; break;
+ case MID_NAME: rVal <<= GetValue(); break;
+ default: OSL_FAIL("Wrong MemberId!"); return false;
+ }
+
+ return true;
+}
+
+bool SvxPageModelItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ bool bRet;
+ OUString aStr;
+ switch ( nMemberId )
+ {
+ case MID_AUTO: bRet = ( rVal >>= bAuto ); break;
+ case MID_NAME: bRet = ( rVal >>= aStr ); if ( bRet ) SetValue(aStr); break;
+ default: OSL_FAIL("Wrong MemberId!"); return false;
+ }
+
+ return bRet;
+}
+
+bool SvxPageModelItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ return SfxStringItem::operator==(rAttr) &&
+ bAuto == static_cast<const SvxPageModelItem&>( rAttr ).bAuto;
+}
+
+bool SvxPageModelItem::GetPresentation
+(
+ SfxItemPresentation ePres,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper&
+) const
+{
+ rText.clear();
+ bool bSet = !GetValue().isEmpty();
+
+ switch ( ePres )
+ {
+ case SfxItemPresentation::Nameless:
+ if ( bSet )
+ rText = GetValue();
+ return true;
+
+ case SfxItemPresentation::Complete:
+ if ( bSet )
+ {
+ rText = EditResId(RID_SVXITEMS_PAGEMODEL_COMPLETE) + GetValue();
+ }
+ return true;
+ default: ;//prevent warning
+ }
+ return false;
+}
+
+
+SvxScriptSpaceItem::SvxScriptSpaceItem( bool bOn, const sal_uInt16 nId )
+ : SfxBoolItem( nId, bOn )
+{
+}
+
+SvxScriptSpaceItem* SvxScriptSpaceItem::Clone( SfxItemPool * ) const
+{
+ return new SvxScriptSpaceItem( *this );
+}
+
+bool SvxScriptSpaceItem::GetPresentation(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/,
+ OUString &rText, const IntlWrapper& /*rIntl*/ ) const
+{
+ rText = EditResId( !GetValue()
+ ? RID_SVXITEMS_SCRPTSPC_OFF
+ : RID_SVXITEMS_SCRPTSPC_ON );
+ return true;
+}
+
+
+SvxHangingPunctuationItem::SvxHangingPunctuationItem(
+ bool bOn, const sal_uInt16 nId )
+ : SfxBoolItem( nId, bOn )
+{
+}
+
+SvxHangingPunctuationItem* SvxHangingPunctuationItem::Clone( SfxItemPool * ) const
+{
+ return new SvxHangingPunctuationItem( *this );
+}
+
+bool SvxHangingPunctuationItem::GetPresentation(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/,
+ OUString &rText, const IntlWrapper& /*rIntl*/ ) const
+{
+ rText = EditResId( !GetValue()
+ ? RID_SVXITEMS_HNGPNCT_OFF
+ : RID_SVXITEMS_HNGPNCT_ON );
+ return true;
+}
+
+
+SvxForbiddenRuleItem::SvxForbiddenRuleItem(
+ bool bOn, const sal_uInt16 nId )
+ : SfxBoolItem( nId, bOn )
+{
+}
+
+SvxForbiddenRuleItem* SvxForbiddenRuleItem::Clone( SfxItemPool * ) const
+{
+ return new SvxForbiddenRuleItem( *this );
+}
+
+bool SvxForbiddenRuleItem::GetPresentation(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/,
+ OUString &rText, const IntlWrapper& /*rIntl*/ ) const
+{
+ rText = EditResId( !GetValue()
+ ? RID_SVXITEMS_FORBIDDEN_RULE_OFF
+ : RID_SVXITEMS_FORBIDDEN_RULE_ON );
+ return true;
+}
+
+/*************************************************************************
+|* class SvxParaVertAlignItem
+*************************************************************************/
+
+SvxParaVertAlignItem::SvxParaVertAlignItem( Align nValue,
+ const sal_uInt16 nW )
+ : SfxUInt16Item( nW, static_cast<sal_uInt16>(nValue) )
+{
+}
+
+SvxParaVertAlignItem* SvxParaVertAlignItem::Clone( SfxItemPool* ) const
+{
+ return new SvxParaVertAlignItem( *this );
+}
+
+bool SvxParaVertAlignItem::GetPresentation(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/,
+ OUString &rText, const IntlWrapper& ) const
+{
+ const char* pTmp;
+ switch( GetValue() )
+ {
+ case Align::Automatic: pTmp = RID_SVXITEMS_PARAVERTALIGN_AUTO; break;
+ case Align::Top: pTmp = RID_SVXITEMS_PARAVERTALIGN_TOP; break;
+ case Align::Center: pTmp = RID_SVXITEMS_PARAVERTALIGN_CENTER; break;
+ case Align::Bottom: pTmp = RID_SVXITEMS_PARAVERTALIGN_BOTTOM; break;
+ default: pTmp = RID_SVXITEMS_PARAVERTALIGN_BASELINE; break;
+ }
+ rText = EditResId(pTmp);
+ return true;
+}
+
+bool SvxParaVertAlignItem::QueryValue( css::uno::Any& rVal,
+ sal_uInt8 /*nMemberId*/ ) const
+{
+ rVal <<= static_cast<sal_Int16>(GetValue());
+ return true;
+}
+
+bool SvxParaVertAlignItem::PutValue( const css::uno::Any& rVal,
+ sal_uInt8 /*nMemberId*/ )
+{
+ sal_Int16 nVal = sal_Int16();
+ if((rVal >>= nVal) && nVal >=0 && nVal <= sal_uInt16(Align::Bottom) )
+ {
+ SetValue( static_cast<Align>(nVal) );
+ return true;
+ }
+ else
+ return false;
+}
+
+SvxParaGridItem::SvxParaGridItem( bool bOn, const sal_uInt16 nId )
+ : SfxBoolItem( nId, bOn )
+{
+}
+
+SvxParaGridItem* SvxParaGridItem::Clone( SfxItemPool * ) const
+{
+ return new SvxParaGridItem( *this );
+}
+
+bool SvxParaGridItem::GetPresentation(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/,
+ OUString &rText, const IntlWrapper& /*rIntl*/ ) const
+{
+ rText = GetValue() ?
+ EditResId( RID_SVXITEMS_PARASNAPTOGRID_ON ) :
+ EditResId( RID_SVXITEMS_PARASNAPTOGRID_OFF );
+
+ return true;
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/items/svdfield.cxx b/editeng/source/items/svdfield.cxx
new file mode 100644
index 000000000..288826406
--- /dev/null
+++ b/editeng/source/items/svdfield.cxx
@@ -0,0 +1,37 @@
+/* -*- 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 <editeng/measfld.hxx>
+
+SdrMeasureField::~SdrMeasureField()
+{
+}
+
+std::unique_ptr<SvxFieldData> SdrMeasureField::Clone() const
+{
+ return std::make_unique<SdrMeasureField>(*this);
+}
+
+bool SdrMeasureField::operator==(const SvxFieldData& rSrc) const
+{
+ return eMeasureFieldKind == static_cast<const SdrMeasureField&>(rSrc).GetMeasureFieldKind();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/items/svxfont.cxx b/editeng/source/items/svxfont.cxx
new file mode 100644
index 000000000..234331b7a
--- /dev/null
+++ b/editeng/source/items/svxfont.cxx
@@ -0,0 +1,781 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <vcl/metric.hxx>
+#include <vcl/outdev.hxx>
+#include <vcl/print.hxx>
+#include <tools/debug.hxx>
+#include <tools/gen.hxx>
+#include <tools/poly.hxx>
+#include <unotools/charclass.hxx>
+#include <com/sun/star/i18n/KCharacterType.hpp>
+#include <editeng/svxfont.hxx>
+#include <editeng/escapementitem.hxx>
+#include <sal/log.hxx>
+
+SvxFont::SvxFont()
+{
+ nKern = nEsc = 0;
+ nPropr = 100;
+ eCaseMap = SvxCaseMap::NotMapped;
+ SetLanguage(LANGUAGE_SYSTEM);
+}
+
+SvxFont::SvxFont( const vcl::Font &rFont )
+ : Font( rFont )
+{
+ nKern = nEsc = 0;
+ nPropr = 100;
+ eCaseMap = SvxCaseMap::NotMapped;
+ SetLanguage(LANGUAGE_SYSTEM);
+}
+
+SvxFont::SvxFont( const SvxFont &rFont )
+ : Font( rFont )
+{
+ nKern = rFont.GetFixKerning();
+ nEsc = rFont.GetEscapement();
+ nPropr = rFont.GetPropr();
+ eCaseMap = rFont.GetCaseMap();
+ SetLanguage(rFont.GetLanguage());
+}
+
+void SvxFont::SetNonAutoEscapement(short nNewEsc, const OutputDevice* pOutDev)
+{
+ nEsc = nNewEsc;
+ if ( abs(nEsc) == DFLT_ESC_AUTO_SUPER )
+ {
+ double fAutoAscent = .8;
+ double fAutoDescent = .2;
+ if ( pOutDev )
+ {
+ const FontMetric& rFontMetric = pOutDev->GetFontMetric();
+ double fFontHeight = rFontMetric.GetAscent() + rFontMetric.GetDescent();
+ if ( fFontHeight )
+ {
+ fAutoAscent = rFontMetric.GetAscent() / fFontHeight;
+ fAutoDescent = rFontMetric.GetDescent() / fFontHeight;
+ }
+ }
+
+ if ( nEsc == DFLT_ESC_AUTO_SUPER )
+ nEsc = fAutoAscent * (100 - nPropr);
+ else //DFLT_ESC_AUTO_SUB
+ nEsc = fAutoDescent * -(100 - nPropr);
+ }
+
+ if ( nEsc > MAX_ESC_POS )
+ nEsc = MAX_ESC_POS;
+ else if ( nEsc < -MAX_ESC_POS )
+ nEsc = -MAX_ESC_POS;
+}
+
+void SvxFont::DrawArrow( OutputDevice &rOut, const tools::Rectangle& rRect,
+ const Size& rSize, const Color& rCol, bool bLeft )
+{
+ long nLeft = ( rRect.Left() + rRect.Right() - rSize.Width() )/ 2;
+ long nRight = nLeft + rSize.Width();
+ long nMid = ( rRect.Top() + rRect.Bottom() ) / 2;
+ long nTop = nMid - rSize.Height() / 2;
+ long nBottom = nTop + rSize.Height();
+ if( nLeft < rRect.Left() )
+ {
+ nLeft = rRect.Left();
+ nRight = rRect.Right();
+ }
+ if( nTop < rRect.Top() )
+ {
+ nTop = rRect.Top();
+ nBottom = rRect.Bottom();
+ }
+ tools::Polygon aPoly;
+ Point aTmp( bLeft ? nLeft : nRight, nMid );
+ Point aNxt( bLeft ? nRight : nLeft, nTop );
+ aPoly.Insert( 0, aTmp );
+ aPoly.Insert( 0, aNxt );
+ aNxt.setY( nBottom );
+ aPoly.Insert( 0, aNxt );
+ aPoly.Insert( 0, aTmp );
+ Color aOldLineColor = rOut.GetLineColor();
+ Color aOldFillColor = rOut.GetFillColor();
+ rOut.SetFillColor( rCol );
+ rOut.SetLineColor( COL_BLACK );
+ rOut.DrawPolygon( aPoly );
+ rOut.DrawLine( aTmp, aNxt );
+ rOut.SetLineColor( aOldLineColor );
+ rOut.SetFillColor( aOldFillColor );
+}
+
+
+OUString SvxFont::CalcCaseMap(const OUString &rTxt) const
+{
+ if (!IsCaseMap() || rTxt.isEmpty())
+ return rTxt;
+ OUString aTxt(rTxt);
+ // I still have to get the language
+ const LanguageType eLang = LANGUAGE_DONTKNOW == GetLanguage()
+ ? LANGUAGE_SYSTEM : GetLanguage();
+
+ LanguageTag aLanguageTag(eLang);
+ CharClass aCharClass( aLanguageTag );
+
+ switch( eCaseMap )
+ {
+ case SvxCaseMap::SmallCaps:
+ case SvxCaseMap::Uppercase:
+ {
+ aTxt = aCharClass.uppercase( aTxt );
+ break;
+ }
+
+ case SvxCaseMap::Lowercase:
+ {
+ aTxt = aCharClass.lowercase( aTxt );
+ break;
+ }
+ case SvxCaseMap::Capitalize:
+ {
+ // Every beginning of a word is capitalized, the rest of the word
+ // is taken over as is.
+ // Bug: if the attribute starts in the middle of the word.
+ bool bBlank = true;
+
+ for (sal_Int32 i = 0; i < aTxt.getLength(); ++i)
+ {
+ if( aTxt[i] == ' ' || aTxt[i] == '\t')
+ bBlank = true;
+ else
+ {
+ if (bBlank)
+ {
+ OUString sTitle(aCharClass.uppercase(OUString(aTxt[i])));
+ aTxt = aTxt.replaceAt(i, 1, sTitle);
+ }
+ bBlank = false;
+ }
+ }
+ break;
+ }
+ default:
+ {
+ SAL_WARN( "editeng", "SvxFont::CaseMapTxt: unknown casemap");
+ break;
+ }
+ }
+ return aTxt;
+}
+
+/*************************************************************************
+ * class SvxDoCapitals
+ * The virtual Method Do si called by SvxFont::DoOnCapitals alternately
+ * the uppercase and lowercase parts. The derivate of SvxDoCapitals fills
+ * this method with life.
+ *************************************************************************/
+
+class SvxDoCapitals
+{
+protected:
+ VclPtr<OutputDevice> pOut;
+ const OUString &rTxt;
+ const sal_Int32 nIdx;
+ const sal_Int32 nLen;
+
+public:
+ SvxDoCapitals( OutputDevice *_pOut, const OUString &_rTxt,
+ const sal_Int32 _nIdx, const sal_Int32 _nLen )
+ : pOut(_pOut), rTxt(_rTxt), nIdx(_nIdx), nLen(_nLen)
+ { }
+
+ virtual ~SvxDoCapitals() {}
+
+ virtual void DoSpace( const bool bDraw );
+ virtual void SetSpace();
+ virtual void Do( const OUString &rTxt,
+ const sal_Int32 nIdx, const sal_Int32 nLen,
+ const bool bUpper ) = 0;
+
+ const OUString &GetTxt() const { return rTxt; }
+ sal_Int32 GetIdx() const { return nIdx; }
+ sal_Int32 GetLen() const { return nLen; }
+};
+
+void SvxDoCapitals::DoSpace( const bool /*bDraw*/ ) { }
+
+void SvxDoCapitals::SetSpace() { }
+
+/*************************************************************************
+ * SvxFont::DoOnCapitals() const
+ * Decomposes the String into uppercase and lowercase letters and then
+ * calls the method SvxDoCapitals::Do( ).
+ *************************************************************************/
+
+void SvxFont::DoOnCapitals(SvxDoCapitals &rDo) const
+{
+ const OUString &rTxt = rDo.GetTxt();
+ const sal_Int32 nIdx = rDo.GetIdx();
+ const sal_Int32 nLen = rDo.GetLen();
+
+ const OUString aTxt( CalcCaseMap( rTxt ) );
+ const sal_Int32 nTxtLen = std::min( rTxt.getLength(), nLen );
+ sal_Int32 nPos = 0;
+ sal_Int32 nOldPos = nPos;
+
+ // Test if string length differ between original and CaseMapped
+ bool bCaseMapLengthDiffers(aTxt.getLength() != rTxt.getLength());
+
+ const LanguageType eLang = LANGUAGE_DONTKNOW == GetLanguage()
+ ? LANGUAGE_SYSTEM : GetLanguage();
+
+ LanguageTag aLanguageTag(eLang);
+ CharClass aCharClass( aLanguageTag );
+ OUString aCharString;
+
+ while( nPos < nTxtLen )
+ {
+ // first in turn are the uppercase letters
+
+ // There are characters that are both upper- and lower-case L (eg blank)
+ // Such ambiguities lead to chaos, this is why these characters are
+ // allocated to the lowercase characters!
+
+ while( nPos < nTxtLen )
+ {
+ aCharString = rTxt.copy( nPos + nIdx, 1 );
+ sal_Int32 nCharacterType = aCharClass.getCharacterType( aCharString, 0 );
+ if ( nCharacterType & css::i18n::KCharacterType::LOWER )
+ break;
+ if ( ! ( nCharacterType & css::i18n::KCharacterType::UPPER ) )
+ break;
+ ++nPos;
+ }
+ if( nOldPos != nPos )
+ {
+ if(bCaseMapLengthDiffers)
+ {
+ // If strings differ work preparing the necessary snippet to address that
+ // potential difference
+ const OUString aSnippet = rTxt.copy(nIdx + nOldPos, nPos-nOldPos);
+ OUString aNewText = CalcCaseMap(aSnippet);
+
+ rDo.Do( aNewText, 0, aNewText.getLength(), true );
+ }
+ else
+ {
+ rDo.Do( aTxt, nIdx + nOldPos, nPos-nOldPos, true );
+ }
+
+ nOldPos = nPos;
+ }
+ // Now the lowercase are processed (without blanks)
+ while( nPos < nTxtLen )
+ {
+ sal_uInt32 nCharacterType = aCharClass.getCharacterType( aCharString, 0 );
+ if ( nCharacterType & css::i18n::KCharacterType::UPPER )
+ break;
+ if ( aCharString == " " )
+ break;
+ if( ++nPos < nTxtLen )
+ aCharString = rTxt.copy( nPos + nIdx, 1 );
+ }
+ if( nOldPos != nPos )
+ {
+ if(bCaseMapLengthDiffers)
+ {
+ // If strings differ work preparing the necessary snippet to address that
+ // potential difference
+ const OUString aSnippet = rTxt.copy(nIdx + nOldPos, nPos - nOldPos);
+ OUString aNewText = CalcCaseMap(aSnippet);
+
+ rDo.Do( aNewText, 0, aNewText.getLength(), false );
+ }
+ else
+ {
+ rDo.Do( aTxt, nIdx + nOldPos, nPos-nOldPos, false );
+ }
+
+ nOldPos = nPos;
+ }
+ // Now the blanks are<processed
+ while( nPos < nTxtLen && aCharString == " " && ++nPos < nTxtLen )
+ aCharString = rTxt.copy( nPos + nIdx, 1 );
+
+ if( nOldPos != nPos )
+ {
+ rDo.DoSpace( false );
+
+ if(bCaseMapLengthDiffers)
+ {
+ // If strings differ work preparing the necessary snippet to address that
+ // potential difference
+ const OUString aSnippet = rTxt.copy(nIdx + nOldPos, nPos - nOldPos);
+ OUString aNewText = CalcCaseMap(aSnippet);
+
+ rDo.Do( aNewText, 0, aNewText.getLength(), false );
+ }
+ else
+ {
+ rDo.Do( aTxt, nIdx + nOldPos, nPos - nOldPos, false );
+ }
+
+ nOldPos = nPos;
+ rDo.SetSpace();
+ }
+ }
+ rDo.DoSpace( true );
+}
+
+
+void SvxFont::SetPhysFont( OutputDevice *pOut ) const
+{
+ const vcl::Font& rCurrentFont = pOut->GetFont();
+ if ( nPropr == 100 )
+ {
+ if ( !rCurrentFont.IsSameInstance( *this ) )
+ pOut->SetFont( *this );
+ }
+ else
+ {
+ Font aNewFont( *this );
+ Size aSize( aNewFont.GetFontSize() );
+ aNewFont.SetFontSize( Size( aSize.Width() * nPropr / 100,
+ aSize.Height() * nPropr / 100 ) );
+ if ( !rCurrentFont.IsSameInstance( aNewFont ) )
+ pOut->SetFont( aNewFont );
+ }
+}
+
+
+vcl::Font SvxFont::ChgPhysFont( OutputDevice *pOut ) const
+{
+ vcl::Font aOldFont( pOut->GetFont() );
+ SetPhysFont( pOut );
+ return aOldFont;
+}
+
+
+Size SvxFont::GetPhysTxtSize( const OutputDevice *pOut, const OUString &rTxt,
+ const sal_Int32 nIdx, const sal_Int32 nLen ) const
+{
+ if ( !IsCaseMap() && !IsKern() )
+ return Size( pOut->GetTextWidth( rTxt, nIdx, nLen ),
+ pOut->GetTextHeight() );
+
+ Size aTxtSize;
+ aTxtSize.setHeight( pOut->GetTextHeight() );
+ if ( !IsCaseMap() )
+ aTxtSize.setWidth( pOut->GetTextWidth( rTxt, nIdx, nLen ) );
+ else
+ {
+ const OUString aNewText = CalcCaseMap(rTxt);
+ bool bCaseMapLengthDiffers(aNewText.getLength() != rTxt.getLength());
+ sal_Int32 nWidth(0);
+
+ if(bCaseMapLengthDiffers)
+ {
+ // If strings differ work preparing the necessary snippet to address that
+ // potential difference
+ const OUString aSnippet = rTxt.copy(nIdx, nLen);
+ OUString _aNewText = CalcCaseMap(aSnippet);
+ nWidth = pOut->GetTextWidth( _aNewText, 0, _aNewText.getLength() );
+ }
+ else
+ {
+ nWidth = pOut->GetTextWidth( aNewText, nIdx, nLen );
+ }
+
+ aTxtSize.setWidth(nWidth);
+ }
+
+ if( IsKern() && ( nLen > 1 ) )
+ aTxtSize.AdjustWidth( ( nLen-1 ) * long( nKern ) );
+
+ return aTxtSize;
+}
+
+Size SvxFont::GetPhysTxtSize( const OutputDevice *pOut )
+{
+ if ( !IsCaseMap() && !IsKern() )
+ return Size( pOut->GetTextWidth( "" ), pOut->GetTextHeight() );
+
+ Size aTxtSize;
+ aTxtSize.setHeight( pOut->GetTextHeight() );
+ if ( !IsCaseMap() )
+ aTxtSize.setWidth( pOut->GetTextWidth( "" ) );
+ else
+ aTxtSize.setWidth( pOut->GetTextWidth( CalcCaseMap( "" ) ) );
+
+ return aTxtSize;
+}
+
+Size SvxFont::QuickGetTextSize( const OutputDevice *pOut, const OUString &rTxt,
+ const sal_Int32 nIdx, const sal_Int32 nLen, long* pDXArray ) const
+{
+ if ( !IsCaseMap() && !IsKern() )
+ return Size( pOut->GetTextArray( rTxt, pDXArray, nIdx, nLen ),
+ pOut->GetTextHeight() );
+
+ Size aTxtSize;
+ aTxtSize.setHeight( pOut->GetTextHeight() );
+ if ( !IsCaseMap() )
+ aTxtSize.setWidth( pOut->GetTextArray( rTxt, pDXArray, nIdx, nLen ) );
+ else
+ aTxtSize.setWidth( pOut->GetTextArray( CalcCaseMap( rTxt ),
+ pDXArray, nIdx, nLen ) );
+
+ if( IsKern() && ( nLen > 1 ) )
+ {
+ aTxtSize.AdjustWidth( ( nLen-1 ) * long( nKern ) );
+
+ if ( pDXArray )
+ {
+ for ( sal_Int32 i = 0; i < nLen; i++ )
+ pDXArray[i] += ( (i+1) * long( nKern ) );
+ // The last one is a nKern too big:
+ pDXArray[nLen-1] -= nKern;
+ }
+ }
+ return aTxtSize;
+}
+
+
+Size SvxFont::GetTextSize( const OutputDevice *pOut, const OUString &rTxt,
+ const sal_Int32 nIdx, const sal_Int32 nLen ) const
+{
+ sal_Int32 nTmp = nLen;
+ if ( nTmp == SAL_MAX_INT32 ) // already initialized?
+ nTmp = rTxt.getLength();
+ Font aOldFont( ChgPhysFont(const_cast<OutputDevice *>(pOut)) );
+ Size aTxtSize;
+ if( IsCapital() && !rTxt.isEmpty() )
+ {
+ aTxtSize = GetCapitalSize( pOut, rTxt, nIdx, nTmp );
+ }
+ else aTxtSize = GetPhysTxtSize(pOut,rTxt,nIdx,nTmp);
+ const_cast<OutputDevice *>(pOut)->SetFont( aOldFont );
+ return aTxtSize;
+}
+
+
+void SvxFont::QuickDrawText( OutputDevice *pOut,
+ const Point &rPos, const OUString &rTxt,
+ const sal_Int32 nIdx, const sal_Int32 nLen, const long* pDXArray ) const
+{
+
+ // Font has to be selected in OutputDevice...
+ if ( !IsCaseMap() && !IsCapital() && !IsKern() && !IsEsc() )
+ {
+ pOut->DrawTextArray( rPos, rTxt, pDXArray, nIdx, nLen );
+ return;
+ }
+
+ Point aPos( rPos );
+
+ if ( nEsc )
+ {
+ long nDiff = GetFontSize().Height();
+ nDiff *= nEsc;
+ nDiff /= 100;
+
+ if ( !IsVertical() )
+ aPos.AdjustY( -nDiff );
+ else
+ aPos.AdjustX(nDiff );
+ }
+
+ if( IsCapital() )
+ {
+ DBG_ASSERT( !pDXArray, "DrawCapital not for TextArray!" );
+ DrawCapital( pOut, aPos, rTxt, nIdx, nLen );
+ }
+ else
+ {
+ if ( IsKern() && !pDXArray )
+ {
+ Size aSize = GetPhysTxtSize( pOut, rTxt, nIdx, nLen );
+
+ if ( !IsCaseMap() )
+ pOut->DrawStretchText( aPos, aSize.Width(), rTxt, nIdx, nLen );
+ else
+ pOut->DrawStretchText( aPos, aSize.Width(), CalcCaseMap( rTxt ), nIdx, nLen );
+ }
+ else
+ {
+ if ( !IsCaseMap() )
+ pOut->DrawTextArray( aPos, rTxt, pDXArray, nIdx, nLen );
+ else
+ pOut->DrawTextArray( aPos, CalcCaseMap( rTxt ), pDXArray, nIdx, nLen );
+ }
+ }
+}
+
+
+void SvxFont::DrawPrev( OutputDevice *pOut, Printer* pPrinter,
+ const Point &rPos, const OUString &rTxt,
+ const sal_Int32 nIdx, const sal_Int32 nLen ) const
+{
+ if ( !nLen || rTxt.isEmpty() )
+ return;
+ sal_Int32 nTmp = nLen;
+
+ if ( nTmp == SAL_MAX_INT32 ) // already initialized?
+ nTmp = rTxt.getLength();
+ Point aPos( rPos );
+
+ if ( nEsc )
+ {
+ short nTmpEsc;
+ if( DFLT_ESC_AUTO_SUPER == nEsc )
+ {
+ nTmpEsc = .8 * (100 - nPropr);
+ assert (nTmpEsc == DFLT_ESC_SUPER && "I'm sure this formula needs to be changed, but how to confirm that???");
+ nTmpEsc = DFLT_ESC_SUPER;
+ }
+ else if( DFLT_ESC_AUTO_SUB == nEsc )
+ {
+ nTmpEsc = .2 * -(100 - nPropr);
+ assert (nTmpEsc == -20 && "I'm sure this formula needs to be changed, but how to confirm that???");
+ nTmpEsc = -20;
+ }
+ else
+ nTmpEsc = nEsc;
+ Size aSize = GetFontSize();
+ aPos.AdjustY( -(( nTmpEsc * aSize.Height() ) / 100) );
+ }
+ Font aOldFont( ChgPhysFont( pOut ) );
+ Font aOldPrnFont( ChgPhysFont( pPrinter ) );
+
+ if ( IsCapital() )
+ DrawCapital( pOut, aPos, rTxt, nIdx, nTmp );
+ else
+ {
+ Size aSize = GetPhysTxtSize( pPrinter, rTxt, nIdx, nTmp );
+
+ if ( !IsCaseMap() )
+ pOut->DrawStretchText( aPos, aSize.Width(), rTxt, nIdx, nTmp );
+ else
+ {
+ const OUString aNewText = CalcCaseMap(rTxt);
+ bool bCaseMapLengthDiffers(aNewText.getLength() != rTxt.getLength());
+
+ if(bCaseMapLengthDiffers)
+ {
+ // If strings differ work preparing the necessary snippet to address that
+ // potential difference
+ const OUString aSnippet(rTxt.copy( nIdx, nTmp));
+ OUString _aNewText = CalcCaseMap(aSnippet);
+
+ pOut->DrawStretchText( aPos, aSize.Width(), _aNewText, 0, _aNewText.getLength() );
+ }
+ else
+ {
+ pOut->DrawStretchText( aPos, aSize.Width(), CalcCaseMap( rTxt ), nIdx, nTmp );
+ }
+ }
+ }
+ pOut->SetFont(aOldFont);
+ pPrinter->SetFont( aOldPrnFont );
+}
+
+
+SvxFont& SvxFont::operator=( const vcl::Font& rFont )
+{
+ Font::operator=( rFont );
+ return *this;
+}
+
+SvxFont& SvxFont::operator=( const SvxFont& rFont )
+{
+ Font::operator=( rFont );
+ eCaseMap = rFont.eCaseMap;
+ nEsc = rFont.nEsc;
+ nPropr = rFont.nPropr;
+ nKern = rFont.nKern;
+ return *this;
+}
+
+namespace {
+
+class SvxDoGetCapitalSize : public SvxDoCapitals
+{
+protected:
+ SvxFont* pFont;
+ Size aTxtSize;
+ short nKern;
+public:
+ SvxDoGetCapitalSize( SvxFont *_pFnt, const OutputDevice *_pOut,
+ const OUString &_rTxt, const sal_Int32 _nIdx,
+ const sal_Int32 _nLen, const short _nKrn )
+ : SvxDoCapitals( const_cast<OutputDevice*>(_pOut), _rTxt, _nIdx, _nLen ),
+ pFont( _pFnt ),
+ nKern( _nKrn )
+ { }
+
+ virtual void Do( const OUString &rTxt, const sal_Int32 nIdx,
+ const sal_Int32 nLen, const bool bUpper ) override;
+
+ const Size &GetSize() const { return aTxtSize; };
+};
+
+}
+
+void SvxDoGetCapitalSize::Do( const OUString &_rTxt, const sal_Int32 _nIdx,
+ const sal_Int32 _nLen, const bool bUpper )
+{
+ Size aPartSize;
+ if ( !bUpper )
+ {
+ sal_uInt8 nProp = pFont->GetPropr();
+ pFont->SetProprRel( SMALL_CAPS_PERCENTAGE );
+ pFont->SetPhysFont( pOut );
+ aPartSize.setWidth( pOut->GetTextWidth( _rTxt, _nIdx, _nLen ) );
+ aPartSize.setHeight( pOut->GetTextHeight() );
+ aTxtSize.setHeight( aPartSize.Height() );
+ pFont->SetPropr( nProp );
+ pFont->SetPhysFont( pOut );
+ }
+ else
+ {
+ aPartSize.setWidth( pOut->GetTextWidth( _rTxt, _nIdx, _nLen ) );
+ aPartSize.setHeight( pOut->GetTextHeight() );
+ }
+ aTxtSize.AdjustWidth(aPartSize.Width() );
+ aTxtSize.AdjustWidth( _nLen * long( nKern ) );
+}
+
+Size SvxFont::GetCapitalSize( const OutputDevice *pOut, const OUString &rTxt,
+ const sal_Int32 nIdx, const sal_Int32 nLen) const
+{
+ // Start:
+ SvxDoGetCapitalSize aDo( const_cast<SvxFont *>(this), pOut, rTxt, nIdx, nLen, nKern );
+ DoOnCapitals( aDo );
+ Size aTxtSize( aDo.GetSize() );
+
+ // End:
+ if( !aTxtSize.Height() )
+ {
+ aTxtSize.setWidth( 0 );
+ aTxtSize.setHeight( pOut->GetTextHeight() );
+ }
+ return aTxtSize;
+}
+
+namespace {
+
+class SvxDoDrawCapital : public SvxDoCapitals
+{
+protected:
+ SvxFont *pFont;
+ Point aPos;
+ Point aSpacePos;
+ short nKern;
+public:
+ SvxDoDrawCapital( SvxFont *pFnt, OutputDevice *_pOut, const OUString &_rTxt,
+ const sal_Int32 _nIdx, const sal_Int32 _nLen,
+ const Point &rPos, const short nKrn )
+ : SvxDoCapitals( _pOut, _rTxt, _nIdx, _nLen ),
+ pFont( pFnt ),
+ aPos( rPos ),
+ aSpacePos( rPos ),
+ nKern( nKrn )
+ { }
+ virtual void DoSpace( const bool bDraw ) override;
+ virtual void SetSpace() override;
+ virtual void Do( const OUString &rTxt, const sal_Int32 nIdx,
+ const sal_Int32 nLen, const bool bUpper ) override;
+};
+
+}
+
+void SvxDoDrawCapital::DoSpace( const bool bDraw )
+{
+ if ( !(bDraw || pFont->IsWordLineMode()) )
+ return;
+
+ sal_uLong nDiff = static_cast<sal_uLong>(aPos.X() - aSpacePos.X());
+ if ( nDiff )
+ {
+ bool bWordWise = pFont->IsWordLineMode();
+ bool bTrans = pFont->IsTransparent();
+ pFont->SetWordLineMode( false );
+ pFont->SetTransparent( true );
+ pFont->SetPhysFont( pOut );
+ pOut->DrawStretchText( aSpacePos, nDiff, " ", 0, 2 );
+ pFont->SetWordLineMode( bWordWise );
+ pFont->SetTransparent( bTrans );
+ pFont->SetPhysFont( pOut );
+ }
+}
+
+void SvxDoDrawCapital::SetSpace()
+{
+ if ( pFont->IsWordLineMode() )
+ aSpacePos.setX( aPos.X() );
+}
+
+void SvxDoDrawCapital::Do( const OUString &_rTxt, const sal_Int32 _nIdx,
+ const sal_Int32 _nLen, const bool bUpper)
+{
+ sal_uInt8 nProp = 0;
+ Size aPartSize;
+
+ // Set the desired font
+ FontLineStyle eUnder = pFont->GetUnderline();
+ FontStrikeout eStrike = pFont->GetStrikeout();
+ pFont->SetUnderline( LINESTYLE_NONE );
+ pFont->SetStrikeout( STRIKEOUT_NONE );
+ if ( !bUpper )
+ {
+ nProp = pFont->GetPropr();
+ pFont->SetProprRel( SMALL_CAPS_PERCENTAGE );
+ }
+ pFont->SetPhysFont( pOut );
+
+ aPartSize.setWidth( pOut->GetTextWidth( _rTxt, _nIdx, _nLen ) );
+ aPartSize.setHeight( pOut->GetTextHeight() );
+ long nWidth = aPartSize.Width();
+ if ( nKern )
+ {
+ aPos.AdjustX(nKern/2);
+ if ( _nLen ) nWidth += (_nLen*long(nKern));
+ }
+ pOut->DrawStretchText(aPos,nWidth-nKern,_rTxt,_nIdx,_nLen);
+
+ // Restore Font
+ pFont->SetUnderline( eUnder );
+ pFont->SetStrikeout( eStrike );
+ if ( !bUpper )
+ pFont->SetPropr( nProp );
+ pFont->SetPhysFont( pOut );
+
+ aPos.AdjustX(nWidth-(nKern/2) );
+}
+
+/*************************************************************************
+ * SvxFont::DrawCapital() draws the uppercase letter.
+ *************************************************************************/
+
+void SvxFont::DrawCapital( OutputDevice *pOut,
+ const Point &rPos, const OUString &rTxt,
+ const sal_Int32 nIdx, const sal_Int32 nLen ) const
+{
+ SvxDoDrawCapital aDo( const_cast<SvxFont *>(this),pOut,rTxt,nIdx,nLen,rPos,nKern );
+ DoOnCapitals( aDo );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/items/textitem.cxx b/editeng/source/items/textitem.cxx
new file mode 100644
index 000000000..2e2cf4fe7
--- /dev/null
+++ b/editeng/source/items/textitem.cxx
@@ -0,0 +1,2699 @@
+/* -*- 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/style/CaseMap.hpp>
+#include <com/sun/star/awt/FontDescriptor.hpp>
+#include <com/sun/star/frame/status/FontHeight.hpp>
+#include <math.h>
+#include <sal/log.hxx>
+#include <o3tl/safeint.hxx>
+#include <osl/diagnose.h>
+#include <unotools/fontdefs.hxx>
+#include <unotools/intlwrapper.hxx>
+#include <unotools/syslocale.hxx>
+#include <vcl/outdev.hxx>
+#include <vcl/unohelp.hxx>
+#include <svtools/unitconv.hxx>
+
+#include <editeng/editids.hrc>
+#include <editeng/editrids.hrc>
+#include <tools/mapunit.hxx>
+
+#include <rtl/math.hxx>
+#include <rtl/ustring.hxx>
+#include <i18nlangtag/languagetag.hxx>
+#include <svl/itemset.hxx>
+
+#include <svtools/langtab.hxx>
+#include <svl/itempool.hxx>
+#include <svtools/ctrltool.hxx>
+#include <com/sun/star/awt/FontSlant.hpp>
+#include <com/sun/star/lang/Locale.hpp>
+#include <com/sun/star/text/FontEmphasis.hpp>
+#include <editeng/rsiditem.hxx>
+#include <editeng/memberids.h>
+#include <editeng/flstitem.hxx>
+#include <editeng/fontitem.hxx>
+#include <editeng/postitem.hxx>
+#include <editeng/wghtitem.hxx>
+#include <editeng/fhgtitem.hxx>
+#include <editeng/udlnitem.hxx>
+#include <editeng/crossedoutitem.hxx>
+#include <editeng/shdditem.hxx>
+#include <editeng/autokernitem.hxx>
+#include <editeng/wrlmitem.hxx>
+#include <editeng/contouritem.hxx>
+#include <editeng/colritem.hxx>
+#include <editeng/kernitem.hxx>
+#include <editeng/cmapitem.hxx>
+#include <editeng/escapementitem.hxx>
+#include <editeng/langitem.hxx>
+#include <editeng/nhypitem.hxx>
+#include <editeng/blinkitem.hxx>
+#include <editeng/emphasismarkitem.hxx>
+#include <editeng/twolinesitem.hxx>
+#include <editeng/scripttypeitem.hxx>
+#include <editeng/charrotateitem.hxx>
+#include <editeng/charscaleitem.hxx>
+#include <editeng/charreliefitem.hxx>
+#include <editeng/itemtype.hxx>
+#include <editeng/eerdll.hxx>
+#include <libxml/xmlwriter.h>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::text;
+
+SfxPoolItem* SvxFontItem::CreateDefault() {return new SvxFontItem(0);}
+SfxPoolItem* SvxPostureItem::CreateDefault() { return new SvxPostureItem(ITALIC_NONE, 0);}
+SfxPoolItem* SvxWeightItem::CreateDefault() {return new SvxWeightItem(WEIGHT_NORMAL, 0);}
+SfxPoolItem* SvxFontHeightItem::CreateDefault() {return new SvxFontHeightItem(240, 100, 0);}
+SfxPoolItem* SvxUnderlineItem::CreateDefault() {return new SvxUnderlineItem(LINESTYLE_NONE, 0);}
+SfxPoolItem* SvxOverlineItem::CreateDefault() {return new SvxOverlineItem(LINESTYLE_NONE, 0);}
+SfxPoolItem* SvxCrossedOutItem::CreateDefault() {return new SvxCrossedOutItem(STRIKEOUT_NONE, 0);}
+SfxPoolItem* SvxShadowedItem::CreateDefault() {return new SvxShadowedItem(false, 0);}
+SfxPoolItem* SvxAutoKernItem::CreateDefault() {return new SvxAutoKernItem(false, 0);}
+SfxPoolItem* SvxWordLineModeItem::CreateDefault() {return new SvxWordLineModeItem(false, 0);}
+SfxPoolItem* SvxContourItem::CreateDefault() {return new SvxContourItem(false, 0);}
+SfxPoolItem* SvxColorItem::CreateDefault() {return new SvxColorItem(0);}
+SfxPoolItem* SvxBackgroundColorItem::CreateDefault() {return new SvxBackgroundColorItem(0);}
+SfxPoolItem* SvxKerningItem::CreateDefault() {return new SvxKerningItem(0, 0);}
+SfxPoolItem* SvxCaseMapItem::CreateDefault() {return new SvxCaseMapItem(SvxCaseMap::NotMapped, 0);}
+SfxPoolItem* SvxEscapementItem::CreateDefault() {return new SvxEscapementItem(0);}
+SfxPoolItem* SvxLanguageItem::CreateDefault() {return new SvxLanguageItem(LANGUAGE_GERMAN, 0);}
+SfxPoolItem* SvxBlinkItem::CreateDefault() {return new SvxBlinkItem(false, 0);}
+SfxPoolItem* SvxEmphasisMarkItem::CreateDefault() {return new SvxEmphasisMarkItem(FontEmphasisMark::NONE, 0);}
+SfxPoolItem* SvxCharRotateItem::CreateDefault() {return new SvxCharRotateItem(0, false, 0);}
+SfxPoolItem* SvxCharScaleWidthItem::CreateDefault() {return new SvxCharScaleWidthItem(100, 0);}
+SfxPoolItem* SvxCharReliefItem::CreateDefault() {return new SvxCharReliefItem(FontRelief::NONE, 0);}
+
+
+// class SvxFontListItem -------------------------------------------------
+
+SvxFontListItem::SvxFontListItem( const FontList* pFontLst,
+ const sal_uInt16 nId ) :
+ SfxPoolItem( nId ),
+ pFontList( pFontLst )
+{
+ if ( pFontList )
+ {
+ sal_Int32 nCount = pFontList->GetFontNameCount();
+ aFontNameSeq.realloc( nCount );
+
+ for ( sal_Int32 i = 0; i < nCount; i++ )
+ aFontNameSeq[i] = pFontList->GetFontName(i).GetFamilyName();
+ }
+}
+
+SvxFontListItem* SvxFontListItem::Clone( SfxItemPool* ) const
+{
+ return new SvxFontListItem( *this );
+}
+
+bool SvxFontListItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ assert(SfxPoolItem::operator==(rAttr));
+
+ return( pFontList == static_cast<const SvxFontListItem&>(rAttr).pFontList );
+}
+
+bool SvxFontListItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
+{
+ rVal <<= aFontNameSeq;
+ return true;
+}
+
+
+bool SvxFontListItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper& /*rIntl*/
+) const
+{
+ rText.clear();
+ return false;
+}
+
+// class SvxFontItem -----------------------------------------------------
+
+SvxFontItem::SvxFontItem( const sal_uInt16 nId ) :
+ SfxPoolItem( nId )
+{
+ eFamily = FAMILY_SWISS;
+ ePitch = PITCH_VARIABLE;
+ eTextEncoding = RTL_TEXTENCODING_DONTKNOW;
+}
+
+
+SvxFontItem::SvxFontItem( const FontFamily eFam, const OUString& aName,
+ const OUString& aStName, const FontPitch eFontPitch,
+ const rtl_TextEncoding eFontTextEncoding, const sal_uInt16 nId ) :
+
+ SfxPoolItem( nId ),
+
+ aFamilyName(aName),
+ aStyleName(aStName)
+{
+ eFamily = eFam;
+ ePitch = eFontPitch;
+ eTextEncoding = eFontTextEncoding;
+}
+
+
+bool SvxFontItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch(nMemberId)
+ {
+ case 0:
+ {
+ css::awt::FontDescriptor aFontDescriptor;
+ aFontDescriptor.Name = aFamilyName;
+ aFontDescriptor.StyleName = aStyleName;
+ aFontDescriptor.Family = static_cast<sal_Int16>(eFamily);
+ aFontDescriptor.CharSet = static_cast<sal_Int16>(eTextEncoding);
+ aFontDescriptor.Pitch = static_cast<sal_Int16>(ePitch);
+ rVal <<= aFontDescriptor;
+ }
+ break;
+ case MID_FONT_FAMILY_NAME:
+ rVal <<= aFamilyName;
+ break;
+ case MID_FONT_STYLE_NAME:
+ rVal <<= aStyleName;
+ break;
+ case MID_FONT_FAMILY : rVal <<= static_cast<sal_Int16>(eFamily); break;
+ case MID_FONT_CHAR_SET : rVal <<= static_cast<sal_Int16>(eTextEncoding); break;
+ case MID_FONT_PITCH : rVal <<= static_cast<sal_Int16>(ePitch); break;
+ }
+ return true;
+}
+
+bool SvxFontItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId)
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch(nMemberId)
+ {
+ case 0:
+ {
+ css::awt::FontDescriptor aFontDescriptor;
+ if ( !( rVal >>= aFontDescriptor ))
+ return false;
+
+ aFamilyName = aFontDescriptor.Name;
+ aStyleName = aFontDescriptor.StyleName;
+ eFamily = static_cast<FontFamily>(aFontDescriptor.Family);
+ eTextEncoding = static_cast<rtl_TextEncoding>(aFontDescriptor.CharSet);
+ ePitch = static_cast<FontPitch>(aFontDescriptor.Pitch);
+ }
+ break;
+ case MID_FONT_FAMILY_NAME :
+ {
+ OUString aStr;
+ if(!(rVal >>= aStr))
+ return false;
+ aFamilyName = aStr;
+ }
+ break;
+ case MID_FONT_STYLE_NAME:
+ {
+ OUString aStr;
+ if(!(rVal >>= aStr))
+ return false;
+ aStyleName = aStr;
+ }
+ break;
+ case MID_FONT_FAMILY :
+ {
+ sal_Int16 nFamily = sal_Int16();
+ if(!(rVal >>= nFamily))
+ return false;
+ eFamily = static_cast<FontFamily>(nFamily);
+ }
+ break;
+ case MID_FONT_CHAR_SET :
+ {
+ sal_Int16 nSet = sal_Int16();
+ if(!(rVal >>= nSet))
+ return false;
+ eTextEncoding = static_cast<rtl_TextEncoding>(nSet);
+ }
+ break;
+ case MID_FONT_PITCH :
+ {
+ sal_Int16 nPitch = sal_Int16();
+ if(!(rVal >>= nPitch))
+ return false;
+ ePitch = static_cast<FontPitch>(nPitch);
+ }
+ break;
+ }
+ return true;
+}
+
+
+bool SvxFontItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ assert(SfxPoolItem::operator==(rAttr));
+
+ const SvxFontItem& rItem = static_cast<const SvxFontItem&>(rAttr);
+
+ bool bRet = ( eFamily == rItem.eFamily &&
+ aFamilyName == rItem.aFamilyName &&
+ aStyleName == rItem.aStyleName );
+
+ if ( bRet )
+ {
+ if ( ePitch != rItem.ePitch || eTextEncoding != rItem.eTextEncoding )
+ {
+ bRet = false;
+ SAL_INFO( "editeng.items", "FontItem::operator==(): only pitch or rtl_TextEncoding different ");
+ }
+ }
+ return bRet;
+}
+
+SvxFontItem* SvxFontItem::Clone( SfxItemPool * ) const
+{
+ return new SvxFontItem( *this );
+}
+
+bool SvxFontItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper& /*rIntl*/
+) const
+{
+ rText = aFamilyName;
+ return true;
+}
+
+
+void SvxFontItem::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+ xmlTextWriterStartElement(pWriter, BAD_CAST("SvxFontItem"));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("familyName"), BAD_CAST(aFamilyName.toUtf8().getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("styleName"), BAD_CAST(aStyleName.toUtf8().getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("family"), BAD_CAST(OString::number(eFamily).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("pitch"), BAD_CAST(OString::number(ePitch).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("textEncoding"), BAD_CAST(OString::number(eTextEncoding).getStr()));
+ xmlTextWriterEndElement(pWriter);
+}
+
+// class SvxPostureItem --------------------------------------------------
+
+SvxPostureItem::SvxPostureItem( const FontItalic ePosture, const sal_uInt16 nId ) :
+ SfxEnumItem( nId, ePosture )
+{
+}
+
+SvxPostureItem* SvxPostureItem::Clone( SfxItemPool * ) const
+{
+ return new SvxPostureItem( *this );
+}
+
+sal_uInt16 SvxPostureItem::GetValueCount() const
+{
+ return ITALIC_NORMAL + 1; // ITALIC_NONE also belongs here
+}
+
+
+bool SvxPostureItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper& /*rIntl*/
+) const
+{
+ rText = GetValueTextByPos( GetValue() );
+ return true;
+}
+
+
+OUString SvxPostureItem::GetValueTextByPos( sal_uInt16 nPos )
+{
+ DBG_ASSERT( nPos <= sal_uInt16(ITALIC_NORMAL), "enum overflow!" );
+
+ FontItalic eItalic = static_cast<FontItalic>(nPos);
+ const char* pId = nullptr;
+
+ switch ( eItalic )
+ {
+ case ITALIC_NONE: pId = RID_SVXITEMS_ITALIC_NONE; break;
+ case ITALIC_OBLIQUE: pId = RID_SVXITEMS_ITALIC_OBLIQUE; break;
+ case ITALIC_NORMAL: pId = RID_SVXITEMS_ITALIC_NORMAL; break;
+ default: ;//prevent warning
+ }
+
+ return pId ? EditResId(pId) : OUString();
+}
+
+bool SvxPostureItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch( nMemberId )
+ {
+ case MID_ITALIC:
+ rVal <<= GetBoolValue();
+ break;
+ case MID_POSTURE:
+ rVal <<= vcl::unohelper::ConvertFontSlant(GetValue());
+ break;
+ }
+ return true;
+}
+
+bool SvxPostureItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch( nMemberId )
+ {
+ case MID_ITALIC:
+ SetBoolValue(Any2Bool(rVal));
+ break;
+ case MID_POSTURE:
+ {
+ awt::FontSlant eSlant;
+ if(!(rVal >>= eSlant))
+ {
+ sal_Int32 nValue = 0;
+ if(!(rVal >>= nValue))
+ return false;
+
+ eSlant = static_cast<awt::FontSlant>(nValue);
+ }
+ SetValue(vcl::unohelper::ConvertFontSlant(eSlant));
+ }
+ }
+ return true;
+}
+
+bool SvxPostureItem::HasBoolValue() const
+{
+ return true;
+}
+
+bool SvxPostureItem::GetBoolValue() const
+{
+ return ( GetValue() >= ITALIC_OBLIQUE );
+}
+
+void SvxPostureItem::SetBoolValue( bool bVal )
+{
+ SetValue( bVal ? ITALIC_NORMAL : ITALIC_NONE );
+}
+
+void SvxPostureItem::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+ xmlTextWriterStartElement(pWriter, BAD_CAST("SvxPostureItem"));
+ xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("whichId"), "%d", Which());
+ xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("value"), "%d", GetValue());
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(GetValueTextByPos(GetValue()).toUtf8().getStr()));
+ xmlTextWriterEndElement(pWriter);
+}
+
+// class SvxWeightItem ---------------------------------------------------
+
+SvxWeightItem::SvxWeightItem( const FontWeight eWght, const sal_uInt16 nId ) :
+ SfxEnumItem( nId, eWght )
+{
+}
+
+
+bool SvxWeightItem::HasBoolValue() const
+{
+ return true;
+}
+
+
+bool SvxWeightItem::GetBoolValue() const
+{
+ return GetValue() >= WEIGHT_BOLD;
+}
+
+
+void SvxWeightItem::SetBoolValue( bool bVal )
+{
+ SetValue( bVal ? WEIGHT_BOLD : WEIGHT_NORMAL );
+}
+
+
+sal_uInt16 SvxWeightItem::GetValueCount() const
+{
+ return WEIGHT_BLACK; // WEIGHT_DONTKNOW does not belong
+}
+
+SvxWeightItem* SvxWeightItem::Clone( SfxItemPool * ) const
+{
+ return new SvxWeightItem( *this );
+}
+
+bool SvxWeightItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper& /*rIntl*/
+) const
+{
+ rText = GetValueTextByPos( GetValue() );
+ return true;
+}
+
+OUString SvxWeightItem::GetValueTextByPos( sal_uInt16 nPos )
+{
+ static const char* RID_SVXITEMS_WEIGHTS[] =
+ {
+ RID_SVXITEMS_WEIGHT_DONTKNOW,
+ RID_SVXITEMS_WEIGHT_THIN,
+ RID_SVXITEMS_WEIGHT_ULTRALIGHT,
+ RID_SVXITEMS_WEIGHT_LIGHT,
+ RID_SVXITEMS_WEIGHT_SEMILIGHT,
+ RID_SVXITEMS_WEIGHT_NORMAL,
+ RID_SVXITEMS_WEIGHT_MEDIUM,
+ RID_SVXITEMS_WEIGHT_SEMIBOLD,
+ RID_SVXITEMS_WEIGHT_BOLD,
+ RID_SVXITEMS_WEIGHT_ULTRABOLD,
+ RID_SVXITEMS_WEIGHT_BLACK
+ };
+
+ static_assert(SAL_N_ELEMENTS(RID_SVXITEMS_WEIGHTS) - 1 == WEIGHT_BLACK, "must match");
+ assert(nPos <= sal_uInt16(WEIGHT_BLACK) && "enum overflow!" );
+ return EditResId(RID_SVXITEMS_WEIGHTS[nPos]);
+}
+
+bool SvxWeightItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch( nMemberId )
+ {
+ case MID_BOLD :
+ rVal <<= GetBoolValue();
+ break;
+ case MID_WEIGHT:
+ {
+ rVal <<= vcl::unohelper::ConvertFontWeight( GetValue() );
+ }
+ break;
+ }
+ return true;
+}
+
+bool SvxWeightItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch( nMemberId )
+ {
+ case MID_BOLD :
+ SetBoolValue(Any2Bool(rVal));
+ break;
+ case MID_WEIGHT:
+ {
+ double fValue = 0;
+ if(!(rVal >>= fValue))
+ {
+ sal_Int32 nValue = 0;
+ if(!(rVal >>= nValue))
+ return false;
+ fValue = static_cast<float>(nValue);
+ }
+ SetValue( vcl::unohelper::ConvertFontWeight(static_cast<float>(fValue)) );
+ }
+ break;
+ }
+ return true;
+}
+
+void SvxWeightItem::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+ xmlTextWriterStartElement(pWriter, BAD_CAST("SvxWeightItem"));
+ xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("whichId"), "%d", Which());
+ xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("value"), "%d", GetValue());
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(GetValueTextByPos(GetValue()).toUtf8().getStr()));
+ xmlTextWriterEndElement(pWriter);
+}
+
+// class SvxFontHeightItem -----------------------------------------------
+
+SvxFontHeightItem::SvxFontHeightItem( const sal_uLong nSz,
+ const sal_uInt16 nPrp,
+ const sal_uInt16 nId ) :
+ SfxPoolItem( nId )
+{
+ SetHeight( nSz,nPrp ); // calculate in percentage
+}
+
+SvxFontHeightItem* SvxFontHeightItem::Clone( SfxItemPool * ) const
+{
+ return new SvxFontHeightItem( *this );
+}
+
+bool SvxFontHeightItem::operator==( const SfxPoolItem& rItem ) const
+{
+ assert(SfxPoolItem::operator==(rItem));
+ return GetHeight() == static_cast<const SvxFontHeightItem&>(rItem).GetHeight() &&
+ GetProp() == static_cast<const SvxFontHeightItem&>(rItem).GetProp() &&
+ GetPropUnit() == static_cast<const SvxFontHeightItem&>(rItem).GetPropUnit();
+}
+
+bool SvxFontHeightItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ // In StarOne is the uno::Any always 1/100mm. Through the MemberId it is
+ // controlled if the value in the Item should be 1/100mm or Twips.
+
+ bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
+ nMemberId &= ~CONVERT_TWIPS;
+ switch( nMemberId )
+ {
+ case 0:
+ {
+ css::frame::status::FontHeight aFontHeight;
+
+ // Point (i.e. Twips) is asked for, thus re-calculate if
+ // CONVERT_TWIPS is not set.
+ if( bConvert )
+ {
+ aFontHeight.Height = static_cast<float>( nHeight / 20.0 );
+ }
+ else
+ {
+ double fPoints = convertMm100ToTwip(nHeight) / 20.0;
+ float fRoundPoints =
+ static_cast<float>(::rtl::math::round(fPoints, 1));
+ aFontHeight.Height = fRoundPoints;
+ }
+
+ aFontHeight.Prop = static_cast<sal_Int16>(MapUnit::MapRelative == ePropUnit ? nProp : 100);
+
+ float fRet = static_cast<float>(static_cast<short>(nProp));
+ switch( ePropUnit )
+ {
+ case MapUnit::MapRelative:
+ fRet = 0.;
+ break;
+ case MapUnit::Map100thMM:
+ fRet = convertMm100ToTwip(fRet);
+ fRet /= 20.;
+ break;
+ case MapUnit::MapPoint:
+
+ break;
+ case MapUnit::MapTwip:
+ fRet /= 20.;
+ break;
+ default: ;//prevent warning
+ }
+ aFontHeight.Diff = fRet;
+ rVal <<= aFontHeight;
+ }
+ break;
+ case MID_FONTHEIGHT:
+ {
+ // Point (i.e. Twips) is asked for, thus re-calculate if
+ // CONVERT_TWIPS is not set.
+ if( bConvert )
+ {
+ rVal <<= static_cast<float>( nHeight / 20.0 );
+ }
+ else
+ {
+ double fPoints = convertMm100ToTwip(nHeight) / 20.0;
+ float fRoundPoints =
+ static_cast<float>(::rtl::math::round(fPoints, 1));
+ rVal <<= fRoundPoints;
+ }
+ }
+ break;
+ case MID_FONTHEIGHT_PROP:
+ rVal <<= static_cast<sal_Int16>(MapUnit::MapRelative == ePropUnit ? nProp : 100);
+ break;
+ case MID_FONTHEIGHT_DIFF:
+ {
+ float fRet = static_cast<float>(static_cast<short>(nProp));
+ switch( ePropUnit )
+ {
+ case MapUnit::MapRelative:
+ fRet = 0.;
+ break;
+ case MapUnit::Map100thMM:
+ fRet = convertMm100ToTwip(fRet);
+ fRet /= 20.;
+ break;
+ case MapUnit::MapPoint:
+
+ break;
+ case MapUnit::MapTwip:
+ fRet /= 20.;
+ break;
+ default: ;//prevent warning
+ }
+ rVal <<= fRet;
+ }
+ break;
+ }
+ return true;
+}
+
+// Try to reconstruct the original height input value from the modified height
+// and the prop data; this seems somewhat futile given the various ways how the
+// modified height is calculated (with and without conversion between twips and
+// 100th mm; with an additional eCoreMetric input in one of the SetHeight
+// overloads), and indeed known to occasionally produce nRet values that would
+// be negative, so just guard against negative results here and throw the hands
+// up in despair:
+static sal_uInt32 lcl_GetRealHeight_Impl(sal_uInt32 nHeight, sal_uInt16 nProp, MapUnit eProp, bool bCoreInTwip)
+{
+ sal_uInt32 nRet = nHeight;
+ short nDiff = 0;
+ switch( eProp )
+ {
+ case MapUnit::MapRelative:
+ if (nProp)
+ {
+ nRet *= 100;
+ nRet /= nProp;
+ }
+ break;
+ case MapUnit::MapPoint:
+ {
+ short nTemp = static_cast<short>(nProp);
+ nDiff = nTemp * 20;
+ if(!bCoreInTwip)
+ nDiff = static_cast<short>(convertTwipToMm100(static_cast<long>(nDiff)));
+ break;
+ }
+ case MapUnit::Map100thMM:
+ //then the core is surely also in 1/100 mm
+ nDiff = static_cast<short>(nProp);
+ break;
+ case MapUnit::MapTwip:
+ // Here surely TWIP
+ nDiff = static_cast<short>(nProp);
+ break;
+ default:
+ break;
+ }
+ nRet = (nDiff < 0 || nRet >= o3tl::make_unsigned(nDiff))
+ ? nRet - nDiff : 0;
+ //TODO: overflow in case nDiff < 0 and nRet - nDiff > SAL_MAX_UINT32
+
+ return nRet;
+}
+
+bool SvxFontHeightItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
+ nMemberId &= ~CONVERT_TWIPS;
+ switch( nMemberId )
+ {
+ case 0:
+ {
+ css::frame::status::FontHeight aFontHeight;
+ if ( rVal >>= aFontHeight )
+ {
+ // Height
+ ePropUnit = MapUnit::MapRelative;
+ nProp = 100;
+ double fPoint = aFontHeight.Height;
+ if( fPoint < 0. || fPoint > 10000. )
+ return false;
+
+ nHeight = static_cast<long>( fPoint * 20.0 + 0.5 ); // Twips
+ if (!bConvert)
+ nHeight = convertTwipToMm100(nHeight); // Convert, if the item contains 1/100mm
+
+ nProp = aFontHeight.Prop;
+ }
+ else
+ return false;
+ }
+ break;
+ case MID_FONTHEIGHT:
+ {
+ ePropUnit = MapUnit::MapRelative;
+ nProp = 100;
+ double fPoint = 0;
+ if(!(rVal >>= fPoint))
+ {
+ sal_Int32 nValue = 0;
+ if(!(rVal >>= nValue))
+ return false;
+ fPoint = static_cast<float>(nValue);
+ }
+ if(fPoint < 0. || fPoint > 10000.)
+ return false;
+
+ nHeight = static_cast<long>( fPoint * 20.0 + 0.5 ); // Twips
+ if (!bConvert)
+ nHeight = convertTwipToMm100(nHeight); // Convert, if the item contains 1/100mm
+ }
+ break;
+ case MID_FONTHEIGHT_PROP:
+ {
+ sal_Int16 nNew = sal_Int16();
+ if(!(rVal >>= nNew))
+ return true;
+
+ nHeight = lcl_GetRealHeight_Impl(nHeight, nProp, ePropUnit, bConvert);
+
+ nHeight *= nNew;
+ nHeight /= 100;
+ nProp = nNew;
+ ePropUnit = MapUnit::MapRelative;
+ }
+ break;
+ case MID_FONTHEIGHT_DIFF:
+ {
+ nHeight = lcl_GetRealHeight_Impl(nHeight, nProp, ePropUnit, bConvert);
+ float fValue = 0;
+ if(!(rVal >>= fValue))
+ {
+ sal_Int32 nValue = 0;
+ if(!(rVal >>= nValue))
+ return false;
+ fValue = static_cast<float>(nValue);
+ }
+ sal_Int16 nCoreDiffValue = static_cast<sal_Int16>(fValue * 20.);
+ nHeight += bConvert ? nCoreDiffValue : convertTwipToMm100(nCoreDiffValue);
+ nProp = static_cast<sal_uInt16>(static_cast<sal_Int16>(fValue));
+ ePropUnit = MapUnit::MapPoint;
+ }
+ break;
+ }
+ return true;
+}
+
+
+bool SvxFontHeightItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit eCoreUnit,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper& rIntl
+) const
+{
+ if( MapUnit::MapRelative != ePropUnit )
+ {
+ rText = OUString::number( static_cast<short>(nProp) ) +
+ " " + EditResId( GetMetricId( ePropUnit ) );
+ if( 0 <= static_cast<short>(nProp) )
+ rText = "+" + rText;
+ }
+ else if( 100 == nProp )
+ {
+ rText = GetMetricText( static_cast<long>(nHeight),
+ eCoreUnit, MapUnit::MapPoint, &rIntl ) +
+ " " + EditResId(GetMetricId(MapUnit::MapPoint));
+ }
+ else
+ rText = OUString::number( nProp ) + "%";
+ return true;
+}
+
+
+void SvxFontHeightItem::ScaleMetrics( long nMult, long nDiv )
+{
+ nHeight = static_cast<sal_uInt32>(Scale( nHeight, nMult, nDiv ));
+}
+
+
+bool SvxFontHeightItem::HasMetrics() const
+{
+ return true;
+}
+
+void SvxFontHeightItem::SetHeight( sal_uInt32 nNewHeight, const sal_uInt16 nNewProp,
+ MapUnit eUnit )
+{
+ DBG_ASSERT( GetRefCount() == 0, "SetValue() with pooled item" );
+
+ if( MapUnit::MapRelative != eUnit )
+ nHeight = nNewHeight + ::ItemToControl( short(nNewProp), eUnit,
+ FieldUnit::TWIP );
+ else if( 100 != nNewProp )
+ nHeight = sal_uInt32(( nNewHeight * nNewProp ) / 100 );
+ else
+ nHeight = nNewHeight;
+
+ nProp = nNewProp;
+ ePropUnit = eUnit;
+}
+
+void SvxFontHeightItem::SetHeight( sal_uInt32 nNewHeight, sal_uInt16 nNewProp,
+ MapUnit eMetric, MapUnit eCoreMetric )
+{
+ DBG_ASSERT( GetRefCount() == 0, "SetValue() with pooled item" );
+
+ if( MapUnit::MapRelative != eMetric )
+ nHeight = nNewHeight +
+ ::ControlToItem( ::ItemToControl(static_cast<short>(nNewProp), eMetric,
+ FieldUnit::TWIP ), FieldUnit::TWIP,
+ eCoreMetric );
+ else if( 100 != nNewProp )
+ nHeight = sal_uInt32(( nNewHeight * nNewProp ) / 100 );
+ else
+ nHeight = nNewHeight;
+
+ nProp = nNewProp;
+ ePropUnit = eMetric;
+}
+
+void SvxFontHeightItem::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+ xmlTextWriterStartElement(pWriter, BAD_CAST("SvxFontHeightItem"));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("height"), BAD_CAST(OString::number(nHeight).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("prop"), BAD_CAST(OString::number(nProp).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("propUnit"), BAD_CAST(OString::number(static_cast<int>(ePropUnit)).getStr()));
+ xmlTextWriterEndElement(pWriter);
+}
+
+// class SvxTextLineItem ------------------------------------------------
+
+SvxTextLineItem::SvxTextLineItem( const FontLineStyle eSt, const sal_uInt16 nId )
+ : SfxEnumItem( nId, eSt ), mColor( COL_TRANSPARENT )
+{
+}
+
+
+bool SvxTextLineItem::HasBoolValue() const
+{
+ return true;
+}
+
+
+bool SvxTextLineItem::GetBoolValue() const
+{
+ return GetValue() != LINESTYLE_NONE;
+}
+
+
+void SvxTextLineItem::SetBoolValue( bool bVal )
+{
+ SetValue( bVal ? LINESTYLE_SINGLE : LINESTYLE_NONE );
+}
+
+SvxTextLineItem* SvxTextLineItem::Clone( SfxItemPool * ) const
+{
+ return new SvxTextLineItem( *this );
+}
+
+sal_uInt16 SvxTextLineItem::GetValueCount() const
+{
+ return LINESTYLE_DOTTED + 1; // LINESTYLE_NONE also belongs here
+}
+
+
+bool SvxTextLineItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper& /*rIntl*/
+) const
+{
+ rText = GetValueTextByPos( GetValue() );
+ if( !mColor.GetTransparency() )
+ rText += cpDelim + ::GetColorString( mColor );
+ return true;
+}
+
+
+OUString SvxTextLineItem::GetValueTextByPos( sal_uInt16 /*nPos*/ ) const
+{
+ OSL_FAIL("SvxTextLineItem::GetValueTextByPos: Pure virtual method");
+ return OUString();
+}
+
+bool SvxTextLineItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch(nMemberId)
+ {
+ case MID_TEXTLINED:
+ rVal <<= GetBoolValue();
+ break;
+ case MID_TL_STYLE:
+ rVal <<= static_cast<sal_Int16>(GetValue());
+ break;
+ case MID_TL_COLOR:
+ rVal <<= mColor;
+ break;
+ case MID_TL_HASCOLOR:
+ rVal <<= !mColor.GetTransparency();
+ break;
+ }
+ return true;
+
+}
+
+bool SvxTextLineItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ bool bRet = true;
+ switch(nMemberId)
+ {
+ case MID_TEXTLINED:
+ SetBoolValue(Any2Bool(rVal));
+ break;
+ case MID_TL_STYLE:
+ {
+ sal_Int32 nValue = 0;
+ if(!(rVal >>= nValue))
+ bRet = false;
+ else
+ SetValue(static_cast<FontLineStyle>(nValue));
+ }
+ break;
+ case MID_TL_COLOR:
+ {
+ sal_Int32 nCol = 0;
+ if( !( rVal >>= nCol ) )
+ bRet = false;
+ else
+ {
+ // Keep transparence, because it contains the information
+ // whether the font color or the stored color should be used
+ sal_uInt8 nTrans = mColor.GetTransparency();
+ mColor = Color( nCol );
+ mColor.SetTransparency( nTrans );
+ }
+ }
+ break;
+ case MID_TL_HASCOLOR:
+ mColor.SetTransparency( Any2Bool( rVal ) ? 0 : 0xff );
+ break;
+ }
+ return bRet;
+}
+
+bool SvxTextLineItem::operator==( const SfxPoolItem& rItem ) const
+{
+ return SfxEnumItem::operator==( rItem ) &&
+ GetColor() == static_cast<const SvxTextLineItem&>(rItem).GetColor();
+}
+
+// class SvxUnderlineItem ------------------------------------------------
+
+
+SvxUnderlineItem::SvxUnderlineItem( const FontLineStyle eSt, const sal_uInt16 nId )
+ : SvxTextLineItem( eSt, nId )
+{
+}
+
+SvxUnderlineItem* SvxUnderlineItem::Clone( SfxItemPool * ) const
+{
+ return new SvxUnderlineItem( *this );
+}
+
+OUString SvxUnderlineItem::GetValueTextByPos( sal_uInt16 nPos ) const
+{
+ static const char* RID_SVXITEMS_UL[] =
+ {
+ RID_SVXITEMS_UL_NONE,
+ RID_SVXITEMS_UL_SINGLE,
+ RID_SVXITEMS_UL_DOUBLE,
+ RID_SVXITEMS_UL_DOTTED,
+ RID_SVXITEMS_UL_DONTKNOW,
+ RID_SVXITEMS_UL_DASH,
+ RID_SVXITEMS_UL_LONGDASH,
+ RID_SVXITEMS_UL_DASHDOT,
+ RID_SVXITEMS_UL_DASHDOTDOT,
+ RID_SVXITEMS_UL_SMALLWAVE,
+ RID_SVXITEMS_UL_WAVE,
+ RID_SVXITEMS_UL_DOUBLEWAVE,
+ RID_SVXITEMS_UL_BOLD,
+ RID_SVXITEMS_UL_BOLDDOTTED,
+ RID_SVXITEMS_UL_BOLDDASH,
+ RID_SVXITEMS_UL_BOLDLONGDASH,
+ RID_SVXITEMS_UL_BOLDDASHDOT,
+ RID_SVXITEMS_UL_BOLDDASHDOTDOT,
+ RID_SVXITEMS_UL_BOLDWAVE
+ };
+ static_assert(SAL_N_ELEMENTS(RID_SVXITEMS_UL) - 1 == LINESTYLE_BOLDWAVE, "must match");
+ assert(nPos <= sal_uInt16(LINESTYLE_BOLDWAVE) && "enum overflow!");
+ return EditResId(RID_SVXITEMS_UL[nPos]);
+}
+
+// class SvxOverlineItem ------------------------------------------------
+
+SvxOverlineItem::SvxOverlineItem( const FontLineStyle eSt, const sal_uInt16 nId )
+ : SvxTextLineItem( eSt, nId )
+{
+}
+
+SvxOverlineItem* SvxOverlineItem::Clone( SfxItemPool * ) const
+{
+ return new SvxOverlineItem( *this );
+}
+
+OUString SvxOverlineItem::GetValueTextByPos( sal_uInt16 nPos ) const
+{
+ static const char* RID_SVXITEMS_OL[] =
+ {
+ RID_SVXITEMS_OL_NONE,
+ RID_SVXITEMS_OL_SINGLE,
+ RID_SVXITEMS_OL_DOUBLE,
+ RID_SVXITEMS_OL_DOTTED,
+ RID_SVXITEMS_OL_DONTKNOW,
+ RID_SVXITEMS_OL_DASH,
+ RID_SVXITEMS_OL_LONGDASH,
+ RID_SVXITEMS_OL_DASHDOT,
+ RID_SVXITEMS_OL_DASHDOTDOT,
+ RID_SVXITEMS_OL_SMALLWAVE,
+ RID_SVXITEMS_OL_WAVE,
+ RID_SVXITEMS_OL_DOUBLEWAVE,
+ RID_SVXITEMS_OL_BOLD,
+ RID_SVXITEMS_OL_BOLDDOTTED,
+ RID_SVXITEMS_OL_BOLDDASH,
+ RID_SVXITEMS_OL_BOLDLONGDASH,
+ RID_SVXITEMS_OL_BOLDDASHDOT,
+ RID_SVXITEMS_OL_BOLDDASHDOTDOT,
+ RID_SVXITEMS_OL_BOLDWAVE
+ };
+ static_assert(SAL_N_ELEMENTS(RID_SVXITEMS_OL) - 1 == LINESTYLE_BOLDWAVE, "must match");
+ assert(nPos <= sal_uInt16(LINESTYLE_BOLDWAVE) && "enum overflow!");
+ return EditResId(RID_SVXITEMS_OL[nPos]);
+}
+
+// class SvxCrossedOutItem -----------------------------------------------
+
+SvxCrossedOutItem::SvxCrossedOutItem( const FontStrikeout eSt, const sal_uInt16 nId )
+ : SfxEnumItem( nId, eSt )
+{
+}
+
+
+bool SvxCrossedOutItem::HasBoolValue() const
+{
+ return true;
+}
+
+
+bool SvxCrossedOutItem::GetBoolValue() const
+{
+ return GetValue() != STRIKEOUT_NONE;
+}
+
+
+void SvxCrossedOutItem::SetBoolValue( bool bVal )
+{
+ SetValue( bVal ? STRIKEOUT_SINGLE : STRIKEOUT_NONE );
+}
+
+
+sal_uInt16 SvxCrossedOutItem::GetValueCount() const
+{
+ return STRIKEOUT_DOUBLE + 1; // STRIKEOUT_NONE belongs also here
+}
+
+SvxCrossedOutItem* SvxCrossedOutItem::Clone( SfxItemPool * ) const
+{
+ return new SvxCrossedOutItem( *this );
+}
+
+bool SvxCrossedOutItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper& /*rIntl*/
+) const
+{
+ rText = GetValueTextByPos( GetValue() );
+ return true;
+}
+
+OUString SvxCrossedOutItem::GetValueTextByPos( sal_uInt16 nPos )
+{
+ static const char* RID_SVXITEMS_STRIKEOUT[] =
+ {
+ RID_SVXITEMS_STRIKEOUT_NONE,
+ RID_SVXITEMS_STRIKEOUT_SINGLE,
+ RID_SVXITEMS_STRIKEOUT_DOUBLE,
+ RID_SVXITEMS_STRIKEOUT_DONTKNOW,
+ RID_SVXITEMS_STRIKEOUT_BOLD,
+ RID_SVXITEMS_STRIKEOUT_SLASH,
+ RID_SVXITEMS_STRIKEOUT_X
+ };
+ static_assert(SAL_N_ELEMENTS(RID_SVXITEMS_STRIKEOUT) - 1 == STRIKEOUT_X, "must match");
+ assert(nPos <= sal_uInt16(STRIKEOUT_X) && "enum overflow!");
+ return EditResId(RID_SVXITEMS_STRIKEOUT[nPos]);
+}
+
+bool SvxCrossedOutItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch(nMemberId)
+ {
+ case MID_CROSSED_OUT:
+ rVal <<= GetBoolValue();
+ break;
+ case MID_CROSS_OUT:
+ rVal <<= static_cast<sal_Int16>(GetValue());
+ break;
+ }
+ return true;
+}
+
+bool SvxCrossedOutItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch(nMemberId)
+ {
+ case MID_CROSSED_OUT:
+ SetBoolValue(Any2Bool(rVal));
+ break;
+ case MID_CROSS_OUT:
+ {
+ sal_Int32 nValue = 0;
+ if(!(rVal >>= nValue))
+ return false;
+ SetValue(static_cast<FontStrikeout>(nValue));
+ }
+ break;
+ }
+ return true;
+}
+// class SvxShadowedItem -------------------------------------------------
+
+SvxShadowedItem::SvxShadowedItem( const bool bShadowed, const sal_uInt16 nId ) :
+ SfxBoolItem( nId, bShadowed )
+{
+}
+
+SvxShadowedItem* SvxShadowedItem::Clone( SfxItemPool * ) const
+{
+ return new SvxShadowedItem( *this );
+}
+
+bool SvxShadowedItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper& /*rIntl*/
+) const
+{
+ const char* pId = RID_SVXITEMS_SHADOWED_FALSE;
+
+ if ( GetValue() )
+ pId = RID_SVXITEMS_SHADOWED_TRUE;
+ rText = EditResId(pId);
+ return true;
+}
+
+// class SvxAutoKernItem -------------------------------------------------
+
+SvxAutoKernItem::SvxAutoKernItem( const bool bAutoKern, const sal_uInt16 nId ) :
+ SfxBoolItem( nId, bAutoKern )
+{
+}
+
+SvxAutoKernItem* SvxAutoKernItem::Clone( SfxItemPool * ) const
+{
+ return new SvxAutoKernItem( *this );
+}
+
+bool SvxAutoKernItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper& /*rIntl*/
+) const
+{
+ const char* pId = RID_SVXITEMS_AUTOKERN_FALSE;
+
+ if ( GetValue() )
+ pId = RID_SVXITEMS_AUTOKERN_TRUE;
+ rText = EditResId(pId);
+ return true;
+}
+
+// class SvxWordLineModeItem ---------------------------------------------
+
+SvxWordLineModeItem::SvxWordLineModeItem( const bool bWordLineMode,
+ const sal_uInt16 nId ) :
+ SfxBoolItem( nId, bWordLineMode )
+{
+}
+
+SvxWordLineModeItem* SvxWordLineModeItem::Clone( SfxItemPool * ) const
+{
+ return new SvxWordLineModeItem( *this );
+}
+
+bool SvxWordLineModeItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper& /*rIntl*/
+) const
+{
+ const char* pId = RID_SVXITEMS_WORDLINE_FALSE;
+
+ if ( GetValue() )
+ pId = RID_SVXITEMS_WORDLINE_TRUE;
+ rText = EditResId(pId);
+ return true;
+}
+
+// class SvxContourItem --------------------------------------------------
+
+SvxContourItem::SvxContourItem( const bool bContoured, const sal_uInt16 nId ) :
+ SfxBoolItem( nId, bContoured )
+{
+}
+
+SvxContourItem* SvxContourItem::Clone( SfxItemPool * ) const
+{
+ return new SvxContourItem( *this );
+}
+
+bool SvxContourItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper& /*rIntl*/
+) const
+{
+ const char* pId = RID_SVXITEMS_CONTOUR_FALSE;
+
+ if ( GetValue() )
+ pId = RID_SVXITEMS_CONTOUR_TRUE;
+ rText = EditResId(pId);
+ return true;
+}
+
+// class SvxBackgroundColorItem -----------------------------------------
+
+SvxBackgroundColorItem::SvxBackgroundColorItem( const sal_uInt16 nId ) :
+ SvxColorItem( nId )
+{
+}
+
+
+SvxBackgroundColorItem::SvxBackgroundColorItem( const Color& rCol,
+ const sal_uInt16 nId ) :
+ SvxColorItem( rCol, nId )
+{
+}
+
+SvxBackgroundColorItem* SvxBackgroundColorItem::Clone( SfxItemPool * ) const
+{
+ return new SvxBackgroundColorItem(*this);
+}
+
+bool SvxBackgroundColorItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ Color aColor = SvxColorItem::GetValue();
+
+ switch( nMemberId )
+ {
+ case MID_GRAPHIC_TRANSPARENT:
+ {
+ rVal <<= aColor.GetTransparency() == 0xff;
+ break;
+ }
+ default:
+ {
+ rVal <<= aColor;
+ break;
+ }
+ }
+ return true;
+}
+
+bool SvxBackgroundColorItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ sal_Int32 nColor = 0;
+ Color aColor = SvxColorItem::GetValue();
+
+ switch( nMemberId )
+ {
+ case MID_GRAPHIC_TRANSPARENT:
+ {
+ aColor.SetTransparency( Any2Bool( rVal ) ? 0xff : 0 );
+ SvxColorItem::SetValue( aColor );
+ break;
+ }
+ default:
+ {
+ if(!(rVal >>= nColor))
+ return false;
+ SvxColorItem::SetValue( Color(nColor) );
+ break;
+ }
+ }
+ return true;
+}
+
+// class SvxColorItem ----------------------------------------------------
+SvxColorItem::SvxColorItem( const sal_uInt16 nId ) :
+ SfxPoolItem( nId ),
+ mColor( COL_BLACK )
+{
+}
+
+SvxColorItem::SvxColorItem( const Color& rCol, const sal_uInt16 nId ) :
+ SfxPoolItem( nId ),
+ mColor( rCol )
+{
+}
+
+SvxColorItem::~SvxColorItem()
+{
+}
+
+bool SvxColorItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ assert(SfxPoolItem::operator==(rAttr));
+
+ return mColor == static_cast<const SvxColorItem&>( rAttr ).mColor;
+}
+
+bool SvxColorItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch (nMemberId)
+ {
+ case MID_COLOR_ALPHA:
+ {
+ auto fTransparency = static_cast<double>(mColor.GetTransparency()) * 100 / 255;
+ rVal <<= static_cast<sal_Int16>(basegfx::fround(fTransparency));
+ break;
+ }
+ default:
+ {
+ rVal <<= mColor;
+ break;
+ }
+ }
+ return true;
+}
+
+bool SvxColorItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch(nMemberId)
+ {
+ case MID_COLOR_ALPHA:
+ {
+ sal_Int16 nTransparency = 0;
+ bool bRet = rVal >>= nTransparency;
+ if (bRet)
+ {
+ auto fTransparency = static_cast<double>(nTransparency) * 255 / 100;
+ mColor.SetTransparency(static_cast<sal_uInt8>(basegfx::fround(fTransparency)));
+ }
+ return bRet;
+ }
+ default:
+ {
+ return rVal >>= mColor;
+ }
+ }
+}
+
+SvxColorItem* SvxColorItem::Clone( SfxItemPool * ) const
+{
+ return new SvxColorItem( *this );
+}
+
+bool SvxColorItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper& /*rIntl*/
+) const
+{
+ rText = ::GetColorString( mColor );
+ return true;
+}
+
+void SvxColorItem::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+ xmlTextWriterStartElement(pWriter, BAD_CAST("SvxColorItem"));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+
+ std::stringstream ss;
+ ss << mColor;
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(ss.str().c_str()));
+
+ OUString aStr;
+ IntlWrapper aIntlWrapper(SvtSysLocale().GetUILanguageTag());
+ GetPresentation( SfxItemPresentation::Complete, MapUnit::Map100thMM, MapUnit::Map100thMM, aStr, aIntlWrapper);
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("presentation"), BAD_CAST(OUStringToOString(aStr, RTL_TEXTENCODING_UTF8).getStr()));
+ xmlTextWriterEndElement(pWriter);
+}
+
+
+
+void SvxColorItem::SetValue( const Color& rNewCol )
+{
+ mColor = rNewCol;
+}
+
+// class SvxKerningItem --------------------------------------------------
+
+SvxKerningItem::SvxKerningItem( const short nKern, const sal_uInt16 nId ) :
+ SfxInt16Item( nId, nKern )
+{
+}
+
+SvxKerningItem* SvxKerningItem::Clone( SfxItemPool * ) const
+{
+ return new SvxKerningItem( *this );
+}
+
+void SvxKerningItem::ScaleMetrics( long nMult, long nDiv )
+{
+ SetValue( static_cast<sal_Int16>(Scale( GetValue(), nMult, nDiv )) );
+}
+
+
+bool SvxKerningItem::HasMetrics() const
+{
+ return true;
+}
+
+
+bool SvxKerningItem::GetPresentation
+(
+ SfxItemPresentation ePres,
+ MapUnit eCoreUnit,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper& rIntl
+) const
+{
+ switch ( ePres )
+ {
+ case SfxItemPresentation::Nameless:
+ rText = GetMetricText( static_cast<long>(GetValue()), eCoreUnit, MapUnit::MapPoint, &rIntl ) +
+ " " + EditResId(GetMetricId(MapUnit::MapPoint));
+ return true;
+ case SfxItemPresentation::Complete:
+ {
+ rText = EditResId(RID_SVXITEMS_KERNING_COMPLETE);
+ const char* pId = nullptr;
+
+ if ( GetValue() > 0 )
+ pId = RID_SVXITEMS_KERNING_EXPANDED;
+ else if ( GetValue() < 0 )
+ pId = RID_SVXITEMS_KERNING_CONDENSED;
+
+ if (pId)
+ rText += EditResId(pId);
+ rText += GetMetricText( static_cast<long>(GetValue()), eCoreUnit, MapUnit::MapPoint, &rIntl ) +
+ " " + EditResId(GetMetricId(MapUnit::MapPoint));
+ return true;
+ }
+ default: ; //prevent warning
+ }
+ return false;
+}
+
+bool SvxKerningItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ sal_Int16 nVal = GetValue();
+ if(nMemberId & CONVERT_TWIPS)
+ nVal = static_cast<sal_Int16>(convertTwipToMm100(nVal));
+ rVal <<= nVal;
+ return true;
+}
+
+bool SvxKerningItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId)
+{
+ sal_Int16 nVal = sal_Int16();
+ if(!(rVal >>= nVal))
+ return false;
+ if(nMemberId & CONVERT_TWIPS)
+ nVal = static_cast<sal_Int16>(convertMm100ToTwip(nVal));
+ SetValue(nVal);
+ return true;
+}
+
+// class SvxCaseMapItem --------------------------------------------------
+
+SvxCaseMapItem::SvxCaseMapItem( const SvxCaseMap eMap, const sal_uInt16 nId ) :
+ SfxEnumItem( nId, eMap )
+{
+}
+
+sal_uInt16 SvxCaseMapItem::GetValueCount() const
+{
+ return sal_uInt16(SvxCaseMap::End); // SvxCaseMap::SmallCaps + 1
+}
+
+SvxCaseMapItem* SvxCaseMapItem::Clone( SfxItemPool * ) const
+{
+ return new SvxCaseMapItem( *this );
+}
+
+bool SvxCaseMapItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper& /*rIntl*/
+) const
+{
+ rText = GetValueTextByPos( static_cast<sal_uInt16>(GetValue()) );
+ return true;
+}
+
+OUString SvxCaseMapItem::GetValueTextByPos( sal_uInt16 nPos )
+{
+ static const char* RID_SVXITEMS_CASEMAP[] =
+ {
+ RID_SVXITEMS_CASEMAP_NONE,
+ RID_SVXITEMS_CASEMAP_UPPERCASE,
+ RID_SVXITEMS_CASEMAP_LOWERCASE,
+ RID_SVXITEMS_CASEMAP_TITLE,
+ RID_SVXITEMS_CASEMAP_SMALLCAPS
+ };
+
+ static_assert(SAL_N_ELEMENTS(RID_SVXITEMS_CASEMAP) == size_t(SvxCaseMap::End), "must match");
+ assert(nPos < sal_uInt16(SvxCaseMap::End) && "enum overflow!");
+ return EditResId(RID_SVXITEMS_CASEMAP[nPos]);
+}
+
+bool SvxCaseMapItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
+{
+ sal_Int16 nRet = style::CaseMap::NONE;
+ switch( GetValue() )
+ {
+ case SvxCaseMap::Uppercase : nRet = style::CaseMap::UPPERCASE; break;
+ case SvxCaseMap::Lowercase : nRet = style::CaseMap::LOWERCASE; break;
+ case SvxCaseMap::Capitalize : nRet = style::CaseMap::TITLE ; break;
+ case SvxCaseMap::SmallCaps: nRet = style::CaseMap::SMALLCAPS; break;
+ default: break;
+ }
+ rVal <<= nRet;
+ return true;
+}
+
+bool SvxCaseMapItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
+{
+ sal_uInt16 nVal = sal_uInt16();
+ if(!(rVal >>= nVal))
+ return false;
+
+ SvxCaseMap eVal;
+ switch( nVal )
+ {
+ case style::CaseMap::NONE : eVal = SvxCaseMap::NotMapped; break;
+ case style::CaseMap::UPPERCASE: eVal = SvxCaseMap::Uppercase; break;
+ case style::CaseMap::LOWERCASE: eVal = SvxCaseMap::Lowercase; break;
+ case style::CaseMap::TITLE : eVal = SvxCaseMap::Capitalize; break;
+ case style::CaseMap::SMALLCAPS: eVal = SvxCaseMap::SmallCaps; break;
+ default: return false;
+ }
+ SetValue(eVal);
+ return true;
+}
+
+// class SvxEscapementItem -----------------------------------------------
+
+SvxEscapementItem::SvxEscapementItem( const sal_uInt16 nId ) :
+ SfxEnumItemInterface( nId ),
+
+ nEsc ( 0 ),
+ nProp ( 100 )
+{
+}
+
+
+SvxEscapementItem::SvxEscapementItem( const SvxEscapement eEscape,
+ const sal_uInt16 nId ) :
+ SfxEnumItemInterface( nId ),
+ nProp( 100 )
+{
+ SetEscapement( eEscape );
+ if( nEsc )
+ nProp = DFLT_ESC_PROP;
+}
+
+
+SvxEscapementItem::SvxEscapementItem( const short _nEsc,
+ const sal_uInt8 _nProp,
+ const sal_uInt16 nId ) :
+ SfxEnumItemInterface( nId ),
+ nEsc ( _nEsc ),
+ nProp ( _nProp )
+{
+}
+
+
+bool SvxEscapementItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ assert(SfxPoolItem::operator==(rAttr));
+
+ return( nEsc == static_cast<const SvxEscapementItem&>(rAttr).nEsc &&
+ nProp == static_cast<const SvxEscapementItem&>(rAttr).nProp );
+}
+
+SvxEscapementItem* SvxEscapementItem::Clone( SfxItemPool * ) const
+{
+ return new SvxEscapementItem( *this );
+}
+
+sal_uInt16 SvxEscapementItem::GetValueCount() const
+{
+ return sal_uInt16(SvxEscapement::End); // SvxEscapement::Subscript + 1
+}
+
+
+bool SvxEscapementItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper& /*rIntl*/
+) const
+{
+ rText = GetValueTextByPos( GetEnumValue() );
+
+ if ( nEsc != 0 )
+ {
+ if( DFLT_ESC_AUTO_SUPER == nEsc || DFLT_ESC_AUTO_SUB == nEsc )
+ rText += EditResId(RID_SVXITEMS_ESCAPEMENT_AUTO);
+ else
+ rText += OUString::number( nEsc ) + "%";
+ }
+ return true;
+}
+
+OUString SvxEscapementItem::GetValueTextByPos( sal_uInt16 nPos )
+{
+ static const char* RID_SVXITEMS_ESCAPEMENT[] =
+ {
+ RID_SVXITEMS_ESCAPEMENT_OFF,
+ RID_SVXITEMS_ESCAPEMENT_SUPER,
+ RID_SVXITEMS_ESCAPEMENT_SUB
+ };
+
+ static_assert(SAL_N_ELEMENTS(RID_SVXITEMS_ESCAPEMENT) == size_t(SvxEscapement::End), "must match");
+ assert(nPos < sal_uInt16(SvxEscapement::End) && "enum overflow!");
+ return EditResId(RID_SVXITEMS_ESCAPEMENT[nPos]);
+}
+
+sal_uInt16 SvxEscapementItem::GetEnumValue() const
+{
+ if ( nEsc < 0 )
+ return sal_uInt16(SvxEscapement::Subscript);
+ else if ( nEsc > 0 )
+ return sal_uInt16(SvxEscapement::Superscript);
+ return sal_uInt16(SvxEscapement::Off);
+}
+
+
+void SvxEscapementItem::SetEnumValue( sal_uInt16 nVal )
+{
+ SetEscapement( static_cast<SvxEscapement>(nVal) );
+}
+
+bool SvxEscapementItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch(nMemberId)
+ {
+ case MID_ESC:
+ rVal <<= static_cast<sal_Int16>(nEsc);
+ break;
+ case MID_ESC_HEIGHT:
+ rVal <<= static_cast<sal_Int8>(nProp);
+ break;
+ case MID_AUTO_ESC:
+ rVal <<= (DFLT_ESC_AUTO_SUB == nEsc || DFLT_ESC_AUTO_SUPER == nEsc);
+ break;
+ }
+ return true;
+}
+
+bool SvxEscapementItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch(nMemberId)
+ {
+ case MID_ESC:
+ {
+ sal_Int16 nVal = sal_Int16();
+ if( (rVal >>= nVal) && (std::abs(nVal) <= MAX_ESC_POS+1))
+ nEsc = nVal;
+ else
+ return false;
+ }
+ break;
+ case MID_ESC_HEIGHT:
+ {
+ sal_Int8 nVal = sal_Int8();
+ if( (rVal >>= nVal) && (nVal <= 100))
+ nProp = nVal;
+ else
+ return false;
+ }
+ break;
+ case MID_AUTO_ESC:
+ {
+ bool bVal = Any2Bool(rVal);
+ if(bVal)
+ {
+ if(nEsc < 0)
+ nEsc = DFLT_ESC_AUTO_SUB;
+ else
+ nEsc = DFLT_ESC_AUTO_SUPER;
+ }
+ else
+ if(DFLT_ESC_AUTO_SUPER == nEsc )
+ --nEsc;
+ else if(DFLT_ESC_AUTO_SUB == nEsc)
+ ++nEsc;
+ }
+ break;
+ }
+ return true;
+}
+
+// class SvxLanguageItem -------------------------------------------------
+
+SvxLanguageItem::SvxLanguageItem( const LanguageType eLang, const sal_uInt16 nId )
+ : SvxLanguageItem_Base( nId , eLang )
+{
+}
+
+
+sal_uInt16 SvxLanguageItem::GetValueCount() const
+{
+ // #i50205# got rid of class International
+ SAL_WARN( "editeng.items", "SvxLanguageItem::GetValueCount: supposed to return a count of what?");
+ // Could be SvtLanguageTable::GetEntryCount() (all locales with resource string)?
+ // Could be LocaleDataWrapper::getInstalledLanguageTypes() (all locales with locale data)?
+ return 0;
+}
+
+SvxLanguageItem* SvxLanguageItem::Clone( SfxItemPool * ) const
+{
+ return new SvxLanguageItem( *this );
+}
+
+bool SvxLanguageItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper& /*rIntl*/
+) const
+{
+ rText = SvtLanguageTable::GetLanguageString( GetValue() );
+ return true;
+}
+
+bool SvxLanguageItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch(nMemberId)
+ {
+ case MID_LANG_INT: // for basic conversions!
+ rVal <<= static_cast<sal_Int16>(static_cast<sal_uInt16>(GetValue()));
+ break;
+ case MID_LANG_LOCALE:
+ lang::Locale aRet( LanguageTag::convertToLocale( GetValue(), false));
+ rVal <<= aRet;
+ break;
+ }
+ return true;
+}
+
+bool SvxLanguageItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch(nMemberId)
+ {
+ case MID_LANG_INT: // for basic conversions!
+ {
+ sal_Int32 nValue = 0;
+ if(!(rVal >>= nValue))
+ return false;
+
+ SetValue(LanguageType(nValue));
+ }
+ break;
+ case MID_LANG_LOCALE:
+ {
+ lang::Locale aLocale;
+ if(!(rVal >>= aLocale))
+ return false;
+
+ SetValue( LanguageTag::convertToLanguageType( aLocale, false));
+ }
+ break;
+ }
+ return true;
+}
+
+// class SvxNoHyphenItem -------------------------------------------------
+
+SvxNoHyphenItem::SvxNoHyphenItem( const sal_uInt16 nId ) :
+ SfxBoolItem( nId , true )
+{
+}
+
+SvxNoHyphenItem* SvxNoHyphenItem::Clone( SfxItemPool* ) const
+{
+ return new SvxNoHyphenItem( *this );
+}
+
+bool SvxNoHyphenItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper& /*rIntl*/
+) const
+{
+ rText.clear();
+ return false;
+}
+
+/*
+ * Dummy item for ToolBox controls:
+ *
+ */
+
+
+// class SvxBlinkItem -------------------------------------------------
+
+
+SvxBlinkItem::SvxBlinkItem( const bool bBlink, const sal_uInt16 nId ) :
+ SfxBoolItem( nId, bBlink )
+{
+}
+
+SvxBlinkItem* SvxBlinkItem::Clone( SfxItemPool * ) const
+{
+ return new SvxBlinkItem( *this );
+}
+
+bool SvxBlinkItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper& /*rIntl*/
+) const
+{
+ const char* pId = RID_SVXITEMS_BLINK_FALSE;
+
+ if ( GetValue() )
+ pId = RID_SVXITEMS_BLINK_TRUE;
+ rText = EditResId(pId);
+ return true;
+}
+
+// class SvxEmphaisMarkItem ---------------------------------------------------
+
+SvxEmphasisMarkItem::SvxEmphasisMarkItem( const FontEmphasisMark nValue,
+ const sal_uInt16 nId )
+ : SfxUInt16Item( nId, static_cast<sal_uInt16>(nValue) )
+{
+}
+
+SvxEmphasisMarkItem* SvxEmphasisMarkItem::Clone( SfxItemPool * ) const
+{
+ return new SvxEmphasisMarkItem( *this );
+}
+
+bool SvxEmphasisMarkItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText,
+ const IntlWrapper& /*rIntl*/
+) const
+{
+ static const char* RID_SVXITEMS_EMPHASIS[] =
+ {
+ RID_SVXITEMS_EMPHASIS_NONE_STYLE,
+ RID_SVXITEMS_EMPHASIS_DOT_STYLE,
+ RID_SVXITEMS_EMPHASIS_CIRCLE_STYLE,
+ RID_SVXITEMS_EMPHASIS_DISC_STYLE,
+ RID_SVXITEMS_EMPHASIS_ACCENT_STYLE
+ };
+
+ FontEmphasisMark nVal = GetEmphasisMark();
+ rText = EditResId(RID_SVXITEMS_EMPHASIS[
+ static_cast<sal_uInt16>(static_cast<FontEmphasisMark>( nVal & FontEmphasisMark::Style ))]);
+ const char* pId = ( FontEmphasisMark::PosAbove & nVal )
+ ? RID_SVXITEMS_EMPHASIS_ABOVE_POS
+ : ( FontEmphasisMark::PosBelow & nVal )
+ ? RID_SVXITEMS_EMPHASIS_BELOW_POS
+ : nullptr;
+ if( pId )
+ rText += EditResId( pId );
+ return true;
+}
+
+bool SvxEmphasisMarkItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch( nMemberId )
+ {
+ case MID_EMPHASIS:
+ {
+ FontEmphasisMark nValue = GetEmphasisMark();
+ sal_Int16 nRet = 0;
+ switch(nValue & FontEmphasisMark::Style)
+ {
+ case FontEmphasisMark::NONE : nRet = FontEmphasis::NONE; break;
+ case FontEmphasisMark::Dot : nRet = FontEmphasis::DOT_ABOVE; break;
+ case FontEmphasisMark::Circle : nRet = FontEmphasis::CIRCLE_ABOVE; break;
+ case FontEmphasisMark::Disc : nRet = FontEmphasis::DISK_ABOVE; break;
+ case FontEmphasisMark::Accent : nRet = FontEmphasis::ACCENT_ABOVE; break;
+ default: break;
+ }
+ if(nRet && nValue & FontEmphasisMark::PosBelow)
+ nRet += 10;
+ rVal <<= nRet;
+ }
+ break;
+ }
+ return true;
+}
+
+bool SvxEmphasisMarkItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId )
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ switch( nMemberId )
+ {
+ case MID_EMPHASIS:
+ {
+ sal_Int32 nValue = -1;
+ rVal >>= nValue;
+ FontEmphasisMark nMark;
+ switch(nValue)
+ {
+ case FontEmphasis::NONE : nMark = FontEmphasisMark::NONE; break;
+ case FontEmphasis::DOT_ABOVE : nMark = FontEmphasisMark::Dot|FontEmphasisMark::PosAbove; break;
+ case FontEmphasis::CIRCLE_ABOVE: nMark = FontEmphasisMark::Circle|FontEmphasisMark::PosAbove; break;
+ case FontEmphasis::DISK_ABOVE : nMark = FontEmphasisMark::Disc|FontEmphasisMark::PosAbove; break;
+ case FontEmphasis::ACCENT_ABOVE: nMark = FontEmphasisMark::Accent|FontEmphasisMark::PosAbove; break;
+ case FontEmphasis::DOT_BELOW : nMark = FontEmphasisMark::Dot|FontEmphasisMark::PosBelow; break;
+ case FontEmphasis::CIRCLE_BELOW: nMark = FontEmphasisMark::Circle|FontEmphasisMark::PosBelow; break;
+ case FontEmphasis::DISK_BELOW : nMark = FontEmphasisMark::Disc|FontEmphasisMark::PosBelow; break;
+ case FontEmphasis::ACCENT_BELOW: nMark = FontEmphasisMark::Accent|FontEmphasisMark::PosBelow; break;
+ default: return false;
+ }
+ SetValue( static_cast<sal_Int16>(nMark) );
+ }
+ break;
+ }
+ return true;
+}
+
+/*************************************************************************
+|* class SvxTwoLinesItem
+*************************************************************************/
+
+SvxTwoLinesItem::SvxTwoLinesItem( bool bFlag, sal_Unicode nStartBracket,
+ sal_Unicode nEndBracket, sal_uInt16 nW )
+ : SfxPoolItem( nW ),
+ cStartBracket( nStartBracket ), cEndBracket( nEndBracket ), bOn( bFlag )
+{
+}
+
+SvxTwoLinesItem::~SvxTwoLinesItem()
+{
+}
+
+bool SvxTwoLinesItem::operator==( const SfxPoolItem& rAttr ) const
+{
+ assert(SfxPoolItem::operator==(rAttr));
+ return bOn == static_cast<const SvxTwoLinesItem&>(rAttr).bOn &&
+ cStartBracket == static_cast<const SvxTwoLinesItem&>(rAttr).cStartBracket &&
+ cEndBracket == static_cast<const SvxTwoLinesItem&>(rAttr).cEndBracket;
+}
+
+SvxTwoLinesItem* SvxTwoLinesItem::Clone( SfxItemPool* ) const
+{
+ return new SvxTwoLinesItem( *this );
+}
+
+bool SvxTwoLinesItem::QueryValue( css::uno::Any& rVal,
+ sal_uInt8 nMemberId ) const
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ bool bRet = true;
+ switch( nMemberId )
+ {
+ case MID_TWOLINES:
+ rVal <<= bOn;
+ break;
+ case MID_START_BRACKET:
+ {
+ OUString s;
+ if( cStartBracket )
+ s = OUString( cStartBracket );
+ rVal <<= s;
+ }
+ break;
+ case MID_END_BRACKET:
+ {
+ OUString s;
+ if( cEndBracket )
+ s = OUString( cEndBracket );
+ rVal <<= s;
+ }
+ break;
+ default:
+ bRet = false;
+ break;
+ }
+ return bRet;
+}
+
+bool SvxTwoLinesItem::PutValue( const css::uno::Any& rVal,
+ sal_uInt8 nMemberId )
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ bool bRet = false;
+ OUString s;
+ switch( nMemberId )
+ {
+ case MID_TWOLINES:
+ bOn = Any2Bool( rVal );
+ bRet = true;
+ break;
+ case MID_START_BRACKET:
+ if( rVal >>= s )
+ {
+ cStartBracket = s.isEmpty() ? 0 : s[ 0 ];
+ bRet = true;
+ }
+ break;
+ case MID_END_BRACKET:
+ if( rVal >>= s )
+ {
+ cEndBracket = s.isEmpty() ? 0 : s[ 0 ];
+ bRet = true;
+ }
+ break;
+ }
+ return bRet;
+}
+
+bool SvxTwoLinesItem::GetPresentation( SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/,
+ OUString &rText, const IntlWrapper& /*rIntl*/ ) const
+{
+ if( !GetValue() )
+ rText = EditResId( RID_SVXITEMS_TWOLINES_OFF );
+ else
+ {
+ rText = EditResId( RID_SVXITEMS_TWOLINES );
+ if( GetStartBracket() )
+ rText = OUStringChar(GetStartBracket()) + rText;
+ if( GetEndBracket() )
+ rText += OUStringChar(GetEndBracket());
+ }
+ return true;
+}
+
+
+/*************************************************************************
+|* class SvxTextRotateItem
+*************************************************************************/
+
+SvxTextRotateItem::SvxTextRotateItem(sal_uInt16 nValue, const sal_uInt16 nW)
+ : SfxUInt16Item(nW, nValue)
+{
+}
+
+SvxTextRotateItem* SvxTextRotateItem::Clone(SfxItemPool*) const
+{
+ return new SvxTextRotateItem(*this);
+}
+
+bool SvxTextRotateItem::GetPresentation(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/,
+ OUString &rText, const IntlWrapper&) const
+{
+ if (!GetValue())
+ rText = EditResId(RID_SVXITEMS_TEXTROTATE_OFF);
+ else
+ {
+ rText = EditResId(RID_SVXITEMS_TEXTROTATE);
+ rText = rText.replaceFirst("$(ARG1)",
+ OUString::number(GetValue() / 10));
+ }
+ return true;
+}
+
+bool SvxTextRotateItem::QueryValue(css::uno::Any& rVal,
+ sal_uInt8 nMemberId) const
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ bool bRet = true;
+ switch (nMemberId)
+ {
+ case MID_ROTATE:
+ rVal <<= static_cast<sal_Int16>(GetValue());
+ break;
+ default:
+ bRet = false;
+ break;
+ }
+ return bRet;
+}
+
+bool SvxTextRotateItem::PutValue(const css::uno::Any& rVal, sal_uInt8 nMemberId)
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ bool bRet = true;
+ switch (nMemberId)
+ {
+ case MID_ROTATE:
+ {
+ sal_Int16 nVal = 0;
+ if ((rVal >>= nVal) && (0 == nVal || 900 == nVal || 2700 == nVal))
+ SetValue(static_cast<sal_uInt16>(nVal));
+ else
+ bRet = false;
+ break;
+ }
+ default:
+ bRet = false;
+ }
+ return bRet;
+}
+
+void SvxTextRotateItem::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+ xmlTextWriterStartElement(pWriter, BAD_CAST("SvxTextRotateItem"));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue()).getStr()));
+ xmlTextWriterEndElement(pWriter);
+}
+
+
+/*************************************************************************
+|* class SvxCharRotateItem
+*************************************************************************/
+
+SvxCharRotateItem::SvxCharRotateItem( sal_uInt16 nValue,
+ bool bFitIntoLine,
+ const sal_uInt16 nW )
+ : SvxTextRotateItem(nValue, nW), bFitToLine( bFitIntoLine )
+{
+}
+
+SvxCharRotateItem* SvxCharRotateItem::Clone( SfxItemPool* ) const
+{
+ return new SvxCharRotateItem( *this );
+}
+
+bool SvxCharRotateItem::GetPresentation(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/,
+ OUString &rText, const IntlWrapper&) const
+{
+ if( !GetValue() )
+ rText = EditResId( RID_SVXITEMS_CHARROTATE_OFF );
+ else
+ {
+ rText = EditResId( RID_SVXITEMS_CHARROTATE );
+ rText = rText.replaceFirst( "$(ARG1)",
+ OUString::number( GetValue() / 10 ));
+ if( IsFitToLine() )
+ rText += EditResId( RID_SVXITEMS_CHARROTATE_FITLINE );
+ }
+ return true;
+}
+
+bool SvxCharRotateItem::QueryValue( css::uno::Any& rVal,
+ sal_uInt8 nMemberId ) const
+{
+ bool bRet = true;
+ switch(nMemberId & ~CONVERT_TWIPS)
+ {
+ case MID_ROTATE:
+ SvxTextRotateItem::QueryValue(rVal, nMemberId);
+ break;
+ case MID_FITTOLINE:
+ rVal <<= IsFitToLine();
+ break;
+ default:
+ bRet = false;
+ break;
+ }
+ return bRet;
+}
+
+bool SvxCharRotateItem::PutValue( const css::uno::Any& rVal,
+ sal_uInt8 nMemberId )
+{
+ bool bRet = true;
+ switch(nMemberId & ~CONVERT_TWIPS)
+ {
+ case MID_ROTATE:
+ {
+ bRet = SvxTextRotateItem::PutValue(rVal, nMemberId);
+ break;
+ }
+
+ case MID_FITTOLINE:
+ SetFitToLine( Any2Bool( rVal ) );
+ break;
+ default:
+ bRet = false;
+ }
+ return bRet;
+}
+
+bool SvxCharRotateItem::operator==( const SfxPoolItem& rItem ) const
+{
+ assert(SfxPoolItem::operator==(rItem));
+ return SvxTextRotateItem::operator==( rItem ) &&
+ IsFitToLine() == static_cast<const SvxCharRotateItem&>(rItem).IsFitToLine();
+}
+
+void SvxCharRotateItem::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+ xmlTextWriterStartElement(pWriter, BAD_CAST("SvxCharRotateItem"));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::number(GetValue()).getStr()));
+ xmlTextWriterWriteAttribute(pWriter, BAD_CAST("fitToLine"), BAD_CAST(OString::boolean(IsFitToLine()).getStr()));
+ xmlTextWriterEndElement(pWriter);
+}
+
+/*************************************************************************
+|* class SvxCharScaleItem
+*************************************************************************/
+
+SvxCharScaleWidthItem::SvxCharScaleWidthItem( sal_uInt16 nValue,
+ const sal_uInt16 nW )
+ : SfxUInt16Item( nW, nValue )
+{
+}
+
+SvxCharScaleWidthItem* SvxCharScaleWidthItem::Clone( SfxItemPool* ) const
+{
+ return new SvxCharScaleWidthItem( *this );
+}
+
+bool SvxCharScaleWidthItem::GetPresentation(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/,
+ OUString &rText, const IntlWrapper&) const
+{
+ if( !GetValue() )
+ rText = EditResId( RID_SVXITEMS_CHARSCALE_OFF );
+ else
+ {
+ rText = EditResId( RID_SVXITEMS_CHARSCALE );
+ rText = rText.replaceFirst( "$(ARG1)",
+ OUString::number( GetValue() ));
+ }
+ return true;
+}
+
+bool SvxCharScaleWidthItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
+{
+ // SfxUInt16Item::QueryValue returns sal_Int32 in Any now... (srx642w)
+ // where we still want this to be a sal_Int16
+ sal_Int16 nValue = sal_Int16();
+ if (rVal >>= nValue)
+ {
+ SetValue( static_cast<sal_uInt16>(nValue) );
+ return true;
+ }
+
+ SAL_WARN("editeng.items", "SvxCharScaleWidthItem::PutValue - Wrong type!" );
+ return false;
+}
+
+bool SvxCharScaleWidthItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
+{
+ // SfxUInt16Item::QueryValue returns sal_Int32 in Any now... (srx642w)
+ // where we still want this to be a sal_Int16
+ rVal <<= static_cast<sal_Int16>(GetValue());
+ return true;
+}
+
+/*************************************************************************
+|* class SvxCharReliefItem
+*************************************************************************/
+
+SvxCharReliefItem::SvxCharReliefItem( FontRelief eValue,
+ const sal_uInt16 nId )
+ : SfxEnumItem( nId, eValue )
+{
+}
+
+SvxCharReliefItem* SvxCharReliefItem::Clone( SfxItemPool * ) const
+{
+ return new SvxCharReliefItem( *this );
+}
+
+static const char* RID_SVXITEMS_RELIEF[] =
+{
+ RID_SVXITEMS_RELIEF_NONE,
+ RID_SVXITEMS_RELIEF_EMBOSSED,
+ RID_SVXITEMS_RELIEF_ENGRAVED
+};
+
+OUString SvxCharReliefItem::GetValueTextByPos(sal_uInt16 nPos)
+{
+ assert(nPos < SAL_N_ELEMENTS(RID_SVXITEMS_RELIEF) && "enum overflow");
+ return EditResId(RID_SVXITEMS_RELIEF[nPos]);
+}
+
+sal_uInt16 SvxCharReliefItem::GetValueCount() const
+{
+ return SAL_N_ELEMENTS(RID_SVXITEMS_RELIEF) - 1;
+}
+
+bool SvxCharReliefItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper& /*rIntl*/
+) const
+{
+ rText = GetValueTextByPos( static_cast<sal_uInt16>(GetValue()) );
+ return true;
+}
+
+bool SvxCharReliefItem::PutValue( const css::uno::Any& rVal,
+ sal_uInt8 nMemberId )
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ bool bRet = true;
+ switch( nMemberId )
+ {
+ case MID_RELIEF:
+ {
+ sal_Int16 nVal = -1;
+ rVal >>= nVal;
+ if(nVal >= 0 && nVal <= sal_Int16(FontRelief::Engraved))
+ SetValue( static_cast<FontRelief>(nVal) );
+ else
+ bRet = false;
+ }
+ break;
+ default:
+ bRet = false;
+ break;
+ }
+ return bRet;
+}
+
+bool SvxCharReliefItem::QueryValue( css::uno::Any& rVal,
+ sal_uInt8 nMemberId ) const
+{
+ nMemberId &= ~CONVERT_TWIPS;
+ bool bRet = true;
+ switch( nMemberId )
+ {
+ case MID_RELIEF:
+ rVal <<= static_cast<sal_Int16>(GetValue());
+ break;
+ default:
+ bRet = false;
+ break;
+ }
+ return bRet;
+}
+
+/*************************************************************************
+|* class SvxScriptSetItem
+*************************************************************************/
+
+SvxScriptSetItem::SvxScriptSetItem( sal_uInt16 nSlotId, SfxItemPool& rPool )
+ : SfxSetItem( nSlotId, std::make_unique<SfxItemSet>( rPool,
+ svl::Items<SID_ATTR_CHAR_FONT, SID_ATTR_CHAR_FONT>{} ))
+{
+ sal_uInt16 nLatin, nAsian, nComplex;
+ GetWhichIds( nLatin, nAsian, nComplex );
+ GetItemSet().MergeRange( nLatin, nLatin );
+ GetItemSet().MergeRange( nAsian, nAsian );
+ GetItemSet().MergeRange( nComplex, nComplex );
+}
+
+SvxScriptSetItem* SvxScriptSetItem::Clone( SfxItemPool * ) const
+{
+ SvxScriptSetItem* p = new SvxScriptSetItem( Which(), *GetItemSet().GetPool() );
+ p->GetItemSet().Put( GetItemSet(), false );
+ return p;
+}
+
+const SfxPoolItem* SvxScriptSetItem::GetItemOfScriptSet(
+ const SfxItemSet& rSet, sal_uInt16 nId )
+{
+ const SfxPoolItem* pI;
+ SfxItemState eSt = rSet.GetItemState( nId, false, &pI );
+ if( SfxItemState::SET != eSt )
+ pI = SfxItemState::DEFAULT == eSt ? &rSet.Get( nId ) : nullptr;
+ return pI;
+}
+
+const SfxPoolItem* SvxScriptSetItem::GetItemOfScript( sal_uInt16 nSlotId, const SfxItemSet& rSet, SvtScriptType nScript )
+{
+ sal_uInt16 nLatin, nAsian, nComplex;
+ GetWhichIds( nSlotId, rSet, nLatin, nAsian, nComplex );
+
+ const SfxPoolItem *pRet, *pAsn, *pCmplx;
+ if (nScript == SvtScriptType::ASIAN)
+ {
+ pRet = GetItemOfScriptSet( rSet, nAsian );
+ } else if (nScript == SvtScriptType::COMPLEX)
+ {
+ pRet = GetItemOfScriptSet( rSet, nComplex );
+ } else if (nScript == (SvtScriptType::LATIN|SvtScriptType::ASIAN))
+ {
+ if( nullptr == (pRet = GetItemOfScriptSet( rSet, nLatin )) ||
+ nullptr == (pAsn = GetItemOfScriptSet( rSet, nAsian )) ||
+ *pRet != *pAsn )
+ pRet = nullptr;
+ } else if (nScript == (SvtScriptType::LATIN|SvtScriptType::COMPLEX))
+ {
+ if( nullptr == (pRet = GetItemOfScriptSet( rSet, nLatin )) ||
+ nullptr == (pCmplx = GetItemOfScriptSet( rSet, nComplex )) ||
+ *pRet != *pCmplx )
+ pRet = nullptr;
+ } else if (nScript == (SvtScriptType::ASIAN|SvtScriptType::COMPLEX))
+ {
+ if( nullptr == (pRet = GetItemOfScriptSet( rSet, nAsian )) ||
+ nullptr == (pCmplx = GetItemOfScriptSet( rSet, nComplex )) ||
+ *pRet != *pCmplx )
+ pRet = nullptr;
+ } else if (nScript == (SvtScriptType::LATIN|SvtScriptType::ASIAN|SvtScriptType::COMPLEX))
+ {
+ if( nullptr == (pRet = GetItemOfScriptSet( rSet, nLatin )) ||
+ nullptr == (pAsn = GetItemOfScriptSet( rSet, nAsian )) ||
+ nullptr == (pCmplx = GetItemOfScriptSet( rSet, nComplex )) ||
+ *pRet != *pAsn || *pRet != *pCmplx )
+ pRet = nullptr;
+ } else {
+ //no one valid -> match to latin
+ pRet = GetItemOfScriptSet( rSet, nLatin );
+ }
+ return pRet;
+}
+
+const SfxPoolItem* SvxScriptSetItem::GetItemOfScript( SvtScriptType nScript ) const
+{
+ return GetItemOfScript( Which(), GetItemSet(), nScript );
+}
+
+void SvxScriptSetItem::PutItemForScriptType( SvtScriptType nScriptType,
+ const SfxPoolItem& rItem )
+{
+ sal_uInt16 nLatin, nAsian, nComplex;
+ GetWhichIds( nLatin, nAsian, nComplex );
+
+ std::unique_ptr<SfxPoolItem> pCpy(rItem.Clone());
+ if( SvtScriptType::LATIN & nScriptType )
+ {
+ pCpy->SetWhich( nLatin );
+ GetItemSet().Put( *pCpy );
+ }
+ if( SvtScriptType::ASIAN & nScriptType )
+ {
+ pCpy->SetWhich( nAsian );
+ GetItemSet().Put( *pCpy );
+ }
+ if( SvtScriptType::COMPLEX & nScriptType )
+ {
+ pCpy->SetWhich( nComplex );
+ GetItemSet().Put( *pCpy );
+ }
+}
+
+void SvxScriptSetItem::GetWhichIds( sal_uInt16 nSlotId, const SfxItemSet& rSet, sal_uInt16& rLatin, sal_uInt16& rAsian, sal_uInt16& rComplex )
+{
+ const SfxItemPool& rPool = *rSet.GetPool();
+ GetSlotIds( nSlotId, rLatin, rAsian, rComplex );
+ rLatin = rPool.GetWhich( rLatin );
+ rAsian = rPool.GetWhich( rAsian );
+ rComplex = rPool.GetWhich( rComplex );
+}
+
+void SvxScriptSetItem::GetWhichIds( sal_uInt16& rLatin, sal_uInt16& rAsian,
+ sal_uInt16& rComplex ) const
+{
+ GetWhichIds( Which(), GetItemSet(), rLatin, rAsian, rComplex );
+}
+
+void SvxScriptSetItem::GetSlotIds( sal_uInt16 nSlotId, sal_uInt16& rLatin,
+ sal_uInt16& rAsian, sal_uInt16& rComplex )
+{
+ switch( nSlotId )
+ {
+ default:
+ SAL_WARN( "editeng.items", "wrong SlotId for class SvxScriptSetItem" );
+ [[fallthrough]]; // default to font - Id Range !!
+
+ case SID_ATTR_CHAR_FONT:
+ rLatin = SID_ATTR_CHAR_FONT;
+ rAsian = SID_ATTR_CHAR_CJK_FONT;
+ rComplex = SID_ATTR_CHAR_CTL_FONT;
+ break;
+ case SID_ATTR_CHAR_FONTHEIGHT:
+ rLatin = SID_ATTR_CHAR_FONTHEIGHT;
+ rAsian = SID_ATTR_CHAR_CJK_FONTHEIGHT;
+ rComplex = SID_ATTR_CHAR_CTL_FONTHEIGHT;
+ break;
+ case SID_ATTR_CHAR_WEIGHT:
+ rLatin = SID_ATTR_CHAR_WEIGHT;
+ rAsian = SID_ATTR_CHAR_CJK_WEIGHT;
+ rComplex = SID_ATTR_CHAR_CTL_WEIGHT;
+ break;
+ case SID_ATTR_CHAR_POSTURE:
+ rLatin = SID_ATTR_CHAR_POSTURE;
+ rAsian = SID_ATTR_CHAR_CJK_POSTURE;
+ rComplex = SID_ATTR_CHAR_CTL_POSTURE;
+ break;
+ case SID_ATTR_CHAR_LANGUAGE:
+ rLatin = SID_ATTR_CHAR_LANGUAGE;
+ rAsian = SID_ATTR_CHAR_CJK_LANGUAGE;
+ rComplex = SID_ATTR_CHAR_CTL_LANGUAGE;
+ break;
+ case SID_ATTR_CHAR_SHADOWED:
+ rLatin = SID_ATTR_CHAR_SHADOWED;
+ rAsian = SID_ATTR_CHAR_SHADOWED;
+ rComplex = SID_ATTR_CHAR_SHADOWED;
+ break;
+ case SID_ATTR_CHAR_STRIKEOUT:
+ rLatin = SID_ATTR_CHAR_STRIKEOUT;
+ rAsian = SID_ATTR_CHAR_STRIKEOUT;
+ rComplex = SID_ATTR_CHAR_STRIKEOUT;
+ break;
+ }
+}
+
+void GetDefaultFonts( SvxFontItem& rLatin, SvxFontItem& rAsian, SvxFontItem& rComplex )
+{
+ const sal_uInt16 nItemCnt = 3;
+
+ static struct
+ {
+ DefaultFontType nFontType;
+ LanguageType nLanguage;
+ }
+ const aOutTypeArr[ nItemCnt ] =
+ {
+ { DefaultFontType::LATIN_TEXT, LANGUAGE_ENGLISH_US },
+ { DefaultFontType::CJK_TEXT, LANGUAGE_ENGLISH_US },
+ { DefaultFontType::CTL_TEXT, LANGUAGE_ARABIC_SAUDI_ARABIA }
+ };
+
+ SvxFontItem* aItemArr[ nItemCnt ] = { &rLatin, &rAsian, &rComplex };
+
+ for ( sal_uInt16 n = 0; n < nItemCnt; ++n )
+ {
+ vcl::Font aFont( OutputDevice::GetDefaultFont( aOutTypeArr[ n ].nFontType,
+ aOutTypeArr[ n ].nLanguage,
+ GetDefaultFontFlags::OnlyOne ) );
+ SvxFontItem* pItem = aItemArr[ n ];
+ pItem->SetFamily( aFont.GetFamilyType() );
+ pItem->SetFamilyName( aFont.GetFamilyName() );
+ pItem->SetStyleName( OUString() );
+ pItem->SetPitch( aFont.GetPitch());
+ pItem->SetCharSet(aFont.GetCharSet());
+ }
+}
+
+
+bool SvxRsidItem::QueryValue( uno::Any& rVal, sal_uInt8 ) const
+{
+ rVal <<= GetValue();
+ return true;
+}
+
+bool SvxRsidItem::PutValue( const uno::Any& rVal, sal_uInt8 )
+{
+ sal_uInt32 nRsid = 0;
+ if( !( rVal >>= nRsid ) )
+ return false;
+
+ SetValue( nRsid );
+ return true;
+}
+
+SvxRsidItem* SvxRsidItem::Clone( SfxItemPool * ) const
+{
+ return new SvxRsidItem( *this );
+}
+
+bool SvxRsidItem::GetPresentation
+(
+ SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreUnit*/,
+ MapUnit /*ePresUnit*/,
+ OUString& rText, const IntlWrapper& /*rIntl*/
+) const
+{
+ rText.clear();
+ return false;
+}
+
+void SvxRsidItem::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+ xmlTextWriterStartElement(pWriter, BAD_CAST("SvxRsidItem"));
+ xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("whichId"), "%d", Which());
+ xmlTextWriterWriteFormatAttribute(pWriter, BAD_CAST("value"), "%" SAL_PRIuUINT32, GetValue());
+ xmlTextWriterEndElement(pWriter);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/items/writingmodeitem.cxx b/editeng/source/items/writingmodeitem.cxx
new file mode 100644
index 000000000..252c8c055
--- /dev/null
+++ b/editeng/source/items/writingmodeitem.cxx
@@ -0,0 +1,94 @@
+/* -*- 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 <editeng/writingmodeitem.hxx>
+#include <editeng/frmdir.hxx>
+#include <editeng/eerdll.hxx>
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::text;
+
+
+SvxWritingModeItem::SvxWritingModeItem( WritingMode eValue, sal_uInt16 _nWhich )
+ : SfxUInt16Item( _nWhich, static_cast<sal_uInt16>(eValue) )
+{
+}
+
+SvxWritingModeItem::~SvxWritingModeItem()
+{
+}
+
+SvxWritingModeItem* SvxWritingModeItem::Clone( SfxItemPool * ) const
+{
+ return new SvxWritingModeItem( *this );
+}
+
+bool SvxWritingModeItem::GetPresentation( SfxItemPresentation /*ePres*/,
+ MapUnit /*eCoreMetric*/,
+ MapUnit /*ePresMetric*/,
+ OUString &rText,
+ const IntlWrapper& ) const
+{
+ rText = EditResId(getFrmDirResId(static_cast<int>(GetValue())));
+ return true;
+}
+
+bool SvxWritingModeItem::PutValue( const css::uno::Any& rVal, sal_uInt8 )
+{
+ sal_Int32 nVal = 0;
+ bool bRet = ( rVal >>= nVal );
+
+ if( !bRet )
+ {
+ WritingMode eMode;
+ bRet = rVal >>= eMode;
+
+ if( bRet )
+ {
+ nVal = static_cast<sal_Int32>(eMode);
+ }
+ }
+
+ if( bRet )
+ {
+ switch( static_cast<WritingMode>(nVal) )
+ {
+ case WritingMode_LR_TB:
+ case WritingMode_RL_TB:
+ case WritingMode_TB_RL:
+ SetValue( static_cast<sal_uInt16>(nVal) );
+ bRet = true;
+ break;
+ default:
+ bRet = false;
+ break;
+ }
+ }
+
+ return bRet;
+}
+
+bool SvxWritingModeItem::QueryValue( css::uno::Any& rVal,
+ sal_uInt8 ) const
+{
+ rVal <<= GetValue();
+ return true;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/items/xmlcnitm.cxx b/editeng/source/items/xmlcnitm.cxx
new file mode 100644
index 000000000..5ee7c47e8
--- /dev/null
+++ b/editeng/source/items/xmlcnitm.cxx
@@ -0,0 +1,211 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <memory>
+#include <com/sun/star/xml/AttributeData.hpp>
+#include <com/sun/star/lang/XUnoTunnel.hpp>
+#include <o3tl/any.hxx>
+#include <xmloff/xmlcnimp.hxx>
+#include <xmloff/unoatrcn.hxx>
+#include <editeng/xmlcnitm.hxx>
+#include <tools/solar.h>
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::xml;
+
+
+SvXMLAttrContainerItem::SvXMLAttrContainerItem( sal_uInt16 _nWhich ) :
+ SfxPoolItem( _nWhich ),
+ pImpl( new SvXMLAttrContainerData )
+{
+}
+
+SvXMLAttrContainerItem::SvXMLAttrContainerItem(
+ const SvXMLAttrContainerItem& rItem ) :
+ SfxPoolItem( rItem ),
+ pImpl( new SvXMLAttrContainerData( *rItem.pImpl ) )
+{
+}
+
+SvXMLAttrContainerItem::~SvXMLAttrContainerItem()
+{
+}
+
+bool SvXMLAttrContainerItem::operator==( const SfxPoolItem& rItem ) const
+{
+ return SfxPoolItem::operator==(rItem) &&
+ *pImpl == *static_cast<const SvXMLAttrContainerItem&>(rItem).pImpl;
+}
+
+bool SvXMLAttrContainerItem::GetPresentation(
+ SfxItemPresentation /*ePresentation*/,
+ MapUnit /*eCoreMetric*/,
+ MapUnit /*ePresentationMetric*/,
+ OUString & /*rText*/,
+ const IntlWrapper& /*rIntlWrapper*/ ) const
+{
+ return false;
+}
+
+bool SvXMLAttrContainerItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
+{
+ Reference<XNameContainer> xContainer
+ = new SvUnoAttributeContainer(std::make_unique<SvXMLAttrContainerData>(*pImpl));
+
+ rVal <<= xContainer;
+ return true;
+}
+
+bool SvXMLAttrContainerItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
+{
+ SvUnoAttributeContainer* pContainer = nullptr;
+
+ Reference<XUnoTunnel> xTunnel(rVal, UNO_QUERY);
+ if( xTunnel.is() )
+ pContainer = reinterpret_cast<SvUnoAttributeContainer*>(static_cast<sal_uLong>(xTunnel->getSomething(SvUnoAttributeContainer::getUnoTunnelId())));
+
+ if( pContainer )
+ {
+ pImpl.reset( new SvXMLAttrContainerData( * pContainer->GetContainerImpl() ) );
+ }
+ else
+ {
+ std::unique_ptr<SvXMLAttrContainerData> pNewImpl(new SvXMLAttrContainerData);
+
+ try
+ {
+ Reference<XNameContainer> xContainer( rVal, UNO_QUERY );
+ if( !xContainer.is() )
+ return false;
+
+ const Sequence< OUString > aNameSequence( xContainer->getElementNames() );
+ const OUString* pNames = aNameSequence.getConstArray();
+ const sal_Int32 nCount = aNameSequence.getLength();
+ Any aAny;
+ sal_Int32 nAttr;
+
+ for( nAttr = 0; nAttr < nCount; nAttr++ )
+ {
+ const OUString aName( *pNames++ );
+
+ aAny = xContainer->getByName( aName );
+ auto pData = o3tl::tryAccess<AttributeData>(aAny);
+ if( !pData )
+ return false;
+
+ sal_Int32 pos = aName.indexOf( ':' );
+ if( pos != -1 )
+ {
+ const OUString aPrefix( aName.copy( 0, pos ));
+ const OUString aLName( aName.copy( pos+1 ));
+
+ if( pData->Namespace.isEmpty() )
+ {
+ if( !pNewImpl->AddAttr( aPrefix, aLName, pData->Value ) )
+ break;
+ }
+ else
+ {
+ if( !pNewImpl->AddAttr( aPrefix, pData->Namespace, aLName, pData->Value ) )
+ break;
+ }
+ }
+ else
+ {
+ if( !pNewImpl->AddAttr( aName, pData->Value ) )
+ break;
+ }
+ }
+
+ if( nAttr == nCount )
+ pImpl = std::move(pNewImpl);
+ else
+ return false;
+ }
+ catch(...)
+ {
+ return false;
+ }
+ }
+ return true;
+}
+
+
+bool SvXMLAttrContainerItem::AddAttr( const OUString& rLName,
+ const OUString& rValue )
+{
+ return pImpl->AddAttr( rLName, rValue );
+}
+
+bool SvXMLAttrContainerItem::AddAttr( const OUString& rPrefix,
+ const OUString& rNamespace, const OUString& rLName,
+ const OUString& rValue )
+{
+ return pImpl->AddAttr( rPrefix, rNamespace, rLName, rValue );
+}
+
+sal_uInt16 SvXMLAttrContainerItem::GetAttrCount() const
+{
+ return static_cast<sal_uInt16>(pImpl->GetAttrCount());
+}
+
+OUString SvXMLAttrContainerItem::GetAttrNamespace( sal_uInt16 i ) const
+{
+ return pImpl->GetAttrNamespace( i );
+}
+
+OUString SvXMLAttrContainerItem::GetAttrPrefix( sal_uInt16 i ) const
+{
+ return pImpl->GetAttrPrefix( i );
+}
+
+const OUString& SvXMLAttrContainerItem::GetAttrLName( sal_uInt16 i ) const
+{
+ return pImpl->GetAttrLName( i );
+}
+
+const OUString& SvXMLAttrContainerItem::GetAttrValue( sal_uInt16 i ) const
+{
+ return pImpl->GetAttrValue( i );
+}
+
+
+sal_uInt16 SvXMLAttrContainerItem::GetFirstNamespaceIndex() const
+{
+ return pImpl->GetFirstNamespaceIndex();
+}
+
+sal_uInt16 SvXMLAttrContainerItem::GetNextNamespaceIndex( sal_uInt16 nIdx ) const
+{
+ return pImpl->GetNextNamespaceIndex( nIdx );
+}
+
+const OUString& SvXMLAttrContainerItem::GetNamespace( sal_uInt16 i ) const
+{
+ return pImpl->GetNamespace( i );
+}
+
+const OUString& SvXMLAttrContainerItem::GetPrefix( sal_uInt16 i ) const
+{
+ return pImpl->GetPrefix( i );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-27 14:14:28 +0000