summaryrefslogtreecommitdiffstats
path: root/xmloff/source/text/txtimppr.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'xmloff/source/text/txtimppr.cxx')
-rw-r--r--xmloff/source/text/txtimppr.cxx848
1 files changed, 848 insertions, 0 deletions
diff --git a/xmloff/source/text/txtimppr.cxx b/xmloff/source/text/txtimppr.cxx
new file mode 100644
index 000000000..dcf9d1d3e
--- /dev/null
+++ b/xmloff/source/text/txtimppr.cxx
@@ -0,0 +1,848 @@
+/* -*- 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 <sal/config.h>
+
+#include <o3tl/any.hxx>
+#include <osl/thread.h>
+#include <com/sun/star/awt/FontFamily.hpp>
+#include <com/sun/star/awt/FontPitch.hpp>
+#include <com/sun/star/drawing/FillStyle.hpp>
+#include <com/sun/star/table/BorderLine2.hpp>
+#include <com/sun/star/text/VertOrientation.hpp>
+#include <com/sun/star/text/SizeType.hpp>
+#include <xmloff/XMLFontStylesContext.hxx>
+#include <xmloff/txtprmap.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/txtimppr.hxx>
+#include <xmloff/maptype.hxx>
+
+#define XML_LINE_LEFT 0
+#define XML_LINE_RIGHT 1
+#define XML_LINE_TOP 2
+#define XML_LINE_BOTTOM 3
+
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::table;
+using namespace ::com::sun::star::text;
+
+bool XMLTextImportPropertyMapper::handleSpecialItem(
+ XMLPropertyState& rProperty,
+ ::std::vector< XMLPropertyState >& rProperties,
+ const OUString& rValue,
+ const SvXMLUnitConverter& rUnitConverter,
+ const SvXMLNamespaceMap& rNamespaceMap ) const
+{
+ bool bRet = false;
+ sal_Int32 nIndex = rProperty.mnIndex;
+ switch( getPropertySetMapper()->GetEntryContextId( nIndex ) )
+ {
+ case CTF_FONTNAME:
+ case CTF_FONTNAME_CJK:
+ case CTF_FONTNAME_CTL:
+ if( GetImport().GetFontDecls() != nullptr )
+ {
+ assert((
+ ( CTF_FONTFAMILYNAME ==
+ getPropertySetMapper()->GetEntryContextId(nIndex+1) &&
+ CTF_FONTSTYLENAME ==
+ getPropertySetMapper()->GetEntryContextId(nIndex+2) &&
+ CTF_FONTFAMILY ==
+ getPropertySetMapper()->GetEntryContextId(nIndex+3) &&
+ CTF_FONTPITCH ==
+ getPropertySetMapper()->GetEntryContextId(nIndex+4) &&
+ CTF_FONTCHARSET ==
+ getPropertySetMapper()->GetEntryContextId(nIndex+5) ) ||
+ ( CTF_FONTFAMILYNAME_CJK ==
+ getPropertySetMapper()->GetEntryContextId(nIndex+1) &&
+ CTF_FONTSTYLENAME_CJK ==
+ getPropertySetMapper()->GetEntryContextId(nIndex+2) &&
+ CTF_FONTFAMILY_CJK ==
+ getPropertySetMapper()->GetEntryContextId(nIndex+3) &&
+ CTF_FONTPITCH_CJK ==
+ getPropertySetMapper()->GetEntryContextId(nIndex+4) &&
+ CTF_FONTCHARSET_CJK ==
+ getPropertySetMapper()->GetEntryContextId(nIndex+5) ) ||
+ ( CTF_FONTFAMILYNAME_CTL ==
+ getPropertySetMapper()->GetEntryContextId(nIndex+1) &&
+ CTF_FONTSTYLENAME_CTL ==
+ getPropertySetMapper()->GetEntryContextId(nIndex+2) &&
+ CTF_FONTFAMILY_CTL ==
+ getPropertySetMapper()->GetEntryContextId(nIndex+3) &&
+ CTF_FONTPITCH_CTL ==
+ getPropertySetMapper()->GetEntryContextId(nIndex+4) &&
+ CTF_FONTCHARSET_CTL ==
+ getPropertySetMapper()->GetEntryContextId(nIndex+5) )
+ ) && "illegal property map" );
+
+ GetImport().GetFontDecls()->FillProperties(
+ rValue, rProperties,
+ rProperty.mnIndex+1, rProperty.mnIndex+2,
+ rProperty.mnIndex+3, rProperty.mnIndex+4,
+ rProperty.mnIndex+5 );
+ bRet = false; // the property hasn't been filled
+ }
+ break;
+
+ // If we want to do StarMath/StarSymbol font conversion, then we'll
+ // want these special items to be treated just like regular ones...
+ // For the Writer, we'll catch and convert them in _FillPropertySet;
+ // the other apps probably don't care. For the other apps, we just
+ // imitate the default non-special-item mechanism.
+ case CTF_FONTFAMILYNAME:
+ case CTF_FONTFAMILYNAME_CJK:
+ case CTF_FONTFAMILYNAME_CTL:
+ bRet = getPropertySetMapper()->importXML( rValue, rProperty,
+ rUnitConverter );
+ break;
+
+ case CTF_TEXT_DISPLAY:
+ bRet = getPropertySetMapper()->importXML( rValue, rProperty,
+ rUnitConverter );
+ if( SvXMLImport::OOo_2x == GetImport().getGeneratorVersion() )
+ {
+ bool bHidden = false;
+ rProperty.maValue >>= bHidden;
+ bHidden = !bHidden;
+ rProperty.maValue <<= bHidden;
+ }
+ break;
+ default:
+ bRet = SvXMLImportPropertyMapper::handleSpecialItem( rProperty,
+ rProperties, rValue, rUnitConverter, rNamespaceMap );
+ break;
+ }
+
+ return bRet;
+}
+
+XMLTextImportPropertyMapper::XMLTextImportPropertyMapper(
+ const rtl::Reference< XMLPropertySetMapper >& rMapper,
+ SvXMLImport& rImp ) :
+ SvXMLImportPropertyMapper( rMapper, rImp ),
+ nSizeTypeIndex( -2 ),
+ nWidthTypeIndex( -2 )
+{
+}
+
+XMLTextImportPropertyMapper::~XMLTextImportPropertyMapper()
+{
+}
+
+void XMLTextImportPropertyMapper::FontFinished(
+ XMLPropertyState *pFontFamilyNameState,
+ XMLPropertyState *pFontStyleNameState,
+ XMLPropertyState *pFontFamilyState,
+ XMLPropertyState *pFontPitchState,
+ XMLPropertyState *pFontCharsetState )
+{
+ if( pFontFamilyNameState && pFontFamilyNameState->mnIndex != -1 )
+ {
+ OUString sName;
+ pFontFamilyNameState->maValue >>= sName;
+ if( sName.isEmpty() )
+ pFontFamilyNameState->mnIndex = -1;
+ }
+ if( !pFontFamilyNameState || pFontFamilyNameState->mnIndex == -1 )
+ {
+ if( pFontStyleNameState )
+ pFontStyleNameState->mnIndex = -1;
+ if( pFontFamilyState )
+ pFontFamilyState->mnIndex = -1;
+ if( pFontPitchState )
+ pFontPitchState->mnIndex = -1;
+ if( pFontCharsetState )
+ pFontCharsetState->mnIndex = -1;
+ }
+}
+
+/** since the properties "CharFontFamilyName", "CharFontStyleName", "CharFontFamily",
+ "CharFontPitch" and "CharFontSet" and their CJK and CTL counterparts are only
+ usable as a union, we add defaults to all values that are not set as long as we
+ have an "CharFontFamilyName"
+
+ #99928# CL */
+void XMLTextImportPropertyMapper::FontDefaultsCheck(
+ XMLPropertyState const * pFontFamilyName,
+ XMLPropertyState const * pFontStyleName,
+ XMLPropertyState const * pFontFamily,
+ XMLPropertyState const * pFontPitch,
+ XMLPropertyState const * pFontCharSet,
+ std::optional<XMLPropertyState>* ppNewFontStyleName,
+ std::optional<XMLPropertyState>* ppNewFontFamily,
+ std::optional<XMLPropertyState>* ppNewFontPitch,
+ std::optional<XMLPropertyState>* ppNewFontCharSet ) const
+{
+ if( pFontFamilyName )
+ {
+ Any aAny;
+
+ if( !pFontStyleName )
+ {
+ aAny <<= OUString();
+ #if OSL_DEBUG_LEVEL > 0 && !defined NDEBUG
+ sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
+ pFontFamilyName->mnIndex + 1 );
+ assert(nTmp == CTF_FONTSTYLENAME || nTmp == CTF_FONTSTYLENAME_CJK || nTmp == CTF_FONTSTYLENAME_CTL);
+ #endif
+ ppNewFontStyleName->emplace( pFontFamilyName->mnIndex + 1, aAny );
+ }
+
+ if( !pFontFamily )
+ {
+ aAny <<= sal_Int16(css::awt::FontFamily::DONTKNOW);
+
+ #if OSL_DEBUG_LEVEL > 0 && !defined NDEBUG
+ sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
+ pFontFamilyName->mnIndex + 2 );
+ assert(nTmp == CTF_FONTFAMILY || nTmp == CTF_FONTFAMILY_CJK || nTmp == CTF_FONTFAMILY_CTL);
+ #endif
+ ppNewFontFamily->emplace( pFontFamilyName->mnIndex + 2, aAny );
+ }
+
+ if( !pFontPitch )
+ {
+ aAny <<= sal_Int16(css::awt::FontPitch::DONTKNOW);
+ #if OSL_DEBUG_LEVEL > 0 && !defined NDEBUG
+ sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
+ pFontFamilyName->mnIndex + 3 );
+ assert(nTmp == CTF_FONTPITCH || nTmp == CTF_FONTPITCH_CJK || nTmp == CTF_FONTPITCH_CTL);
+ #endif
+ ppNewFontPitch->emplace( pFontFamilyName->mnIndex + 3, aAny );
+ }
+
+ if( !pFontCharSet )
+ {
+ aAny <<= static_cast<sal_Int16>(osl_getThreadTextEncoding());
+ #if OSL_DEBUG_LEVEL > 0 && !defined NDEBUG
+ sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
+ pFontFamilyName->mnIndex + 4 );
+ assert(nTmp == CTF_FONTCHARSET || nTmp == CTF_FONTCHARSET_CJK || nTmp == CTF_FONTCHARSET_CTL);
+ #endif
+ ppNewFontCharSet->emplace( pFontFamilyName->mnIndex + 4, aAny );
+ }
+ }
+
+ (void) this; // avoid loplugin:staticmethods
+}
+
+namespace {
+//fdo#58730 The [UL|LR]Space class has a deficiency where "100%" also serves as
+//a flag that the value is an absolute value so we can't truly handle an
+//up/lower space property which wants to specify its 200% upper but 100% lower
+//of its parent (try typing 100% vs 200% into the edit style dialog and revisit
+//your style). So on xml load that ends up meaning 200%, 0 lower. This is a
+//crock.
+
+//On import clear 100% all-margins relative sizes.
+bool
+isNotDefaultRelSize(const XMLPropertyState* pRelState, const rtl::Reference<XMLPropertySetMapper>& rPrMap)
+{
+ if (rPrMap->GetEntryContextId(pRelState->mnIndex) == CTF_PARAMARGINALL_REL)
+ {
+ sal_Int32 nTemp = 0;
+ pRelState->maValue >>= nTemp;
+ return nTemp != 100;
+ }
+ return true;
+}
+
+/**
+ * Separate compressed border attributes.
+ * During export, border attributes are compressed if there are equal to all four side.
+ * Since Writer hasn't the same compressed attributes, but has distinct ones for all
+ * four side, we have to duplicate the compressed attribute during import.
+**/
+void lcl_SeparateBorder(
+ sal_uInt16 nIndex, XMLPropertyState const * pAllBorderDistance,
+ XMLPropertyState* pBorderDistances[4], XMLPropertyState* pNewBorderDistances[4],
+ XMLPropertyState const * pAllBorder, XMLPropertyState* pBorders[4],
+ XMLPropertyState* pNewBorders[4], XMLPropertyState* pAllBorderWidth,
+ XMLPropertyState* pBorderWidths[4]
+#if OSL_DEBUG_LEVEL > 0 && !defined NDEBUG
+ , const rtl::Reference< XMLPropertySetMapper >& rMapper
+#endif
+)
+{
+ if( pAllBorderDistance && !pBorderDistances[nIndex] )
+ {
+#if OSL_DEBUG_LEVEL > 0 && !defined NDEBUG
+ sal_Int16 nTmp = rMapper->GetEntryContextId(
+ pAllBorderDistance->mnIndex + nIndex + 1 );
+ if (CTF_CHARALLBORDERDISTANCE ==
+ rMapper->GetEntryContextId(pAllBorderDistance->mnIndex))
+ {
+ assert(nTmp >= CTF_CHARLEFTBORDERDISTANCE &&
+ nTmp <= CTF_CHARBOTTOMBORDERDISTANCE);
+ }
+ else
+ {
+ assert(nTmp >= CTF_LEFTBORDERDISTANCE &&
+ nTmp <= CTF_BOTTOMBORDERDISTANCE);
+ }
+#endif
+ pNewBorderDistances[nIndex] =
+ new XMLPropertyState( pAllBorderDistance->mnIndex + nIndex + 1,
+ pAllBorderDistance->maValue );
+ pBorderDistances[nIndex] = pNewBorderDistances[nIndex];
+ }
+ if( pAllBorder && !pBorders[nIndex] )
+ {
+#if OSL_DEBUG_LEVEL > 0 && !defined NDEBUG
+ sal_Int16 nTmp = rMapper->GetEntryContextId(
+ pAllBorder->mnIndex + nIndex + 1 );
+ if (CTF_CHARALLBORDER ==
+ rMapper->GetEntryContextId(pAllBorder->mnIndex))
+ {
+ assert(nTmp >= CTF_CHARLEFTBORDER && nTmp <= CTF_CHARBOTTOMBORDER);
+ }
+ else
+ {
+ assert(nTmp >= CTF_LEFTBORDER && nTmp <= CTF_BOTTOMBORDER);
+ }
+#endif
+ pNewBorders[nIndex] = new XMLPropertyState( pAllBorder->mnIndex + nIndex + 1,
+ pAllBorder->maValue );
+ pBorders[nIndex] = pNewBorders[nIndex];
+ }
+ if( !pBorderWidths[nIndex] )
+ pBorderWidths[nIndex] = pAllBorderWidth;
+ else
+ pBorderWidths[nIndex]->mnIndex = -1;
+
+ if( !(pBorders[nIndex] && pBorderWidths[nIndex]) )
+ return;
+
+ table::BorderLine2 aBorderLine;
+ pBorders[nIndex]->maValue >>= aBorderLine;
+
+ table::BorderLine2 aBorderLineWidth;
+ pBorderWidths[nIndex]->maValue >>= aBorderLineWidth;
+
+ aBorderLine.OuterLineWidth = aBorderLineWidth.OuterLineWidth;
+ aBorderLine.InnerLineWidth = aBorderLineWidth.InnerLineWidth;
+ aBorderLine.LineDistance = aBorderLineWidth.LineDistance;
+ aBorderLine.LineWidth = aBorderLineWidth.LineWidth;
+
+ pBorders[nIndex]->maValue <<= aBorderLine;
+}
+
+}
+
+void XMLTextImportPropertyMapper::finished(
+ ::std::vector< XMLPropertyState >& rProperties,
+ sal_Int32 /*nStartIndex*/, sal_Int32 /*nEndIndex*/ ) const
+{
+ bool bHasAnyHeight = false;
+ bool bHasAnyMinHeight = false;
+ bool bHasAnyWidth = false;
+ bool bHasAnyMinWidth = false;
+
+ XMLPropertyState* pFontFamilyName = nullptr;
+ XMLPropertyState* pFontStyleName = nullptr;
+ XMLPropertyState* pFontFamily = nullptr;
+ XMLPropertyState* pFontPitch = nullptr;
+ XMLPropertyState* pFontCharSet = nullptr;
+ std::optional<XMLPropertyState> pNewFontStyleName;
+ std::optional<XMLPropertyState> pNewFontFamily;
+ std::optional<XMLPropertyState> pNewFontPitch;
+ std::optional<XMLPropertyState> pNewFontCharSet;
+ XMLPropertyState* pFontFamilyNameCJK = nullptr;
+ XMLPropertyState* pFontStyleNameCJK = nullptr;
+ XMLPropertyState* pFontFamilyCJK = nullptr;
+ XMLPropertyState* pFontPitchCJK = nullptr;
+ XMLPropertyState* pFontCharSetCJK = nullptr;
+ std::optional<XMLPropertyState> pNewFontStyleNameCJK;
+ std::optional<XMLPropertyState> pNewFontFamilyCJK;
+ std::optional<XMLPropertyState> pNewFontPitchCJK;
+ std::optional<XMLPropertyState> pNewFontCharSetCJK;
+ XMLPropertyState* pFontFamilyNameCTL = nullptr;
+ XMLPropertyState* pFontStyleNameCTL = nullptr;
+ XMLPropertyState* pFontFamilyCTL = nullptr;
+ XMLPropertyState* pFontPitchCTL = nullptr;
+ XMLPropertyState* pFontCharSetCTL = nullptr;
+ std::optional<XMLPropertyState> pNewFontStyleNameCTL;
+ std::optional<XMLPropertyState> pNewFontFamilyCTL;
+ std::optional<XMLPropertyState> pNewFontPitchCTL;
+ std::optional<XMLPropertyState> pNewFontCharSetCTL;
+ XMLPropertyState* pAllBorderDistance = nullptr;
+ XMLPropertyState* pBorderDistances[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pNewBorderDistances[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pAllBorder = nullptr;
+ XMLPropertyState* pBorders[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pNewBorders[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pAllBorderWidth = nullptr;
+ XMLPropertyState* pBorderWidths[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pCharAllBorderDistance = nullptr;
+ XMLPropertyState* pCharBorderDistances[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pCharNewBorderDistances[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pCharAllBorder = nullptr;
+ XMLPropertyState* pCharBorders[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pCharNewBorders[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pCharAllBorderWidth = nullptr;
+ XMLPropertyState* pCharBorderWidths[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pVertOrient = nullptr;
+ XMLPropertyState* pVertOrientRelAsChar = nullptr;
+ XMLPropertyState* pBackTransparency = nullptr; // transparency in %
+ XMLPropertyState* pBackTransparent = nullptr; // transparency as boolean
+ XMLPropertyState* pAllParaMargin = nullptr;
+ XMLPropertyState* pParaMargins[4] = { nullptr, nullptr, nullptr, nullptr };
+ ::std::optional<XMLPropertyState> pNewParaMargins[4];
+ XMLPropertyState* pAllMargin = nullptr;
+ XMLPropertyState* pMargins[4] = { nullptr, nullptr, nullptr, nullptr };
+ ::std::optional<XMLPropertyState> pNewMargins[4];
+ XMLPropertyState* pFillStyle(nullptr);
+ XMLPropertyState* pFillColor(nullptr);
+
+ for( auto& rProperty : rProperties )
+ {
+ XMLPropertyState* property = &rProperty;
+ if( -1 == property->mnIndex )
+ continue;
+
+ switch( getPropertySetMapper()->GetEntryContextId( property->mnIndex ) )
+ {
+ case CTF_FONTFAMILYNAME: pFontFamilyName = property; break;
+ case CTF_FONTSTYLENAME: pFontStyleName = property; break;
+ case CTF_FONTFAMILY: pFontFamily = property; break;
+ case CTF_FONTPITCH: pFontPitch = property; break;
+ case CTF_FONTCHARSET: pFontCharSet = property; break;
+
+ case CTF_FONTFAMILYNAME_CJK: pFontFamilyNameCJK = property; break;
+ case CTF_FONTSTYLENAME_CJK: pFontStyleNameCJK = property; break;
+ case CTF_FONTFAMILY_CJK: pFontFamilyCJK = property; break;
+ case CTF_FONTPITCH_CJK: pFontPitchCJK = property; break;
+ case CTF_FONTCHARSET_CJK: pFontCharSetCJK = property; break;
+
+ case CTF_FONTFAMILYNAME_CTL: pFontFamilyNameCTL = property; break;
+ case CTF_FONTSTYLENAME_CTL: pFontStyleNameCTL = property; break;
+ case CTF_FONTFAMILY_CTL: pFontFamilyCTL = property; break;
+ case CTF_FONTPITCH_CTL: pFontPitchCTL = property; break;
+ case CTF_FONTCHARSET_CTL: pFontCharSetCTL = property; break;
+
+ case CTF_ALLBORDERDISTANCE: pAllBorderDistance = property; break;
+ case CTF_LEFTBORDERDISTANCE: pBorderDistances[XML_LINE_LEFT] = property; break;
+ case CTF_RIGHTBORDERDISTANCE: pBorderDistances[XML_LINE_RIGHT] = property; break;
+ case CTF_TOPBORDERDISTANCE: pBorderDistances[XML_LINE_TOP] = property; break;
+ case CTF_BOTTOMBORDERDISTANCE: pBorderDistances[XML_LINE_BOTTOM] = property; break;
+ case CTF_ALLBORDER: pAllBorder = property; break;
+ case CTF_LEFTBORDER: pBorders[XML_LINE_LEFT] = property; break;
+ case CTF_RIGHTBORDER: pBorders[XML_LINE_RIGHT] = property; break;
+ case CTF_TOPBORDER: pBorders[XML_LINE_TOP] = property; break;
+ case CTF_BOTTOMBORDER: pBorders[XML_LINE_BOTTOM] = property; break;
+ case CTF_ALLBORDERWIDTH: pAllBorderWidth = property; break;
+ case CTF_LEFTBORDERWIDTH: pBorderWidths[XML_LINE_LEFT] = property; break;
+ case CTF_RIGHTBORDERWIDTH: pBorderWidths[XML_LINE_RIGHT] = property; break;
+ case CTF_TOPBORDERWIDTH: pBorderWidths[XML_LINE_TOP] = property; break;
+ case CTF_BOTTOMBORDERWIDTH: pBorderWidths[XML_LINE_BOTTOM] = property; break;
+
+ case CTF_CHARALLBORDERDISTANCE: pCharAllBorderDistance = property; break;
+ case CTF_CHARLEFTBORDERDISTANCE: pCharBorderDistances[XML_LINE_LEFT] = property; break;
+ case CTF_CHARRIGHTBORDERDISTANCE: pCharBorderDistances[XML_LINE_RIGHT] = property; break;
+ case CTF_CHARTOPBORDERDISTANCE: pCharBorderDistances[XML_LINE_TOP] = property; break;
+ case CTF_CHARBOTTOMBORDERDISTANCE: pCharBorderDistances[XML_LINE_BOTTOM] = property; break;
+ case CTF_CHARALLBORDER: pCharAllBorder = property; break;
+ case CTF_CHARLEFTBORDER: pCharBorders[XML_LINE_LEFT] = property; break;
+ case CTF_CHARRIGHTBORDER: pCharBorders[XML_LINE_RIGHT] = property; break;
+ case CTF_CHARTOPBORDER: pCharBorders[XML_LINE_TOP] = property; break;
+ case CTF_CHARBOTTOMBORDER: pCharBorders[XML_LINE_BOTTOM] = property; break;
+ case CTF_CHARALLBORDERWIDTH: pCharAllBorderWidth = property; break;
+ case CTF_CHARLEFTBORDERWIDTH: pCharBorderWidths[XML_LINE_LEFT] = property; break;
+ case CTF_CHARRIGHTBORDERWIDTH: pCharBorderWidths[XML_LINE_RIGHT] = property; break;
+ case CTF_CHARTOPBORDERWIDTH: pCharBorderWidths[XML_LINE_TOP] = property; break;
+ case CTF_CHARBOTTOMBORDERWIDTH: pCharBorderWidths[XML_LINE_BOTTOM] = property; break;
+
+ case CTF_ANCHORTYPE: break;
+ case CTF_VERTICALPOS: pVertOrient = property; break;
+ case CTF_VERTICALREL_ASCHAR: pVertOrientRelAsChar = property; break;
+
+ case CTF_FRAMEHEIGHT_MIN_ABS:
+ case CTF_FRAMEHEIGHT_MIN_REL:
+// case CTF_SYNCHEIGHT_MIN:
+ bHasAnyMinHeight = true;
+ [[fallthrough]];
+ case CTF_FRAMEHEIGHT_ABS:
+ case CTF_FRAMEHEIGHT_REL:
+// case CTF_SYNCHEIGHT:
+ bHasAnyHeight = true; break;
+ case CTF_FRAMEWIDTH_MIN_ABS:
+ case CTF_FRAMEWIDTH_MIN_REL:
+ bHasAnyMinWidth = true;
+ [[fallthrough]];
+ case CTF_FRAMEWIDTH_ABS:
+ case CTF_FRAMEWIDTH_REL:
+ bHasAnyWidth = true; break;
+ case CTF_BACKGROUND_TRANSPARENCY: pBackTransparency = property; break;
+ case CTF_BACKGROUND_TRANSPARENT: pBackTransparent = property; break;
+ case CTF_FILLSTYLE: pFillStyle = property; break;
+ case CTF_FILLCOLOR: pFillColor = property; break;
+ case CTF_PARAMARGINALL:
+ case CTF_PARAMARGINALL_REL:
+ pAllParaMargin = property; break;
+ case CTF_PARALEFTMARGIN:
+ case CTF_PARALEFTMARGIN_REL:
+ pParaMargins[XML_LINE_LEFT] = property; break;
+ case CTF_PARARIGHTMARGIN:
+ case CTF_PARARIGHTMARGIN_REL:
+ pParaMargins[XML_LINE_RIGHT] = property; break;
+ case CTF_PARATOPMARGIN:
+ case CTF_PARATOPMARGIN_REL:
+ pParaMargins[XML_LINE_TOP] = property; break;
+ case CTF_PARABOTTOMMARGIN:
+ case CTF_PARABOTTOMMARGIN_REL:
+ pParaMargins[XML_LINE_BOTTOM] = property; break;
+ case CTF_MARGINALL:
+ pAllMargin = property; break;
+ case CTF_MARGINLEFT:
+ pMargins[XML_LINE_LEFT] = property; break;
+ case CTF_MARGINRIGHT:
+ pMargins[XML_LINE_RIGHT] = property; break;
+ case CTF_MARGINTOP:
+ pMargins[XML_LINE_TOP] = property; break;
+ case CTF_MARGINBOTTOM:
+ pMargins[XML_LINE_BOTTOM] = property; break;
+ }
+ }
+
+ if( pFontFamilyName || pFontStyleName || pFontFamily ||
+ pFontPitch || pFontCharSet )
+ FontFinished( pFontFamilyName, pFontStyleName, pFontFamily,
+ pFontPitch, pFontCharSet );
+ if( pFontFamilyNameCJK || pFontStyleNameCJK || pFontFamilyCJK ||
+ pFontPitchCJK || pFontCharSetCJK )
+ FontFinished( pFontFamilyNameCJK, pFontStyleNameCJK, pFontFamilyCJK,
+ pFontPitchCJK, pFontCharSetCJK );
+ if( pFontFamilyNameCTL || pFontStyleNameCTL || pFontFamilyCTL ||
+ pFontPitchCTL || pFontCharSetCTL )
+ FontFinished( pFontFamilyNameCTL, pFontStyleNameCTL, pFontFamilyCTL,
+ pFontPitchCTL, pFontCharSetCTL );
+
+ for (sal_uInt16 i = 0; i < 4; i++)
+ {
+ if (pAllParaMargin && !pParaMargins[i]
+ && isNotDefaultRelSize(pAllParaMargin, getPropertySetMapper()))
+ {
+#if OSL_DEBUG_LEVEL > 0 && !defined NDEBUG
+ sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
+ pAllParaMargin->mnIndex + (2*i) + 2 );
+ assert(nTmp >= CTF_PARALEFTMARGIN &&
+ nTmp <= CTF_PARABOTTOMMARGIN_REL);
+#endif
+ pNewParaMargins[i].emplace(
+ pAllParaMargin->mnIndex + (2*i) + 2, pAllParaMargin->maValue);
+ }
+ if (pAllMargin && !pMargins[i])
+ {
+#if OSL_DEBUG_LEVEL > 0 && !defined NDEBUG
+ sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
+ pAllMargin->mnIndex + i + 1 );
+ assert(nTmp >= CTF_MARGINLEFT && nTmp <= CTF_MARGINBOTTOM);
+#endif
+ pNewMargins[i].emplace(
+ pAllMargin->mnIndex + i + 1, pAllMargin->maValue);
+ }
+
+ lcl_SeparateBorder(
+ i, pAllBorderDistance, pBorderDistances, pNewBorderDistances,
+ pAllBorder, pBorders, pNewBorders,
+ pAllBorderWidth, pBorderWidths
+#if OSL_DEBUG_LEVEL > 0 && !defined NDEBUG
+ , getPropertySetMapper()
+#endif
+ );
+
+ lcl_SeparateBorder(
+ i, pCharAllBorderDistance, pCharBorderDistances,
+ pCharNewBorderDistances, pCharAllBorder, pCharBorders,
+ pCharNewBorders, pCharAllBorderWidth, pCharBorderWidths
+#if OSL_DEBUG_LEVEL > 0 && !defined NDEBUG
+ , getPropertySetMapper()
+#endif
+ );
+ }
+
+ if (pAllParaMargin)
+ {
+ pAllParaMargin->mnIndex = -1;
+ }
+ if (pAllMargin)
+ {
+ pAllMargin->mnIndex = -1;
+ }
+
+ if( pAllBorderDistance )
+ pAllBorderDistance->mnIndex = -1;
+
+ if( pAllBorder )
+ pAllBorder->mnIndex = -1;
+
+ if( pAllBorderWidth )
+ pAllBorderWidth->mnIndex = -1;
+
+ if( pCharAllBorderDistance )
+ pCharAllBorderDistance->mnIndex = -1;
+
+ if( pCharAllBorder )
+ pCharAllBorder->mnIndex = -1;
+
+ if( pCharAllBorderWidth )
+ pCharAllBorderWidth->mnIndex = -1;
+
+ if( pVertOrient && pVertOrientRelAsChar )
+ {
+ sal_Int16 nVertOrient;
+ pVertOrient->maValue >>= nVertOrient;
+ sal_Int16 nVertOrientRel = 0;
+ pVertOrientRelAsChar->maValue >>= nVertOrientRel;
+ switch( nVertOrient )
+ {
+ case VertOrientation::TOP:
+ nVertOrient = nVertOrientRel;
+ break;
+ case VertOrientation::CENTER:
+ switch( nVertOrientRel )
+ {
+ case VertOrientation::CHAR_TOP:
+ nVertOrient = VertOrientation::CHAR_CENTER;
+ break;
+ case VertOrientation::LINE_TOP:
+ nVertOrient = VertOrientation::LINE_CENTER;
+ break;
+ }
+ break;
+ case VertOrientation::BOTTOM:
+ switch( nVertOrientRel )
+ {
+ case VertOrientation::CHAR_TOP:
+ nVertOrient = VertOrientation::CHAR_BOTTOM;
+ break;
+ case VertOrientation::LINE_TOP:
+ nVertOrient = VertOrientation::LINE_BOTTOM;
+ break;
+ }
+ break;
+ }
+ pVertOrient->maValue <<= nVertOrient;
+ pVertOrientRelAsChar->mnIndex = -1;
+ }
+
+ FontDefaultsCheck( pFontFamilyName,
+ pFontStyleName, pFontFamily, pFontPitch, pFontCharSet,
+ &pNewFontStyleName, &pNewFontFamily, &pNewFontPitch, &pNewFontCharSet );
+
+ FontDefaultsCheck( pFontFamilyNameCJK,
+ pFontStyleNameCJK, pFontFamilyCJK, pFontPitchCJK, pFontCharSetCJK,
+ &pNewFontStyleNameCJK, &pNewFontFamilyCJK, &pNewFontPitchCJK, &pNewFontCharSetCJK );
+
+ FontDefaultsCheck( pFontFamilyNameCTL,
+ pFontStyleNameCTL, pFontFamilyCTL, pFontPitchCTL, pFontCharSetCTL,
+ &pNewFontStyleNameCTL, &pNewFontFamilyCTL, &pNewFontPitchCTL, &pNewFontCharSetCTL );
+
+ if (pFillStyle && !pFillColor && pBackTransparent
+ && drawing::FillStyle_SOLID == pFillStyle->maValue.get<drawing::FillStyle>()
+ && pBackTransparent->maValue.get<bool>())
+ {
+ // fo:background="transparent", draw:fill="solid" without draw:fill-color
+ // prevent getSvxBrushItemFromSourceSet from adding bogus default color
+ pFillStyle->mnIndex = -1;
+ }
+
+ // #i5775# don't overwrite %transparency with binary transparency
+ if( ( pBackTransparency != nullptr ) && ( pBackTransparent != nullptr ) )
+ {
+ if( ! *o3tl::doAccess<bool>(pBackTransparent->maValue) )
+ pBackTransparent->mnIndex = -1;
+ }
+
+
+ // insert newly created properties. This invalidates all iterators!
+ // Most of the pXXX variables in this method are iterators and will be
+ // invalidated!!!
+
+ if( pNewFontStyleName )
+ {
+ rProperties.push_back( *pNewFontStyleName );
+ pNewFontStyleName.reset();
+ }
+
+ if( pNewFontFamily )
+ {
+ rProperties.push_back( *pNewFontFamily );
+ pNewFontFamily.reset();
+ }
+
+ if( pNewFontPitch )
+ {
+ rProperties.push_back( *pNewFontPitch );
+ pNewFontPitch.reset();
+ }
+
+ if( pNewFontCharSet )
+ {
+ rProperties.push_back( *pNewFontCharSet );
+ pNewFontCharSet.reset();
+ }
+
+ if( pNewFontStyleNameCJK )
+ {
+ rProperties.push_back( *pNewFontStyleNameCJK );
+ pNewFontStyleNameCJK.reset();
+ }
+
+ if( pNewFontFamilyCJK )
+ {
+ rProperties.push_back( *pNewFontFamilyCJK );
+ pNewFontFamilyCJK.reset();
+ }
+
+ if( pNewFontPitchCJK )
+ {
+ rProperties.push_back( *pNewFontPitchCJK );
+ pNewFontPitchCJK.reset();
+ }
+
+ if( pNewFontCharSetCJK )
+ {
+ rProperties.push_back( *pNewFontCharSetCJK );
+ pNewFontCharSetCJK.reset();
+ }
+
+ if( pNewFontStyleNameCTL)
+ {
+ rProperties.push_back( *pNewFontStyleNameCTL );
+ pNewFontStyleNameCTL.reset();
+ }
+
+ if( pNewFontFamilyCTL )
+ {
+ rProperties.push_back( *pNewFontFamilyCTL );
+ pNewFontFamilyCTL.reset();
+ }
+
+ if( pNewFontPitchCTL )
+ {
+ rProperties.push_back( *pNewFontPitchCTL );
+ pNewFontPitchCTL.reset();
+ }
+
+ if( pNewFontCharSetCTL )
+ {
+ rProperties.push_back( *pNewFontCharSetCTL );
+ pNewFontCharSetCTL.reset();
+ }
+
+ for (sal_uInt16 i=0; i<4; i++)
+ {
+ if (pNewParaMargins[i])
+ {
+ rProperties.push_back(*pNewParaMargins[i]);
+ }
+ if (pNewMargins[i])
+ {
+ rProperties.push_back(*pNewMargins[i]);
+ }
+ if( pNewBorderDistances[i] )
+ {
+ rProperties.push_back( *pNewBorderDistances[i] );
+ delete pNewBorderDistances[i];
+ }
+ if( pNewBorders[i] )
+ {
+ rProperties.push_back( *pNewBorders[i] );
+ delete pNewBorders[i];
+ }
+ if( pCharNewBorderDistances[i] )
+ {
+ rProperties.push_back( *pCharNewBorderDistances[i] );
+ delete pCharNewBorderDistances[i];
+ }
+ if( pCharNewBorders[i] )
+ {
+ rProperties.push_back( *pCharNewBorders[i] );
+ delete pCharNewBorders[i];
+ }
+ }
+
+ if( bHasAnyHeight )
+ {
+ if( nSizeTypeIndex == -2 )
+ {
+ const_cast < XMLTextImportPropertyMapper * > ( this )
+ ->nSizeTypeIndex = -1;
+ sal_Int32 nPropCount = getPropertySetMapper()->GetEntryCount();
+ for( sal_Int32 j=0; j < nPropCount; j++ )
+ {
+ if( CTF_SIZETYPE == getPropertySetMapper()
+ ->GetEntryContextId( j ) )
+ {
+ const_cast < XMLTextImportPropertyMapper * > ( this )
+ ->nSizeTypeIndex = j;
+ break;
+ }
+ }
+ }
+ if( nSizeTypeIndex != -1 )
+ {
+ XMLPropertyState aSizeTypeState( nSizeTypeIndex );
+ aSizeTypeState.maValue <<= static_cast<sal_Int16>( bHasAnyMinHeight
+ ? SizeType::MIN
+ : SizeType::FIX);
+ rProperties.push_back( aSizeTypeState );
+ }
+ }
+
+ if( !bHasAnyWidth )
+ return;
+
+ if( nWidthTypeIndex == -2 )
+ {
+ const_cast < XMLTextImportPropertyMapper * > ( this )
+ ->nWidthTypeIndex = -1;
+ sal_Int32 nCount = getPropertySetMapper()->GetEntryCount();
+ for( sal_Int32 j=0; j < nCount; j++ )
+ {
+ if( CTF_FRAMEWIDTH_TYPE == getPropertySetMapper()
+ ->GetEntryContextId( j ) )
+ {
+ const_cast < XMLTextImportPropertyMapper * > ( this )
+ ->nWidthTypeIndex = j;
+ break;
+ }
+ }
+ }
+ if( nWidthTypeIndex != -1 )
+ {
+ XMLPropertyState aSizeTypeState( nWidthTypeIndex );
+ aSizeTypeState.maValue <<= static_cast<sal_Int16>( bHasAnyMinWidth
+ ? SizeType::MIN
+ : SizeType::FIX);
+ rProperties.push_back( aSizeTypeState );
+ }
+
+ // DO NOT USE ITERATORS/POINTERS INTO THE rProperties-VECTOR AFTER
+ // THIS LINE. All iterators into the rProperties-vector, especially all
+ // pXXX-type variables set in the first switch statement of this method,
+ // may have been invalidated by the above push_back() calls!
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-11 07:06:03 +0000