summaryrefslogtreecommitdiffstats
path: root/xmloff/source/style
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--xmloff/source/style/AttributeContainerHandler.cxx86
-rw-r--r--xmloff/source/style/DashStyle.cxx275
-rw-r--r--xmloff/source/style/DrawAspectHdl.cxx61
-rw-r--r--xmloff/source/style/DrawAspectHdl.hxx36
-rw-r--r--xmloff/source/style/EnumPropertyHdl.cxx82
-rw-r--r--xmloff/source/style/FillStyleContext.cxx317
-rw-r--r--xmloff/source/style/FillStyleContext.hxx144
-rw-r--r--xmloff/source/style/GradientStyle.cxx238
-rw-r--r--xmloff/source/style/HatchStyle.cxx178
-rw-r--r--xmloff/source/style/ImageStyle.cxx135
-rw-r--r--xmloff/source/style/MarkerStyle.cxx193
-rw-r--r--xmloff/source/style/MultiPropertySetHelper.cxx169
-rw-r--r--xmloff/source/style/NamedBoolPropertyHdl.cxx67
-rw-r--r--xmloff/source/style/PageHeaderFooterContext.cxx71
-rw-r--r--xmloff/source/style/PageHeaderFooterContext.hxx48
-rw-r--r--xmloff/source/style/PageMasterExportPropMapper.cxx650
-rw-r--r--xmloff/source/style/PageMasterExportPropMapper.hxx66
-rw-r--r--xmloff/source/style/PageMasterImportContext.cxx434
-rw-r--r--xmloff/source/style/PageMasterImportPropMapper.cxx521
-rw-r--r--xmloff/source/style/PageMasterImportPropMapper.hxx53
-rw-r--r--xmloff/source/style/PageMasterPropHdl.cxx398
-rw-r--r--xmloff/source/style/PageMasterPropHdl.hxx158
-rw-r--r--xmloff/source/style/PageMasterPropHdlFactory.cxx170
-rw-r--r--xmloff/source/style/PageMasterPropMapper.cxx48
-rw-r--r--xmloff/source/style/PageMasterStyleMap.cxx305
-rw-r--r--xmloff/source/style/PagePropertySetContext.cxx119
-rw-r--r--xmloff/source/style/PagePropertySetContext.hxx54
-rw-r--r--xmloff/source/style/SinglePropertySetInfoCache.cxx54
-rw-r--r--xmloff/source/style/StyleMap.cxx32
-rw-r--r--xmloff/source/style/TransGradientStyle.cxx246
-rw-r--r--xmloff/source/style/WordWrapPropertyHdl.cxx88
-rw-r--r--xmloff/source/style/XMLBackgroundImageContext.cxx397
-rw-r--r--xmloff/source/style/XMLBackgroundImageExport.cxx165
-rw-r--r--xmloff/source/style/XMLBitmapLogicalSizePropertyHandler.cxx53
-rw-r--r--xmloff/source/style/XMLBitmapRepeatOffsetPropertyHandler.cxx94
-rw-r--r--xmloff/source/style/XMLClipPropertyHandler.cxx141
-rw-r--r--xmloff/source/style/XMLConstantsPropertyHandler.cxx91
-rw-r--r--xmloff/source/style/XMLElementPropertyContext.cxx44
-rw-r--r--xmloff/source/style/XMLFillBitmapSizePropertyHandler.cxx88
-rw-r--r--xmloff/source/style/XMLFontAutoStylePool.cxx680
-rw-r--r--xmloff/source/style/XMLFontStylesContext.cxx352
-rw-r--r--xmloff/source/style/XMLFontStylesContext_impl.hxx122
-rw-r--r--xmloff/source/style/XMLFootnoteSeparatorExport.cxx179
-rw-r--r--xmloff/source/style/XMLFootnoteSeparatorExport.hxx50
-rw-r--r--xmloff/source/style/XMLFootnoteSeparatorImport.cxx198
-rw-r--r--xmloff/source/style/XMLFootnoteSeparatorImport.hxx61
-rw-r--r--xmloff/source/style/XMLIsPercentagePropertyHandler.cxx50
-rw-r--r--xmloff/source/style/XMLPageExport.cxx319
-rw-r--r--xmloff/source/style/XMLPercentOrMeasurePropertyHandler.cxx75
-rw-r--r--xmloff/source/style/XMLRectangleMembersHandler.cxx112
-rw-r--r--xmloff/source/style/XMLRtlGutterPropertyHandler.cxx51
-rw-r--r--xmloff/source/style/adjushdl.cxx121
-rw-r--r--xmloff/source/style/adjushdl.hxx48
-rw-r--r--xmloff/source/style/backhdl.cxx285
-rw-r--r--xmloff/source/style/backhdl.hxx43
-rw-r--r--xmloff/source/style/bordrhdl.cxx351
-rw-r--r--xmloff/source/style/bordrhdl.hxx45
-rw-r--r--xmloff/source/style/breakhdl.cxx179
-rw-r--r--xmloff/source/style/breakhdl.hxx48
-rw-r--r--xmloff/source/style/cdouthdl.cxx305
-rw-r--r--xmloff/source/style/cdouthdl.hxx63
-rw-r--r--xmloff/source/style/chrhghdl.cxx150
-rw-r--r--xmloff/source/style/chrhghdl.hxx54
-rw-r--r--xmloff/source/style/chrlohdl.cxx423
-rw-r--r--xmloff/source/style/chrlohdl.hxx71
-rw-r--r--xmloff/source/style/csmaphdl.cxx120
-rw-r--r--xmloff/source/style/csmaphdl.hxx45
-rw-r--r--xmloff/source/style/durationhdl.cxx71
-rw-r--r--xmloff/source/style/durationhdl.hxx36
-rw-r--r--xmloff/source/style/escphdl.cxx156
-rw-r--r--xmloff/source/style/escphdl.hxx45
-rw-r--r--xmloff/source/style/fonthdl.cxx291
-rw-r--r--xmloff/source/style/fonthdl.hxx73
-rw-r--r--xmloff/source/style/impastpl.cxx716
-rw-r--r--xmloff/source/style/impastpl.hxx180
-rw-r--r--xmloff/source/style/kernihdl.cxx78
-rw-r--r--xmloff/source/style/kernihdl.hxx36
-rw-r--r--xmloff/source/style/lspachdl.cxx173
-rw-r--r--xmloff/source/style/lspachdl.hxx54
-rw-r--r--xmloff/source/style/numehelp.cxx510
-rw-r--r--xmloff/source/style/opaquhdl.cxx61
-rw-r--r--xmloff/source/style/opaquhdl.hxx36
-rw-r--r--xmloff/source/style/postuhdl.cxx81
-rw-r--r--xmloff/source/style/postuhdl.hxx36
-rw-r--r--xmloff/source/style/prhdlfac.cxx475
-rw-r--r--xmloff/source/style/prstylecond.cxx91
-rw-r--r--xmloff/source/style/prstylei.cxx664
-rw-r--r--xmloff/source/style/shadwhdl.cxx167
-rw-r--r--xmloff/source/style/shadwhdl.hxx36
-rw-r--r--xmloff/source/style/shdwdhdl.cxx67
-rw-r--r--xmloff/source/style/shdwdhdl.hxx36
-rw-r--r--xmloff/source/style/styleexp.cxx592
-rw-r--r--xmloff/source/style/tabsthdl.cxx65
-rw-r--r--xmloff/source/style/tabsthdl.hxx39
-rw-r--r--xmloff/source/style/undlihdl.cxx365
-rw-r--r--xmloff/source/style/undlihdl.hxx54
-rw-r--r--xmloff/source/style/weighhdl.cxx154
-rw-r--r--xmloff/source/style/weighhdl.hxx37
-rw-r--r--xmloff/source/style/xmlaustp.cxx384
-rw-r--r--xmloff/source/style/xmlbahdl.cxx904
-rw-r--r--xmloff/source/style/xmlbahdl.hxx314
-rw-r--r--xmloff/source/style/xmlexppr.cxx1129
-rw-r--r--xmloff/source/style/xmlimppr.cxx762
-rw-r--r--xmloff/source/style/xmlnume.cxx832
-rw-r--r--xmloff/source/style/xmlnumfe.cxx2026
-rw-r--r--xmloff/source/style/xmlnumfi.cxx2231
-rw-r--r--xmloff/source/style/xmlnumi.cxx1081
-rw-r--r--xmloff/source/style/xmlprcon.cxx89
-rw-r--r--xmloff/source/style/xmlprhdl.cxx33
-rw-r--r--xmloff/source/style/xmlprmap.cxx361
-rw-r--r--xmloff/source/style/xmlstyle.cxx806
-rw-r--r--xmloff/source/style/xmltabe.cxx120
-rw-r--r--xmloff/source/style/xmltabi.cxx186
113 files changed, 27902 insertions, 0 deletions
diff --git a/xmloff/source/style/AttributeContainerHandler.cxx b/xmloff/source/style/AttributeContainerHandler.cxx
new file mode 100644
index 000000000..17dc4391e
--- /dev/null
+++ b/xmloff/source/style/AttributeContainerHandler.cxx
@@ -0,0 +1,86 @@
+/* -*- 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/container/XNameContainer.hpp>
+#include <com/sun/star/xml/AttributeData.hpp>
+#include <com/sun/star/uno/Any.hxx>
+
+#include <AttributeContainerHandler.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::container;
+
+
+
+
+XMLAttributeContainerHandler::~XMLAttributeContainerHandler()
+{
+ // nothing to do
+}
+
+bool XMLAttributeContainerHandler::equals(
+ const Any& r1,
+ const Any& r2 ) const
+{
+ Reference< XNameContainer > xContainer1;
+ Reference< XNameContainer > xContainer2;
+
+ if( ( r1 >>= xContainer1 ) && ( r2 >>= xContainer2 ) )
+ {
+ const uno::Sequence< OUString > aAttribNames1( xContainer1->getElementNames() );
+ uno::Sequence< OUString > aAttribNames2( xContainer2->getElementNames() );
+
+ if( aAttribNames1.getLength() == aAttribNames2.getLength() )
+ {
+ xml::AttributeData aData1;
+ xml::AttributeData aData2;
+
+ for( const OUString& rAttribName : aAttribNames1 )
+ {
+ if( !xContainer2->hasByName( rAttribName ) )
+ return false;
+
+ xContainer1->getByName( rAttribName ) >>= aData1;
+ xContainer2->getByName( rAttribName ) >>= aData2;
+
+ if( ( aData1.Namespace != aData2.Namespace ) ||
+ ( aData1.Type != aData2.Type ) ||
+ ( aData1.Value != aData2.Value ) )
+ return false;
+ }
+
+ return true;
+ }
+ }
+
+ return false;
+}
+
+bool XMLAttributeContainerHandler::importXML( const OUString& /*rStrImpValue*/, Any& /*rValue*/, const SvXMLUnitConverter& /*rUnitConverter*/ ) const
+{
+ return true;
+}
+
+bool XMLAttributeContainerHandler::exportXML( OUString& /*rStrExpValue*/, const Any& /*rValue*/, const SvXMLUnitConverter& /*rUnitConverter*/ ) const
+{
+ return true;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/DashStyle.cxx b/xmloff/source/style/DashStyle.cxx
new file mode 100644
index 000000000..acb866df8
--- /dev/null
+++ b/xmloff/source/style/DashStyle.cxx
@@ -0,0 +1,275 @@
+/* -*- 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/drawing/DashStyle.hpp>
+#include <com/sun/star/drawing/LineDash.hpp>
+
+#include <sax/tools/converter.hxx>
+
+#include <xmloff/DashStyle.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmlement.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <rtl/ustring.hxx>
+#include <sal/log.hxx>
+#include <xmloff/xmltkmap.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+SvXMLEnumMapEntry<drawing::DashStyle> const pXML_DashStyle_Enum[] =
+{
+ { XML_RECT, drawing::DashStyle_RECT },
+ { XML_ROUND, drawing::DashStyle_ROUND },
+ { XML_RECT, drawing::DashStyle_RECTRELATIVE },
+ { XML_ROUND, drawing::DashStyle_ROUNDRELATIVE },
+ { XML_TOKEN_INVALID, drawing::DashStyle(0) }
+};
+
+// Import
+
+XMLDashStyleImport::XMLDashStyleImport( SvXMLImport& rImp )
+ : rImport(rImp)
+{
+}
+
+void XMLDashStyleImport::importXML(
+ const uno::Reference< xml::sax::XFastAttributeList >& xAttrList,
+ uno::Any& rValue,
+ OUString& rStrName )
+{
+ drawing::LineDash aLineDash;
+ aLineDash.Style = drawing::DashStyle_RECT;
+ aLineDash.Dots = 0;
+ aLineDash.DotLen = 0;
+ aLineDash.Dashes = 0;
+ aLineDash.DashLen = 0;
+ aLineDash.Distance = 20;
+ OUString aDisplayName;
+
+ bool bIsRel = false;
+
+ SvXMLUnitConverter& rUnitConverter = rImport.GetMM100UnitConverter();
+
+ for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+ {
+ switch( aIter.getToken() )
+ {
+ case XML_ELEMENT(DRAW, XML_NAME):
+ case XML_ELEMENT(DRAW_OOO, XML_NAME):
+ {
+ rStrName = aIter.toString();
+ }
+ break;
+ case XML_ELEMENT(DRAW, XML_DISPLAY_NAME):
+ case XML_ELEMENT(DRAW_OOO, XML_DISPLAY_NAME):
+ {
+ aDisplayName = aIter.toString();
+ }
+ break;
+ case XML_ELEMENT(DRAW, XML_STYLE):
+ case XML_ELEMENT(DRAW_OOO, XML_STYLE):
+ {
+ SvXMLUnitConverter::convertEnum( aLineDash.Style, aIter.toView(), pXML_DashStyle_Enum );
+ }
+ break;
+ case XML_ELEMENT(DRAW, XML_DOTS1):
+ case XML_ELEMENT(DRAW_OOO, XML_DOTS1):
+ aLineDash.Dots = static_cast<sal_Int16>(aIter.toInt32());
+ break;
+
+ case XML_ELEMENT(DRAW, XML_DOTS1_LENGTH):
+ case XML_ELEMENT(DRAW_OOO, XML_DOTS1_LENGTH):
+ {
+ if( aIter.toView().find( '%' ) != std::string_view::npos ) // it's a percentage
+ {
+ bIsRel = true;
+ ::sax::Converter::convertPercent(aLineDash.DotLen, aIter.toView());
+ }
+ else
+ {
+ rUnitConverter.convertMeasureToCore( aLineDash.DotLen,
+ aIter.toView() );
+ }
+ }
+ break;
+
+ case XML_ELEMENT(DRAW, XML_DOTS2):
+ case XML_ELEMENT(DRAW_OOO, XML_DOTS2):
+ aLineDash.Dashes = static_cast<sal_Int16>(aIter.toInt32());
+ break;
+
+ case XML_ELEMENT(DRAW, XML_DOTS2_LENGTH):
+ case XML_ELEMENT(DRAW_OOO, XML_DOTS2_LENGTH):
+ {
+ if( aIter.toView().find( '%' ) != std::string_view::npos ) // it's a percentage
+ {
+ bIsRel = true;
+ ::sax::Converter::convertPercent(aLineDash.DashLen, aIter.toView());
+ }
+ else
+ {
+ rUnitConverter.convertMeasureToCore( aLineDash.DashLen,
+ aIter.toView() );
+ }
+ }
+ break;
+
+ case XML_ELEMENT(DRAW, XML_DISTANCE):
+ case XML_ELEMENT(DRAW_OOO, XML_DISTANCE):
+ {
+ if( aIter.toView().find( '%' ) != std::string_view::npos ) // it's a percentage
+ {
+ bIsRel = true;
+ ::sax::Converter::convertPercent(aLineDash.Distance, aIter.toView());
+ }
+ else
+ {
+ rUnitConverter.convertMeasureToCore( aLineDash.Distance,
+ aIter.toView() );
+ }
+ }
+ break;
+ default:
+ XMLOFF_WARN_UNKNOWN("xmloff.style", aIter);
+ }
+ }
+
+ if( bIsRel )
+ aLineDash.Style = aLineDash.Style == drawing::DashStyle_RECT ? drawing::DashStyle_RECTRELATIVE : drawing::DashStyle_ROUNDRELATIVE;
+
+ rValue <<= aLineDash;
+
+ if( !aDisplayName.isEmpty() )
+ {
+ rImport.AddStyleDisplayName( XmlStyleFamily::SD_STROKE_DASH_ID,
+ rStrName, aDisplayName );
+ rStrName = aDisplayName;
+ }
+}
+
+// Export
+
+XMLDashStyleExport::XMLDashStyleExport( SvXMLExport& rExp )
+ : rExport(rExp)
+{
+}
+
+void XMLDashStyleExport::exportXML(
+ const OUString& rStrName,
+ const uno::Any& rValue )
+{
+ SvXMLUnitConverter & rUnitConverter = rExport.GetMM100UnitConverter();
+
+ drawing::LineDash aLineDash;
+
+ if( rStrName.isEmpty() )
+ return;
+
+ if( !(rValue >>= aLineDash) )
+ return;
+
+ bool bIsRel = aLineDash.Style == drawing::DashStyle_RECTRELATIVE || aLineDash.Style == drawing::DashStyle_ROUNDRELATIVE;
+
+ OUString aStrValue;
+ OUStringBuffer aOut;
+
+ // Name
+ bool bEncoded = false;
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME,
+ rExport.EncodeStyleName( rStrName,
+ &bEncoded ) );
+ if( bEncoded )
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DISPLAY_NAME,
+ rStrName );
+
+ // Style
+ SvXMLUnitConverter::convertEnum( aOut, aLineDash.Style, pXML_DashStyle_Enum );
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_STYLE, aStrValue );
+
+ // dots
+ if( aLineDash.Dots )
+ {
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DOTS1, OUString::number( aLineDash.Dots ) );
+
+ if( aLineDash.DotLen )
+ {
+ // dashes length
+ if( bIsRel )
+ {
+ ::sax::Converter::convertPercent(aOut, aLineDash.DotLen);
+ }
+ else
+ {
+ rUnitConverter.convertMeasureToXML( aOut,
+ aLineDash.DotLen );
+ }
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DOTS1_LENGTH, aStrValue );
+ }
+ }
+
+ // dashes
+ if( aLineDash.Dashes )
+ {
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DOTS2, OUString::number( aLineDash.Dashes ) );
+
+ if( aLineDash.DashLen )
+ {
+ // dashes length
+ if( bIsRel )
+ {
+ ::sax::Converter::convertPercent(aOut, aLineDash.DashLen);
+ }
+ else
+ {
+ rUnitConverter.convertMeasureToXML( aOut,
+ aLineDash.DashLen );
+ }
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DOTS2_LENGTH, aStrValue );
+ }
+ }
+
+ // distance
+ if( bIsRel )
+ {
+ ::sax::Converter::convertPercent( aOut, aLineDash.Distance );
+ }
+ else
+ {
+ rUnitConverter.convertMeasureToXML( aOut,
+ aLineDash.Distance );
+ }
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DISTANCE, aStrValue );
+
+ // do Write
+ SvXMLElementExport rElem( rExport,
+ XML_NAMESPACE_DRAW, XML_STROKE_DASH,
+ true, false );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/DrawAspectHdl.cxx b/xmloff/source/style/DrawAspectHdl.cxx
new file mode 100644
index 000000000..7eeb374ca
--- /dev/null
+++ b/xmloff/source/style/DrawAspectHdl.cxx
@@ -0,0 +1,61 @@
+/* -*- 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 "DrawAspectHdl.hxx"
+
+#include <com/sun/star/uno/Any.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <sax/tools/converter.hxx>
+#include <xmloff/xmltoken.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+DrawAspectHdl::~DrawAspectHdl()
+{
+ // nothing to do
+}
+
+bool DrawAspectHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_Int64 nAspect = 0;
+
+ ::sax::Converter::convertNumber64( nAspect, rStrImpValue );
+ rValue <<= nAspect;
+
+ return nAspect > 0;
+}
+
+bool DrawAspectHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+
+ sal_Int64 nAspect = 0;
+ if( ( rValue >>= nAspect ) && nAspect > 0 )
+ {
+ // store the aspect as an integer value
+ rStrExpValue = OUString::number(nAspect);
+
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/DrawAspectHdl.hxx b/xmloff/source/style/DrawAspectHdl.hxx
new file mode 100644
index 000000000..0eb1fae15
--- /dev/null
+++ b/xmloff/source/style/DrawAspectHdl.hxx
@@ -0,0 +1,36 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class DrawAspectHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~DrawAspectHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/EnumPropertyHdl.cxx b/xmloff/source/style/EnumPropertyHdl.cxx
new file mode 100644
index 000000000..903ac3914
--- /dev/null
+++ b/xmloff/source/style/EnumPropertyHdl.cxx
@@ -0,0 +1,82 @@
+/* -*- 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 <xmloff/EnumPropertyHdl.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <comphelper/extract.hxx>
+#include <rtl/ustring.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <com/sun/star/uno/Any.hxx>
+
+using namespace ::com::sun::star::uno;
+
+
+
+XMLEnumPropertyHdl::~XMLEnumPropertyHdl()
+{
+ // Nothing to do
+}
+
+bool XMLEnumPropertyHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_uInt16 nValue = 0;
+
+ if( SvXMLUnitConverter::convertEnum( nValue, rStrImpValue, mpEnumMap ) )
+ {
+ switch( mrType.getTypeClass() )
+ {
+ case TypeClass_ENUM:
+ rValue = ::cppu::int2enum( nValue, mrType );
+ break;
+ case TypeClass_LONG:
+ rValue <<= static_cast<sal_Int32>(nValue);
+ break;
+ case TypeClass_SHORT:
+ rValue <<= static_cast<sal_Int16>(nValue);
+ break;
+ case TypeClass_BYTE:
+ rValue <<= static_cast<sal_Int8>(nValue);
+ break;
+ default:
+ assert(!"Wrong type for enum property handler!");
+ return false;
+ }
+ return true;
+ }
+
+ return false;
+}
+
+bool XMLEnumPropertyHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_Int32 nValue = 0;
+ if(!(rValue >>= nValue ))
+ if(!::cppu::enum2int(nValue, rValue) )
+ return false;
+
+ OUStringBuffer aOut;
+
+ if(!SvXMLUnitConverter::convertEnum( aOut, static_cast<sal_uInt16>(nValue), mpEnumMap ))
+ return false;
+
+ rStrExpValue = aOut.makeStringAndClear();
+ return true;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/FillStyleContext.cxx b/xmloff/source/style/FillStyleContext.cxx
new file mode 100644
index 000000000..8cd99a25b
--- /dev/null
+++ b/xmloff/source/style/FillStyleContext.cxx
@@ -0,0 +1,317 @@
+/* -*- 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/container/XNameContainer.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+#include <com/sun/star/awt/XBitmap.hpp>
+#include "FillStyleContext.hxx"
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/GradientStyle.hxx>
+#include <xmloff/HatchStyle.hxx>
+#include <xmloff/ImageStyle.hxx>
+#include <TransGradientStyle.hxx>
+#include <xmloff/MarkerStyle.hxx>
+#include <xmloff/DashStyle.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltkmap.hxx>
+#include <xmloff/XMLBase64ImportContext.hxx>
+
+using namespace ::com::sun::star;
+
+
+XMLGradientStyleContext::XMLGradientStyleContext( SvXMLImport& rImport, sal_Int32 ,
+ const uno::Reference< xml::sax::XFastAttributeList >& xAttrList)
+: SvXMLStyleContext(rImport)
+{
+ // start import
+ XMLGradientStyleImport aGradientStyle( GetImport() );
+ aGradientStyle.importXML( xAttrList, maAny, maStrName );
+}
+
+XMLGradientStyleContext::~XMLGradientStyleContext()
+{
+}
+
+void XMLGradientStyleContext::endFastElement(sal_Int32 )
+{
+ uno::Reference< container::XNameContainer > xGradient( GetImport().GetGradientHelper() );
+
+ try
+ {
+ if(xGradient.is())
+ {
+ if( xGradient->hasByName( maStrName ) )
+ {
+ xGradient->replaceByName( maStrName, maAny );
+ }
+ else
+ {
+ xGradient->insertByName( maStrName, maAny );
+ }
+ }
+ }
+ catch( container::ElementExistException& )
+ {}
+}
+
+bool XMLGradientStyleContext::IsTransient() const
+{
+ return true;
+}
+
+
+XMLHatchStyleContext::XMLHatchStyleContext( SvXMLImport& rImport, sal_Int32 /*nElement*/,
+ const uno::Reference< xml::sax::XFastAttributeList >& xAttrList)
+: SvXMLStyleContext(rImport)
+{
+ // start import
+ XMLHatchStyleImport aHatchStyle( GetImport() );
+ aHatchStyle.importXML( xAttrList, maAny, maStrName );
+}
+
+XMLHatchStyleContext::~XMLHatchStyleContext()
+{
+}
+
+void XMLHatchStyleContext::endFastElement(sal_Int32 )
+{
+ uno::Reference< container::XNameContainer > xHatch( GetImport().GetHatchHelper() );
+
+ try
+ {
+ if(xHatch.is())
+ {
+ if( xHatch->hasByName( maStrName ) )
+ {
+ xHatch->replaceByName( maStrName, maAny );
+ }
+ else
+ {
+ xHatch->insertByName( maStrName, maAny );
+ }
+ }
+ }
+ catch( container::ElementExistException& )
+ {}
+}
+
+bool XMLHatchStyleContext::IsTransient() const
+{
+ return true;
+}
+
+
+XMLBitmapStyleContext::XMLBitmapStyleContext( SvXMLImport& rImport, sal_Int32 /*nElement*/,
+ const uno::Reference< xml::sax::XFastAttributeList >& xAttrList)
+: SvXMLStyleContext(rImport)
+{
+ // start import
+ XMLImageStyle::importXML( xAttrList, maAny, maStrName, rImport );
+}
+
+XMLBitmapStyleContext::~XMLBitmapStyleContext()
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > XMLBitmapStyleContext::createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& )
+{
+ if( nElement == XML_ELEMENT(OFFICE, xmloff::token::XML_BINARY_DATA) )
+ {
+ OUString sURL;
+ maAny >>= sURL;
+ if( sURL.isEmpty() && !mxBase64Stream.is() )
+ {
+ mxBase64Stream = GetImport().GetStreamForGraphicObjectURLFromBase64();
+ if( mxBase64Stream.is() )
+ return new XMLBase64ImportContext( GetImport(), mxBase64Stream );
+ }
+ }
+
+ return nullptr;
+}
+
+void XMLBitmapStyleContext::endFastElement(sal_Int32 )
+{
+ if (!maAny.has<uno::Reference<graphic::XGraphic>>() && mxBase64Stream.is())
+ {
+ // No graphic so far? Then see if it's inline.
+ uno::Reference<graphic::XGraphic> xGraphic = GetImport().loadGraphicFromBase64(mxBase64Stream);
+ if (xGraphic.is())
+ {
+ maAny <<= xGraphic;
+ }
+ }
+
+ if (!maAny.has<uno::Reference<graphic::XGraphic>>())
+ return;
+
+ uno::Reference<container::XNameContainer> xBitmapContainer(GetImport().GetBitmapHelper());
+
+ uno::Reference<graphic::XGraphic> xGraphic = maAny.get<uno::Reference<graphic::XGraphic>>();
+ uno::Reference<awt::XBitmap> xBitmap(xGraphic, uno::UNO_QUERY);
+
+ try
+ {
+ if (xBitmapContainer.is())
+ {
+ if (xBitmapContainer->hasByName(maStrName))
+ {
+ xBitmapContainer->replaceByName(maStrName, uno::Any(xBitmap));
+ }
+ else
+ {
+ xBitmapContainer->insertByName(maStrName, uno::Any(xBitmap));
+ }
+ }
+ }
+ catch (container::ElementExistException&)
+ {}
+}
+
+bool XMLBitmapStyleContext::IsTransient() const
+{
+ return true;
+}
+
+
+XMLTransGradientStyleContext::XMLTransGradientStyleContext( SvXMLImport& rImport, sal_Int32 /*nElement*/,
+ const uno::Reference< xml::sax::XFastAttributeList >& xAttrList)
+: SvXMLStyleContext(rImport)
+{
+ // start import
+ XMLTransGradientStyleImport aTransGradientStyle( GetImport() );
+ aTransGradientStyle.importXML( xAttrList, maAny, maStrName );
+}
+
+XMLTransGradientStyleContext::~XMLTransGradientStyleContext()
+{
+}
+
+void XMLTransGradientStyleContext::endFastElement(sal_Int32 )
+{
+ uno::Reference< container::XNameContainer > xTransGradient( GetImport().GetTransGradientHelper() );
+
+ try
+ {
+ if(xTransGradient.is())
+ {
+ if( xTransGradient->hasByName( maStrName ) )
+ {
+ xTransGradient->replaceByName( maStrName, maAny );
+ }
+ else
+ {
+ xTransGradient->insertByName( maStrName, maAny );
+ }
+ }
+ }
+ catch( container::ElementExistException& )
+ {}
+}
+
+bool XMLTransGradientStyleContext::IsTransient() const
+{
+ return true;
+}
+
+
+XMLMarkerStyleContext::XMLMarkerStyleContext( SvXMLImport& rImport, sal_Int32 /*nElement*/,
+ const uno::Reference< xml::sax::XFastAttributeList >& xAttrList)
+: SvXMLStyleContext(rImport)
+{
+ // start import
+ XMLMarkerStyleImport aMarkerStyle( GetImport() );
+ aMarkerStyle.importXML( xAttrList, maAny, maStrName );
+}
+
+XMLMarkerStyleContext::~XMLMarkerStyleContext()
+{
+}
+
+void XMLMarkerStyleContext::endFastElement(sal_Int32 )
+{
+ uno::Reference< container::XNameContainer > xMarker( GetImport().GetMarkerHelper() );
+
+ try
+ {
+ if(xMarker.is())
+ {
+ if( xMarker->hasByName( maStrName ) )
+ {
+ xMarker->replaceByName( maStrName, maAny );
+ }
+ else
+ {
+ xMarker->insertByName( maStrName, maAny );
+ }
+ }
+ }
+ catch( container::ElementExistException& )
+ {}
+}
+
+bool XMLMarkerStyleContext::IsTransient() const
+{
+ return true;
+}
+
+
+XMLDashStyleContext::XMLDashStyleContext( SvXMLImport& rImport, sal_Int32 /*nElement*/,
+ const uno::Reference< xml::sax::XFastAttributeList >& xAttrList)
+: SvXMLStyleContext(rImport)
+{
+ // start import
+ XMLDashStyleImport aDashStyle( GetImport() );
+ aDashStyle.importXML( xAttrList, maAny, maStrName );
+}
+
+XMLDashStyleContext::~XMLDashStyleContext()
+{
+}
+
+void XMLDashStyleContext::endFastElement(sal_Int32 )
+{
+ uno::Reference< container::XNameContainer > xDashes( GetImport().GetDashHelper() );
+
+ try
+ {
+ if(xDashes.is())
+ {
+ if( xDashes->hasByName( maStrName ) )
+ {
+ xDashes->replaceByName( maStrName, maAny );
+ }
+ else
+ {
+ xDashes->insertByName( maStrName, maAny );
+ }
+ }
+ }
+ catch( container::ElementExistException& )
+ {}
+}
+
+bool XMLDashStyleContext::IsTransient() const
+{
+ return true;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/FillStyleContext.hxx b/xmloff/source/style/FillStyleContext.hxx
new file mode 100644
index 000000000..3b17c29c8
--- /dev/null
+++ b/xmloff/source/style/FillStyleContext.hxx
@@ -0,0 +1,144 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <com/sun/star/io/XOutputStream.hpp>
+#include <xmloff/xmlstyle.hxx>
+#include <rtl/ustring.hxx>
+
+// draw:gradient context
+
+class XMLGradientStyleContext: public SvXMLStyleContext
+{
+private:
+ css::uno::Any maAny;
+ OUString maStrName;
+
+public:
+
+ XMLGradientStyleContext( SvXMLImport& rImport, sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList );
+ virtual ~XMLGradientStyleContext() override;
+
+ virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+ virtual bool IsTransient() const override;
+};
+
+// draw:hatch context
+
+class XMLHatchStyleContext: public SvXMLStyleContext
+{
+private:
+ css::uno::Any maAny;
+ OUString maStrName;
+
+public:
+
+ XMLHatchStyleContext( SvXMLImport& rImport, sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList );
+ virtual ~XMLHatchStyleContext() override;
+
+ virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+ virtual bool IsTransient() const override;
+};
+
+// draw:fill-image context
+
+class XMLBitmapStyleContext: public SvXMLStyleContext
+{
+private:
+ css::uno::Any maAny;
+ OUString maStrName;
+ css::uno::Reference < css::io::XOutputStream > mxBase64Stream;
+
+public:
+
+ XMLBitmapStyleContext( SvXMLImport& rImport, sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList );
+ virtual ~XMLBitmapStyleContext() override;
+
+ virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+ sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+
+ virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+ virtual bool IsTransient() const override;
+};
+
+// draw:transparency context
+
+class XMLTransGradientStyleContext: public SvXMLStyleContext
+{
+private:
+ css::uno::Any maAny;
+ OUString maStrName;
+
+public:
+
+ XMLTransGradientStyleContext( SvXMLImport& rImport, sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList );
+ virtual ~XMLTransGradientStyleContext() override;
+
+ virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+ virtual bool IsTransient() const override;
+};
+
+// draw:marker context
+
+class XMLMarkerStyleContext: public SvXMLStyleContext
+{
+private:
+ css::uno::Any maAny;
+ OUString maStrName;
+
+public:
+
+ XMLMarkerStyleContext( SvXMLImport& rImport, sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList );
+ virtual ~XMLMarkerStyleContext() override;
+
+ virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+ virtual bool IsTransient() const override;
+};
+
+// draw:marker context
+
+class XMLDashStyleContext: public SvXMLStyleContext
+{
+private:
+ css::uno::Any maAny;
+ OUString maStrName;
+
+public:
+
+ XMLDashStyleContext( SvXMLImport& rImport, sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList );
+ virtual ~XMLDashStyleContext() override;
+
+ virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+ virtual bool IsTransient() const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/GradientStyle.cxx b/xmloff/source/style/GradientStyle.cxx
new file mode 100644
index 000000000..81ccd84d2
--- /dev/null
+++ b/xmloff/source/style/GradientStyle.cxx
@@ -0,0 +1,238 @@
+/* -*- 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 <xmloff/GradientStyle.hxx>
+
+#include <com/sun/star/awt/Gradient.hpp>
+
+#include <sax/tools/converter.hxx>
+#include <comphelper/documentconstants.hxx>
+
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <rtl/ustring.hxx>
+#include <sal/log.hxx>
+#include <xmloff/xmltkmap.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmlement.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+SvXMLEnumMapEntry<awt::GradientStyle> const pXML_GradientStyle_Enum[] =
+{
+ { XML_LINEAR, awt::GradientStyle_LINEAR },
+ { XML_GRADIENTSTYLE_AXIAL, awt::GradientStyle_AXIAL },
+ { XML_GRADIENTSTYLE_RADIAL, awt::GradientStyle_RADIAL },
+ { XML_GRADIENTSTYLE_ELLIPSOID, awt::GradientStyle_ELLIPTICAL },
+ { XML_GRADIENTSTYLE_SQUARE, awt::GradientStyle_SQUARE },
+ { XML_GRADIENTSTYLE_RECTANGULAR, awt::GradientStyle_RECT },
+ { XML_TOKEN_INVALID, awt::GradientStyle(0) }
+};
+
+// Import
+XMLGradientStyleImport::XMLGradientStyleImport(
+ SvXMLImport& rImp )
+ : rImport(rImp)
+{
+}
+
+void XMLGradientStyleImport::importXML(
+ const uno::Reference< xml::sax::XFastAttributeList >& xAttrList,
+ uno::Any& rValue,
+ OUString& rStrName )
+{
+ OUString aDisplayName;
+
+ awt::Gradient aGradient;
+ aGradient.Style = css::awt::GradientStyle_LINEAR;
+ aGradient.StartColor = 0;
+ aGradient.EndColor = 0;
+ aGradient.Angle = 0;
+ aGradient.Border = 0;
+ aGradient.XOffset = 0;
+ aGradient.YOffset = 0;
+ aGradient.StartIntensity = 100;
+ aGradient.EndIntensity = 100;
+ aGradient.StepCount = 0;
+
+ for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+ {
+ sal_Int32 nTmpValue(0);
+
+ switch( aIter.getToken() )
+ {
+ case XML_ELEMENT(DRAW, XML_NAME):
+ rStrName = aIter.toString();
+ break;
+ case XML_ELEMENT(DRAW, XML_DISPLAY_NAME):
+ aDisplayName = aIter.toString();
+ break;
+ case XML_ELEMENT(DRAW, XML_STYLE):
+ SvXMLUnitConverter::convertEnum( aGradient.Style, aIter.toView(), pXML_GradientStyle_Enum );
+ break;
+ case XML_ELEMENT(DRAW, XML_CX):
+ ::sax::Converter::convertPercent( nTmpValue, aIter.toView() );
+ aGradient.XOffset = static_cast< sal_Int16 >( nTmpValue );
+ break;
+ case XML_ELEMENT(DRAW, XML_CY):
+ ::sax::Converter::convertPercent( nTmpValue, aIter.toView() );
+ aGradient.YOffset = static_cast< sal_Int16 >( nTmpValue );
+ break;
+ case XML_ELEMENT(DRAW, XML_START_COLOR):
+ ::sax::Converter::convertColor(aGradient.StartColor, aIter.toView());
+ break;
+ case XML_ELEMENT(DRAW, XML_END_COLOR):
+ ::sax::Converter::convertColor(aGradient.EndColor, aIter.toView());
+ break;
+ case XML_ELEMENT(DRAW, XML_START_INTENSITY):
+ ::sax::Converter::convertPercent( nTmpValue, aIter.toView() );
+ aGradient.StartIntensity = static_cast< sal_Int16 >( nTmpValue );
+ break;
+ case XML_ELEMENT(DRAW, XML_END_INTENSITY):
+ ::sax::Converter::convertPercent( nTmpValue, aIter.toView() );
+ aGradient.EndIntensity = static_cast< sal_Int16 >( nTmpValue );
+ break;
+ case XML_ELEMENT(DRAW, XML_GRADIENT_ANGLE):
+ {
+ auto const cmp12(rImport.GetODFVersion().compareTo(ODFVER_012_TEXT));
+ bool const bSuccess =
+ ::sax::Converter::convertAngle(aGradient.Angle, aIter.toView(),
+ // tdf#89475 try to detect borked OOo angles
+ (cmp12 < 0) || (cmp12 == 0
+ && (rImport.isGeneratorVersionOlderThan(SvXMLImport::AOO_4x, SvXMLImport::LO_7x)
+ // also for AOO 4.x, assume there won't ever be a 4.2
+ || rImport.getGeneratorVersion() == SvXMLImport::AOO_4x)));
+ SAL_INFO_IF(!bSuccess, "xmloff.style", "failed to import draw:angle");
+ }
+ break;
+ case XML_ELEMENT(DRAW, XML_BORDER):
+ ::sax::Converter::convertPercent( nTmpValue, aIter.toView() );
+ aGradient.Border = static_cast< sal_Int16 >( nTmpValue );
+ break;
+
+ default:
+ XMLOFF_WARN_UNKNOWN("xmloff.style", aIter);
+ }
+ }
+
+ rValue <<= aGradient;
+
+ if( !aDisplayName.isEmpty() )
+ {
+ rImport.AddStyleDisplayName( XmlStyleFamily::SD_GRADIENT_ID, rStrName,
+ aDisplayName );
+ rStrName = aDisplayName;
+ }
+}
+
+// Export
+
+XMLGradientStyleExport::XMLGradientStyleExport(
+ SvXMLExport& rExp )
+ : rExport(rExp)
+{
+}
+
+void XMLGradientStyleExport::exportXML(
+ const OUString& rStrName,
+ const uno::Any& rValue )
+{
+ awt::Gradient aGradient;
+
+ if( rStrName.isEmpty() )
+ return;
+
+ if( !(rValue >>= aGradient) )
+ return;
+
+ OUString aStrValue;
+ OUStringBuffer aOut;
+
+ // Style
+ if( !SvXMLUnitConverter::convertEnum( aOut, aGradient.Style, pXML_GradientStyle_Enum ) )
+ return;
+
+ // Name
+ bool bEncoded = false;
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME,
+ rExport.EncodeStyleName( rStrName,
+ &bEncoded ) );
+ if( bEncoded )
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DISPLAY_NAME,
+ rStrName );
+
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_STYLE, aStrValue );
+
+ // Center x/y
+ if( aGradient.Style != awt::GradientStyle_LINEAR &&
+ aGradient.Style != awt::GradientStyle_AXIAL )
+ {
+ ::sax::Converter::convertPercent(aOut, aGradient.XOffset);
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CX, aStrValue );
+ ::sax::Converter::convertPercent(aOut, aGradient.YOffset);
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CY, aStrValue );
+ }
+
+ // Color start
+ ::sax::Converter::convertColor(aOut, aGradient.StartColor);
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_START_COLOR, aStrValue );
+
+ // Color end
+ ::sax::Converter::convertColor(aOut, aGradient.EndColor);
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_END_COLOR, aStrValue );
+
+ // Intensity start
+ ::sax::Converter::convertPercent(aOut, aGradient.StartIntensity);
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_START_INTENSITY, aStrValue );
+
+ // Intensity end
+ ::sax::Converter::convertPercent(aOut, aGradient.EndIntensity);
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_END_INTENSITY, aStrValue );
+
+ // Angle
+ if( aGradient.Style != awt::GradientStyle_RADIAL )
+ {
+ ::sax::Converter::convertAngle(aOut, aGradient.Angle, rExport.getSaneDefaultVersion());
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_GRADIENT_ANGLE, aStrValue );
+ }
+
+ // Border
+ ::sax::Converter::convertPercent( aOut, aGradient.Border );
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_BORDER, aStrValue );
+
+ // Do Write
+ SvXMLElementExport aElem( rExport, XML_NAMESPACE_DRAW, XML_GRADIENT,
+ true, false );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/HatchStyle.cxx b/xmloff/source/style/HatchStyle.cxx
new file mode 100644
index 000000000..a70ee506e
--- /dev/null
+++ b/xmloff/source/style/HatchStyle.cxx
@@ -0,0 +1,178 @@
+/* -*- 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 <xmloff/HatchStyle.hxx>
+
+#include <com/sun/star/drawing/Hatch.hpp>
+
+#include <sax/tools/converter.hxx>
+
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <rtl/ustring.hxx>
+#include <sal/log.hxx>
+#include <xmloff/xmltkmap.hxx>
+#include <xmloff/xmlement.hxx>
+
+using namespace ::com::sun::star;
+
+using namespace ::xmloff::token;
+
+SvXMLEnumMapEntry<drawing::HatchStyle> const pXML_HatchStyle_Enum[] =
+{
+ { XML_SINGLE, drawing::HatchStyle_SINGLE },
+ { XML_DOUBLE, drawing::HatchStyle_DOUBLE },
+ { XML_HATCHSTYLE_TRIPLE, drawing::HatchStyle_TRIPLE },
+ { XML_TOKEN_INVALID, drawing::HatchStyle(0) }
+};
+
+// Import
+
+XMLHatchStyleImport::XMLHatchStyleImport( SvXMLImport& rImp )
+ : rImport(rImp)
+{
+}
+
+void XMLHatchStyleImport::importXML(
+ const uno::Reference< xml::sax::XFastAttributeList >& xAttrList,
+ uno::Any& rValue,
+ OUString& rStrName )
+{
+ OUString aDisplayName;
+
+ drawing::Hatch aHatch;
+ aHatch.Style = drawing::HatchStyle_SINGLE;
+ aHatch.Color = 0;
+ aHatch.Distance = 0;
+ aHatch.Angle = 0;
+
+ SvXMLUnitConverter& rUnitConverter = rImport.GetMM100UnitConverter();
+
+ for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+ {
+ switch( aIter.getToken() )
+ {
+ case XML_ELEMENT(DRAW, XML_NAME):
+ case XML_ELEMENT(DRAW_OOO, XML_NAME):
+ rStrName = aIter.toString();
+ break;
+ case XML_ELEMENT(DRAW, XML_DISPLAY_NAME):
+ case XML_ELEMENT(DRAW_OOO, XML_DISPLAY_NAME):
+ aDisplayName = aIter.toString();
+ break;
+ case XML_ELEMENT(DRAW, XML_STYLE):
+ case XML_ELEMENT(DRAW_OOO, XML_STYLE):
+ SvXMLUnitConverter::convertEnum( aHatch.Style, aIter.toView(), pXML_HatchStyle_Enum );
+ break;
+ case XML_ELEMENT(DRAW, XML_COLOR):
+ case XML_ELEMENT(DRAW_OOO, XML_COLOR):
+ ::sax::Converter::convertColor(aHatch.Color, aIter.toView());
+ break;
+ case XML_ELEMENT(DRAW, XML_DISTANCE):
+ case XML_ELEMENT(DRAW_OOO, XML_DISTANCE):
+ rUnitConverter.convertMeasureToCore(aHatch.Distance, aIter.toView());
+ break;
+ case XML_ELEMENT(DRAW, XML_ROTATION):
+ case XML_ELEMENT(DRAW_OOO, XML_ROTATION):
+ {
+ sal_Int32 nValue;
+ if (::sax::Converter::convertNumber(nValue, aIter.toView(), 0, 3600))
+ aHatch.Angle = sal_Int16(nValue);
+ break;
+ }
+ default:
+ XMLOFF_WARN_UNKNOWN("xmloff.style", aIter);
+ }
+ }
+
+ rValue <<= aHatch;
+
+ if( !aDisplayName.isEmpty() )
+ {
+ rImport.AddStyleDisplayName( XmlStyleFamily::SD_HATCH_ID, rStrName,
+ aDisplayName );
+ rStrName = aDisplayName;
+ }
+}
+
+// Export
+
+XMLHatchStyleExport::XMLHatchStyleExport( SvXMLExport& rExp )
+ : rExport(rExp)
+{
+}
+
+void XMLHatchStyleExport::exportXML(
+ const OUString& rStrName,
+ const uno::Any& rValue )
+{
+ drawing::Hatch aHatch;
+
+ if( rStrName.isEmpty() )
+ return;
+
+ if( !(rValue >>= aHatch) )
+ return;
+
+ OUString aStrValue;
+ OUStringBuffer aOut;
+
+ SvXMLUnitConverter& rUnitConverter =
+ rExport.GetMM100UnitConverter();
+
+ // Style
+ if( !SvXMLUnitConverter::convertEnum( aOut, aHatch.Style, pXML_HatchStyle_Enum ) )
+ return;
+
+ // Name
+ bool bEncoded = false;
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME,
+ rExport.EncodeStyleName( rStrName,
+ &bEncoded ) );
+ if( bEncoded )
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DISPLAY_NAME,
+ rStrName );
+
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_STYLE, aStrValue );
+
+ // Color
+ ::sax::Converter::convertColor(aOut, aHatch.Color);
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_COLOR, aStrValue );
+
+ // Distance
+ rUnitConverter.convertMeasureToXML( aOut, aHatch.Distance );
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DISTANCE, aStrValue );
+
+ // Angle
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_ROTATION, OUString::number(aHatch.Angle) );
+
+ // Do Write
+ SvXMLElementExport rElem( rExport, XML_NAMESPACE_DRAW, XML_HATCH,
+ true, false );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/ImageStyle.cxx b/xmloff/source/style/ImageStyle.cxx
new file mode 100644
index 000000000..13443d4ad
--- /dev/null
+++ b/xmloff/source/style/ImageStyle.cxx
@@ -0,0 +1,135 @@
+/* -*- 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 <xmloff/ImageStyle.hxx>
+#include <com/sun/star/awt/XBitmap.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <rtl/ustring.hxx>
+#include <sal/log.hxx>
+#include <xmloff/xmltkmap.hxx>
+
+using namespace css;
+using namespace xmloff::token;
+
+void XMLImageStyle::exportXML(OUString const & rStrName, uno::Any const & rValue, SvXMLExport& rExport)
+{
+ if (rStrName.isEmpty())
+ return;
+
+ if (!rValue.has<uno::Reference<awt::XBitmap>>())
+ return;
+
+ // Name
+ bool bEncoded = false;
+ rExport.AddAttribute(XML_NAMESPACE_DRAW, XML_NAME,
+ rExport.EncodeStyleName(rStrName, &bEncoded));
+ if (bEncoded)
+ {
+ rExport.AddAttribute(XML_NAMESPACE_DRAW, XML_DISPLAY_NAME, rStrName);
+ }
+
+ auto xBitmap = rValue.get<uno::Reference<awt::XBitmap>>();
+ uno::Reference<graphic::XGraphic> xGraphic(xBitmap, uno::UNO_QUERY);
+
+ OUString aMimeType;
+ const OUString aStr = rExport.AddEmbeddedXGraphic(xGraphic, aMimeType);
+
+ // uri
+ if (!aStr.isEmpty())
+ {
+ rExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, aStr );
+ rExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+ rExport.AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+ rExport.AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+ }
+
+ // Do Write
+ SvXMLElementExport aElem(rExport, XML_NAMESPACE_DRAW, XML_FILL_IMAGE, true, true);
+
+ if (xBitmap.is() && xGraphic.is())
+ {
+ // optional office:binary-data
+ rExport.AddEmbeddedXGraphicAsBase64(xGraphic);
+ }
+}
+
+bool XMLImageStyle::importXML(uno::Reference<xml::sax::XFastAttributeList> const & xAttrList,
+ uno::Any& rValue, OUString& rStrName, SvXMLImport& rImport)
+{
+ bool bHasHRef = false;
+ bool bHasName = false;
+ OUString aDisplayName;
+ uno::Reference<graphic::XGraphic> xGraphic;
+
+ for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+ {
+ const OUString aStrValue = aIter.toString();
+
+ switch( aIter.getToken() )
+ {
+ case XML_ELEMENT(DRAW, XML_NAME):
+ {
+ rStrName = aStrValue;
+ bHasName = true;
+ }
+ break;
+ case XML_ELEMENT(DRAW, XML_DISPLAY_NAME):
+ {
+ aDisplayName = aStrValue;
+ }
+ break;
+ case XML_ELEMENT(XLINK, XML_HREF):
+ {
+ xGraphic = rImport.loadGraphicByURL(aStrValue);
+ bHasHRef = true;
+ }
+ break;
+ case XML_ELEMENT(XLINK, XML_TYPE):
+ // ignore
+ break;
+ case XML_ELEMENT(XLINK, XML_SHOW):
+ // ignore
+ break;
+ case XML_ELEMENT(XLINK, XML_ACTUATE):
+ // ignore
+ break;
+ default:
+ XMLOFF_WARN_UNKNOWN("xmloff.style", aIter);
+ }
+ }
+
+ if (xGraphic.is())
+ rValue <<= xGraphic;
+
+ if( !aDisplayName.isEmpty() )
+ {
+ rImport.AddStyleDisplayName( XmlStyleFamily::SD_FILL_IMAGE_ID,
+ rStrName, aDisplayName );
+ rStrName = aDisplayName;
+ }
+
+ return bHasName && bHasHRef;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/MarkerStyle.cxx b/xmloff/source/style/MarkerStyle.cxx
new file mode 100644
index 000000000..8f902feb9
--- /dev/null
+++ b/xmloff/source/style/MarkerStyle.cxx
@@ -0,0 +1,193 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <memory>
+#include <xmloff/MarkerStyle.hxx>
+#include <xexptran.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <sal/log.hxx>
+#include <rtl/ustring.hxx>
+#include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
+#include <basegfx/polygon/b2dpolypolygon.hxx>
+#include <basegfx/polygon/b2dpolypolygontools.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
+
+using namespace ::com::sun::star;
+
+using namespace ::xmloff::token;
+
+// Import
+
+XMLMarkerStyleImport::XMLMarkerStyleImport( SvXMLImport& rImp )
+ : rImport( rImp )
+{
+}
+
+void XMLMarkerStyleImport::importXML(
+ const uno::Reference< xml::sax::XFastAttributeList >& xAttrList,
+ uno::Any& rValue,
+ OUString& rStrName )
+{
+ bool bHasViewBox = false;
+ bool bHasPathData = false;
+ OUString aDisplayName;
+
+ std::unique_ptr<SdXMLImExViewBox> xViewBox;
+
+ SvXMLUnitConverter& rUnitConverter = rImport.GetMM100UnitConverter();
+
+ OUString strPathData;
+
+ for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+ {
+ OUString aStrValue = aIter.toString();
+
+ switch (aIter.getToken() & TOKEN_MASK)
+ {
+ case XML_NAME:
+ rStrName = aStrValue;
+ break;
+ case XML_DISPLAY_NAME:
+ aDisplayName = aStrValue;
+ break;
+ case XML_VIEWBOX:
+ xViewBox.reset(new SdXMLImExViewBox(aStrValue, rUnitConverter));
+ bHasViewBox = true;
+ break;
+ case XML_D:
+ strPathData = aStrValue;
+ bHasPathData = true;
+ break;
+ default:
+ XMLOFF_WARN_UNKNOWN("xmloff.style", aIter);
+ }
+ }
+
+ if( bHasViewBox && bHasPathData )
+ {
+ basegfx::B2DPolyPolygon aPolyPolygon;
+
+ if(basegfx::utils::importFromSvgD(aPolyPolygon, strPathData, rImport.needFixPositionAfterZ(), nullptr))
+ {
+ if(aPolyPolygon.count())
+ {
+ // ViewBox probably not used, but stay with former processing inside of
+ // SdXMLImExSvgDElement
+ const basegfx::B2DRange aSourceRange(
+ xViewBox->GetX(), xViewBox->GetY(),
+ xViewBox->GetX() + xViewBox->GetWidth(),
+ xViewBox->GetY() + xViewBox->GetHeight());
+ const basegfx::B2DRange aTargetRange(
+ 0.0, 0.0,
+ xViewBox->GetWidth(), xViewBox->GetHeight());
+
+ if(!aSourceRange.equal(aTargetRange))
+ {
+ aPolyPolygon.transform(
+ basegfx::utils::createSourceRangeTargetRangeTransform(
+ aSourceRange,
+ aTargetRange));
+ }
+
+ // always use PolyPolygonBezierCoords here
+ drawing::PolyPolygonBezierCoords aSourcePolyPolygon;
+
+ basegfx::utils::B2DPolyPolygonToUnoPolyPolygonBezierCoords(
+ aPolyPolygon,
+ aSourcePolyPolygon);
+ rValue <<= aSourcePolyPolygon;
+ }
+ }
+
+ if( !aDisplayName.isEmpty() )
+ {
+ rImport.AddStyleDisplayName( XmlStyleFamily::SD_MARKER_ID, rStrName,
+ aDisplayName );
+ rStrName = aDisplayName;
+ }
+ }
+
+ xViewBox.reset();
+}
+
+// Export
+
+XMLMarkerStyleExport::XMLMarkerStyleExport( SvXMLExport& rExp )
+ : rExport( rExp )
+{
+}
+
+void XMLMarkerStyleExport::exportXML(
+ const OUString& rStrName,
+ const uno::Any& rValue )
+{
+ if(rStrName.isEmpty())
+ return;
+
+ drawing::PolyPolygonBezierCoords aBezier;
+
+ if(!(rValue >>= aBezier))
+ return;
+
+ // Name
+ bool bEncoded(false);
+
+ rExport.AddAttribute(XML_NAMESPACE_DRAW, XML_NAME, rExport.EncodeStyleName( rStrName, &bEncoded ) );
+
+ if( bEncoded )
+ {
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DISPLAY_NAME, rStrName );
+ }
+
+ const basegfx::B2DPolyPolygon aPolyPolygon(
+ basegfx::utils::UnoPolyPolygonBezierCoordsToB2DPolyPolygon(
+ aBezier));
+ const basegfx::B2DRange aPolyPolygonRange(aPolyPolygon.getB2DRange());
+
+
+ // Viewbox (viewBox="0 0 1500 1000")
+
+ SdXMLImExViewBox aViewBox(
+ aPolyPolygonRange.getMinX(),
+ aPolyPolygonRange.getMinY(),
+ aPolyPolygonRange.getWidth(),
+ aPolyPolygonRange.getHeight());
+ rExport.AddAttribute( XML_NAMESPACE_SVG, XML_VIEWBOX, aViewBox.GetExportString() );
+
+ // Pathdata
+ const OUString aPolygonString(
+ basegfx::utils::exportToSvgD(
+ aPolyPolygon,
+ true, // bUseRelativeCoordinates
+ false, // bDetectQuadraticBeziers: not used in old, but maybe activated now
+ true)); // bHandleRelativeNextPointCompatible
+
+ // write point array
+ rExport.AddAttribute(XML_NAMESPACE_SVG, XML_D, aPolygonString);
+
+ // Do Write
+ SvXMLElementExport rElem( rExport, XML_NAMESPACE_DRAW, XML_MARKER, true, false );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/MultiPropertySetHelper.cxx b/xmloff/source/style/MultiPropertySetHelper.cxx
new file mode 100644
index 000000000..7636278eb
--- /dev/null
+++ b/xmloff/source/style/MultiPropertySetHelper.cxx
@@ -0,0 +1,169 @@
+/* -*- 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 <MultiPropertySetHelper.hxx>
+#include <com/sun/star/beans/XPropertySetInfo.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/beans/XMultiPropertySet.hpp>
+
+#include <sal/log.hxx>
+
+using ::com::sun::star::beans::XMultiPropertySet;
+using ::com::sun::star::beans::XPropertySet;
+using ::com::sun::star::beans::XPropertySetInfo;
+using ::com::sun::star::uno::Any;
+using ::com::sun::star::uno::Reference;
+using ::com::sun::star::uno::UNO_QUERY;
+
+
+MultiPropertySetHelper::MultiPropertySetHelper(
+ const char** pNames ) :
+ nLength( 0 ),
+ pValues( nullptr )
+{
+ // first count the elements
+ for( const char** pPtr = pNames; *pPtr != nullptr; pPtr++ )
+ nLength++;
+
+ // allocate array and create strings
+ pPropertyNames.reset( new OUString[nLength] );
+ for( sal_Int16 i = 0; i < nLength; i++ )
+ pPropertyNames[i] = OUString::createFromAscii( pNames[i] );
+}
+
+
+MultiPropertySetHelper::~MultiPropertySetHelper()
+{
+ pValues = nullptr; // memory 'owned' by aValues
+}
+
+
+void MultiPropertySetHelper::hasProperties(
+ const Reference<XPropertySetInfo> & rInfo )
+{
+ SAL_WARN_IF( !rInfo.is(), "xmloff", "I'd really like an XPropertySetInfo here." );
+
+ // allocate sequence index
+ if ( !pSequenceIndex )
+ pSequenceIndex.reset( new sal_Int16[nLength] );
+
+ // construct pSequenceIndex
+ sal_Int16 nNumberOfProperties = 0;
+ sal_Int16 i;
+
+ for( i = 0; i < nLength; i++ )
+ {
+ // ask for property
+ bool bHasProperty =
+ rInfo->hasPropertyByName( pPropertyNames[i] );
+
+ // set index and increment (if appropriate)
+ pSequenceIndex[i]= bHasProperty ? nNumberOfProperties : -1;
+ if ( bHasProperty )
+ nNumberOfProperties++;
+ }
+
+ // construct property sequence from index array
+ if ( aPropertySequence.getLength() != nNumberOfProperties )
+ aPropertySequence.realloc( nNumberOfProperties );
+ OUString* pPropertySequence = aPropertySequence.getArray();
+ for( i = 0; i < nLength; i ++ )
+ {
+ sal_Int16 nIndex = pSequenceIndex[i];
+ if ( nIndex != -1 )
+ pPropertySequence[nIndex] = pPropertyNames[i];
+ }
+}
+
+bool MultiPropertySetHelper::checkedProperties()
+{
+ return (nullptr != pSequenceIndex);
+}
+
+
+void MultiPropertySetHelper::getValues(
+ const Reference<XMultiPropertySet> & rMultiPropertySet )
+{
+ SAL_WARN_IF( !rMultiPropertySet.is(), "xmloff", "We need an XMultiPropertySet." );
+
+ aValues = rMultiPropertySet->getPropertyValues( aPropertySequence );
+ pValues = aValues.getConstArray();
+}
+
+void MultiPropertySetHelper::getValues(
+ const Reference<XPropertySet> & rPropertySet )
+{
+ SAL_WARN_IF( !rPropertySet.is(), "xmloff", "We need an XPropertySet." );
+
+ // re-alloc aValues (if necessary) and fill with values from XPropertySet
+ sal_Int16 nSupportedPropertiesCount =
+ static_cast<sal_Int16>(aPropertySequence.getLength());
+ if ( aValues.getLength() != nSupportedPropertiesCount )
+ aValues.realloc( nSupportedPropertiesCount );
+ Any* pMutableArray = aValues.getArray();
+ for( sal_Int16 i = 0; i < nSupportedPropertiesCount; i++ )
+ {
+ pMutableArray[i] = rPropertySet->getPropertyValue(
+ pPropertyNames[ pSequenceIndex[ i ] ] );
+ }
+
+ // re-establish pValues pointer
+ pValues = aValues.getConstArray();
+}
+
+
+const Any& MultiPropertySetHelper::getValue( sal_Int16 nIndex,
+ const Reference< XPropertySet> & rPropSet,
+ bool bTryMulti )
+{
+ if( !pValues )
+ {
+ if( bTryMulti )
+ {
+ Reference < XMultiPropertySet > xMultiPropSet( rPropSet,
+ UNO_QUERY );
+ if( xMultiPropSet.is() )
+ getValues( xMultiPropSet );
+ else
+ getValues( rPropSet );
+ }
+ else
+ {
+ getValues( rPropSet );
+ }
+ }
+
+ return getValue( nIndex );
+}
+
+const Any& MultiPropertySetHelper::getValue( sal_Int16 nIndex,
+ const Reference< XMultiPropertySet> & rMultiPropSet )
+{
+ if( !pValues )
+ getValues( rMultiPropSet );
+
+ return getValue( nIndex );
+}
+
+// inline methods defined in header:
+// inline Any& MultiPropertySetHelper::getValue( sal_Int16 nIndex )
+// inline sal_Bool MultiPropertySetHelper::hasProperty( sal_Int16 nValueNo )
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/NamedBoolPropertyHdl.cxx b/xmloff/source/style/NamedBoolPropertyHdl.cxx
new file mode 100644
index 000000000..be74fa4b7
--- /dev/null
+++ b/xmloff/source/style/NamedBoolPropertyHdl.cxx
@@ -0,0 +1,67 @@
+/* -*- 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 <xmloff/NamedBoolPropertyHdl.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <comphelper/extract.hxx>
+#include <rtl/ustring.hxx>
+#include <com/sun/star/uno/Any.hxx>
+
+using namespace ::com::sun::star::uno;
+
+
+
+
+XMLNamedBoolPropertyHdl::~XMLNamedBoolPropertyHdl()
+{
+ // Nothing to do
+}
+
+bool XMLNamedBoolPropertyHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ if( rStrImpValue == maTrueStr )
+ {
+ rValue <<= true;
+ return true;
+ }
+
+ if( rStrImpValue == maFalseStr )
+ {
+ rValue <<= false;
+ return true;
+ }
+
+ return false;
+}
+
+bool XMLNamedBoolPropertyHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ if( ::cppu::any2bool( rValue ) )
+ {
+ rStrExpValue = maTrueStr;
+ }
+ else
+ {
+ rStrExpValue = maFalseStr;
+ }
+
+ return true;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/PageHeaderFooterContext.cxx b/xmloff/source/style/PageHeaderFooterContext.cxx
new file mode 100644
index 000000000..3c9e0993b
--- /dev/null
+++ b/xmloff/source/style/PageHeaderFooterContext.cxx
@@ -0,0 +1,71 @@
+/* -*- 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 "PageHeaderFooterContext.hxx"
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmltypes.hxx>
+#include <xmloff/xmlimppr.hxx>
+#include "PagePropertySetContext.hxx"
+#include <sal/log.hxx>
+
+using namespace com::sun::star;
+using ::xmloff::token::IsXMLToken;
+using ::xmloff::token::XML_HEADER_FOOTER_PROPERTIES;
+
+PageHeaderFooterContext::PageHeaderFooterContext( SvXMLImport& rImport,
+ ::std::vector< XMLPropertyState > & rTempProperties,
+ const rtl::Reference < SvXMLImportPropertyMapper > &rTempMap,
+ sal_Int32 nStart, sal_Int32 nEnd,
+ const bool bTempHeader ) :
+ SvXMLImportContext( rImport ),
+ rProperties(rTempProperties),
+ nStartIndex(nStart),
+ nEndIndex(nEnd),
+ rMap(rTempMap)
+{
+ bHeader = bTempHeader;
+}
+
+PageHeaderFooterContext::~PageHeaderFooterContext()
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > PageHeaderFooterContext::createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+ if( nElement == XML_ELEMENT(STYLE, XML_HEADER_FOOTER_PROPERTIES) )
+ {
+ PageContextType aType = Header;
+ if (!bHeader)
+ aType = Footer;
+ return new PagePropertySetContext( GetImport(), nElement,
+ xAttrList,
+ XML_TYPE_PROP_HEADER_FOOTER,
+ rProperties,
+ rMap, nStartIndex, nEndIndex, aType);
+ }
+ else
+ XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+
+ return nullptr;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/PageHeaderFooterContext.hxx b/xmloff/source/style/PageHeaderFooterContext.hxx
new file mode 100644
index 000000000..a96a8a393
--- /dev/null
+++ b/xmloff/source/style/PageHeaderFooterContext.hxx
@@ -0,0 +1,48 @@
+/* -*- 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 .
+ */
+#pragma once
+
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/maptype.hxx>
+
+class PageHeaderFooterContext : public SvXMLImportContext
+{
+ ::std::vector< XMLPropertyState > & rProperties;
+ sal_Int32 nStartIndex;
+ sal_Int32 nEndIndex;
+ bool bHeader;
+ const rtl::Reference < SvXMLImportPropertyMapper > rMap;
+
+public:
+
+ PageHeaderFooterContext( SvXMLImport& rImport,
+ ::std::vector< XMLPropertyState > & rProperties,
+ const rtl::Reference < SvXMLImportPropertyMapper > &rMap,
+ sal_Int32 nStartIndex, sal_Int32 nEndIndex,
+ const bool bHeader);
+
+ virtual ~PageHeaderFooterContext() override;
+
+ virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+ sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+
+};
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/PageMasterExportPropMapper.cxx b/xmloff/source/style/PageMasterExportPropMapper.cxx
new file mode 100644
index 000000000..725ad6f9e
--- /dev/null
+++ b/xmloff/source/style/PageMasterExportPropMapper.cxx
@@ -0,0 +1,650 @@
+/* -*- 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 "PageMasterExportPropMapper.hxx"
+#include <xmloff/xmlprmap.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <comphelper/types.hxx>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/table/BorderLine2.hpp>
+#include <PageMasterStyleMap.hxx>
+#include <rtl/ref.hxx>
+#include <comphelper/extract.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::comphelper;
+using namespace ::xmloff::token;
+
+static bool lcl_HasSameLineWidth( const table::BorderLine2& rLine1, const table::BorderLine2& rLine2 )
+{
+ return (rLine1.InnerLineWidth == rLine2.InnerLineWidth) &&
+ (rLine1.OuterLineWidth == rLine2.OuterLineWidth) &&
+ (rLine1.LineDistance == rLine2.LineDistance) &&
+ (rLine1.LineWidth == rLine2.LineWidth);
+}
+
+static void lcl_RemoveState( XMLPropertyState* pState )
+{
+ pState->mnIndex = -1;
+ pState->maValue.clear();
+}
+
+static void lcl_RemoveStateIfZero16( XMLPropertyState* pState )
+{
+ sal_Int16 nValue = sal_Int16();
+ if( (pState->maValue >>= nValue) && !nValue )
+ lcl_RemoveState( pState );
+}
+
+static void lcl_AddState(::std::vector< XMLPropertyState >& rPropState, sal_Int32 nIndex, const OUString& rProperty, const uno::Reference< beans::XPropertySet >& xProps)
+{
+ if(::cppu::any2bool(xProps->getPropertyValue(rProperty)))
+ rPropState.emplace_back(nIndex, css::uno::Any(true));
+}
+
+// helper struct to handle equal XMLPropertyState's for page, header and footer
+
+namespace {
+
+struct XMLPropertyStateBuffer
+{
+ XMLPropertyState* pPMMarginAll;
+
+ XMLPropertyState* pPMBorderAll;
+ XMLPropertyState* pPMBorderTop;
+ XMLPropertyState* pPMBorderBottom;
+ XMLPropertyState* pPMBorderLeft;
+ XMLPropertyState* pPMBorderRight;
+
+ XMLPropertyState* pPMBorderWidthAll;
+ XMLPropertyState* pPMBorderWidthTop;
+ XMLPropertyState* pPMBorderWidthBottom;
+ XMLPropertyState* pPMBorderWidthLeft;
+ XMLPropertyState* pPMBorderWidthRight;
+
+ XMLPropertyState* pPMPaddingAll;
+ XMLPropertyState* pPMPaddingTop;
+ XMLPropertyState* pPMPaddingBottom;
+ XMLPropertyState* pPMPaddingLeft;
+ XMLPropertyState* pPMPaddingRight;
+
+ XMLPropertyState* pPMMarginGutter;
+ XMLPropertyState* pPMMarginLeft;
+ XMLPropertyState* pPMRtlGutter;
+ XMLPropertyState* pPMMarginRight;
+ bool m_bGutterAtTop;
+ XMLPropertyState* pPMMarginTop;
+
+ XMLPropertyStateBuffer();
+ void ContextFilter( ::std::vector< XMLPropertyState >& rPropState );
+};
+
+}
+
+XMLPropertyStateBuffer::XMLPropertyStateBuffer()
+ : pPMMarginAll( nullptr )
+ ,
+ pPMBorderAll( nullptr ),
+ pPMBorderTop( nullptr ),
+ pPMBorderBottom( nullptr ),
+ pPMBorderLeft( nullptr ),
+ pPMBorderRight( nullptr ),
+
+ pPMBorderWidthAll( nullptr ),
+ pPMBorderWidthTop( nullptr ),
+ pPMBorderWidthBottom( nullptr ),
+ pPMBorderWidthLeft( nullptr ),
+ pPMBorderWidthRight( nullptr ),
+
+ pPMPaddingAll( nullptr ),
+ pPMPaddingTop( nullptr ),
+ pPMPaddingBottom( nullptr ),
+ pPMPaddingLeft( nullptr ),
+ pPMPaddingRight( nullptr ),
+
+ pPMMarginGutter( nullptr ),
+ pPMMarginLeft( nullptr ),
+ pPMRtlGutter( nullptr ),
+ pPMMarginRight( nullptr ),
+ m_bGutterAtTop( false ),
+ pPMMarginTop( nullptr )
+{
+}
+
+void XMLPropertyStateBuffer::ContextFilter( ::std::vector< XMLPropertyState >& )
+{
+ if (pPMMarginGutter)
+ {
+ sal_Int32 nGutterMargin{};
+ pPMMarginGutter->maValue >>= nGutterMargin;
+ if (m_bGutterAtTop)
+ {
+ if (nGutterMargin && pPMMarginTop)
+ {
+ // Increase top margin to include gutter.
+ sal_Int32 nTopMargin{};
+ pPMMarginTop->maValue >>= nTopMargin;
+ nTopMargin += nGutterMargin;
+ pPMMarginTop->maValue <<= nTopMargin;
+ }
+ }
+ else
+ {
+ bool bRtlGutter{};
+ if (nGutterMargin && pPMRtlGutter)
+ {
+ pPMRtlGutter->maValue >>= bRtlGutter;
+ }
+ if (bRtlGutter)
+ {
+ if (nGutterMargin && pPMMarginRight)
+ {
+ // Increase right margin to include gutter.
+ sal_Int32 nRightMargin{};
+ pPMMarginRight->maValue >>= nRightMargin;
+ nRightMargin += nGutterMargin;
+ pPMMarginRight->maValue <<= nRightMargin;
+ }
+ }
+ else
+ {
+ if (nGutterMargin && pPMMarginLeft)
+ {
+ // Increase left margin to include gutter.
+ sal_Int32 nLeftMargin{};
+ pPMMarginLeft->maValue >>= nLeftMargin;
+ nLeftMargin += nGutterMargin;
+ pPMMarginLeft->maValue <<= nLeftMargin;
+ }
+ }
+ }
+ }
+
+ if (pPMMarginAll)
+ {
+ lcl_RemoveState(pPMMarginAll); // #i117696# do not write fo:margin
+ }
+
+ if( pPMBorderAll )
+ {
+ if( pPMBorderTop && pPMBorderBottom && pPMBorderLeft && pPMBorderRight )
+ {
+ table::BorderLine2 aLineTop, aLineBottom, aLineLeft, aLineRight;
+
+ pPMBorderTop->maValue >>= aLineTop;
+ pPMBorderBottom->maValue >>= aLineBottom;
+ pPMBorderLeft->maValue >>= aLineLeft;
+ pPMBorderRight->maValue >>= aLineRight;
+
+ if( (aLineTop == aLineBottom) && (aLineBottom == aLineLeft) && (aLineLeft == aLineRight) )
+ {
+ lcl_RemoveState( pPMBorderTop );
+ lcl_RemoveState( pPMBorderBottom );
+ lcl_RemoveState( pPMBorderLeft );
+ lcl_RemoveState( pPMBorderRight );
+ }
+ else
+ lcl_RemoveState( pPMBorderAll );
+ }
+ else
+ lcl_RemoveState( pPMBorderAll );
+ }
+
+ if( pPMBorderWidthAll )
+ {
+ if( pPMBorderWidthTop && pPMBorderWidthBottom && pPMBorderWidthLeft && pPMBorderWidthRight )
+ {
+ table::BorderLine2 aLineTop, aLineBottom, aLineLeft, aLineRight;
+
+ pPMBorderWidthTop->maValue >>= aLineTop;
+ pPMBorderWidthBottom->maValue >>= aLineBottom;
+ pPMBorderWidthLeft->maValue >>= aLineLeft;
+ pPMBorderWidthRight->maValue >>= aLineRight;
+
+ if( lcl_HasSameLineWidth( aLineTop, aLineBottom ) &&
+ lcl_HasSameLineWidth( aLineBottom, aLineLeft ) &&
+ lcl_HasSameLineWidth( aLineLeft, aLineRight ) )
+ {
+ lcl_RemoveState( pPMBorderWidthTop );
+ lcl_RemoveState( pPMBorderWidthBottom );
+ lcl_RemoveState( pPMBorderWidthLeft );
+ lcl_RemoveState( pPMBorderWidthRight );
+ }
+ else
+ lcl_RemoveState( pPMBorderWidthAll );
+ }
+ else
+ lcl_RemoveState( pPMBorderWidthAll );
+ }
+
+ if( !pPMPaddingAll )
+ return;
+
+ if( pPMPaddingTop && pPMPaddingBottom && pPMPaddingLeft && pPMPaddingRight )
+ {
+ sal_Int32 nTop = 0, nBottom = 0, nLeft = 0, nRight = 0;
+
+ pPMPaddingTop->maValue >>= nTop;
+ pPMPaddingBottom->maValue >>= nBottom;
+ pPMPaddingLeft->maValue >>= nLeft;
+ pPMPaddingRight->maValue >>= nRight;
+
+ if( (nTop == nBottom) && (nBottom == nLeft) && (nLeft == nRight) )
+ {
+ lcl_RemoveState( pPMPaddingTop );
+ lcl_RemoveState( pPMPaddingBottom );
+ lcl_RemoveState( pPMPaddingLeft );
+ lcl_RemoveState( pPMPaddingRight );
+ }
+ else
+ lcl_RemoveState( pPMPaddingAll );
+ }
+ else
+ lcl_RemoveState( pPMPaddingAll );
+}
+
+XMLPageMasterExportPropMapper::XMLPageMasterExportPropMapper(
+ const rtl::Reference< XMLPropertySetMapper >& rMapper,
+ SvXMLExport& rExport ) :
+ SvXMLExportPropertyMapper( rMapper ),
+ aBackgroundImageExport( rExport ),
+ aTextColumnsExport( rExport ),
+ aFootnoteSeparatorExport( rExport )
+{
+}
+
+XMLPageMasterExportPropMapper::~XMLPageMasterExportPropMapper()
+{
+}
+
+void XMLPageMasterExportPropMapper::handleElementItem(
+ SvXMLExport&,
+ const XMLPropertyState& rProperty,
+ SvXmlExportFlags /*nFlags*/,
+ const ::std::vector< XMLPropertyState >* pProperties,
+ sal_uInt32 nIdx ) const
+{
+ XMLPageMasterExportPropMapper* pThis = const_cast<XMLPageMasterExportPropMapper*>(this);
+
+ sal_uInt32 nContextId = getPropertySetMapper()->GetEntryContextId( rProperty.mnIndex );
+ switch( nContextId )
+ {
+ case CTF_PM_GRAPHICURL:
+ case CTF_PM_HEADERGRAPHICURL:
+ case CTF_PM_FOOTERGRAPHICURL:
+ {
+ assert(pProperties);
+ assert(nIdx >= 2 && "horrible array ordering borked again");
+ sal_Int32 nPos(-1);
+ sal_Int32 nFilter(-1);
+ switch( nContextId )
+ {
+ case CTF_PM_GRAPHICURL:
+ nPos = CTF_PM_GRAPHICPOSITION;
+ nFilter = CTF_PM_GRAPHICFILTER;
+ break;
+ case CTF_PM_HEADERGRAPHICURL:
+ nPos = CTF_PM_HEADERGRAPHICPOSITION;
+ nFilter = CTF_PM_HEADERGRAPHICFILTER;
+ break;
+ case CTF_PM_FOOTERGRAPHICURL:
+ nPos = CTF_PM_FOOTERGRAPHICPOSITION;
+ nFilter = CTF_PM_FOOTERGRAPHICFILTER;
+ break;
+ default:
+ assert(false);
+ }
+ const Any* pPos = nullptr;
+ const Any* pFilter = nullptr;
+ sal_uInt32 nIndex(nIdx - 1);
+ const XMLPropertyState& rFilter = (*pProperties)[nIndex];
+ if (getPropertySetMapper()->GetEntryContextId(rFilter.mnIndex) == nFilter)
+ {
+ pFilter = &rFilter.maValue;
+ --nIndex;
+ }
+ const XMLPropertyState& rPos = (*pProperties)[nIndex];
+ if (getPropertySetMapper()->GetEntryContextId(rPos.mnIndex) == nPos)
+ {
+ pPos = &rPos.maValue;
+ --nIndex;
+ }
+ sal_uInt32 nPropIndex = rProperty.mnIndex;
+ pThis->aBackgroundImageExport.exportXML( rProperty.maValue, pPos, pFilter, nullptr,
+ getPropertySetMapper()->GetEntryNameSpace( nPropIndex ),
+ getPropertySetMapper()->GetEntryXMLName( nPropIndex ) );
+ }
+ break;
+ case CTF_PM_TEXTCOLUMNS:
+ pThis->aTextColumnsExport.exportXML( rProperty.maValue );
+ break;
+ case CTF_PM_FTN_LINE_WEIGHT:
+ pThis->aFootnoteSeparatorExport.exportXML( pProperties, nIdx,
+ getPropertySetMapper());
+ break;
+ }
+}
+
+void XMLPageMasterExportPropMapper::handleSpecialItem(
+ SvXMLAttributeList&,
+ const XMLPropertyState&,
+ const SvXMLUnitConverter&,
+ const SvXMLNamespaceMap&,
+ const ::std::vector< XMLPropertyState >*,
+ sal_uInt32 /*nIdx*/) const
+{
+}
+
+void XMLPageMasterExportPropMapper::ContextFilter(
+ bool bEnableFoFontFamily,
+ ::std::vector< XMLPropertyState >& rPropState,
+ const Reference< XPropertySet >& rPropSet ) const
+{
+ XMLPropertyStateBuffer aPageBuffer;
+ if (m_bGutterAtTop)
+ {
+ aPageBuffer.m_bGutterAtTop = true;
+ }
+
+ XMLPropertyStateBuffer aHeaderBuffer;
+ XMLPropertyStateBuffer aFooterBuffer;
+
+ XMLPropertyState* pPMHeaderHeight = nullptr;
+ XMLPropertyState* pPMHeaderMinHeight = nullptr;
+ XMLPropertyState* pPMHeaderDynamic = nullptr;
+
+ XMLPropertyState* pPMFooterHeight = nullptr;
+ XMLPropertyState* pPMFooterMinHeight = nullptr;
+ XMLPropertyState* pPMFooterDynamic = nullptr;
+
+ XMLPropertyState* pPMScaleTo = nullptr;
+ XMLPropertyState* pPMScaleToPages = nullptr;
+ XMLPropertyState* pPMScaleToX = nullptr;
+ XMLPropertyState* pPMScaleToY = nullptr;
+ XMLPropertyState* pPMStandardMode = nullptr;
+ XMLPropertyState* pPMGridBaseWidth = nullptr;
+ // same as pPMGridSnapTo but for backward compatibility only
+ XMLPropertyState* pPMGridSnapToChars = nullptr;
+ XMLPropertyState* pPMGridSnapTo = nullptr;
+
+ XMLPropertyState* pPrint = nullptr;
+
+ XMLPropertyState* pRepeatOffsetX = nullptr;
+ XMLPropertyState* pRepeatOffsetY = nullptr;
+ XMLPropertyState* pHeaderRepeatOffsetX = nullptr;
+ XMLPropertyState* pHeaderRepeatOffsetY = nullptr;
+ XMLPropertyState* pFooterRepeatOffsetX = nullptr;
+ XMLPropertyState* pFooterRepeatOffsetY = nullptr;
+
+ rtl::Reference < XMLPropertySetMapper > aPropMapper(getPropertySetMapper());
+
+ // distinguish 2 cases: drawing-page export has CTF_PM_FILL, page-layout-properties export does not
+ bool const isDrawingPageExport(aPropMapper->FindEntryIndex(CTF_PM_FILL) != -1);
+
+ for( auto& rProp : rPropState )
+ {
+ XMLPropertyState *pProp = &rProp;
+ sal_Int16 nContextId = aPropMapper->GetEntryContextId( pProp->mnIndex );
+ sal_Int16 nFlag = nContextId & CTF_PM_FLAGMASK;
+ sal_Int16 nSimpleId = nContextId & (~CTF_PM_FLAGMASK | XML_PM_CTF_START);
+ sal_Int16 nPrintId = nContextId & CTF_PM_PRINTMASK;
+
+
+ // tdf#103602 don't export draw:fill attributes on page-layout-properties in strict ODF
+ if (!isDrawingPageExport
+ && [](OUString const& rName) -> bool {
+ return rName.startsWith("Fill")
+ || rName.startsWith("HeaderFill")
+ || rName.startsWith("FooterFill");
+ } (aPropMapper->GetEntryAPIName(rProp.mnIndex))
+ && ((aBackgroundImageExport.GetExport().getSaneDefaultVersion()
+ & SvtSaveOptions::ODFSVER_EXTENDED) == 0))
+ {
+ lcl_RemoveState(&rProp);
+ continue;
+ }
+
+ XMLPropertyStateBuffer* pBuffer;
+ switch( nFlag )
+ {
+ case CTF_PM_HEADERFLAG: pBuffer = &aHeaderBuffer; break;
+ case CTF_PM_FOOTERFLAG: pBuffer = &aFooterBuffer; break;
+ default: pBuffer = &aPageBuffer; break;
+ }
+
+ switch( nSimpleId )
+ {
+ case CTF_PM_MARGINALL: pBuffer->pPMMarginAll = pProp; break;
+ case CTF_PM_BORDERALL: pBuffer->pPMBorderAll = pProp; break;
+ case CTF_PM_BORDERTOP: pBuffer->pPMBorderTop = pProp; break;
+ case CTF_PM_BORDERBOTTOM: pBuffer->pPMBorderBottom = pProp; break;
+ case CTF_PM_BORDERLEFT: pBuffer->pPMBorderLeft = pProp; break;
+ case CTF_PM_BORDERRIGHT: pBuffer->pPMBorderRight = pProp; break;
+ case CTF_PM_BORDERWIDTHALL: pBuffer->pPMBorderWidthAll = pProp; break;
+ case CTF_PM_BORDERWIDTHTOP: pBuffer->pPMBorderWidthTop = pProp; break;
+ case CTF_PM_BORDERWIDTHBOTTOM: pBuffer->pPMBorderWidthBottom = pProp; break;
+ case CTF_PM_BORDERWIDTHLEFT: pBuffer->pPMBorderWidthLeft = pProp; break;
+ case CTF_PM_BORDERWIDTHRIGHT: pBuffer->pPMBorderWidthRight = pProp; break;
+ case CTF_PM_PADDINGALL: pBuffer->pPMPaddingAll = pProp; break;
+ case CTF_PM_PADDINGTOP: pBuffer->pPMPaddingTop = pProp; break;
+ case CTF_PM_PADDINGBOTTOM: pBuffer->pPMPaddingBottom = pProp; break;
+ case CTF_PM_PADDINGLEFT: pBuffer->pPMPaddingLeft = pProp; break;
+ case CTF_PM_PADDINGRIGHT: pBuffer->pPMPaddingRight = pProp; break;
+ case CTF_PM_MARGINGUTTER:
+ pBuffer->pPMMarginGutter = pProp;
+ break;
+ case CTF_PM_MARGINLEFT:
+ pBuffer->pPMMarginLeft = pProp;
+ break;
+ case CTF_PM_RTLGUTTER:
+ pBuffer->pPMRtlGutter = pProp;
+ break;
+ case CTF_PM_MARGINRIGHT:
+ pBuffer->pPMMarginRight = pProp;
+ break;
+ case CTF_PM_MARGINTOP:
+ pBuffer->pPMMarginTop = pProp;
+ break;
+ }
+
+ switch( nContextId )
+ {
+ case CTF_PM_HEADERHEIGHT: pPMHeaderHeight = pProp; break;
+ case CTF_PM_HEADERMINHEIGHT: pPMHeaderMinHeight = pProp; break;
+ case CTF_PM_HEADERDYNAMIC: pPMHeaderDynamic = pProp; break;
+ case CTF_PM_FOOTERHEIGHT: pPMFooterHeight = pProp; break;
+ case CTF_PM_FOOTERMINHEIGHT: pPMFooterMinHeight = pProp; break;
+ case CTF_PM_FOOTERDYNAMIC: pPMFooterDynamic = pProp; break;
+ case CTF_PM_SCALETO: pPMScaleTo = pProp; break;
+ case CTF_PM_SCALETOPAGES: pPMScaleToPages = pProp; break;
+ case CTF_PM_SCALETOX: pPMScaleToX = pProp; break;
+ case CTF_PM_SCALETOY: pPMScaleToY = pProp; break;
+ case CTF_PM_STANDARD_MODE: pPMStandardMode = pProp; break;
+ case CTP_PM_GRID_BASE_WIDTH: pPMGridBaseWidth = pProp; break;
+ case CTP_PM_GRID_SNAP_TO_CHARS: pPMGridSnapToChars = pProp; break;
+ case CTP_PM_GRID_SNAP_TO: pPMGridSnapTo = pProp; break;
+
+ case CTF_PM_REPEAT_OFFSET_X:
+ pRepeatOffsetX = pProp;
+ break;
+
+ case CTF_PM_REPEAT_OFFSET_Y:
+ pRepeatOffsetY = pProp;
+ break;
+
+ case CTF_PM_HEADERREPEAT_OFFSET_X:
+ pHeaderRepeatOffsetX = pProp;
+ break;
+
+ case CTF_PM_HEADERREPEAT_OFFSET_Y:
+ pHeaderRepeatOffsetY = pProp;
+ break;
+
+ case CTF_PM_FOOTERREPEAT_OFFSET_X:
+ pFooterRepeatOffsetX = pProp;
+ break;
+
+ case CTF_PM_FOOTERREPEAT_OFFSET_Y:
+ pFooterRepeatOffsetY = pProp;
+ break;
+
+ // Sort out empty entries
+ case CTF_PM_FILLGRADIENTNAME:
+ case CTF_PM_FILLHATCHNAME:
+ case CTF_PM_FILLBITMAPNAME:
+ case CTF_PM_FILLTRANSNAME:
+
+ case CTF_PM_HEADERFILLGRADIENTNAME:
+ case CTF_PM_HEADERFILLHATCHNAME:
+ case CTF_PM_HEADERFILLBITMAPNAME:
+ case CTF_PM_HEADERFILLTRANSNAME:
+
+ case CTF_PM_FOOTERFILLGRADIENTNAME:
+ case CTF_PM_FOOTERFILLHATCHNAME:
+ case CTF_PM_FOOTERFILLBITMAPNAME:
+ case CTF_PM_FOOTERFILLTRANSNAME:
+ {
+ OUString aStr;
+
+ if( (pProp->maValue >>= aStr) && 0 == aStr.getLength() )
+ {
+ pProp->mnIndex = -1;
+ }
+
+ break;
+ }
+ }
+
+ if (nPrintId == CTF_PM_PRINTMASK)
+ {
+ pPrint = pProp;
+ lcl_RemoveState(pPrint);
+ }
+ }
+
+ // These entries need to be reduced to a single one for XML export.
+ // Both would be exported as 'draw:tile-repeat-offset' following a percent
+ // value and a 'vertical' or 'horizontal' tag as mark. If both would be active
+ // and both would be exported this would create an XML error (same property twice)
+ if(pRepeatOffsetX && pRepeatOffsetY)
+ {
+ sal_Int32 nOffset(0);
+
+ if((pRepeatOffsetX->maValue >>= nOffset) && (!nOffset))
+ {
+ pRepeatOffsetX->mnIndex = -1;
+ }
+ else
+ {
+ pRepeatOffsetY->mnIndex = -1;
+ }
+ }
+
+ // Same as above for Header
+ if(pHeaderRepeatOffsetX && pHeaderRepeatOffsetY)
+ {
+ sal_Int32 nOffset(0);
+
+ if((pHeaderRepeatOffsetX->maValue >>= nOffset) && (!nOffset))
+ {
+ pHeaderRepeatOffsetX->mnIndex = -1;
+ }
+ else
+ {
+ pHeaderRepeatOffsetY->mnIndex = -1;
+ }
+ }
+
+ // Same as above for Footer
+ if(pFooterRepeatOffsetX && pFooterRepeatOffsetY)
+ {
+ sal_Int32 nOffset(0);
+
+ if((pFooterRepeatOffsetX->maValue >>= nOffset) && (!nOffset))
+ {
+ pFooterRepeatOffsetX->mnIndex = -1;
+ }
+ else
+ {
+ pFooterRepeatOffsetY->mnIndex = -1;
+ }
+ }
+
+ if( pPMStandardMode && !getBOOL(pPMStandardMode->maValue) )
+ {
+ lcl_RemoveState(pPMStandardMode);
+ if( pPMGridBaseWidth )
+ lcl_RemoveState(pPMGridBaseWidth);
+ if( pPMGridSnapToChars )
+ lcl_RemoveState(pPMGridSnapToChars);
+ if (pPMGridSnapTo)
+ {
+ lcl_RemoveState(pPMGridSnapTo);
+ }
+ }
+
+ if( pPMGridBaseWidth && pPMStandardMode )
+ lcl_RemoveState(pPMStandardMode);
+
+ aPageBuffer.ContextFilter( rPropState );
+ aHeaderBuffer.ContextFilter( rPropState );
+ aFooterBuffer.ContextFilter( rPropState );
+
+ if( pPMHeaderHeight && (!pPMHeaderDynamic || getBOOL( pPMHeaderDynamic->maValue )) )
+ lcl_RemoveState( pPMHeaderHeight );
+ if( pPMHeaderMinHeight && pPMHeaderDynamic && !getBOOL( pPMHeaderDynamic->maValue ) )
+ lcl_RemoveState( pPMHeaderMinHeight );
+ if( pPMHeaderDynamic )
+ lcl_RemoveState( pPMHeaderDynamic );
+
+ if( pPMFooterHeight && (!pPMFooterDynamic || getBOOL( pPMFooterDynamic->maValue )) )
+ lcl_RemoveState( pPMFooterHeight );
+ if( pPMFooterMinHeight && pPMFooterDynamic && !getBOOL( pPMFooterDynamic->maValue ) )
+ lcl_RemoveState( pPMFooterMinHeight );
+ if( pPMFooterDynamic )
+ lcl_RemoveState( pPMFooterDynamic );
+
+ if( pPMScaleTo )
+ lcl_RemoveStateIfZero16( pPMScaleTo );
+ if( pPMScaleToPages )
+ lcl_RemoveStateIfZero16( pPMScaleToPages );
+ if( pPMScaleToX )
+ lcl_RemoveStateIfZero16( pPMScaleToX );
+ if( pPMScaleToY )
+ lcl_RemoveStateIfZero16( pPMScaleToY );
+
+ if (pPrint)
+ {
+ lcl_AddState(rPropState, aPropMapper->FindEntryIndex(CTF_PM_PRINT_ANNOTATIONS), "PrintAnnotations", rPropSet);
+ lcl_AddState(rPropState, aPropMapper->FindEntryIndex(CTF_PM_PRINT_CHARTS), "PrintCharts", rPropSet);
+ lcl_AddState(rPropState, aPropMapper->FindEntryIndex(CTF_PM_PRINT_DRAWING), "PrintDrawing", rPropSet);
+ lcl_AddState(rPropState, aPropMapper->FindEntryIndex(CTF_PM_PRINT_FORMULAS), "PrintFormulas", rPropSet);
+ lcl_AddState(rPropState, aPropMapper->FindEntryIndex(CTF_PM_PRINT_GRID), "PrintGrid", rPropSet);
+ lcl_AddState(rPropState, aPropMapper->FindEntryIndex(CTF_PM_PRINT_HEADERS), "PrintHeaders", rPropSet);
+ lcl_AddState(rPropState, aPropMapper->FindEntryIndex(CTF_PM_PRINT_OBJECTS), "PrintObjects", rPropSet);
+ lcl_AddState(rPropState, aPropMapper->FindEntryIndex(CTF_PM_PRINT_ZEROVALUES), "PrintZeroValues", rPropSet);
+ }
+
+ SvXMLExportPropertyMapper::ContextFilter(bEnableFoFontFamily, rPropState, rPropSet);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/PageMasterExportPropMapper.hxx b/xmloff/source/style/PageMasterExportPropMapper.hxx
new file mode 100644
index 000000000..8aa2debc8
--- /dev/null
+++ b/xmloff/source/style/PageMasterExportPropMapper.hxx
@@ -0,0 +1,66 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlexppr.hxx>
+#include <XMLBackgroundImageExport.hxx>
+#include <XMLTextColumnsExport.hxx>
+#include "XMLFootnoteSeparatorExport.hxx"
+
+class XMLPageMasterExportPropMapper : public SvXMLExportPropertyMapper
+{
+ XMLBackgroundImageExport aBackgroundImageExport;
+ XMLTextColumnsExport aTextColumnsExport;
+ XMLFootnoteSeparatorExport aFootnoteSeparatorExport;
+ bool m_bGutterAtTop = false;
+
+ virtual void ContextFilter(
+ bool bEnableFoFontFamily,
+ ::std::vector< XMLPropertyState >& rProperties,
+ const css::uno::Reference< css::beans::XPropertySet >& rPropSet
+ ) const override;
+
+public:
+ XMLPageMasterExportPropMapper(
+ const rtl::Reference< XMLPropertySetMapper >& rMapper,
+ SvXMLExport& rExport
+ );
+ virtual ~XMLPageMasterExportPropMapper() override;
+
+ virtual void handleElementItem(
+ SvXMLExport& rExport,
+ const XMLPropertyState& rProperty,
+ SvXmlExportFlags nFlags,
+ const ::std::vector< XMLPropertyState >* pProperties,
+ sal_uInt32 nIdx
+ ) const override;
+ virtual void handleSpecialItem(
+ SvXMLAttributeList& rAttrList,
+ const XMLPropertyState& rProperty,
+ const SvXMLUnitConverter& rUnitConverter,
+ const SvXMLNamespaceMap& rNamespaceMap,
+ const ::std::vector< XMLPropertyState >* pProperties,
+ sal_uInt32 nIdx
+ ) const override;
+
+ void SetGutterAtTop(bool bGutterAtTop) { m_bGutterAtTop = bGutterAtTop; }
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/PageMasterImportContext.cxx b/xmloff/source/style/PageMasterImportContext.cxx
new file mode 100644
index 000000000..874c87509
--- /dev/null
+++ b/xmloff/source/style/PageMasterImportContext.cxx
@@ -0,0 +1,434 @@
+/* -*- 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 <PageMasterImportContext.hxx>
+#include <xmloff/xmlimppr.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmlprmap.hxx>
+#include <xmloff/xmltoken.hxx>
+#include "PageMasterPropHdl.hxx"
+#include "PagePropertySetContext.hxx"
+#include "PageHeaderFooterContext.hxx"
+#include <PageMasterStyleMap.hxx>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <osl/diagnose.h>
+
+//
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/beans/XPropertySetInfo.hpp>
+#include <com/sun/star/drawing/FillStyle.hpp>
+#include <com/sun/star/drawing/BitmapMode.hpp>
+#include <xmloff/xmlerror.hxx>
+#include <xmloff/XMLTextMasterPageContext.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+
+//
+using namespace ::com::sun::star::beans;
+
+void PageStyleContext::SetAttribute( sal_Int32 nElement,
+ const OUString& rValue )
+{
+ if( nElement == XML_ELEMENT(STYLE, XML_PAGE_USAGE) )
+ {
+ sPageUsage = rValue;
+ }
+ else
+ {
+ XMLPropStyleContext::SetAttribute( nElement, rValue );
+ }
+}
+
+
+PageStyleContext::PageStyleContext( SvXMLImport& rImport,
+ SvXMLStylesContext& rStyles,
+ bool bDefaultStyle) :
+ XMLPropStyleContext( rImport, rStyles, XmlStyleFamily::PAGE_MASTER, bDefaultStyle),
+ m_bIsFillStyleAlreadyConverted(false) //
+{
+}
+
+PageStyleContext::~PageStyleContext()
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > PageStyleContext::createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+ if( nElement == XML_ELEMENT(STYLE, XML_HEADER_STYLE) ||
+ nElement == XML_ELEMENT(STYLE, XML_FOOTER_STYLE) )
+ {
+ bool bHeader = nElement == XML_ELEMENT(STYLE, XML_HEADER_STYLE);
+ rtl::Reference < SvXMLImportPropertyMapper > xImpPrMap =
+ GetStyles()->GetImportPropertyMapper( GetFamily() );
+ if( xImpPrMap.is() )
+ {
+ const rtl::Reference< XMLPropertySetMapper >& rMapper = xImpPrMap->getPropertySetMapper();
+ sal_Int32 nFlag;
+ if (bHeader)
+ nFlag = CTF_PM_HEADERFLAG;
+ else
+ nFlag = CTF_PM_FOOTERFLAG;
+ sal_Int32 nStartIndex (-1);
+ sal_Int32 nEndIndex (-1);
+ bool bFirst(false);
+ bool bEnd(false);
+ sal_Int32 nIndex = 0;
+ while ( nIndex < rMapper->GetEntryCount() && !bEnd)
+ {
+ if ((rMapper->GetEntryContextId( nIndex ) & CTF_PM_FLAGMASK) == nFlag)
+ {
+ if (!bFirst)
+ {
+ bFirst = true;
+ nStartIndex = nIndex;
+ }
+ }
+ else if (bFirst)
+ {
+ bEnd = true;
+ nEndIndex = nIndex;
+ }
+ nIndex++;
+ }
+ if (!bEnd)
+ nEndIndex = nIndex;
+ return new PageHeaderFooterContext(GetImport(),
+ GetProperties(), xImpPrMap, nStartIndex, nEndIndex, bHeader);
+ }
+ }
+
+ if( nElement == XML_ELEMENT(STYLE, XML_PAGE_LAYOUT_PROPERTIES) )
+ {
+ rtl::Reference < SvXMLImportPropertyMapper > xImpPrMap =
+ GetStyles()->GetImportPropertyMapper( GetFamily() );
+ if( xImpPrMap.is() )
+ {
+ const rtl::Reference< XMLPropertySetMapper >& rMapper = xImpPrMap->getPropertySetMapper();
+ sal_Int32 nEndIndex (-1);
+ bool bEnd(false);
+ sal_Int32 nIndex = 0;
+ sal_Int16 nContextID;
+ while ( nIndex < rMapper->GetEntryCount() && !bEnd)
+ {
+ nContextID = rMapper->GetEntryContextId( nIndex );
+ if (nContextID && ((nContextID & CTF_PM_FLAGMASK) != XML_PM_CTF_START))
+ {
+ nEndIndex = nIndex;
+ bEnd = true;
+ }
+ nIndex++;
+ }
+ if (!bEnd)
+ nEndIndex = nIndex;
+ return new PagePropertySetContext( GetImport(), nElement,
+ xAttrList,
+ XML_TYPE_PROP_PAGE_LAYOUT,
+ GetProperties(),
+ xImpPrMap, 0, nEndIndex, Page);
+ }
+ }
+
+ return XMLPropStyleContext::createFastChildContext(nElement, xAttrList);
+}
+
+void PageStyleContext::FillPropertySet(const uno::Reference<beans::XPropertySet > &)
+{
+ assert(false); // don't call this virtual, call function below
+}
+
+void PageStyleContext::FillPropertySet_PageStyle(
+ const uno::Reference<beans::XPropertySet> & xPropSet,
+ XMLPropStyleContext *const pDrawingPageStyle)
+{
+ // need to filter out old fill definitions when the new ones are used. The new
+ // ones are used when a FillStyle is defined
+ if(!m_bIsFillStyleAlreadyConverted && !GetProperties().empty())
+ {
+ static constexpr OUStringLiteral s_FillStyle(u"FillStyle");
+ static constexpr OUStringLiteral s_HeaderFillStyle(u"HeaderFillStyle");
+ static constexpr OUStringLiteral s_FooterFillStyle(u"FooterFillStyle");
+
+ // note: the function must only check by property name, not any id/flag!
+ if (doNewDrawingLayerFillStyleDefinitionsExist(s_FillStyle)
+ || (pDrawingPageStyle && pDrawingPageStyle->doNewDrawingLayerFillStyleDefinitionsExist(s_FillStyle)))
+ {
+ deactivateOldFillStyleDefinitions(getStandardSet());
+ }
+
+ if(doNewDrawingLayerFillStyleDefinitionsExist(s_HeaderFillStyle))
+ {
+ deactivateOldFillStyleDefinitions(getHeaderSet());
+ }
+
+ if(doNewDrawingLayerFillStyleDefinitionsExist(s_FooterFillStyle))
+ {
+ deactivateOldFillStyleDefinitions(getFooterSet());
+ }
+
+ m_bIsFillStyleAlreadyConverted = true;
+ }
+
+ // do not use XMLPropStyleContext::FillPropertySet, we need to handle this ourselves since
+ // we have properties which use the MID_FLAG_NO_PROPERTY_IMPORT flag since they need some special
+ // handling
+ rtl::Reference < SvXMLImportPropertyMapper > xImpPrMap = GetStyles()->GetImportPropertyMapper(GetFamily());
+
+ if(xImpPrMap.is())
+ {
+ // properties that need special handling because they need the used name to be translated first
+ struct ContextID_Index_Pair aContextIDs[] =
+ {
+ { CTF_PM_FILLGRADIENTNAME, -1, drawing::FillStyle::FillStyle_GRADIENT },
+ { CTF_PM_FILLTRANSNAME, -1, drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE },
+ { CTF_PM_FILLHATCHNAME, -1, drawing::FillStyle::FillStyle_HATCH },
+ { CTF_PM_FILLBITMAPNAME, -1, drawing::FillStyle::FillStyle_BITMAP },
+
+ // also need to special handling for header entries
+ { CTF_PM_HEADERFILLGRADIENTNAME, -1, drawing::FillStyle::FillStyle_GRADIENT },
+ { CTF_PM_HEADERFILLTRANSNAME, -1, drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE },
+ { CTF_PM_HEADERFILLHATCHNAME, -1, drawing::FillStyle::FillStyle_HATCH },
+ { CTF_PM_HEADERFILLBITMAPNAME, -1, drawing::FillStyle::FillStyle_BITMAP },
+
+ // also need to special handling for footer entries
+ { CTF_PM_FOOTERFILLGRADIENTNAME, -1, drawing::FillStyle::FillStyle_GRADIENT },
+ { CTF_PM_FOOTERFILLTRANSNAME, -1, drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE },
+ { CTF_PM_FOOTERFILLHATCHNAME, -1, drawing::FillStyle::FillStyle_HATCH },
+ { CTF_PM_FOOTERFILLBITMAPNAME, -1, drawing::FillStyle::FillStyle_BITMAP },
+
+ {-1, -1, drawing::FillStyle::FillStyle_GRADIENT}
+ };
+
+ // the style families associated with the same index modulo 4
+ static const XmlStyleFamily aFamilies[] =
+ {
+ XmlStyleFamily::SD_GRADIENT_ID,
+ XmlStyleFamily::SD_GRADIENT_ID,
+ XmlStyleFamily::SD_HATCH_ID,
+ XmlStyleFamily::SD_FILL_IMAGE_ID
+ };
+
+ // Fill PropertySet, but let it handle special properties not itself
+ xImpPrMap->FillPropertySet(GetProperties(), xPropSet, aContextIDs);
+
+ // get property set mapper
+ const rtl::Reference< XMLPropertySetMapper >& rMapper = xImpPrMap->getPropertySetMapper();
+ Reference<XPropertySetInfo> const xInfo(xPropSet->getPropertySetInfo());
+
+ // don't look at the attributes, look at the property, could
+ // theoretically be inherited and we don't want to delete erroneously
+ drawing::FillStyle fillStyle{drawing::FillStyle_NONE};
+ drawing::FillStyle fillStyleHeader{drawing::FillStyle_NONE};
+ drawing::FillStyle fillStyleFooter{drawing::FillStyle_NONE};
+ if (xInfo->hasPropertyByName("FillStyle")) // SwXTextDefaults lacks it?
+ {
+ xPropSet->getPropertyValue("FillStyle") >>= fillStyle;
+ xPropSet->getPropertyValue("HeaderFillStyle") >>= fillStyleHeader;
+ xPropSet->getPropertyValue("FooterFillStyle") >>= fillStyleFooter;
+ }
+
+ // handle special attributes which have MID_FLAG_NO_PROPERTY_IMPORT set
+ for(sal_uInt16 i = 0; aContextIDs[i].nContextID != -1; i++)
+ {
+ sal_Int32 nIndex = aContextIDs[i].nIndex;
+
+ if(nIndex != -1)
+ {
+ drawing::FillStyle const* pFillStyle(nullptr);
+ switch(aContextIDs[i].nContextID)
+ {
+ case CTF_PM_FILLGRADIENTNAME:
+ case CTF_PM_FILLTRANSNAME:
+ case CTF_PM_FILLHATCHNAME:
+ case CTF_PM_FILLBITMAPNAME:
+ pFillStyle = &fillStyle;
+ [[fallthrough]];
+ case CTF_PM_HEADERFILLGRADIENTNAME:
+ case CTF_PM_HEADERFILLTRANSNAME:
+ case CTF_PM_HEADERFILLHATCHNAME:
+ case CTF_PM_HEADERFILLBITMAPNAME:
+ if (!pFillStyle) { pFillStyle = &fillStyleHeader; }
+ [[fallthrough]];
+ case CTF_PM_FOOTERFILLGRADIENTNAME:
+ case CTF_PM_FOOTERFILLTRANSNAME:
+ case CTF_PM_FOOTERFILLHATCHNAME:
+ case CTF_PM_FOOTERFILLBITMAPNAME:
+ {
+ if (!pFillStyle) { pFillStyle = &fillStyleFooter; }
+ struct XMLPropertyState& rState = GetProperties()[nIndex];
+ OUString sStyleName;
+ rState.maValue >>= sStyleName;
+
+ if (aContextIDs[i].nExpectedFillStyle != drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE
+ && aContextIDs[i].nExpectedFillStyle != *pFillStyle)
+ {
+ SAL_INFO("xmloff.style", "PageStyleContext: dropping fill named item: " << sStyleName);
+ break; // ignore it, it's not used
+ }
+ // translate the used name from ODF intern to the name used in the Model
+ sStyleName = GetImport().GetStyleDisplayName(aFamilies[i%4], sStyleName);
+
+ try
+ {
+ // set property
+ const OUString& rPropertyName = rMapper->GetEntryAPIName(rState.mnIndex);
+
+ if(xInfo->hasPropertyByName(rPropertyName))
+ {
+ xPropSet->setPropertyValue(rPropertyName,Any(sStyleName));
+ }
+ }
+ catch(css::lang::IllegalArgumentException& e)
+ {
+ Sequence<OUString> aSeq { sStyleName };
+ GetImport().SetError(
+ XMLERROR_STYLE_PROP_VALUE | XMLERROR_FLAG_WARNING,
+ aSeq,e.Message,nullptr);
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ OSL_ENSURE(xImpPrMap.is(), "Got no SvXMLImportPropertyMapper (!)");
+ }
+
+ // pDrawingPageStyle overrides this
+ if (pDrawingPageStyle)
+ {
+ pDrawingPageStyle->FillPropertySet(xPropSet);
+ }
+ // horrible heuristic to guess BackgroundFullSize for Writer < 7.0
+ else if (!IsDefaultStyle() // ignore pool default, only fix existing styles
+ && (GetImport().isGeneratorVersionOlderThan(SvXMLImport::AOO_4x, SvXMLImport::LO_7x)
+ // also for AOO 4.x, assume there won't ever be a 4.2
+ || GetImport().getGeneratorVersion() == SvXMLImport::AOO_4x))
+ {
+ bool isFullSize(true); // default is current LO default
+ drawing::FillStyle fillStyle{drawing::FillStyle_NONE};
+ xPropSet->getPropertyValue("FillStyle") >>= fillStyle;
+ if (GetImport().isGeneratorVersionOlderThan(SvXMLImport::AOO_4x, SvXMLImport::LO_63x)
+ // also for AOO 4.x, assume there won't ever be a 4.2
+ || GetImport().getGeneratorVersion() == SvXMLImport::AOO_4x)
+ {
+ // before LO 6.3, always inside the margins (but ignore it if NONE)
+ if (fillStyle != drawing::FillStyle_NONE)
+ {
+ isFullSize = false;
+ }
+ }
+ else
+ {
+ // LO 6.3/6.4: guess depending on fill style/bitmap mode
+ // this should work even if the document doesn't contain fill style
+ // but only old background attributes
+ // (can't use the aContextIDs stuff above because that requires
+ // re-routing through handleSpecialItem())
+ switch (fillStyle)
+ {
+ case drawing::FillStyle_NONE:
+ break;
+ case drawing::FillStyle_SOLID:
+ case drawing::FillStyle_GRADIENT:
+ case drawing::FillStyle_HATCH:
+ isFullSize = true;
+ break;
+ case drawing::FillStyle_BITMAP:
+ {
+ drawing::BitmapMode bitmapMode{};
+ xPropSet->getPropertyValue("FillBitmapMode") >>= bitmapMode;
+ switch (bitmapMode)
+ {
+ case drawing::BitmapMode_REPEAT:
+ isFullSize = true;
+ break;
+ case drawing::BitmapMode_STRETCH:
+ case drawing::BitmapMode_NO_REPEAT:
+ isFullSize = false;
+ break;
+ default:
+ assert(false);
+ }
+ }
+ break;
+ default:
+ assert(false);
+ }
+ }
+ // set it explicitly if it's not the default
+ if (!isFullSize)
+ {
+ SAL_INFO("xmloff.style", "FillPropertySet_PageStyle: Heuristically resetting BackgroundFullSize");
+ xPropSet->setPropertyValue("BackgroundFullSize", uno::Any(isFullSize));
+ }
+ }
+
+ // old code, replaced by above stuff
+ // XMLPropStyleContext::FillPropertySet(rPropSet);
+
+ if (!sPageUsage.isEmpty())
+ {
+ uno::Any aPageUsage;
+ XMLPMPropHdl_PageStyleLayout aPageUsageHdl;
+ if (aPageUsageHdl.importXML(sPageUsage, aPageUsage, GetImport().GetMM100UnitConverter()))
+ xPropSet->setPropertyValue("PageStyleLayout", aPageUsage);
+ }
+}
+
+extern ContextID_Index_Pair const g_MasterPageContextIDs[] =
+{
+ { CTF_PM_FILLGRADIENTNAME, -1, drawing::FillStyle::FillStyle_GRADIENT },
+ { CTF_PM_FILLTRANSNAME, -1, drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE },
+ { CTF_PM_FILLHATCHNAME, -1, drawing::FillStyle::FillStyle_HATCH },
+ { CTF_PM_FILLBITMAPNAME, -1, drawing::FillStyle::FillStyle_BITMAP },
+
+ {-1, -1, drawing::FillStyle::FillStyle_MAKE_FIXED_SIZE}
+};
+
+extern XmlStyleFamily const g_MasterPageFamilies[] =
+{
+ XmlStyleFamily::SD_GRADIENT_ID,
+ XmlStyleFamily::SD_GRADIENT_ID,
+ XmlStyleFamily::SD_HATCH_ID,
+ XmlStyleFamily::SD_FILL_IMAGE_ID
+};
+
+// text grid enhancement for better CJK support
+//set default page layout style
+void PageStyleContext::SetDefaults( )
+{
+ Reference < XMultiServiceFactory > xFactory ( GetImport().GetModel(), UNO_QUERY);
+ if (xFactory.is())
+ {
+ Reference < XInterface > xInt = xFactory->createInstance( "com.sun.star.text.Defaults" );
+ Reference < beans::XPropertySet > xProperties ( xInt, UNO_QUERY );
+ if ( xProperties.is() )
+ FillPropertySet_PageStyle(xProperties, nullptr);
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/PageMasterImportPropMapper.cxx b/xmloff/source/style/PageMasterImportPropMapper.cxx
new file mode 100644
index 000000000..d4eba7601
--- /dev/null
+++ b/xmloff/source/style/PageMasterImportPropMapper.cxx
@@ -0,0 +1,521 @@
+/* -*- 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 "PageMasterImportPropMapper.hxx"
+#include <PageMasterStyleMap.hxx>
+#include <xmloff/maptype.hxx>
+#include <com/sun/star/table/BorderLine2.hpp>
+#include <com/sun/star/container/XNameContainer.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmlprmap.hxx>
+#include <memory>
+
+#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::container;
+
+PageMasterImportPropertyMapper::PageMasterImportPropertyMapper(
+ const rtl::Reference< XMLPropertySetMapper >& rMapper,
+ SvXMLImport& rImp ) :
+ SvXMLImportPropertyMapper( rMapper, rImp ),
+ rImport( rImp )
+{
+}
+
+PageMasterImportPropertyMapper::~PageMasterImportPropertyMapper()
+{
+}
+
+bool PageMasterImportPropertyMapper::handleSpecialItem(
+ XMLPropertyState& rProperty,
+ std::vector< XMLPropertyState >& rProperties,
+ const OUString& rValue,
+ const SvXMLUnitConverter& rUnitConverter,
+ const SvXMLNamespaceMap& rNamespaceMap ) const
+{
+ bool bRet = false;
+ sal_Int16 nContextID =
+ getPropertySetMapper()->GetEntryContextId(rProperty.mnIndex);
+
+ if( CTF_PM_REGISTER_STYLE==nContextID )
+ {
+ OUString sDisplayName( rImport.GetStyleDisplayName(
+ XmlStyleFamily::TEXT_PARAGRAPH, rValue ) );
+ Reference < XNameContainer > xParaStyles =
+ rImport.GetTextImport()->GetParaStyles();
+ if( xParaStyles.is() && xParaStyles->hasByName( sDisplayName ) )
+ {
+ rProperty.maValue <<= sDisplayName;
+ bRet = true;
+ }
+ }
+ else
+ {
+ bRet = SvXMLImportPropertyMapper::handleSpecialItem(
+ rProperty, rProperties, rValue,
+ rUnitConverter, rNamespaceMap );
+ }
+
+ return bRet;
+}
+
+
+void PageMasterImportPropertyMapper::finished(std::vector< XMLPropertyState >& rProperties, sal_Int32 nStartIndex, sal_Int32 nEndIndex ) const
+{
+ SvXMLImportPropertyMapper::finished(rProperties, nStartIndex, nEndIndex);
+ XMLPropertyState* pAllPaddingProperty = nullptr;
+ XMLPropertyState* pPadding[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pNewPadding[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pAllBorderProperty = nullptr;
+ XMLPropertyState* pBorders[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pNewBorders[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pAllBorderWidthProperty = nullptr;
+ XMLPropertyState* pBorderWidths[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pAllHeaderPaddingProperty = nullptr;
+ XMLPropertyState* pHeaderPadding[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pHeaderNewPadding[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pAllHeaderBorderProperty = nullptr;
+ XMLPropertyState* pHeaderBorders[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pHeaderNewBorders[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pAllHeaderBorderWidthProperty = nullptr;
+ XMLPropertyState* pHeaderBorderWidths[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pAllFooterPaddingProperty = nullptr;
+ XMLPropertyState* pFooterPadding[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pFooterNewPadding[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pAllFooterBorderProperty = nullptr;
+ XMLPropertyState* pFooterBorders[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pFooterNewBorders[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pAllFooterBorderWidthProperty = nullptr;
+ XMLPropertyState* pFooterBorderWidths[4] = { nullptr, nullptr, nullptr, nullptr };
+ XMLPropertyState* pHeaderHeight = nullptr;
+ XMLPropertyState* pHeaderMinHeight = nullptr;
+ std::optional<XMLPropertyState> xHeaderDynamic;
+ XMLPropertyState* pFooterHeight = nullptr;
+ XMLPropertyState* pFooterMinHeight = nullptr;
+ std::optional<XMLPropertyState> xFooterDynamic;
+ XMLPropertyState* pAllMarginProperty = nullptr;
+ XMLPropertyState* pMargins[4] = { nullptr, nullptr, nullptr, nullptr };
+ std::optional<XMLPropertyState> pNewMargins[4];
+ XMLPropertyState* pAllHeaderMarginProperty = nullptr;
+ XMLPropertyState* pHeaderMargins[4] = { nullptr, nullptr, nullptr, nullptr };
+ std::optional<XMLPropertyState> pNewHeaderMargins[4];
+ XMLPropertyState* pAllFooterMarginProperty = nullptr;
+ XMLPropertyState* pFooterMargins[4] = { nullptr, nullptr, nullptr, nullptr };
+ std::optional<XMLPropertyState> pNewFooterMargins[4];
+ XMLPropertyState* pMarginGutter = nullptr;
+ XMLPropertyState* pRtlGutter = nullptr;
+
+ for (auto& rProp : rProperties)
+ {
+ XMLPropertyState *property = &rProp;
+ sal_Int16 nContextID = getPropertySetMapper()->GetEntryContextId(property->mnIndex);
+ if (property->mnIndex >= nStartIndex && property->mnIndex < nEndIndex)
+ {
+ switch (nContextID)
+ {
+ case CTF_PM_PADDINGALL : pAllPaddingProperty = property; break;
+ case CTF_PM_PADDINGLEFT : pPadding[XML_LINE_LEFT] = property; break;
+ case CTF_PM_PADDINGRIGHT : pPadding[XML_LINE_RIGHT] = property; break;
+ case CTF_PM_PADDINGTOP : pPadding[XML_LINE_TOP] = property; break;
+ case CTF_PM_PADDINGBOTTOM : pPadding[XML_LINE_BOTTOM] = property; break;
+ case CTF_PM_BORDERALL : pAllBorderProperty = property; break;
+ case CTF_PM_BORDERLEFT : pBorders[XML_LINE_LEFT] = property; break;
+ case CTF_PM_BORDERRIGHT : pBorders[XML_LINE_RIGHT] = property; break;
+ case CTF_PM_BORDERTOP : pBorders[XML_LINE_TOP] = property; break;
+ case CTF_PM_BORDERBOTTOM : pBorders[XML_LINE_BOTTOM] = property; break;
+ case CTF_PM_BORDERWIDTHALL : pAllBorderWidthProperty = property; break;
+ case CTF_PM_BORDERWIDTHLEFT : pBorderWidths[XML_LINE_LEFT] = property; break;
+ case CTF_PM_BORDERWIDTHRIGHT : pBorderWidths[XML_LINE_RIGHT] = property; break;
+ case CTF_PM_BORDERWIDTHTOP : pBorderWidths[XML_LINE_TOP] = property; break;
+ case CTF_PM_BORDERWIDTHBOTTOM : pBorderWidths[XML_LINE_BOTTOM] = property; break;
+ case CTF_PM_HEADERPADDINGALL : pAllHeaderPaddingProperty = property; break;
+ case CTF_PM_HEADERPADDINGLEFT : pHeaderPadding[XML_LINE_LEFT] = property; break;
+ case CTF_PM_HEADERPADDINGRIGHT : pHeaderPadding[XML_LINE_RIGHT] = property; break;
+ case CTF_PM_HEADERPADDINGTOP : pHeaderPadding[XML_LINE_TOP] = property; break;
+ case CTF_PM_HEADERPADDINGBOTTOM : pHeaderPadding[XML_LINE_BOTTOM] = property; break;
+ case CTF_PM_HEADERBORDERALL : pAllHeaderBorderProperty = property; break;
+ case CTF_PM_HEADERBORDERLEFT : pHeaderBorders[XML_LINE_LEFT] = property; break;
+ case CTF_PM_HEADERBORDERRIGHT : pHeaderBorders[XML_LINE_RIGHT] = property; break;
+ case CTF_PM_HEADERBORDERTOP : pHeaderBorders[XML_LINE_TOP] = property; break;
+ case CTF_PM_HEADERBORDERBOTTOM : pHeaderBorders[XML_LINE_BOTTOM] = property; break;
+ case CTF_PM_HEADERBORDERWIDTHALL : pAllHeaderBorderWidthProperty = property; break;
+ case CTF_PM_HEADERBORDERWIDTHLEFT : pHeaderBorderWidths[XML_LINE_LEFT] = property; break;
+ case CTF_PM_HEADERBORDERWIDTHRIGHT : pHeaderBorderWidths[XML_LINE_RIGHT] = property; break;
+ case CTF_PM_HEADERBORDERWIDTHTOP : pHeaderBorderWidths[XML_LINE_TOP] = property; break;
+ case CTF_PM_HEADERBORDERWIDTHBOTTOM : pHeaderBorderWidths[XML_LINE_BOTTOM] = property; break;
+ case CTF_PM_FOOTERPADDINGALL : pAllFooterPaddingProperty = property; break;
+ case CTF_PM_FOOTERPADDINGLEFT : pFooterPadding[XML_LINE_LEFT] = property; break;
+ case CTF_PM_FOOTERPADDINGRIGHT : pFooterPadding[XML_LINE_RIGHT] = property; break;
+ case CTF_PM_FOOTERPADDINGTOP : pFooterPadding[XML_LINE_TOP] = property; break;
+ case CTF_PM_FOOTERPADDINGBOTTOM : pFooterPadding[XML_LINE_BOTTOM] = property; break;
+ case CTF_PM_FOOTERBORDERALL : pAllFooterBorderProperty = property; break;
+ case CTF_PM_FOOTERBORDERLEFT : pFooterBorders[XML_LINE_LEFT] = property; break;
+ case CTF_PM_FOOTERBORDERRIGHT : pFooterBorders[XML_LINE_RIGHT] = property; break;
+ case CTF_PM_FOOTERBORDERTOP : pFooterBorders[XML_LINE_TOP] = property; break;
+ case CTF_PM_FOOTERBORDERBOTTOM : pFooterBorders[XML_LINE_BOTTOM] = property; break;
+ case CTF_PM_FOOTERBORDERWIDTHALL : pAllFooterBorderWidthProperty = property; break;
+ case CTF_PM_FOOTERBORDERWIDTHLEFT : pFooterBorderWidths[XML_LINE_LEFT] = property; break;
+ case CTF_PM_FOOTERBORDERWIDTHRIGHT : pFooterBorderWidths[XML_LINE_RIGHT] = property; break;
+ case CTF_PM_FOOTERBORDERWIDTHTOP : pFooterBorderWidths[XML_LINE_TOP] = property; break;
+ case CTF_PM_FOOTERBORDERWIDTHBOTTOM : pFooterBorderWidths[XML_LINE_BOTTOM] = property; break;
+ case CTF_PM_HEADERHEIGHT : pHeaderHeight = property; break;
+ case CTF_PM_HEADERMINHEIGHT : pHeaderMinHeight = property; break;
+ case CTF_PM_FOOTERHEIGHT : pFooterHeight = property; break;
+ case CTF_PM_FOOTERMINHEIGHT : pFooterMinHeight = property; break;
+ case CTF_PM_MARGINALL :
+ pAllMarginProperty = property; break;
+ case CTF_PM_MARGINTOP :
+ pMargins[XML_LINE_TOP] = property; break;
+ case CTF_PM_MARGINBOTTOM:
+ pMargins[XML_LINE_BOTTOM] = property; break;
+ case CTF_PM_MARGINLEFT :
+ pMargins[XML_LINE_LEFT] = property; break;
+ case CTF_PM_MARGINRIGHT :
+ pMargins[XML_LINE_RIGHT] = property; break;
+ case CTF_PM_MARGINGUTTER:
+ pMarginGutter = property;
+ break;
+ case CTF_PM_RTLGUTTER:
+ pRtlGutter = property;
+ break;
+ case CTF_PM_HEADERMARGINALL :
+ pAllHeaderMarginProperty = property; break;
+ case CTF_PM_HEADERMARGINTOP :
+ pHeaderMargins[XML_LINE_TOP] = property; break;
+ case CTF_PM_HEADERMARGINBOTTOM:
+ pHeaderMargins[XML_LINE_BOTTOM] = property; break;
+ case CTF_PM_HEADERMARGINLEFT :
+ pHeaderMargins[XML_LINE_LEFT] = property; break;
+ case CTF_PM_HEADERMARGINRIGHT :
+ pHeaderMargins[XML_LINE_RIGHT] = property; break;
+ case CTF_PM_FOOTERMARGINALL :
+ pAllFooterMarginProperty = property; break;
+ case CTF_PM_FOOTERMARGINTOP :
+ pFooterMargins[XML_LINE_TOP] = property; break;
+ case CTF_PM_FOOTERMARGINBOTTOM:
+ pFooterMargins[XML_LINE_BOTTOM] = property; break;
+ case CTF_PM_FOOTERMARGINLEFT :
+ pFooterMargins[XML_LINE_LEFT] = property; break;
+ case CTF_PM_FOOTERMARGINRIGHT :
+ pFooterMargins[XML_LINE_RIGHT] = property; break;
+ }
+ }
+ }
+
+ for (sal_uInt16 i = 0; i < 4; i++)
+ {
+ if (pAllMarginProperty && !pMargins[i])
+ {
+ pNewMargins[i].emplace(
+ pAllMarginProperty->mnIndex + 1 + i,
+ pAllMarginProperty->maValue);
+ }
+ if (pAllHeaderMarginProperty && !pHeaderMargins[i])
+ {
+ pNewHeaderMargins[i].emplace(
+ pAllHeaderMarginProperty->mnIndex + 1 + i,
+ pAllHeaderMarginProperty->maValue);
+ }
+ if (pAllFooterMarginProperty && !pFooterMargins[i])
+ {
+ pNewFooterMargins[i].emplace(
+ pAllFooterMarginProperty->mnIndex + 1 + i,
+ pAllFooterMarginProperty->maValue);
+ }
+ if (pAllPaddingProperty && !pPadding[i])
+ pNewPadding[i] = new XMLPropertyState(pAllPaddingProperty->mnIndex + 1 + i, pAllPaddingProperty->maValue);
+ if (pAllBorderProperty && !pBorders[i])
+ {
+ pNewBorders[i] = new XMLPropertyState(pAllBorderProperty->mnIndex + 1 + i, pAllBorderProperty->maValue);
+ pBorders[i] = pNewBorders[i];
+ }
+ if( !pBorderWidths[i] )
+ pBorderWidths[i] = pAllBorderWidthProperty;
+ else
+ pBorderWidths[i]->mnIndex = -1;
+ if( pBorders[i] )
+ {
+ table::BorderLine2 aBorderLine;
+ pBorders[i]->maValue >>= aBorderLine;
+ if( pBorderWidths[i] )
+ {
+ table::BorderLine2 aBorderLineWidth;
+ pBorderWidths[i]->maValue >>= aBorderLineWidth;
+ aBorderLine.OuterLineWidth = aBorderLineWidth.OuterLineWidth;
+ aBorderLine.InnerLineWidth = aBorderLineWidth.InnerLineWidth;
+ aBorderLine.LineDistance = aBorderLineWidth.LineDistance;
+ aBorderLine.LineWidth = aBorderLineWidth.LineWidth;
+ pBorders[i]->maValue <<= aBorderLine;
+ }
+ }
+ if (pAllHeaderPaddingProperty && !pHeaderPadding[i])
+ pHeaderNewPadding[i] = new XMLPropertyState(pAllHeaderPaddingProperty->mnIndex + 1 + i, pAllHeaderPaddingProperty->maValue);
+ if (pAllHeaderBorderProperty && !pHeaderBorders[i])
+ pHeaderNewBorders[i] = new XMLPropertyState(pAllHeaderBorderProperty->mnIndex + 1 + i, pAllHeaderBorderProperty->maValue);
+ if( !pHeaderBorderWidths[i] )
+ pHeaderBorderWidths[i] = pAllHeaderBorderWidthProperty;
+ else
+ pHeaderBorderWidths[i]->mnIndex = -1;
+ if( pHeaderBorders[i] )
+ {
+ table::BorderLine2 aBorderLine;
+ pHeaderBorders[i]->maValue >>= aBorderLine;
+ if( pHeaderBorderWidths[i] )
+ {
+ table::BorderLine2 aBorderLineWidth;
+ pHeaderBorderWidths[i]->maValue >>= aBorderLineWidth;
+ aBorderLine.OuterLineWidth = aBorderLineWidth.OuterLineWidth;
+ aBorderLine.InnerLineWidth = aBorderLineWidth.InnerLineWidth;
+ aBorderLine.LineDistance = aBorderLineWidth.LineDistance;
+ aBorderLine.LineWidth = aBorderLineWidth.LineWidth;
+ pHeaderBorders[i]->maValue <<= aBorderLine;
+ }
+ }
+ if (pAllFooterPaddingProperty && !pFooterPadding[i])
+ pFooterNewPadding[i] = new XMLPropertyState(pAllFooterPaddingProperty->mnIndex + 1 + i, pAllFooterPaddingProperty->maValue);
+ if (pAllFooterBorderProperty && !pFooterBorders[i])
+ pFooterNewBorders[i] = new XMLPropertyState(pAllFooterBorderProperty->mnIndex + 1 + i, pAllFooterBorderProperty->maValue);
+ if( !pFooterBorderWidths[i] )
+ pFooterBorderWidths[i] = pAllFooterBorderWidthProperty;
+ else
+ pFooterBorderWidths[i]->mnIndex = -1;
+ if( pFooterBorders[i] )
+ {
+ table::BorderLine2 aBorderLine;
+ pFooterBorders[i]->maValue >>= aBorderLine;
+ if( pFooterBorderWidths[i] )
+ {
+ table::BorderLine2 aBorderLineWidth;
+ pFooterBorderWidths[i]->maValue >>= aBorderLineWidth;
+ aBorderLine.OuterLineWidth = aBorderLineWidth.OuterLineWidth;
+ aBorderLine.InnerLineWidth = aBorderLineWidth.InnerLineWidth;
+ aBorderLine.LineDistance = aBorderLineWidth.LineDistance;
+ aBorderLine.LineWidth = aBorderLineWidth.LineWidth;
+ pFooterBorders[i]->maValue <<= aBorderLine;
+ }
+ }
+ }
+
+ if (pHeaderHeight)
+ {
+ xHeaderDynamic.emplace(pHeaderHeight->mnIndex + 2, Any(false));
+ }
+ if (pHeaderMinHeight)
+ {
+ xHeaderDynamic.emplace(pHeaderMinHeight->mnIndex + 1, Any(true));
+ }
+ if (pFooterHeight)
+ {
+ xFooterDynamic.emplace(pFooterHeight->mnIndex + 2, Any(false));
+ }
+ if (pFooterMinHeight)
+ {
+ xFooterDynamic.emplace(pFooterMinHeight->mnIndex + 1, Any(true));
+ }
+
+ // fdo#38056: nerf the various AllFoo properties so they do not override
+ // the individual Foo properties later on
+ if (pAllPaddingProperty)
+ {
+ pAllPaddingProperty->mnIndex = -1;
+ }
+ if (pAllBorderProperty)
+ {
+ pAllBorderProperty->mnIndex = -1;
+ }
+ if (pAllBorderWidthProperty)
+ {
+ pAllBorderWidthProperty->mnIndex = -1;
+ }
+ if (pAllHeaderPaddingProperty)
+ {
+ pAllHeaderPaddingProperty->mnIndex = -1;
+ }
+ if (pAllHeaderBorderProperty)
+ {
+ pAllHeaderBorderProperty->mnIndex = -1;
+ }
+ if (pAllHeaderBorderWidthProperty)
+ {
+ pAllHeaderBorderWidthProperty->mnIndex = -1;
+ }
+ if (pAllFooterPaddingProperty)
+ {
+ pAllFooterPaddingProperty->mnIndex = -1;
+ }
+ if (pAllFooterBorderProperty)
+ {
+ pAllFooterBorderProperty->mnIndex = -1;
+ }
+ if (pAllFooterBorderWidthProperty)
+ {
+ pAllFooterBorderWidthProperty->mnIndex = -1;
+ }
+ if (pAllMarginProperty)
+ {
+ pAllMarginProperty->mnIndex = -1;
+ }
+ if (pAllHeaderMarginProperty)
+ {
+ pAllHeaderMarginProperty->mnIndex = -1;
+ }
+ if (pAllFooterMarginProperty)
+ {
+ pAllFooterMarginProperty->mnIndex = -1;
+ }
+
+ if (pMarginGutter)
+ {
+ sal_Int32 nGutterMargin{};
+ pMarginGutter->maValue >>= nGutterMargin;
+
+ bool bGutterAtTop{};
+ uno::Reference<lang::XServiceInfo> xSI(GetImport().GetModel(), uno::UNO_QUERY);
+ if (xSI.is() && xSI->supportsService("com.sun.star.text.TextDocument"))
+ {
+ uno::Reference<lang::XMultiServiceFactory> xFac(GetImport().GetModel(), uno::UNO_QUERY);
+ if (xFac.is())
+ {
+ uno::Reference<beans::XPropertySet> xProps(
+ xFac->createInstance("com.sun.star.document.Settings"), uno::UNO_QUERY);
+ if (xProps.is())
+ {
+ xProps->getPropertyValue("GutterAtTop") >>= bGutterAtTop;
+ }
+ }
+ }
+ if (bGutterAtTop)
+ {
+ if (nGutterMargin && pMargins[XML_LINE_TOP])
+ {
+ // Decrease top margin to not include gutter.
+ sal_Int32 nTopMargin{};
+ pMargins[XML_LINE_TOP]->maValue >>= nTopMargin;
+ nTopMargin -= nGutterMargin;
+ pMargins[XML_LINE_TOP]->maValue <<= nTopMargin;
+ }
+ }
+ else
+ {
+ bool bRtlGutter{};
+ if (nGutterMargin && pRtlGutter)
+ {
+ pRtlGutter->maValue >>= bRtlGutter;
+ }
+ if (bRtlGutter)
+ {
+ if (nGutterMargin && pMargins[XML_LINE_RIGHT])
+ {
+ // Decrease right margin to not include gutter.
+ sal_Int32 nRightMargin{};
+ pMargins[XML_LINE_RIGHT]->maValue >>= nRightMargin;
+ nRightMargin -= nGutterMargin;
+ pMargins[XML_LINE_RIGHT]->maValue <<= nRightMargin;
+ }
+ }
+ else
+ {
+ if (nGutterMargin && pMargins[XML_LINE_LEFT])
+ {
+ // Decrease left margin to not include gutter.
+ sal_Int32 nLeftMargin{};
+ pMargins[XML_LINE_LEFT]->maValue >>= nLeftMargin;
+ nLeftMargin -= nGutterMargin;
+ pMargins[XML_LINE_LEFT]->maValue <<= nLeftMargin;
+ }
+ }
+ }
+ }
+
+ // CAUTION!
+ // The following code adds into the rProperties vector, so all the
+ // XMLPropertyState* pointers that are pointing to the rProperties
+ // elements could potentially be deallocated, so don't use them after
+ // this!
+ for (sal_uInt16 i = 0; i < 4; i++)
+ {
+ if (pNewMargins[i])
+ {
+ rProperties.push_back(*pNewMargins[i]);
+ }
+ if (pNewHeaderMargins[i])
+ {
+ rProperties.push_back(*pNewHeaderMargins[i]);
+ }
+ if (pNewFooterMargins[i])
+ {
+ rProperties.push_back(*pNewFooterMargins[i]);
+ }
+ if (pNewPadding[i])
+ {
+ rProperties.push_back(*pNewPadding[i]);
+ delete pNewPadding[i];
+ }
+ if (pNewBorders[i])
+ {
+ rProperties.push_back(*pNewBorders[i]);
+ delete pNewBorders[i];
+ }
+ if (pHeaderNewPadding[i])
+ {
+ rProperties.push_back(*pHeaderNewPadding[i]);
+ delete pHeaderNewPadding[i];
+ }
+ if (pHeaderNewBorders[i])
+ {
+ rProperties.push_back(*pHeaderNewBorders[i]);
+ delete pHeaderNewBorders[i];
+ }
+ if (pFooterNewPadding[i])
+ {
+ rProperties.push_back(*pFooterNewPadding[i]);
+ delete pFooterNewPadding[i];
+ }
+ if (pFooterNewBorders[i])
+ {
+ rProperties.push_back(*pFooterNewBorders[i]);
+ delete pFooterNewBorders[i];
+ }
+ }
+ // CAUTION - do not use XMLPropertyState* pointers (like pMargins,
+ // pMarginGutter) after this.
+
+ if(xHeaderDynamic)
+ {
+ rProperties.push_back(*xHeaderDynamic);
+ xHeaderDynamic.reset();
+ }
+ if(xFooterDynamic)
+ {
+ rProperties.push_back(*xFooterDynamic);
+ xFooterDynamic.reset();
+ }
+
+}
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/PageMasterImportPropMapper.hxx b/xmloff/source/style/PageMasterImportPropMapper.hxx
new file mode 100644
index 000000000..1493ffd6b
--- /dev/null
+++ b/xmloff/source/style/PageMasterImportPropMapper.hxx
@@ -0,0 +1,53 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlimppr.hxx>
+
+class SvXMLImport;
+
+class PageMasterImportPropertyMapper : public SvXMLImportPropertyMapper
+{
+ SvXMLImport& rImport;
+
+protected:
+
+public:
+
+ PageMasterImportPropertyMapper(
+ const rtl::Reference< XMLPropertySetMapper >& rMapper,
+ SvXMLImport& rImp);
+ virtual ~PageMasterImportPropertyMapper() override;
+
+ /** this method is called for every item that has the MID_FLAG_SPECIAL_ITEM_IMPORT flag set */
+ virtual bool handleSpecialItem(
+ XMLPropertyState& rProperty,
+ ::std::vector< XMLPropertyState >& rProperties,
+ const OUString& rValue,
+ const SvXMLUnitConverter& rUnitConverter,
+ const SvXMLNamespaceMap& rNamespaceMap ) const override;
+
+ /** This method is called when all attributes have been processed. It may be used to remove items that are incomplete */
+ virtual void finished(
+ ::std::vector< XMLPropertyState >& rProperties,
+ sal_Int32 nStartIndex, sal_Int32 nEndIndex ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/PageMasterPropHdl.cxx b/xmloff/source/style/PageMasterPropHdl.cxx
new file mode 100644
index 000000000..c1fb9010b
--- /dev/null
+++ b/xmloff/source/style/PageMasterPropHdl.cxx
@@ -0,0 +1,398 @@
+/* -*- 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 "PageMasterPropHdl.hxx"
+
+#include <sax/tools/converter.hxx>
+
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/style/PageStyleLayout.hpp>
+#include <com/sun/star/style/NumberingType.hpp>
+#include <comphelper/types.hxx>
+#include <comphelper/extract.hxx>
+#include <o3tl/string_view.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::style;
+using namespace ::comphelper;
+using namespace ::xmloff::token;
+
+#define DEFAULT_PAPERTRAY (sal_Int32(-1))
+
+// property handler for style:page-usage (style::PageStyleLayout)
+
+XMLPMPropHdl_PageStyleLayout::~XMLPMPropHdl_PageStyleLayout()
+{
+}
+
+bool XMLPMPropHdl_PageStyleLayout::equals( const Any& rAny1, const Any& rAny2 ) const
+{
+ style::PageStyleLayout eLayout1, eLayout2;
+ return (rAny1 >>= eLayout1) && (rAny2 >>= eLayout2) && (eLayout1 == eLayout2);
+}
+
+bool XMLPMPropHdl_PageStyleLayout::importXML(
+ const OUString& rStrImpValue,
+ Any& rValue,
+ const SvXMLUnitConverter& ) const
+{
+ bool bRet = true;
+
+ if( IsXMLToken( rStrImpValue, XML_ALL ) )
+ rValue <<= PageStyleLayout_ALL;
+ else if( IsXMLToken( rStrImpValue, XML_LEFT ) )
+ rValue <<= PageStyleLayout_LEFT;
+ else if( IsXMLToken( rStrImpValue, XML_RIGHT ) )
+ rValue <<= PageStyleLayout_RIGHT;
+ else if( IsXMLToken( rStrImpValue, XML_MIRRORED ) )
+ rValue <<= PageStyleLayout_MIRRORED;
+ else
+ bRet = false;
+
+ return bRet;
+}
+
+bool XMLPMPropHdl_PageStyleLayout::exportXML(
+ OUString& rStrExpValue,
+ const Any& rValue,
+ const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ PageStyleLayout eLayout;
+
+ if( rValue >>= eLayout )
+ {
+ bRet = true;
+ switch( eLayout )
+ {
+ case PageStyleLayout_ALL:
+ rStrExpValue = GetXMLToken( XML_ALL );
+ break;
+ case PageStyleLayout_LEFT:
+ rStrExpValue = GetXMLToken( XML_LEFT );
+ break;
+ case PageStyleLayout_RIGHT:
+ rStrExpValue = GetXMLToken( XML_RIGHT );
+ break;
+ case PageStyleLayout_MIRRORED:
+ rStrExpValue = GetXMLToken( XML_MIRRORED );
+ break;
+ default:
+ bRet = false;
+ }
+ }
+
+ return bRet;
+}
+
+// property handler for style:num-format (style::NumberingType)
+
+XMLPMPropHdl_NumFormat::~XMLPMPropHdl_NumFormat()
+{
+}
+
+bool XMLPMPropHdl_NumFormat::importXML(
+ const OUString& rStrImpValue,
+ Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter ) const
+{
+ sal_Int16 nSync = sal_Int16();
+ sal_Int16 nNumType = NumberingType::NUMBER_NONE;
+ rUnitConverter.convertNumFormat( nNumType, rStrImpValue, u"", true );
+
+ if( !(rValue >>= nSync) )
+ nSync = NumberingType::NUMBER_NONE;
+
+ // if num-letter-sync appears before num-format, the function
+ // XMLPMPropHdl_NumLetterSync::importXML() sets the value
+ // NumberingType::CHARS_LOWER_LETTER_N
+ if( nSync == NumberingType::CHARS_LOWER_LETTER_N )
+ {
+ switch( nNumType )
+ {
+ case NumberingType::CHARS_LOWER_LETTER:
+ nNumType = NumberingType::CHARS_LOWER_LETTER_N;
+ break;
+ case NumberingType::CHARS_UPPER_LETTER:
+ nNumType = NumberingType::CHARS_UPPER_LETTER_N;
+ break;
+ }
+ }
+ rValue <<= nNumType;
+
+ return true;
+}
+
+bool XMLPMPropHdl_NumFormat::exportXML(
+ OUString& rStrExpValue,
+ const Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter ) const
+{
+ bool bRet = false;
+ sal_Int16 nNumType = sal_Int16();
+
+ if( rValue >>= nNumType )
+ {
+ OUStringBuffer aBuffer( 10 );
+ rUnitConverter.convertNumFormat( aBuffer, nNumType );
+ rStrExpValue = aBuffer.makeStringAndClear();
+ bRet = true;
+ }
+ return bRet;
+}
+
+// property handler for style:num-letter-sync (style::NumberingType)
+
+XMLPMPropHdl_NumLetterSync::~XMLPMPropHdl_NumLetterSync()
+{
+}
+
+bool XMLPMPropHdl_NumLetterSync::importXML(
+ const OUString& rStrImpValue,
+ Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter ) const
+{
+ sal_Int16 nNumType;
+ sal_Int16 nSync = NumberingType::NUMBER_NONE;
+ rUnitConverter.convertNumFormat( nSync, rStrImpValue,
+ GetXMLToken( XML_A ), true );
+
+ if( !(rValue >>= nNumType) )
+ nNumType = NumberingType::NUMBER_NONE;
+
+ if( nSync == NumberingType::CHARS_LOWER_LETTER_N )
+ {
+ switch( nNumType )
+ {
+ case NumberingType::CHARS_LOWER_LETTER:
+ nNumType = NumberingType::CHARS_LOWER_LETTER_N;
+ break;
+ case NumberingType::CHARS_UPPER_LETTER:
+ nNumType = NumberingType::CHARS_UPPER_LETTER_N;
+ break;
+ }
+ }
+ rValue <<= nNumType;
+
+ return true;
+}
+
+bool XMLPMPropHdl_NumLetterSync::exportXML(
+ OUString& rStrExpValue,
+ const Any& rValue,
+ const SvXMLUnitConverter& /*rUnitConverter*/ ) const
+{
+ bool bRet = false;
+ sal_Int16 nNumType = sal_Int16();
+
+ if( rValue >>= nNumType )
+ {
+ OUStringBuffer aBuffer( 5 );
+ SvXMLUnitConverter::convertNumLetterSync( aBuffer, nNumType );
+ rStrExpValue = aBuffer.makeStringAndClear();
+ bRet = !rStrExpValue.isEmpty();
+ }
+ return bRet;
+}
+
+// property handler for style:paper-tray-number
+
+XMLPMPropHdl_PaperTrayNumber::~XMLPMPropHdl_PaperTrayNumber()
+{
+}
+
+bool XMLPMPropHdl_PaperTrayNumber::importXML(
+ const OUString& rStrImpValue,
+ Any& rValue,
+ const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+
+ if( IsXMLToken( rStrImpValue, XML_DEFAULT ) )
+ {
+ rValue <<= DEFAULT_PAPERTRAY;
+ bRet = true;
+ }
+ else
+ {
+ sal_Int32 nPaperTray;
+ if (::sax::Converter::convertNumber( nPaperTray, rStrImpValue, 0 ))
+ {
+ rValue <<= nPaperTray;
+ bRet = true;
+ }
+ }
+
+ return bRet;
+}
+
+bool XMLPMPropHdl_PaperTrayNumber::exportXML(
+ OUString& rStrExpValue,
+ const Any& rValue,
+ const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_Int32 nPaperTray = 0;
+
+ if( rValue >>= nPaperTray )
+ {
+ if( nPaperTray == DEFAULT_PAPERTRAY )
+ rStrExpValue = GetXMLToken( XML_DEFAULT );
+ else
+ {
+ rStrExpValue = OUString::number( nPaperTray );
+ }
+ bRet = true;
+ }
+ return bRet;
+}
+
+// property handler for style:print
+
+XMLPMPropHdl_Print::XMLPMPropHdl_Print( enum XMLTokenEnum eValue ) :
+ sAttrValue( GetXMLToken( eValue ) )
+{
+}
+
+XMLPMPropHdl_Print::~XMLPMPropHdl_Print()
+{
+}
+
+bool XMLPMPropHdl_Print::importXML(
+ const OUString& rStrImpValue,
+ Any& rValue,
+ const SvXMLUnitConverter& ) const
+{
+ sal_Int32 nTokenIndex = 0;
+ bool bFound = false;
+
+ do
+ {
+ bFound = (sAttrValue == o3tl::getToken(rStrImpValue, 0, ' ', nTokenIndex ));
+ }
+ while ( (nTokenIndex >= 0) && !bFound );
+
+ rValue <<= bFound;
+ return true;
+}
+
+bool XMLPMPropHdl_Print::exportXML(
+ OUString& rStrExpValue,
+ const Any& rValue,
+ const SvXMLUnitConverter& ) const
+{
+ if( getBOOL( rValue ) )
+ {
+ if( !rStrExpValue.isEmpty() )
+ rStrExpValue += " ";
+ rStrExpValue += sAttrValue;
+ }
+
+ return true;
+}
+
+// property handler for style:table-centering
+
+XMLPMPropHdl_CenterHorizontal::~XMLPMPropHdl_CenterHorizontal()
+{
+}
+
+bool XMLPMPropHdl_CenterHorizontal::importXML(
+ const OUString& rStrImpValue,
+ Any& rValue,
+ const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+
+ if (!rStrImpValue.isEmpty())
+ if (IsXMLToken( rStrImpValue, XML_BOTH) ||
+ IsXMLToken( rStrImpValue, XML_HORIZONTAL))
+ {
+ rValue <<= true;
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+bool XMLPMPropHdl_CenterHorizontal::exportXML(
+ OUString& rStrExpValue,
+ const Any& rValue,
+ const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+
+ if ( ::cppu::any2bool( rValue ) )
+ {
+ bRet = true;
+ if (!rStrExpValue.isEmpty())
+ rStrExpValue = GetXMLToken(XML_BOTH);
+ else
+ rStrExpValue = GetXMLToken(XML_HORIZONTAL);
+ }
+
+ return bRet;
+}
+
+XMLPMPropHdl_CenterVertical::~XMLPMPropHdl_CenterVertical()
+{
+}
+
+bool XMLPMPropHdl_CenterVertical::importXML(
+ const OUString& rStrImpValue,
+ Any& rValue,
+ const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+
+ if (!rStrImpValue.isEmpty())
+ if (IsXMLToken(rStrImpValue, XML_BOTH) ||
+ IsXMLToken(rStrImpValue, XML_VERTICAL) )
+ {
+ rValue <<= true;
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+bool XMLPMPropHdl_CenterVertical::exportXML(
+ OUString& rStrExpValue,
+ const Any& rValue,
+ const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+
+ if ( ::cppu::any2bool( rValue ) )
+ {
+ bRet = true;
+ if (!rStrExpValue.isEmpty())
+ rStrExpValue = GetXMLToken(XML_BOTH);
+ else
+ rStrExpValue = GetXMLToken(XML_VERTICAL);
+ }
+
+ return bRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/PageMasterPropHdl.hxx b/xmloff/source/style/PageMasterPropHdl.hxx
new file mode 100644
index 000000000..2cfd39aff
--- /dev/null
+++ b/xmloff/source/style/PageMasterPropHdl.hxx
@@ -0,0 +1,158 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+#include <rtl/ustring.hxx>
+#include <xmloff/xmltoken.hxx>
+
+// property handler for style:page-usage (style::PageStyleLayout)
+
+class XMLPMPropHdl_PageStyleLayout : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLPMPropHdl_PageStyleLayout() override;
+ virtual bool equals(
+ const css::uno::Any& rAny1,
+ const css::uno::Any& rAny2
+ ) const override;
+ virtual bool importXML(
+ const OUString& rStrImpValue,
+ css::uno::Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter
+ ) const override;
+ virtual bool exportXML(
+ OUString& rStrExpValue,
+ const css::uno::Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter
+ ) const override;
+};
+
+// property handler for style:num-format (style::NumberingType)
+
+class XMLPMPropHdl_NumFormat : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLPMPropHdl_NumFormat() override;
+ virtual bool importXML(
+ const OUString& rStrImpValue,
+ css::uno::Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter
+ ) const override;
+ virtual bool exportXML(
+ OUString& rStrExpValue,
+ const css::uno::Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter
+ ) const override;
+};
+
+// property handler for style:num-letter-sync (style::NumberingType)
+
+class XMLPMPropHdl_NumLetterSync : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLPMPropHdl_NumLetterSync() override;
+ virtual bool importXML(
+ const OUString& rStrImpValue,
+ css::uno::Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter
+ ) const override;
+ virtual bool exportXML(
+ OUString& rStrExpValue,
+ const css::uno::Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter
+ ) const override;
+};
+
+// property handler for style:paper-tray-number
+
+class XMLPMPropHdl_PaperTrayNumber : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLPMPropHdl_PaperTrayNumber() override;
+ virtual bool importXML(
+ const OUString& rStrImpValue,
+ css::uno::Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter
+ ) const override;
+ virtual bool exportXML(
+ OUString& rStrExpValue,
+ const css::uno::Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter
+ ) const override;
+};
+
+// property handler for style:print
+
+class XMLPMPropHdl_Print : public XMLPropertyHandler
+{
+ OUString sAttrValue;
+
+public:
+ explicit XMLPMPropHdl_Print( enum ::xmloff::token::XMLTokenEnum eValue );
+ virtual ~XMLPMPropHdl_Print() override;
+
+ virtual bool importXML(
+ const OUString& rStrImpValue,
+ css::uno::Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter
+ ) const override;
+ virtual bool exportXML(
+ OUString& rStrExpValue,
+ const css::uno::Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter
+ ) const override;
+};
+
+// property handler for style:table-centering
+
+class XMLPMPropHdl_CenterHorizontal : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLPMPropHdl_CenterHorizontal() override;
+ virtual bool importXML(
+ const OUString& rStrImpValue,
+ css::uno::Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter
+ ) const override;
+ virtual bool exportXML(
+ OUString& rStrExpValue,
+ const css::uno::Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter
+ ) const override;
+};
+
+class XMLPMPropHdl_CenterVertical : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLPMPropHdl_CenterVertical() override;
+ virtual bool importXML(
+ const OUString& rStrImpValue,
+ css::uno::Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter
+ ) const override;
+ virtual bool exportXML(
+ OUString& rStrExpValue,
+ const css::uno::Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter
+ ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/PageMasterPropHdlFactory.cxx b/xmloff/source/style/PageMasterPropHdlFactory.cxx
new file mode 100644
index 000000000..88a14fb80
--- /dev/null
+++ b/xmloff/source/style/PageMasterPropHdlFactory.cxx
@@ -0,0 +1,170 @@
+/* -*- 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 <PageMasterPropHdlFactory.hxx>
+#include <enummaps.hxx>
+#include <xmloff/xmlement.hxx>
+#include <xmloff/xmltypes.hxx>
+#include <xmloff/xmltoken.hxx>
+#include "xmlbahdl.hxx"
+#include <xmloff/NamedBoolPropertyHdl.hxx>
+#include <XMLTextColumnsPropertyHandler.hxx>
+#include <xmloff/XMLConstantsPropertyHandler.hxx>
+#include "PageMasterPropHdl.hxx"
+#include <PageMasterStyleMap.hxx>
+#include <com/sun/star/text/TextGridMode.hpp>
+#include <xmloff/EnumPropertyHdl.hxx>
+#include <osl/diagnose.h>
+#include <XMLFillBitmapSizePropertyHandler.hxx>
+#include <XMLBitmapLogicalSizePropertyHandler.hxx>
+#include <com/sun/star/drawing/BitmapMode.hpp>
+#include <XMLBitmapRepeatOffsetPropertyHandler.hxx>
+#include <XMLRtlGutterPropertyHandler.hxx>
+
+using namespace ::xmloff::token;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::drawing;
+
+SvXMLEnumMapEntry<sal_uInt16> const aXML_TextGridMode_ConstantMap[] =
+{
+ { XML_NONE, text::TextGridMode::NONE },
+ { XML_LINE, text::TextGridMode::LINES },
+ { XML_BOTH, text::TextGridMode::LINES_AND_CHARS },
+ { XML_TOKEN_INVALID, 0 }
+};
+
+XMLPageMasterPropHdlFactory::XMLPageMasterPropHdlFactory()
+{
+}
+
+XMLPageMasterPropHdlFactory::~XMLPageMasterPropHdlFactory()
+{
+}
+
+const XMLPropertyHandler* XMLPageMasterPropHdlFactory::GetPropertyHandler( sal_Int32 nType ) const
+{
+ nType &= MID_FLAG_MASK;
+
+ XMLPropertyHandler* pHdl = const_cast<XMLPropertyHandler*>(XMLPropertyHandlerFactory::GetPropertyHandler( nType ));
+ if( !pHdl )
+ {
+ switch( nType )
+ {
+ case XML_PM_TYPE_PAGESTYLELAYOUT:
+ pHdl = new XMLPMPropHdl_PageStyleLayout;
+ break;
+ case XML_PM_TYPE_NUMFORMAT:
+ pHdl = new XMLPMPropHdl_NumFormat;
+ break;
+ case XML_PM_TYPE_NUMLETTERSYNC:
+ pHdl = new XMLPMPropHdl_NumLetterSync;
+ break;
+ case XML_PM_TYPE_PAPERTRAYNUMBER:
+ pHdl = new XMLPMPropHdl_PaperTrayNumber;
+ break;
+ case XML_PM_TYPE_PRINTORIENTATION:
+ pHdl = new XMLNamedBoolPropertyHdl(
+ GetXMLToken( XML_LANDSCAPE ),
+ GetXMLToken( XML_PORTRAIT ) );
+ break;
+ case XML_PM_TYPE_PRINTANNOTATIONS:
+ pHdl = new XMLPMPropHdl_Print( XML_ANNOTATIONS );
+ break;
+ case XML_PM_TYPE_PRINTCHARTS:
+ pHdl = new XMLPMPropHdl_Print( XML_CHARTS );
+ break;
+ case XML_PM_TYPE_PRINTDRAWING:
+ pHdl = new XMLPMPropHdl_Print( XML_DRAWINGS );
+ break;
+ case XML_PM_TYPE_PRINTFORMULAS:
+ pHdl = new XMLPMPropHdl_Print( XML_FORMULAS );
+ break;
+ case XML_PM_TYPE_PRINTGRID:
+ pHdl = new XMLPMPropHdl_Print( XML_GRID );
+ break;
+ case XML_PM_TYPE_PRINTHEADERS:
+ pHdl = new XMLPMPropHdl_Print( XML_HEADERS );
+ break;
+ case XML_PM_TYPE_PRINTOBJECTS:
+ pHdl = new XMLPMPropHdl_Print( XML_OBJECTS );
+ break;
+ case XML_PM_TYPE_PRINTZEROVALUES:
+ pHdl = new XMLPMPropHdl_Print( XML_ZERO_VALUES );
+ break;
+ case XML_PM_TYPE_PRINTPAGEORDER:
+ pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken( XML_TTB ),
+ GetXMLToken( XML_LTR ) );
+ break;
+ case XML_PM_TYPE_FIRSTPAGENUMBER:
+ pHdl = new XMLNumberNonePropHdl( XML_CONTINUE, 2 );
+ break;
+ case XML_PM_TYPE_CENTER_HORIZONTAL:
+ pHdl = new XMLPMPropHdl_CenterHorizontal;
+ break;
+ case XML_PM_TYPE_CENTER_VERTICAL:
+ pHdl = new XMLPMPropHdl_CenterVertical;
+ break;
+ case XML_TYPE_TEXT_COLUMNS:
+ pHdl = new XMLTextColumnsPropertyHandler;
+ break;
+ case XML_TYPE_LAYOUT_GRID_MODE:
+ pHdl = new XMLConstantsPropertyHandler(
+ aXML_TextGridMode_ConstantMap, XML_NONE );
+ break;
+
+ case XML_SW_TYPE_FILLSTYLE:
+ pHdl = new XMLEnumPropertyHdl( aXML_FillStyle_EnumMap );
+ break;
+ case XML_SW_TYPE_PRESPAGE_BACKSIZE:
+ pHdl = new XMLNamedBoolPropertyHdl(GetXMLToken(XML_FULL), GetXMLToken(XML_BORDER));
+ break;
+ case XML_SW_TYPE_FILLBITMAPSIZE:
+ pHdl = new XMLFillBitmapSizePropertyHandler();
+ break;
+ case XML_SW_TYPE_LOGICAL_SIZE:
+ pHdl = new XMLBitmapLogicalSizePropertyHandler();
+ break;
+ case XML_SW_TYPE_BITMAP_REFPOINT:
+ pHdl = new XMLEnumPropertyHdl( aXML_RefPoint_EnumMap );
+ break;
+ case XML_SW_TYPE_BITMAP_MODE:
+ pHdl = new XMLEnumPropertyHdl( aXML_BitmapMode_EnumMap );
+ break;
+ case XML_SW_TYPE_BITMAPREPOFFSETX:
+ case XML_SW_TYPE_BITMAPREPOFFSETY:
+ pHdl = new XMLBitmapRepeatOffsetPropertyHandler(XML_SW_TYPE_BITMAPREPOFFSETX == nType);
+ break;
+ case XML_SW_TYPE_RTLGUTTER:
+ pHdl = new XMLRtlGutterPropertyHandler();
+ break;
+
+ default:
+ {
+ OSL_ENSURE(false, "XMLPropertyHandler missing (!)");
+ break;
+ }
+ }
+
+ if( pHdl )
+ PutHdlCache( nType, pHdl );
+ }
+ return pHdl;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/PageMasterPropMapper.cxx b/xmloff/source/style/PageMasterPropMapper.cxx
new file mode 100644
index 000000000..c792ff0a0
--- /dev/null
+++ b/xmloff/source/style/PageMasterPropMapper.cxx
@@ -0,0 +1,48 @@
+/* -*- 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 <PageMasterPropMapper.hxx>
+
+#include <rtl/ref.hxx>
+#include <PageMasterStyleMap.hxx>
+#include <PageMasterPropHdlFactory.hxx>
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+
+XMLPageMasterPropSetMapper::XMLPageMasterPropSetMapper():
+ XMLPropertySetMapper( aXMLPageMasterStyleMap, new XMLPageMasterPropHdlFactory(), false/*bForExport*/)
+{
+}
+
+XMLPageMasterPropSetMapper::XMLPageMasterPropSetMapper(
+ const XMLPropertyMapEntry* pEntries,
+ const rtl::Reference< XMLPropertyHandlerFactory >& rFactory ) :
+ XMLPropertySetMapper( pEntries, rFactory, true/*bForExport*/ )
+{
+}
+
+XMLPageMasterPropSetMapper::~XMLPageMasterPropSetMapper()
+{
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/PageMasterStyleMap.cxx b/xmloff/source/style/PageMasterStyleMap.cxx
new file mode 100644
index 000000000..349badc23
--- /dev/null
+++ b/xmloff/source/style/PageMasterStyleMap.cxx
@@ -0,0 +1,305 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <PageMasterStyleMap.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+
+using namespace ::xmloff::token;
+
+#define MAP(name,prefix,token,type,context,version) { name, prefix, token, type, context, version, false }
+#define DPMAP(name,prefix,token,type,context) MAP(name, prefix, token, type|XML_TYPE_PROP_DRAWING_PAGE, context, SvtSaveOptions::ODFSVER_013)
+#define PLMAP(name,prefix,token,type,context) \
+ MAP(name, prefix, token, type|XML_TYPE_PROP_PAGE_LAYOUT, context, SvtSaveOptions::ODFSVER_010)
+#define PLMAP_12(name,prefix,token,type,context) \
+ MAP(name, prefix, token, type|XML_TYPE_PROP_PAGE_LAYOUT, context, SvtSaveOptions::ODFSVER_012)
+#define PLMAP_ODF13(name,prefix,token,type,context) \
+ MAP(name, prefix, token, type|XML_TYPE_PROP_PAGE_LAYOUT, context, SvtSaveOptions::ODFSVER_013)
+#define PLMAP_EXT(name,prefix,token,type,context) \
+ MAP(name, prefix, token, type|XML_TYPE_PROP_PAGE_LAYOUT, context, SvtSaveOptions::ODFSVER_FUTURE_EXTENDED)
+#define HFMAP(name,prefix,token,type,context) \
+ MAP(name, prefix, token, type|XML_TYPE_PROP_HEADER_FOOTER, context, SvtSaveOptions::ODFSVER_010)
+
+const XMLPropertyMapEntry aXMLPageMasterStyleMap[] =
+{
+ //////////////////////////////////////////////////////////////////////////
+ // Section for 'page-layout-properties'
+
+ // page master
+ PLMAP( "PageStyleLayout", XML_NAMESPACE_STYLE, XML_PAGE_USAGE, XML_PM_TYPE_PAGESTYLELAYOUT | MID_FLAG_SPECIAL_ITEM, CTF_PM_PAGEUSAGE ),
+ PLMAP( "Width", XML_NAMESPACE_FO, XML_PAGE_WIDTH, XML_TYPE_MEASURE, 0 ),
+ PLMAP( "Height", XML_NAMESPACE_FO, XML_PAGE_HEIGHT, XML_TYPE_MEASURE, 0 ),
+ PLMAP( "NumberingType", XML_NAMESPACE_STYLE, XML_NUM_FORMAT, XML_PM_TYPE_NUMFORMAT | MID_FLAG_MERGE_PROPERTY, 0 ),
+ PLMAP( "NumberingType", XML_NAMESPACE_STYLE, XML_NUM_LETTER_SYNC, XML_PM_TYPE_NUMLETTERSYNC, 0 ),
+ PLMAP( "PrinterPaperTray", XML_NAMESPACE_STYLE, XML_PAPER_TRAY_NAME, XML_TYPE_STRING | MID_FLAG_PROPERTY_MAY_THROW, 0 ),
+ PLMAP( "IsLandscape", XML_NAMESPACE_STYLE, XML_PRINT_ORIENTATION, XML_PM_TYPE_PRINTORIENTATION, 0 ),
+ PLMAP( "TopMargin", XML_NAMESPACE_FO, XML_MARGIN, XML_TYPE_MEASURE, CTF_PM_MARGINALL ),
+ PLMAP( "TopMargin", XML_NAMESPACE_FO, XML_MARGIN_TOP, XML_TYPE_MEASURE, CTF_PM_MARGINTOP ),
+ PLMAP( "BottomMargin", XML_NAMESPACE_FO, XML_MARGIN_BOTTOM, XML_TYPE_MEASURE, CTF_PM_MARGINBOTTOM ),
+ PLMAP( "LeftMargin", XML_NAMESPACE_FO, XML_MARGIN_LEFT, XML_TYPE_MEASURE, CTF_PM_MARGINLEFT ),
+ PLMAP( "RightMargin", XML_NAMESPACE_FO, XML_MARGIN_RIGHT, XML_TYPE_MEASURE, CTF_PM_MARGINRIGHT ),
+ PLMAP( "TopBorder", XML_NAMESPACE_FO, XML_BORDER, XML_TYPE_BORDER, CTF_PM_BORDERALL ),
+ PLMAP( "TopBorder", XML_NAMESPACE_FO, XML_BORDER_TOP, XML_TYPE_BORDER, CTF_PM_BORDERTOP ),
+ PLMAP( "BottomBorder", XML_NAMESPACE_FO, XML_BORDER_BOTTOM, XML_TYPE_BORDER, CTF_PM_BORDERBOTTOM ),
+ PLMAP( "LeftBorder", XML_NAMESPACE_FO, XML_BORDER_LEFT, XML_TYPE_BORDER, CTF_PM_BORDERLEFT ),
+ PLMAP( "RightBorder", XML_NAMESPACE_FO, XML_BORDER_RIGHT, XML_TYPE_BORDER, CTF_PM_BORDERRIGHT ),
+ PLMAP( "TopBorder", XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH, XML_TYPE_BORDER_WIDTH, CTF_PM_BORDERWIDTHALL ),
+ PLMAP( "TopBorder", XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH_TOP, XML_TYPE_BORDER_WIDTH, CTF_PM_BORDERWIDTHTOP ),
+ PLMAP( "BottomBorder", XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH_BOTTOM, XML_TYPE_BORDER_WIDTH, CTF_PM_BORDERWIDTHBOTTOM ),
+ PLMAP( "LeftBorder", XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH_LEFT, XML_TYPE_BORDER_WIDTH, CTF_PM_BORDERWIDTHLEFT ),
+ PLMAP( "RightBorder", XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH_RIGHT, XML_TYPE_BORDER_WIDTH, CTF_PM_BORDERWIDTHRIGHT ),
+ PLMAP( "TopBorderDistance", XML_NAMESPACE_FO, XML_PADDING, XML_TYPE_MEASURE, CTF_PM_PADDINGALL ),
+ PLMAP( "TopBorderDistance", XML_NAMESPACE_FO, XML_PADDING_TOP, XML_TYPE_MEASURE, CTF_PM_PADDINGTOP ),
+ PLMAP( "BottomBorderDistance", XML_NAMESPACE_FO, XML_PADDING_BOTTOM, XML_TYPE_MEASURE, CTF_PM_PADDINGBOTTOM ),
+ PLMAP( "LeftBorderDistance", XML_NAMESPACE_FO, XML_PADDING_LEFT, XML_TYPE_MEASURE, CTF_PM_PADDINGLEFT ),
+ PLMAP( "RightBorderDistance", XML_NAMESPACE_FO, XML_PADDING_RIGHT, XML_TYPE_MEASURE, CTF_PM_PADDINGRIGHT ),
+ PLMAP( "ShadowFormat", XML_NAMESPACE_STYLE, XML_SHADOW, XML_TYPE_TEXT_SHADOW, 0 ),
+ PLMAP( "BackColor", XML_NAMESPACE_FO, XML_BACKGROUND_COLOR, XML_TYPE_COLORTRANSPARENT | MID_FLAG_MULTI_PROPERTY, 0 ),
+ PLMAP( "BackTransparent", XML_NAMESPACE_FO, XML_BACKGROUND_COLOR, XML_TYPE_ISTRANSPARENT | MID_FLAG_MERGE_ATTRIBUTE, 0 ),
+ PLMAP( "BackGraphicLocation", XML_NAMESPACE_STYLE, XML_POSITION, XML_TYPE_BUILDIN_CMP_ONLY | MID_FLAG_SPECIAL_ITEM, CTF_PM_GRAPHICPOSITION ),
+ PLMAP( "BackGraphicFilter", XML_NAMESPACE_STYLE, XML_FILTER_NAME, XML_TYPE_STRING | MID_FLAG_SPECIAL_ITEM, CTF_PM_GRAPHICFILTER ),
+ PLMAP( "BackGraphic", XML_NAMESPACE_STYLE, XML_BACKGROUND_IMAGE, XML_TYPE_STRING | MID_FLAG_ELEMENT_ITEM, CTF_PM_GRAPHICURL ),
+ PLMAP( "PrintAnnotations", XML_NAMESPACE_STYLE, XML_PRINT, XML_PM_TYPE_PRINTANNOTATIONS | MID_FLAG_MULTI_PROPERTY, CTF_PM_PRINT_ANNOTATIONS ),
+ PLMAP( "PrintCharts", XML_NAMESPACE_STYLE, XML_PRINT, XML_PM_TYPE_PRINTCHARTS | MID_FLAG_MULTI_PROPERTY | MID_FLAG_MERGE_ATTRIBUTE, CTF_PM_PRINT_CHARTS ),
+ PLMAP( "PrintDrawing", XML_NAMESPACE_STYLE, XML_PRINT, XML_PM_TYPE_PRINTDRAWING | MID_FLAG_MULTI_PROPERTY | MID_FLAG_MERGE_ATTRIBUTE, CTF_PM_PRINT_DRAWING ),
+ PLMAP( "PrintFormulas", XML_NAMESPACE_STYLE, XML_PRINT, XML_PM_TYPE_PRINTFORMULAS | MID_FLAG_MULTI_PROPERTY | MID_FLAG_MERGE_ATTRIBUTE, CTF_PM_PRINT_FORMULAS ),
+ PLMAP( "PrintGrid", XML_NAMESPACE_STYLE, XML_PRINT, XML_PM_TYPE_PRINTGRID | MID_FLAG_MULTI_PROPERTY | MID_FLAG_MERGE_ATTRIBUTE, CTF_PM_PRINT_GRID ),
+ PLMAP( "PrintHeaders", XML_NAMESPACE_STYLE, XML_PRINT, XML_PM_TYPE_PRINTHEADERS | MID_FLAG_MULTI_PROPERTY | MID_FLAG_MERGE_ATTRIBUTE, CTF_PM_PRINT_HEADERS ),
+ PLMAP( "PrintObjects", XML_NAMESPACE_STYLE, XML_PRINT, XML_PM_TYPE_PRINTOBJECTS | MID_FLAG_MULTI_PROPERTY | MID_FLAG_MERGE_ATTRIBUTE, CTF_PM_PRINT_OBJECTS ),
+ PLMAP( "PrintZeroValues", XML_NAMESPACE_STYLE, XML_PRINT, XML_PM_TYPE_PRINTZEROVALUES | MID_FLAG_MERGE_ATTRIBUTE, CTF_PM_PRINT_ZEROVALUES ),
+ PLMAP( "PrintDownFirst", XML_NAMESPACE_STYLE, XML_PRINT_PAGE_ORDER, XML_PM_TYPE_PRINTPAGEORDER, 0 ),
+ PLMAP( "FirstPageNumber", XML_NAMESPACE_STYLE, XML_FIRST_PAGE_NUMBER, XML_PM_TYPE_FIRSTPAGENUMBER, 0 ),
+ PLMAP( "PageScale", XML_NAMESPACE_STYLE, XML_SCALE_TO, XML_TYPE_PERCENT16, CTF_PM_SCALETO ),
+ PLMAP( "ScaleToPages", XML_NAMESPACE_STYLE, XML_SCALE_TO_PAGES, XML_TYPE_NUMBER16, CTF_PM_SCALETOPAGES ),
+ // ODF 1.3 OFFICE-3857
+ PLMAP_ODF13( "ScaleToPagesX", XML_NAMESPACE_STYLE, XML_SCALE_TO_X, XML_TYPE_NUMBER16, CTF_PM_SCALETOX ),
+ PLMAP_ODF13( "ScaleToPagesY", XML_NAMESPACE_STYLE, XML_SCALE_TO_Y, XML_TYPE_NUMBER16, CTF_PM_SCALETOY ),
+ PLMAP_ODF13( "ScaleToPagesX", XML_NAMESPACE_LO_EXT, XML_SCALE_TO_X, XML_TYPE_NUMBER16, CTF_PM_SCALETOX ),
+ PLMAP_ODF13( "ScaleToPagesY", XML_NAMESPACE_LO_EXT, XML_SCALE_TO_Y, XML_TYPE_NUMBER16, CTF_PM_SCALETOY ),
+ PLMAP( "CenterHorizontally", XML_NAMESPACE_STYLE, XML_TABLE_CENTERING, XML_PM_TYPE_CENTER_HORIZONTAL | MID_FLAG_MULTI_PROPERTY | MID_FLAG_MERGE_ATTRIBUTE, 0 ),
+ PLMAP( "CenterVertically", XML_NAMESPACE_STYLE, XML_TABLE_CENTERING, XML_PM_TYPE_CENTER_VERTICAL | MID_FLAG_MULTI_PROPERTY | MID_FLAG_MERGE_ATTRIBUTE, 0 ),
+ PLMAP( "TextColumns", XML_NAMESPACE_STYLE, XML_COLUMNS, MID_FLAG_ELEMENT_ITEM|XML_TYPE_TEXT_COLUMNS, CTF_PM_TEXTCOLUMNS ),
+ PLMAP( "RegisterModeActive", XML_NAMESPACE_STYLE, XML_REGISTER_TRUE, XML_TYPE_BOOL, 0 ),
+ PLMAP( "RegisterParagraphStyle", XML_NAMESPACE_STYLE, XML_REGISTER_TRUTH_REF_STYLE_NAME, XML_TYPE_STYLENAME| MID_FLAG_SPECIAL_ITEM_IMPORT, CTF_PM_REGISTER_STYLE ),
+ PLMAP( "WritingMode", XML_NAMESPACE_STYLE, XML_WRITING_MODE, XML_TYPE_TEXT_WRITING_MODE | MID_FLAG_MULTI_PROPERTY, CTF_PM_WRITINGMODE ),
+ PLMAP( "RtlGutter", XML_NAMESPACE_STYLE, XML_WRITING_MODE, XML_SW_TYPE_RTLGUTTER | MID_FLAG_MULTI_PROPERTY, CTF_PM_RTLGUTTER ),
+
+ // Index 53: Grid definitions
+ PLMAP( "GridColor", XML_NAMESPACE_STYLE, XML_LAYOUT_GRID_COLOR, XML_TYPE_COLOR, 0 ),
+ PLMAP( "GridLines", XML_NAMESPACE_STYLE, XML_LAYOUT_GRID_LINES, XML_TYPE_NUMBER16, 0 ),
+ PLMAP( "GridBaseHeight", XML_NAMESPACE_STYLE, XML_LAYOUT_GRID_BASE_HEIGHT, XML_TYPE_MEASURE, 0 ),
+ PLMAP( "GridRubyHeight", XML_NAMESPACE_STYLE, XML_LAYOUT_GRID_RUBY_HEIGHT, XML_TYPE_MEASURE, 0 ),
+ PLMAP( "GridMode", XML_NAMESPACE_STYLE, XML_LAYOUT_GRID_MODE, XML_TYPE_LAYOUT_GRID_MODE, 0 ),
+ PLMAP( "RubyBelow", XML_NAMESPACE_STYLE, XML_LAYOUT_GRID_RUBY_BELOW, XML_TYPE_BOOL, 0 ),
+ PLMAP( "GridPrint", XML_NAMESPACE_STYLE, XML_LAYOUT_GRID_PRINT, XML_TYPE_BOOL, 0 ),
+ PLMAP( "GridDisplay", XML_NAMESPACE_STYLE, XML_LAYOUT_GRID_DISPLAY, XML_TYPE_BOOL, 0 ),
+
+ //text grid enhancement for better CJK support
+ PLMAP_12( "GridBaseWidth", XML_NAMESPACE_STYLE, XML_LAYOUT_GRID_BASE_WIDTH, XML_TYPE_MEASURE, CTP_PM_GRID_BASE_WIDTH ),
+ PLMAP_12( "GridSnapToChars", XML_NAMESPACE_STYLE, XML_LAYOUT_GRID_SNAP_TO, XML_TYPE_BOOL, CTP_PM_GRID_SNAP_TO ),
+ //export as a default attribute
+ PLMAP_12( "StandardPageMode", XML_NAMESPACE_STYLE, XML_LAYOUT_GRID_STANDARD_MODE, XML_TYPE_BOOL|MID_FLAG_DEFAULT_ITEM_EXPORT, CTF_PM_STANDARD_MODE ),
+
+ PLMAP( "UserDefinedAttributes", XML_NAMESPACE_TEXT, XML_XMLNS, XML_TYPE_ATTRIBUTE_CONTAINER | MID_FLAG_SPECIAL_ITEM, 0 ),
+
+ //Index 65: fill attributes; use PLMAP macro here instead of GMAP, this list is ordered and its order is used
+ // to decide in which section in ODF to export the contained stuff (the PageMasterStyle creates several XML
+ // sections, for Page, Header and Footer). The needed order seems to rely not on filtering, but using sections
+ // based on the order used in this list.
+ // Also need own defines for the used context flags (e.g. CTF_PM_FILLGRADIENTNAME instead of
+ // CTF_FILLGRADIENTNAME) since these are used to *filter* up to which entry the attributes belong to the
+ // 'page-layout-properties' section (!), see SvXMLAutoStylePoolP_Impl::exportXML, look for XmlStyleFamily::PAGE_MASTER
+ // note: these are duplicated below, in g_XMLPageMasterDrawingPageStyleMap
+ PLMAP( "FillStyle", XML_NAMESPACE_DRAW, XML_FILL, XML_SW_TYPE_FILLSTYLE, 0 ),
+ PLMAP( "FillColor", XML_NAMESPACE_DRAW, XML_FILL_COLOR, XML_TYPE_COLOR, 0 ),
+ PLMAP( "FillColor2", XML_NAMESPACE_DRAW, XML_SECONDARY_FILL_COLOR, XML_TYPE_COLOR, 0 ),
+ PLMAP( "FillGradientName", XML_NAMESPACE_DRAW, XML_FILL_GRADIENT_NAME, XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_PM_FILLGRADIENTNAME ),
+ PLMAP( "FillGradientStepCount", XML_NAMESPACE_DRAW, XML_GRADIENT_STEP_COUNT, XML_TYPE_NUMBER16, 0 ),
+ PLMAP( "FillHatchName", XML_NAMESPACE_DRAW, XML_FILL_HATCH_NAME, XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_PM_FILLHATCHNAME ),
+ PLMAP( "FillBackground", XML_NAMESPACE_DRAW, XML_FILL_HATCH_SOLID, XML_TYPE_BOOL, 0 ),
+ PLMAP( "FillBitmapName", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_NAME, XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_PM_FILLBITMAPNAME ),
+ PLMAP( "FillTransparence", XML_NAMESPACE_DRAW, XML_OPACITY, XML_TYPE_NEG_PERCENT16|MID_FLAG_MULTI_PROPERTY, 0 ), // exists in SW, too
+ PLMAP( "FillTransparenceGradientName", XML_NAMESPACE_DRAW, XML_OPACITY_NAME, XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_PM_FILLTRANSNAME ),
+ PLMAP( "FillBitmapSizeX", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_WIDTH, XML_SW_TYPE_FILLBITMAPSIZE|MID_FLAG_MULTI_PROPERTY, 0 ),
+ PLMAP( "FillBitmapLogicalSize", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_WIDTH, XML_SW_TYPE_LOGICAL_SIZE|MID_FLAG_MULTI_PROPERTY, 0 ),
+ PLMAP( "FillBitmapSizeY", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_HEIGHT, XML_SW_TYPE_FILLBITMAPSIZE|MID_FLAG_MULTI_PROPERTY, 0 ),
+ PLMAP( "FillBitmapLogicalSize", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_HEIGHT, XML_SW_TYPE_LOGICAL_SIZE|MID_FLAG_MULTI_PROPERTY, 0 ),
+ PLMAP( "FillBitmapMode", XML_NAMESPACE_STYLE, XML_REPEAT, XML_SW_TYPE_BITMAP_MODE|MID_FLAG_MULTI_PROPERTY, CTF_PM_FILLBITMAPMODE ),
+ PLMAP( "FillBitmapPositionOffsetX", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_REF_POINT_X, XML_TYPE_PERCENT, 0 ),
+ PLMAP( "FillBitmapPositionOffsetY", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_REF_POINT_Y, XML_TYPE_PERCENT, 0 ),
+ PLMAP( "FillBitmapRectanglePoint", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_REF_POINT, XML_SW_TYPE_BITMAP_REFPOINT, 0 ),
+ PLMAP( "FillBitmapOffsetX", XML_NAMESPACE_DRAW, XML_TILE_REPEAT_OFFSET, XML_SW_TYPE_BITMAPREPOFFSETX|MID_FLAG_MULTI_PROPERTY, CTF_PM_REPEAT_OFFSET_X ),
+ PLMAP( "FillBitmapOffsetY", XML_NAMESPACE_DRAW, XML_TILE_REPEAT_OFFSET, XML_SW_TYPE_BITMAPREPOFFSETY|MID_FLAG_MULTI_PROPERTY, CTF_PM_REPEAT_OFFSET_Y ),
+
+ // Index 85: footnote
+ PLMAP( "FootnoteHeight", XML_NAMESPACE_STYLE, XML_FOOTNOTE_MAX_HEIGHT, XML_TYPE_MEASURE, CTF_PM_FTN_HEIGHT ),
+ PLMAP( "FootnoteLineAdjust", XML_NAMESPACE_STYLE, XML__EMPTY, XML_TYPE_TEXT_HORIZONTAL_ADJUST|MID_FLAG_SPECIAL_ITEM, CTF_PM_FTN_LINE_ADJUST ),
+ PLMAP( "FootnoteLineColor", XML_NAMESPACE_STYLE, XML__EMPTY, XML_TYPE_COLOR|MID_FLAG_SPECIAL_ITEM, CTF_PM_FTN_LINE_COLOR ),
+ PLMAP( "FootnoteLineDistance", XML_NAMESPACE_STYLE, XML__EMPTY, XML_TYPE_MEASURE|MID_FLAG_SPECIAL_ITEM,CTF_PM_FTN_DISTANCE ),
+ PLMAP( "FootnoteLineRelativeWidth", XML_NAMESPACE_STYLE, XML__EMPTY, XML_TYPE_PERCENT8|MID_FLAG_SPECIAL_ITEM, CTF_PM_FTN_LINE_WIDTH ),
+ PLMAP( "FootnoteLineTextDistance", XML_NAMESPACE_STYLE, XML__EMPTY, XML_TYPE_MEASURE|MID_FLAG_SPECIAL_ITEM, CTF_PM_FTN_LINE_DISTANCE ),
+ PLMAP( "FootnoteLineWeight", XML_NAMESPACE_STYLE, XML_FOOTNOTE_SEP, XML_TYPE_MEASURE16|MID_FLAG_ELEMENT_ITEM, CTF_PM_FTN_LINE_WEIGHT ),
+ PLMAP( "FootnoteLineStyle", XML_NAMESPACE_STYLE, XML_EMPTY, XML_TYPE_STRING|MID_FLAG_ELEMENT_ITEM, CTF_PM_FTN_LINE_STYLE ),
+ PLMAP_EXT("GutterMargin", XML_NAMESPACE_LO_EXT, XML_MARGIN_GUTTER, XML_TYPE_MEASURE, CTF_PM_MARGINGUTTER),
+
+ //////////////////////////////////////////////////////////////////////////
+ //Index 92: Section for 'header-style' own section, all members *have* to use CTF_PM_HEADERFLAG in the context entry (the 5th one)
+ HFMAP( "HeaderHeight", XML_NAMESPACE_SVG, XML_HEIGHT, XML_TYPE_MEASURE, CTF_PM_HEADERHEIGHT ),
+ HFMAP( "HeaderHeight", XML_NAMESPACE_FO, XML_MIN_HEIGHT, XML_TYPE_MEASURE, CTF_PM_HEADERMINHEIGHT ),
+ HFMAP( "HeaderIsDynamicHeight", XML_NAMESPACE_STYLE, XML__EMPTY, XML_TYPE_BOOL, CTF_PM_HEADERDYNAMIC ),
+ HFMAP( "HeaderLeftMargin", XML_NAMESPACE_FO, XML_MARGIN, XML_TYPE_MEASURE, CTF_PM_HEADERMARGINALL ),
+ HFMAP( "HeaderLeftMargin", XML_NAMESPACE_FO, XML_MARGIN_LEFT, XML_TYPE_MEASURE, CTF_PM_HEADERMARGINLEFT ),
+ HFMAP( "HeaderRightMargin", XML_NAMESPACE_FO, XML_MARGIN_RIGHT, XML_TYPE_MEASURE, CTF_PM_HEADERMARGINRIGHT ),
+ HFMAP( "HeaderBodyDistance", XML_NAMESPACE_FO, XML_MARGIN_BOTTOM, XML_TYPE_MEASURE, CTF_PM_HEADERMARGINBOTTOM ),
+ HFMAP( "HeaderTopBorder", XML_NAMESPACE_FO, XML_BORDER, XML_TYPE_BORDER, CTF_PM_HEADERBORDERALL ),
+ HFMAP( "HeaderTopBorder", XML_NAMESPACE_FO, XML_BORDER_TOP, XML_TYPE_BORDER, CTF_PM_HEADERBORDERTOP ),
+ HFMAP( "HeaderBottomBorder", XML_NAMESPACE_FO, XML_BORDER_BOTTOM, XML_TYPE_BORDER, CTF_PM_HEADERBORDERBOTTOM ),
+ HFMAP( "HeaderLeftBorder", XML_NAMESPACE_FO, XML_BORDER_LEFT, XML_TYPE_BORDER, CTF_PM_HEADERBORDERLEFT ),
+ HFMAP( "HeaderRightBorder", XML_NAMESPACE_FO, XML_BORDER_RIGHT, XML_TYPE_BORDER, CTF_PM_HEADERBORDERRIGHT ),
+ HFMAP( "HeaderTopBorder", XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH, XML_TYPE_BORDER_WIDTH, CTF_PM_HEADERBORDERWIDTHALL ),
+ HFMAP( "HeaderTopBorder", XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH_TOP, XML_TYPE_BORDER_WIDTH, CTF_PM_HEADERBORDERWIDTHTOP ),
+ HFMAP( "HeaderBottomBorder", XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH_BOTTOM, XML_TYPE_BORDER_WIDTH, CTF_PM_HEADERBORDERWIDTHBOTTOM ),
+ HFMAP( "HeaderLeftBorder", XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH_LEFT, XML_TYPE_BORDER_WIDTH, CTF_PM_HEADERBORDERWIDTHLEFT ),
+ HFMAP( "HeaderRightBorder", XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH_RIGHT, XML_TYPE_BORDER_WIDTH, CTF_PM_HEADERBORDERWIDTHRIGHT ),
+ HFMAP( "HeaderTopBorderDistance", XML_NAMESPACE_FO, XML_PADDING, XML_TYPE_MEASURE, CTF_PM_HEADERPADDINGALL ),
+ HFMAP( "HeaderTopBorderDistance", XML_NAMESPACE_FO, XML_PADDING_TOP, XML_TYPE_MEASURE, CTF_PM_HEADERPADDINGTOP ),
+ HFMAP( "HeaderBottomBorderDistance", XML_NAMESPACE_FO, XML_PADDING_BOTTOM, XML_TYPE_MEASURE, CTF_PM_HEADERPADDINGBOTTOM ),
+ HFMAP( "HeaderLeftBorderDistance", XML_NAMESPACE_FO, XML_PADDING_LEFT, XML_TYPE_MEASURE, CTF_PM_HEADERPADDINGLEFT ),
+ HFMAP( "HeaderRightBorderDistance", XML_NAMESPACE_FO, XML_PADDING_RIGHT, XML_TYPE_MEASURE, CTF_PM_HEADERPADDINGRIGHT ),
+ HFMAP( "HeaderShadowFormat", XML_NAMESPACE_STYLE, XML_SHADOW, XML_TYPE_TEXT_SHADOW, CTF_PM_HEADERFLAG ),
+ HFMAP( "HeaderBackColor", XML_NAMESPACE_FO, XML_BACKGROUND_COLOR, XML_TYPE_COLORTRANSPARENT | MID_FLAG_MULTI_PROPERTY, CTF_PM_HEADERFLAG ),
+ HFMAP( "HeaderBackTransparent", XML_NAMESPACE_FO, XML_BACKGROUND_COLOR, XML_TYPE_ISTRANSPARENT | MID_FLAG_MERGE_ATTRIBUTE, CTF_PM_HEADERFLAG ),
+ HFMAP( "HeaderBackGraphicLocation", XML_NAMESPACE_STYLE, XML_POSITION, XML_TYPE_BUILDIN_CMP_ONLY | MID_FLAG_SPECIAL_ITEM, CTF_PM_HEADERGRAPHICPOSITION ),
+ HFMAP( "HeaderBackGraphicFilter", XML_NAMESPACE_STYLE, XML_FILTER_NAME, XML_TYPE_STRING | MID_FLAG_SPECIAL_ITEM, CTF_PM_HEADERGRAPHICFILTER ),
+ HFMAP( "HeaderBackGraphic", XML_NAMESPACE_STYLE, XML_BACKGROUND_IMAGE, XML_TYPE_STRING | MID_FLAG_ELEMENT_ITEM, CTF_PM_HEADERGRAPHICURL ),
+ HFMAP( "HeaderDynamicSpacing", XML_NAMESPACE_STYLE, XML_DYNAMIC_SPACING, XML_TYPE_BOOL, CTF_PM_HEADERFLAG ),
+
+ //Index 121: Header DrawingLayer FillAttributes
+ // Use HFMAP to get XML_TYPE_PROP_HEADER_FOOTER ORed to the 4th entry
+ // Names have to begin with 'Header', all 5th entries need to be ORed with the CTF_PM_HEADERFLAG
+ HFMAP( "HeaderFillStyle", XML_NAMESPACE_DRAW, XML_FILL, XML_SW_TYPE_FILLSTYLE, CTF_PM_HEADERFLAG ),
+ HFMAP( "HeaderFillColor", XML_NAMESPACE_DRAW, XML_FILL_COLOR, XML_TYPE_COLOR, CTF_PM_HEADERFLAG ),
+ HFMAP( "HeaderFillColor2", XML_NAMESPACE_DRAW, XML_SECONDARY_FILL_COLOR, XML_TYPE_COLOR, CTF_PM_HEADERFLAG ),
+ HFMAP( "HeaderFillGradientName", XML_NAMESPACE_DRAW, XML_FILL_GRADIENT_NAME, XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_PM_HEADERFILLGRADIENTNAME ),
+ HFMAP( "HeaderFillGradientStepCount", XML_NAMESPACE_DRAW, XML_GRADIENT_STEP_COUNT, XML_TYPE_NUMBER16, CTF_PM_HEADERFLAG ),
+ HFMAP( "HeaderFillHatchName", XML_NAMESPACE_DRAW, XML_FILL_HATCH_NAME, XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_PM_HEADERFILLHATCHNAME ),
+ HFMAP( "HeaderFillBackground", XML_NAMESPACE_DRAW, XML_FILL_HATCH_SOLID, XML_TYPE_BOOL, CTF_PM_HEADERFLAG ),
+ HFMAP( "HeaderFillBitmapName", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_NAME, XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_PM_HEADERFILLBITMAPNAME ),
+ HFMAP( "HeaderFillTransparence", XML_NAMESPACE_DRAW, XML_OPACITY, XML_TYPE_NEG_PERCENT16|MID_FLAG_MULTI_PROPERTY, CTF_PM_HEADERFLAG ), // exists in SW, too
+ HFMAP( "HeaderFillTransparenceGradientName", XML_NAMESPACE_DRAW, XML_OPACITY_NAME, XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_PM_HEADERFILLTRANSNAME ),
+ HFMAP( "HeaderFillBitmapSizeX", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_WIDTH, XML_SW_TYPE_FILLBITMAPSIZE|MID_FLAG_MULTI_PROPERTY, CTF_PM_HEADERFLAG ),
+ HFMAP( "HeaderFillBitmapLogicalSize", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_WIDTH, XML_SW_TYPE_LOGICAL_SIZE|MID_FLAG_MULTI_PROPERTY, CTF_PM_HEADERFLAG ),
+ HFMAP( "HeaderFillBitmapSizeY", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_HEIGHT, XML_SW_TYPE_FILLBITMAPSIZE|MID_FLAG_MULTI_PROPERTY, CTF_PM_HEADERFLAG ),
+ HFMAP( "HeaderFillBitmapLogicalSize", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_HEIGHT, XML_SW_TYPE_LOGICAL_SIZE|MID_FLAG_MULTI_PROPERTY, CTF_PM_HEADERFLAG ),
+ HFMAP( "HeaderFillBitmapMode", XML_NAMESPACE_STYLE, XML_REPEAT, XML_SW_TYPE_BITMAP_MODE|MID_FLAG_MULTI_PROPERTY, CTF_PM_HEADERFLAG ),
+ HFMAP( "HeaderFillBitmapPositionOffsetX", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_REF_POINT_X, XML_TYPE_PERCENT, CTF_PM_HEADERFLAG ),
+ HFMAP( "HeaderFillBitmapPositionOffsetY", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_REF_POINT_Y, XML_TYPE_PERCENT, CTF_PM_HEADERFLAG ),
+ HFMAP( "HeaderFillBitmapRectanglePoint", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_REF_POINT, XML_SW_TYPE_BITMAP_REFPOINT, CTF_PM_HEADERFLAG ),
+ HFMAP( "HeaderFillBitmapOffsetX", XML_NAMESPACE_DRAW, XML_TILE_REPEAT_OFFSET, XML_SW_TYPE_BITMAPREPOFFSETX|MID_FLAG_MULTI_PROPERTY, CTF_PM_HEADERREPEAT_OFFSET_X ),
+ HFMAP( "HeaderFillBitmapOffsetY", XML_NAMESPACE_DRAW, XML_TILE_REPEAT_OFFSET, XML_SW_TYPE_BITMAPREPOFFSETY|MID_FLAG_MULTI_PROPERTY, CTF_PM_HEADERREPEAT_OFFSET_Y ),
+
+ //////////////////////////////////////////////////////////////////////////
+ //Index 141: Section for 'footer-style' own section, all members *have* to use CTF_PM_FOOTERFLAG in the context entry (the 5th one)
+ HFMAP( "FooterHeight", XML_NAMESPACE_SVG, XML_HEIGHT, XML_TYPE_MEASURE, CTF_PM_FOOTERHEIGHT ),
+ HFMAP( "FooterHeight", XML_NAMESPACE_FO, XML_MIN_HEIGHT, XML_TYPE_MEASURE, CTF_PM_FOOTERMINHEIGHT ),
+ HFMAP( "FooterIsDynamicHeight", XML_NAMESPACE_STYLE, XML__EMPTY, XML_TYPE_BOOL, CTF_PM_FOOTERDYNAMIC ),
+ HFMAP( "FooterLeftMargin", XML_NAMESPACE_FO, XML_MARGIN, XML_TYPE_MEASURE, CTF_PM_FOOTERMARGINALL ),
+ HFMAP( "FooterLeftMargin", XML_NAMESPACE_FO, XML_MARGIN_LEFT, XML_TYPE_MEASURE, CTF_PM_FOOTERMARGINLEFT ),
+ HFMAP( "FooterRightMargin", XML_NAMESPACE_FO, XML_MARGIN_RIGHT, XML_TYPE_MEASURE, CTF_PM_FOOTERMARGINRIGHT ),
+ HFMAP( "FooterBodyDistance", XML_NAMESPACE_FO, XML_MARGIN_TOP, XML_TYPE_MEASURE, CTF_PM_FOOTERMARGINTOP ),
+ HFMAP( "FooterTopBorder", XML_NAMESPACE_FO, XML_BORDER, XML_TYPE_BORDER, CTF_PM_FOOTERBORDERALL ),
+ HFMAP( "FooterTopBorder", XML_NAMESPACE_FO, XML_BORDER_TOP, XML_TYPE_BORDER, CTF_PM_FOOTERBORDERTOP ),
+ HFMAP( "FooterBottomBorder", XML_NAMESPACE_FO, XML_BORDER_BOTTOM, XML_TYPE_BORDER, CTF_PM_FOOTERBORDERBOTTOM ),
+ HFMAP( "FooterLeftBorder", XML_NAMESPACE_FO, XML_BORDER_LEFT, XML_TYPE_BORDER, CTF_PM_FOOTERBORDERLEFT ),
+ HFMAP( "FooterRightBorder", XML_NAMESPACE_FO, XML_BORDER_RIGHT, XML_TYPE_BORDER, CTF_PM_FOOTERBORDERRIGHT ),
+ HFMAP( "FooterTopBorder", XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH, XML_TYPE_BORDER_WIDTH, CTF_PM_FOOTERBORDERWIDTHALL ),
+ HFMAP( "FooterTopBorder", XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH_TOP, XML_TYPE_BORDER_WIDTH, CTF_PM_FOOTERBORDERWIDTHTOP ),
+ HFMAP( "FooterBottomBorder", XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH_BOTTOM, XML_TYPE_BORDER_WIDTH, CTF_PM_FOOTERBORDERWIDTHBOTTOM ),
+ HFMAP( "FooterLeftBorder", XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH_LEFT, XML_TYPE_BORDER_WIDTH, CTF_PM_FOOTERBORDERWIDTHLEFT ),
+ HFMAP( "FooterRightBorder", XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH_RIGHT, XML_TYPE_BORDER_WIDTH, CTF_PM_FOOTERBORDERWIDTHRIGHT ),
+ HFMAP( "FooterTopBorderDistance", XML_NAMESPACE_FO, XML_PADDING, XML_TYPE_MEASURE, CTF_PM_FOOTERPADDINGALL ),
+ HFMAP( "FooterTopBorderDistance", XML_NAMESPACE_FO, XML_PADDING_TOP, XML_TYPE_MEASURE, CTF_PM_FOOTERPADDINGTOP ),
+ HFMAP( "FooterBottomBorderDistance", XML_NAMESPACE_FO, XML_PADDING_BOTTOM, XML_TYPE_MEASURE, CTF_PM_FOOTERPADDINGBOTTOM ),
+ HFMAP( "FooterLeftBorderDistance", XML_NAMESPACE_FO, XML_PADDING_LEFT, XML_TYPE_MEASURE, CTF_PM_FOOTERPADDINGLEFT ),
+ HFMAP( "FooterRightBorderDistance", XML_NAMESPACE_FO, XML_PADDING_RIGHT, XML_TYPE_MEASURE, CTF_PM_FOOTERPADDINGRIGHT ),
+ HFMAP( "FooterShadowFormat", XML_NAMESPACE_STYLE, XML_SHADOW, XML_TYPE_TEXT_SHADOW, CTF_PM_FOOTERFLAG ),
+ HFMAP( "FooterBackColor", XML_NAMESPACE_FO, XML_BACKGROUND_COLOR, XML_TYPE_COLORTRANSPARENT | MID_FLAG_MULTI_PROPERTY, CTF_PM_FOOTERFLAG ),
+ HFMAP( "FooterBackTransparent", XML_NAMESPACE_FO, XML_BACKGROUND_COLOR, XML_TYPE_ISTRANSPARENT | MID_FLAG_MERGE_ATTRIBUTE, CTF_PM_FOOTERFLAG ),
+ HFMAP( "FooterBackGraphicLocation", XML_NAMESPACE_STYLE, XML_POSITION, XML_TYPE_BUILDIN_CMP_ONLY | MID_FLAG_SPECIAL_ITEM, CTF_PM_FOOTERGRAPHICPOSITION ),
+ HFMAP( "FooterBackGraphicFilter", XML_NAMESPACE_STYLE, XML_FILTER_NAME, XML_TYPE_STRING | MID_FLAG_SPECIAL_ITEM, CTF_PM_FOOTERGRAPHICFILTER ),
+ HFMAP( "FooterBackGraphic", XML_NAMESPACE_STYLE, XML_BACKGROUND_IMAGE, XML_TYPE_STRING | MID_FLAG_ELEMENT_ITEM, CTF_PM_FOOTERGRAPHICURL ),
+ HFMAP( "FooterDynamicSpacing", XML_NAMESPACE_STYLE, XML_DYNAMIC_SPACING, XML_TYPE_BOOL, CTF_PM_FOOTERFLAG ),
+
+ //Index 170: Footer DrawingLayer FillAttributes
+ // Use HFMAP to get XML_TYPE_PROP_HEADER_FOOTER ORed to the 4th entry
+ // Names have to begin with 'Footer', all 5th entries need to be ORed with the CTF_PM_FOOTERFLAG
+ HFMAP( "FooterFillStyle", XML_NAMESPACE_DRAW, XML_FILL, XML_SW_TYPE_FILLSTYLE, CTF_PM_FOOTERFLAG ),
+ HFMAP( "FooterFillColor", XML_NAMESPACE_DRAW, XML_FILL_COLOR, XML_TYPE_COLOR, CTF_PM_FOOTERFLAG ),
+ HFMAP( "FooterFillColor2", XML_NAMESPACE_DRAW, XML_SECONDARY_FILL_COLOR, XML_TYPE_COLOR, CTF_PM_FOOTERFLAG ),
+ HFMAP( "FooterFillGradientName", XML_NAMESPACE_DRAW, XML_FILL_GRADIENT_NAME, XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_PM_FOOTERFILLGRADIENTNAME ),
+ HFMAP( "FooterFillGradientStepCount", XML_NAMESPACE_DRAW, XML_GRADIENT_STEP_COUNT, XML_TYPE_NUMBER16, CTF_PM_FOOTERFLAG ),
+ HFMAP( "FooterFillHatchName", XML_NAMESPACE_DRAW, XML_FILL_HATCH_NAME, XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_PM_FOOTERFILLHATCHNAME ),
+ HFMAP( "FooterFillBackground", XML_NAMESPACE_DRAW, XML_FILL_HATCH_SOLID, XML_TYPE_BOOL, CTF_PM_FOOTERFLAG ),
+ HFMAP( "FooterFillBitmapName", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_NAME, XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_PM_FOOTERFILLBITMAPNAME ),
+ HFMAP( "FooterFillTransparence", XML_NAMESPACE_DRAW, XML_OPACITY, XML_TYPE_NEG_PERCENT16|MID_FLAG_MULTI_PROPERTY, CTF_PM_FOOTERFLAG ), // exists in SW, too
+ HFMAP( "FooterFillTransparenceGradientName", XML_NAMESPACE_DRAW, XML_OPACITY_NAME, XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_PM_FOOTERFILLTRANSNAME ),
+ HFMAP( "FooterFillBitmapSizeX", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_WIDTH, XML_SW_TYPE_FILLBITMAPSIZE|MID_FLAG_MULTI_PROPERTY, CTF_PM_FOOTERFLAG ),
+ HFMAP( "FooterFillBitmapLogicalSize", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_WIDTH, XML_SW_TYPE_LOGICAL_SIZE|MID_FLAG_MULTI_PROPERTY, CTF_PM_FOOTERFLAG ),
+ HFMAP( "FooterFillBitmapSizeY", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_HEIGHT, XML_SW_TYPE_FILLBITMAPSIZE|MID_FLAG_MULTI_PROPERTY, CTF_PM_FOOTERFLAG ),
+ HFMAP( "FooterFillBitmapLogicalSize", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_HEIGHT, XML_SW_TYPE_LOGICAL_SIZE|MID_FLAG_MULTI_PROPERTY, CTF_PM_FOOTERFLAG ),
+ HFMAP( "FooterFillBitmapMode", XML_NAMESPACE_STYLE, XML_REPEAT, XML_SW_TYPE_BITMAP_MODE|MID_FLAG_MULTI_PROPERTY, CTF_PM_FOOTERFLAG ),
+ HFMAP( "FooterFillBitmapPositionOffsetX", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_REF_POINT_X, XML_TYPE_PERCENT, CTF_PM_FOOTERFLAG ),
+ HFMAP( "FooterFillBitmapPositionOffsetY", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_REF_POINT_Y, XML_TYPE_PERCENT, CTF_PM_FOOTERFLAG ),
+ HFMAP( "FooterFillBitmapRectanglePoint", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_REF_POINT, XML_SW_TYPE_BITMAP_REFPOINT, CTF_PM_FOOTERFLAG ),
+ HFMAP( "FooterFillBitmapOffsetX", XML_NAMESPACE_DRAW, XML_TILE_REPEAT_OFFSET, XML_SW_TYPE_BITMAPREPOFFSETX|MID_FLAG_MULTI_PROPERTY, CTF_PM_FOOTERREPEAT_OFFSET_X ),
+ HFMAP( "FooterFillBitmapOffsetY", XML_NAMESPACE_DRAW, XML_TILE_REPEAT_OFFSET, XML_SW_TYPE_BITMAPREPOFFSETY|MID_FLAG_MULTI_PROPERTY, CTF_PM_FOOTERREPEAT_OFFSET_Y ),
+
+ { nullptr, 0, XML_EMPTY, 0, 0, SvtSaveOptions::ODFSVER_010, false } // index 190
+};
+
+XMLPropertyMapEntry const g_XMLPageMasterDrawingPageStyleMap[] =
+{
+ // ODF 1.3 OFFICE-3937 style of family "drawing-page" referenced from style:master-page
+ // duplication of relevant part of aXMLPageMasterStyleMap but as DP type
+ DPMAP("FillStyle", XML_NAMESPACE_DRAW, XML_FILL, XML_SW_TYPE_FILLSTYLE, CTF_PM_FILL),
+ DPMAP("BackgroundFullSize", XML_NAMESPACE_DRAW, XML_BACKGROUND_SIZE, XML_SW_TYPE_PRESPAGE_BACKSIZE, CTF_PM_BACKGROUNDSIZE),
+ DPMAP("FillColor", XML_NAMESPACE_DRAW, XML_FILL_COLOR, XML_TYPE_COLOR, 0),
+ DPMAP("FillColor2", XML_NAMESPACE_DRAW, XML_SECONDARY_FILL_COLOR, XML_TYPE_COLOR, 0),
+ DPMAP("FillGradientName", XML_NAMESPACE_DRAW, XML_FILL_GRADIENT_NAME, XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_PM_FILLGRADIENTNAME),
+ DPMAP("FillGradientStepCount", XML_NAMESPACE_DRAW, XML_GRADIENT_STEP_COUNT, XML_TYPE_NUMBER16, 0),
+ DPMAP("FillHatchName", XML_NAMESPACE_DRAW, XML_FILL_HATCH_NAME, XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_PM_FILLHATCHNAME),
+ DPMAP("FillBackground", XML_NAMESPACE_DRAW, XML_FILL_HATCH_SOLID, XML_TYPE_BOOL, 0),
+ DPMAP("FillBitmapName", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_NAME, XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_PM_FILLBITMAPNAME),
+ DPMAP("FillTransparence", XML_NAMESPACE_DRAW, XML_OPACITY, XML_TYPE_NEG_PERCENT16|MID_FLAG_MULTI_PROPERTY, 0), /* exists in SW, too */
+ DPMAP("FillTransparenceGradientName", XML_NAMESPACE_DRAW, XML_OPACITY_NAME, XML_TYPE_STYLENAME|MID_FLAG_NO_PROPERTY_IMPORT, CTF_PM_FILLTRANSNAME),
+ DPMAP("FillBitmapSizeX", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_WIDTH, XML_SW_TYPE_FILLBITMAPSIZE|MID_FLAG_MULTI_PROPERTY, 0),
+ DPMAP("FillBitmapLogicalSize", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_WIDTH, XML_SW_TYPE_LOGICAL_SIZE|MID_FLAG_MULTI_PROPERTY, 0),
+ DPMAP("FillBitmapSizeY", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_HEIGHT, XML_SW_TYPE_FILLBITMAPSIZE|MID_FLAG_MULTI_PROPERTY, 0),
+ DPMAP("FillBitmapLogicalSize", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_HEIGHT, XML_SW_TYPE_LOGICAL_SIZE|MID_FLAG_MULTI_PROPERTY, 0),
+ DPMAP("FillBitmapMode", XML_NAMESPACE_STYLE, XML_REPEAT, XML_SW_TYPE_BITMAP_MODE|MID_FLAG_MULTI_PROPERTY, CTF_PM_FILLBITMAPMODE),
+ DPMAP("FillBitmapPositionOffsetX", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_REF_POINT_X, XML_TYPE_PERCENT, 0),
+ DPMAP("FillBitmapPositionOffsetY", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_REF_POINT_Y, XML_TYPE_PERCENT, 0),
+ DPMAP("FillBitmapRectanglePoint", XML_NAMESPACE_DRAW, XML_FILL_IMAGE_REF_POINT, XML_SW_TYPE_BITMAP_REFPOINT, 0),
+ DPMAP("FillBitmapOffsetX", XML_NAMESPACE_DRAW, XML_TILE_REPEAT_OFFSET, XML_SW_TYPE_BITMAPREPOFFSETX|MID_FLAG_MULTI_PROPERTY, CTF_PM_REPEAT_OFFSET_X),
+ DPMAP("FillBitmapOffsetY", XML_NAMESPACE_DRAW, XML_TILE_REPEAT_OFFSET, XML_SW_TYPE_BITMAPREPOFFSETY|MID_FLAG_MULTI_PROPERTY, CTF_PM_REPEAT_OFFSET_Y),
+
+ { nullptr, 0, XML_EMPTY, 0, 0, SvtSaveOptions::ODFSVER_010, false }
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/PagePropertySetContext.cxx b/xmloff/source/style/PagePropertySetContext.cxx
new file mode 100644
index 000000000..31c541f56
--- /dev/null
+++ b/xmloff/source/style/PagePropertySetContext.cxx
@@ -0,0 +1,119 @@
+/* -*- 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 <tools/debug.hxx>
+#include "PagePropertySetContext.hxx"
+#include <XMLBackgroundImageContext.hxx>
+#include <XMLTextColumnsContext.hxx>
+#include <PageMasterStyleMap.hxx>
+#include "XMLFootnoteSeparatorImport.hxx"
+#include <xmloff/xmlimppr.hxx>
+#include <xmloff/xmlprmap.hxx>
+
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star;
+
+PagePropertySetContext::PagePropertySetContext(
+ SvXMLImport& rImport, sal_Int32 nElement,
+ const Reference< xml::sax::XFastAttributeList > & xAttrList,
+ sal_uInt32 nFam,
+ ::std::vector< XMLPropertyState > &rProps,
+ const rtl::Reference < SvXMLImportPropertyMapper > &rMap,
+ sal_Int32 nStartIndex, sal_Int32 nEndIndex,
+ const PageContextType aTempType ) :
+ SvXMLPropertySetContext( rImport, nElement, xAttrList, nFam,
+ rProps, rMap, nStartIndex, nEndIndex )
+{
+ aType = aTempType;
+}
+
+PagePropertySetContext::~PagePropertySetContext()
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > PagePropertySetContext::createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList,
+ ::std::vector< XMLPropertyState > &rProperties,
+ const XMLPropertyState& rProp )
+{
+ sal_Int32 nPos = CTF_PM_GRAPHICPOSITION;
+ sal_Int32 nFil = CTF_PM_GRAPHICFILTER;
+ switch ( aType )
+ {
+ case Header:
+ {
+ nPos = CTF_PM_HEADERGRAPHICPOSITION;
+ nFil = CTF_PM_HEADERGRAPHICFILTER;
+ }
+ break;
+ case Footer:
+ {
+ nPos = CTF_PM_FOOTERGRAPHICPOSITION;
+ nFil = CTF_PM_FOOTERGRAPHICFILTER;
+ }
+ break;
+ default:
+ break;
+ }
+
+ switch( mxMapper->getPropertySetMapper()
+ ->GetEntryContextId( rProp.mnIndex ) )
+ {
+ case CTF_PM_GRAPHICURL:
+ case CTF_PM_HEADERGRAPHICURL:
+ case CTF_PM_FOOTERGRAPHICURL:
+ DBG_ASSERT( rProp.mnIndex >= 2 &&
+ nPos == mxMapper->getPropertySetMapper()
+ ->GetEntryContextId( rProp.mnIndex-2 ) &&
+ nFil == mxMapper->getPropertySetMapper()
+ ->GetEntryContextId( rProp.mnIndex-1 ),
+ "invalid property map!");
+ return
+ new XMLBackgroundImageContext( GetImport(), nElement,
+ xAttrList,
+ rProp,
+ rProp.mnIndex-2,
+ rProp.mnIndex-1,
+ -1,
+ mxMapper->getPropertySetMapper()->FindEntryIndex(CTF_PM_FILLBITMAPMODE),
+ rProperties );
+ break;
+
+ case CTF_PM_TEXTCOLUMNS:
+ return new XMLTextColumnsContext( GetImport(), nElement,
+ xAttrList, rProp,
+ rProperties );
+ break;
+
+ case CTF_PM_FTN_LINE_WEIGHT:
+ return new XMLFootnoteSeparatorImport(
+ GetImport(), nElement, rProperties,
+ mxMapper->getPropertySetMapper(), rProp.mnIndex);
+ break;
+ }
+
+ return SvXMLPropertySetContext::createFastChildContext( nElement,
+ xAttrList,
+ rProperties, rProp );
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/PagePropertySetContext.hxx b/xmloff/source/style/PagePropertySetContext.hxx
new file mode 100644
index 000000000..2429dc194
--- /dev/null
+++ b/xmloff/source/style/PagePropertySetContext.hxx
@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprcon.hxx>
+
+enum PageContextType
+{
+ Page,
+ Header,
+ Footer
+};
+
+class PagePropertySetContext : public SvXMLPropertySetContext
+{
+ PageContextType aType;
+
+public:
+ PagePropertySetContext( SvXMLImport& rImport, sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList,
+ sal_uInt32 nFam,
+ ::std::vector< XMLPropertyState > &rProps,
+ const rtl::Reference < SvXMLImportPropertyMapper > &rMap,
+ sal_Int32 nStartIndex, sal_Int32 nEndIndex,
+ const PageContextType aType );
+
+ virtual ~PagePropertySetContext() override;
+
+ using SvXMLPropertySetContext::createFastChildContext;
+ virtual css::uno::Reference< css::xml::sax::XFastContextHandler > createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList,
+ ::std::vector< XMLPropertyState > &rProperties,
+ const XMLPropertyState& rProp ) override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/SinglePropertySetInfoCache.cxx b/xmloff/source/style/SinglePropertySetInfoCache.cxx
new file mode 100644
index 000000000..1bc06ef4d
--- /dev/null
+++ b/xmloff/source/style/SinglePropertySetInfoCache.cxx
@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <cppuhelper/weakref.hxx>
+#include <xmloff/SinglePropertySetInfoCache.hxx>
+#include <com/sun/star/beans/XPropertySet.hpp>
+
+using namespace ::com::sun::star::uno;
+using ::com::sun::star::beans::XPropertySet;
+using ::com::sun::star::beans::XPropertySetInfo;
+
+bool SinglePropertySetInfoCache::hasProperty(
+ const Reference< XPropertySet >& rPropSet,
+ Reference< XPropertySetInfo >& rPropSetInfo )
+{
+ if( !rPropSetInfo.is() )
+ rPropSetInfo = rPropSet->getPropertySetInfo();
+ Map::iterator aIter = map_.find( rPropSetInfo );
+ if( aIter != map_.end() )
+ {
+ return (*aIter).second;
+ }
+ bool bRet = rPropSetInfo->hasPropertyByName( sName );
+ // Check whether the property set info is destroyed if it is assigned to a
+ // weak reference only; if it is destroyed, then every instance of
+ // getPropertySetInfo returns a new object; Such property set infos must not
+ // be cached:
+ WeakReference < XPropertySetInfo > xWeakInfo( rPropSetInfo );
+ rPropSetInfo = nullptr;
+ rPropSetInfo = xWeakInfo;
+ if( rPropSetInfo.is() )
+ {
+ map_.emplace(rPropSetInfo, bRet);
+ }
+ return bRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/StyleMap.cxx b/xmloff/source/style/StyleMap.cxx
new file mode 100644
index 000000000..1d52ea112
--- /dev/null
+++ b/xmloff/source/style/StyleMap.cxx
@@ -0,0 +1,32 @@
+/* -*- 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 <StyleMap.hxx>
+
+using namespace css::uno;
+using namespace css::lang;
+
+StyleMap::StyleMap() {}
+
+StyleMap::~StyleMap() {}
+
+// XUnoTunnel & co
+UNO3_GETIMPLEMENTATION_IMPL(StyleMap);
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/TransGradientStyle.cxx b/xmloff/source/style/TransGradientStyle.cxx
new file mode 100644
index 000000000..9b000c3eb
--- /dev/null
+++ b/xmloff/source/style/TransGradientStyle.cxx
@@ -0,0 +1,246 @@
+/* -*- 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 <TransGradientStyle.hxx>
+
+#include <com/sun/star/awt/Gradient.hpp>
+
+#include <sax/tools/converter.hxx>
+#include <comphelper/documentconstants.hxx>
+
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <rtl/ustring.hxx>
+#include <sal/log.hxx>
+#include <tools/color.hxx>
+#include <xmloff/xmltkmap.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmlement.hxx>
+
+using namespace ::com::sun::star;
+
+using namespace ::xmloff::token;
+
+SvXMLEnumMapEntry<awt::GradientStyle> const pXML_GradientStyle_Enum[] =
+{
+ { XML_LINEAR, awt::GradientStyle_LINEAR },
+ { XML_GRADIENTSTYLE_AXIAL, awt::GradientStyle_AXIAL },
+ { XML_GRADIENTSTYLE_RADIAL, awt::GradientStyle_RADIAL },
+ { XML_GRADIENTSTYLE_ELLIPSOID, awt::GradientStyle_ELLIPTICAL },
+ { XML_GRADIENTSTYLE_SQUARE, awt::GradientStyle_SQUARE },
+ { XML_GRADIENTSTYLE_RECTANGULAR, awt::GradientStyle_RECT },
+ { XML_TOKEN_INVALID, awt::GradientStyle(0) }
+};
+
+// Import
+
+XMLTransGradientStyleImport::XMLTransGradientStyleImport( SvXMLImport& rImp )
+ : rImport(rImp)
+{
+}
+
+void XMLTransGradientStyleImport::importXML(
+ const uno::Reference< xml::sax::XFastAttributeList >& xAttrList,
+ uno::Any& rValue,
+ OUString& rStrName )
+{
+ OUString aDisplayName;
+
+ awt::Gradient aGradient;
+ aGradient.XOffset = 0;
+ aGradient.YOffset = 0;
+ aGradient.StartIntensity = 100;
+ aGradient.EndIntensity = 100;
+ aGradient.Angle = 0;
+ aGradient.Border = 0;
+
+ for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+ {
+ sal_Int32 nTmpValue;
+
+ switch( aIter.getToken() )
+ {
+ case XML_ELEMENT(DRAW, XML_NAME):
+ {
+ rStrName = aIter.toString();
+ }
+ break;
+ case XML_ELEMENT(DRAW, XML_DISPLAY_NAME):
+ {
+ aDisplayName = aIter.toString();
+ }
+ break;
+ case XML_ELEMENT(DRAW, XML_STYLE):
+ {
+ SvXMLUnitConverter::convertEnum( aGradient.Style, aIter.toView(), pXML_GradientStyle_Enum );
+ }
+ break;
+ case XML_ELEMENT(DRAW, XML_CX):
+ ::sax::Converter::convertPercent( nTmpValue, aIter.toView() );
+ aGradient.XOffset = sal::static_int_cast< sal_Int16 >(nTmpValue);
+ break;
+ case XML_ELEMENT(DRAW, XML_CY):
+ ::sax::Converter::convertPercent( nTmpValue, aIter.toView() );
+ aGradient.YOffset = sal::static_int_cast< sal_Int16 >(nTmpValue);
+ break;
+ case XML_ELEMENT(DRAW, XML_START):
+ {
+ sal_Int32 aStartTransparency;
+ ::sax::Converter::convertPercent( aStartTransparency, aIter.toView() );
+
+ sal_uInt8 n = sal::static_int_cast< sal_uInt8 >(
+ ( (100 - aStartTransparency) * 255 ) / 100 );
+
+ Color aColor( n, n, n );
+ aGradient.StartColor = static_cast<sal_Int32>( aColor );
+ }
+ break;
+ case XML_ELEMENT(DRAW, XML_END):
+ {
+ sal_Int32 aEndTransparency;
+ ::sax::Converter::convertPercent( aEndTransparency, aIter.toView() );
+
+ sal_uInt8 n = sal::static_int_cast< sal_uInt8 >(
+ ( (100 - aEndTransparency) * 255 ) / 100 );
+
+ Color aColor( n, n, n );
+ aGradient.EndColor = static_cast<sal_Int32>( aColor );
+ }
+ break;
+ case XML_ELEMENT(DRAW, XML_GRADIENT_ANGLE):
+ {
+ auto const cmp12(rImport.GetODFVersion().compareTo(ODFVER_012_TEXT));
+ bool const bSuccess =
+ ::sax::Converter::convertAngle(aGradient.Angle, aIter.toView(),
+ // tdf#89475 try to detect borked OOo angles
+ (cmp12 < 0) || (cmp12 == 0
+ && (rImport.isGeneratorVersionOlderThan(SvXMLImport::AOO_4x, SvXMLImport::LO_7x)
+ // also for AOO 4.x, assume there won't ever be a 4.2
+ || rImport.getGeneratorVersion() == SvXMLImport::AOO_4x)));
+ SAL_INFO_IF(!bSuccess, "xmloff.style", "failed to import draw:angle");
+ }
+ break;
+ case XML_ELEMENT(DRAW, XML_BORDER):
+ ::sax::Converter::convertPercent( nTmpValue, aIter.toView() );
+ aGradient.Border = sal::static_int_cast< sal_Int16 >(nTmpValue);
+ break;
+
+ default:
+ XMLOFF_WARN_UNKNOWN("xmloff.style", aIter);
+ }
+ }
+
+ rValue <<= aGradient;
+
+ if( !aDisplayName.isEmpty() )
+ {
+ rImport.AddStyleDisplayName( XmlStyleFamily::SD_GRADIENT_ID, rStrName,
+ aDisplayName );
+ rStrName = aDisplayName;
+ }
+}
+
+// Export
+
+XMLTransGradientStyleExport::XMLTransGradientStyleExport( SvXMLExport& rExp )
+ : rExport(rExp)
+{
+}
+
+void XMLTransGradientStyleExport::exportXML(
+ const OUString& rStrName,
+ const uno::Any& rValue )
+{
+ awt::Gradient aGradient;
+
+ if( rStrName.isEmpty() )
+ return;
+
+ if( !(rValue >>= aGradient) )
+ return;
+
+ OUString aStrValue;
+ OUStringBuffer aOut;
+
+ // Style
+ if( !SvXMLUnitConverter::convertEnum( aOut, aGradient.Style, pXML_GradientStyle_Enum ) )
+ return;
+
+ // Name
+ bool bEncoded = false;
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_NAME,
+ rExport.EncodeStyleName( rStrName,
+ &bEncoded ) );
+ if( bEncoded )
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_DISPLAY_NAME,
+ rStrName );
+
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_STYLE, aStrValue );
+
+ // Center x/y
+ if( aGradient.Style != awt::GradientStyle_LINEAR &&
+ aGradient.Style != awt::GradientStyle_AXIAL )
+ {
+ ::sax::Converter::convertPercent(aOut, aGradient.XOffset);
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CX, aStrValue );
+
+ ::sax::Converter::convertPercent(aOut, aGradient.YOffset);
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_CY, aStrValue );
+ }
+
+ // Transparency start
+ Color aColor(ColorTransparency, aGradient.StartColor);
+ sal_Int32 aStartValue = 100 - static_cast<sal_Int32>(((aColor.GetRed() + 1) * 100) / 255);
+ ::sax::Converter::convertPercent( aOut, aStartValue );
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_START, aStrValue );
+
+ // Transparency end
+ aColor = Color(ColorTransparency, aGradient.EndColor);
+ sal_Int32 aEndValue = 100 - static_cast<sal_Int32>(((aColor.GetRed() + 1) * 100) / 255);
+ ::sax::Converter::convertPercent( aOut, aEndValue );
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_END, aStrValue );
+
+ // Angle
+ if( aGradient.Style != awt::GradientStyle_RADIAL )
+ {
+ ::sax::Converter::convertAngle(aOut, aGradient.Angle, rExport.getSaneDefaultVersion());
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_GRADIENT_ANGLE, aStrValue );
+ }
+
+ // Border
+ ::sax::Converter::convertPercent( aOut, aGradient.Border );
+ aStrValue = aOut.makeStringAndClear();
+ rExport.AddAttribute( XML_NAMESPACE_DRAW, XML_BORDER, aStrValue );
+
+ // Do Write
+ SvXMLElementExport rElem( rExport,
+ XML_NAMESPACE_DRAW, XML_OPACITY,
+ true, false );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/WordWrapPropertyHdl.cxx b/xmloff/source/style/WordWrapPropertyHdl.cxx
new file mode 100644
index 000000000..0a01bd11d
--- /dev/null
+++ b/xmloff/source/style/WordWrapPropertyHdl.cxx
@@ -0,0 +1,88 @@
+/* -*- 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 <xmloff/xmlimp.hxx>
+#include <WordWrapPropertyHdl.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <comphelper/extract.hxx>
+#include <rtl/ustring.hxx>
+#include <com/sun/star/uno/Any.hxx>
+
+using namespace ::com::sun::star::uno;
+
+
+
+
+XMLWordWrapPropertyHdl::XMLWordWrapPropertyHdl( SvXMLImport* pImport )
+: mpImport( pImport )
+{
+}
+
+XMLWordWrapPropertyHdl::~XMLWordWrapPropertyHdl()
+{
+ // Nothing to do
+}
+
+bool XMLWordWrapPropertyHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRetValue = false;
+ bool bValue = false;
+ if( rStrImpValue == GetXMLToken( xmloff::token::XML_WRAP ) )
+ {
+ bValue = true;
+ bRetValue = true;
+ }
+ if( rStrImpValue == GetXMLToken( xmloff::token::XML_NO_WRAP ) )
+ {
+ bValue = false;
+ bRetValue = true;
+ }
+ if ( bRetValue && mpImport )
+ {
+ sal_Int32 nUPD, nBuildId;
+ if( mpImport->getBuildIds( nUPD, nBuildId ) )
+ {
+ if( nUPD == 300 )
+ {
+ if( ( nBuildId > 0 ) && (nBuildId < 9316 ) )
+ bValue = !bValue; // treat OOo 3.0 beta1 as OOo 2.x
+ }
+ else if( ( nUPD == 680 ) || ( nUPD >= 640 && nUPD <= 645 ) )
+ bValue = !bValue;
+ }
+ rValue <<= bValue;
+ }
+ return bRetValue;
+}
+
+bool XMLWordWrapPropertyHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ if( ::cppu::any2bool( rValue ) )
+ {
+ rStrExpValue = GetXMLToken( xmloff::token::XML_WRAP );
+ }
+ else
+ {
+ rStrExpValue = GetXMLToken( xmloff::token::XML_NO_WRAP );
+ }
+ return true;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/XMLBackgroundImageContext.cxx b/xmloff/source/style/XMLBackgroundImageContext.cxx
new file mode 100644
index 000000000..cd500672c
--- /dev/null
+++ b/xmloff/source/style/XMLBackgroundImageContext.cxx
@@ -0,0 +1,397 @@
+/* -*- 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/io/XOutputStream.hpp>
+#include <com/sun/star/drawing/BitmapMode.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+
+#include <tools/debug.hxx>
+#include <sal/log.hxx>
+#include <sax/tools/converter.hxx>
+
+#include <xmloff/xmltkmap.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/xmlement.hxx>
+#include <xmloff/XMLBase64ImportContext.hxx>
+#include <XMLBackgroundImageContext.hxx>
+
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::style;
+using namespace ::com::sun::star::io;
+using namespace ::xmloff::token;
+
+const SvXMLEnumMapEntry<GraphicLocation> psXML_BrushHoriPos[] =
+{
+ { XML_LEFT, GraphicLocation_LEFT_MIDDLE },
+ { XML_RIGHT, GraphicLocation_RIGHT_MIDDLE },
+ { XML_TOKEN_INVALID, GraphicLocation(0) }
+};
+
+const SvXMLEnumMapEntry<GraphicLocation> psXML_BrushVertPos[] =
+{
+ { XML_TOP, GraphicLocation_MIDDLE_TOP },
+ { XML_BOTTOM, GraphicLocation_MIDDLE_BOTTOM },
+ { XML_TOKEN_INVALID, GraphicLocation(0) }
+};
+
+static void lcl_xmlbic_MergeHoriPos( GraphicLocation& ePos,
+ GraphicLocation eHori )
+{
+ DBG_ASSERT( GraphicLocation_LEFT_MIDDLE==eHori ||
+ GraphicLocation_MIDDLE_MIDDLE==eHori ||
+ GraphicLocation_RIGHT_MIDDLE==eHori,
+ "lcl_xmlbic_MergeHoriPos: vertical pos must be middle" );
+
+ switch( ePos )
+ {
+ case GraphicLocation_LEFT_TOP:
+ case GraphicLocation_MIDDLE_TOP:
+ case GraphicLocation_RIGHT_TOP:
+ ePos = GraphicLocation_LEFT_MIDDLE==eHori
+ ? GraphicLocation_LEFT_TOP
+ : (GraphicLocation_MIDDLE_MIDDLE==eHori
+ ? GraphicLocation_MIDDLE_TOP
+ : GraphicLocation_RIGHT_TOP);
+ break;
+
+ case GraphicLocation_LEFT_MIDDLE:
+ case GraphicLocation_MIDDLE_MIDDLE:
+ case GraphicLocation_RIGHT_MIDDLE:
+ ePos = eHori;
+ break;
+
+ case GraphicLocation_LEFT_BOTTOM:
+ case GraphicLocation_MIDDLE_BOTTOM:
+ case GraphicLocation_RIGHT_BOTTOM:
+ ePos = GraphicLocation_LEFT_MIDDLE==eHori
+ ? GraphicLocation_LEFT_BOTTOM
+ : (GraphicLocation_MIDDLE_MIDDLE==eHori
+ ? GraphicLocation_MIDDLE_BOTTOM
+ : GraphicLocation_RIGHT_BOTTOM);
+ break;
+ default:
+ break;
+ }
+}
+
+static void lcl_xmlbic_MergeVertPos( GraphicLocation& ePos,
+ GraphicLocation eVert )
+{
+ DBG_ASSERT( GraphicLocation_MIDDLE_TOP==eVert ||
+ GraphicLocation_MIDDLE_MIDDLE==eVert ||
+ GraphicLocation_MIDDLE_BOTTOM==eVert,
+ "lcl_xmlbic_MergeVertPos: horizontal pos must be middle" );
+
+ switch( ePos )
+ {
+ case GraphicLocation_LEFT_TOP:
+ case GraphicLocation_LEFT_MIDDLE:
+ case GraphicLocation_LEFT_BOTTOM:
+ ePos = GraphicLocation_MIDDLE_TOP==eVert
+ ? GraphicLocation_LEFT_TOP
+ : (GraphicLocation_MIDDLE_MIDDLE==eVert
+ ? GraphicLocation_LEFT_MIDDLE
+ : GraphicLocation_LEFT_BOTTOM);
+ break;
+
+ case GraphicLocation_MIDDLE_TOP:
+ case GraphicLocation_MIDDLE_MIDDLE:
+ case GraphicLocation_MIDDLE_BOTTOM:
+ ePos = eVert;
+ break;
+
+ case GraphicLocation_RIGHT_TOP:
+ case GraphicLocation_RIGHT_MIDDLE:
+ case GraphicLocation_RIGHT_BOTTOM:
+ ePos = GraphicLocation_MIDDLE_TOP==eVert
+ ? GraphicLocation_RIGHT_TOP
+ : (GraphicLocation_MIDDLE_MIDDLE==eVert
+ ? GraphicLocation_RIGHT_MIDDLE
+ : GraphicLocation_RIGHT_BOTTOM);
+ break;
+ default:
+ break;
+ }
+}
+
+
+void XMLBackgroundImageContext::ProcessAttrs(
+ const Reference< xml::sax::XFastAttributeList >& xAttrList )
+{
+ ePos = GraphicLocation_NONE;
+
+ for (auto &aIter : sax_fastparser::castToFastAttributeList(xAttrList))
+ {
+ switch( aIter.getToken() )
+ {
+ case XML_ELEMENT(XLINK, XML_HREF):
+ m_sURL = aIter.toString();
+ if( GraphicLocation_NONE == ePos )
+ ePos = GraphicLocation_TILED;
+ break;
+ case XML_ELEMENT(XLINK, XML_TYPE):
+ case XML_ELEMENT(XLINK, XML_ACTUATE):
+ case XML_ELEMENT(XLINK, XML_SHOW):
+ break;
+ case XML_ELEMENT(STYLE, XML_POSITION):
+ {
+ GraphicLocation eNewPos = GraphicLocation_NONE, eTmp;
+ OUString sValue = aIter.toString();
+ SvXMLTokenEnumerator aTokenEnum( sValue );
+ std::u16string_view aToken;
+ bool bHori = false, bVert = false;
+ bool bOK = true;
+ while( bOK && aTokenEnum.getNextToken( aToken ) )
+ {
+ GraphicLocation nTmpGraphicLocation;
+ if( bHori && bVert )
+ {
+ bOK = false;
+ }
+ else if( std::u16string_view::npos != aToken.find( '%' ) )
+ {
+ sal_Int32 nPrc = 50;
+ if (::sax::Converter::convertPercent( nPrc, aToken ))
+ {
+ if( !bHori )
+ {
+ eNewPos = nPrc < 25
+ ? GraphicLocation_LEFT_TOP
+ : (nPrc < 75 ? GraphicLocation_MIDDLE_MIDDLE
+ : GraphicLocation_RIGHT_BOTTOM);
+ bHori = true;
+ }
+ else
+ {
+ eTmp = nPrc < 25
+ ? GraphicLocation_LEFT_TOP
+ : (nPrc < 75 ? GraphicLocation_LEFT_MIDDLE
+ : GraphicLocation_LEFT_BOTTOM);
+ lcl_xmlbic_MergeVertPos( eNewPos, eTmp );
+ bVert = true;
+ }
+ }
+ else
+ {
+ // wrong percentage
+ bOK = false;
+ }
+ }
+ else if( IsXMLToken( aToken, XML_CENTER ) )
+ {
+ if( bHori )
+ lcl_xmlbic_MergeVertPos( eNewPos,
+ GraphicLocation_MIDDLE_MIDDLE );
+ else if ( bVert )
+ lcl_xmlbic_MergeHoriPos( eNewPos,
+ GraphicLocation_MIDDLE_MIDDLE );
+ else
+ eNewPos = GraphicLocation_MIDDLE_MIDDLE;
+ }
+ else if( SvXMLUnitConverter::convertEnum( nTmpGraphicLocation, aToken,
+ psXML_BrushHoriPos ) )
+ {
+ if( bVert )
+ lcl_xmlbic_MergeHoriPos( eNewPos, nTmpGraphicLocation );
+ else if( !bHori )
+ eNewPos = nTmpGraphicLocation;
+ else
+ bOK = false;
+ bHori = true;
+ }
+ else if( SvXMLUnitConverter::convertEnum( nTmpGraphicLocation, aToken,
+ psXML_BrushVertPos ) )
+ {
+ if( bHori )
+ lcl_xmlbic_MergeVertPos( eNewPos, nTmpGraphicLocation );
+ else if( !bVert )
+ eNewPos = nTmpGraphicLocation;
+ else
+ bOK = false;
+ bVert = true;
+ }
+ else
+ {
+ bOK = false;
+ }
+ }
+
+ bOK &= GraphicLocation_NONE != eNewPos;
+ if( bOK )
+ ePos = eNewPos;
+ }
+ break;
+ case XML_ELEMENT(STYLE, XML_REPEAT):
+ {
+ GraphicLocation nPos = GraphicLocation_NONE;
+ static const SvXMLEnumMapEntry<GraphicLocation> psXML_BrushRepeat[] =
+ {
+ { XML_REPEAT, GraphicLocation_TILED },
+ { XML_BACKGROUND_NO_REPEAT, GraphicLocation_MIDDLE_MIDDLE },
+ { XML_STRETCH, GraphicLocation_AREA },
+ { XML_TOKEN_INVALID, GraphicLocation(0) }
+ };
+ if( SvXMLUnitConverter::convertEnum( nPos, aIter.toView(),
+ psXML_BrushRepeat ) )
+ {
+ if( GraphicLocation_MIDDLE_MIDDLE != nPos ||
+ GraphicLocation_NONE == ePos ||
+ GraphicLocation_AREA == ePos ||
+ GraphicLocation_TILED == ePos )
+ ePos = nPos;
+ }
+ }
+ break;
+ case XML_ELEMENT(STYLE, XML_FILTER_NAME):
+ sFilter = aIter.toString();
+ break;
+ case XML_ELEMENT(DRAW, XML_OPACITY):
+ {
+ sal_Int32 nTmp;
+ // convert from percent and clip
+ if (::sax::Converter::convertPercent( nTmp, aIter.toView() ))
+ {
+ if( (nTmp >= 0) && (nTmp <= 100) )
+ nTransparency = static_cast<sal_Int8>( 100-nTmp );
+ }
+ }
+ break;
+ default:
+ XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+ }
+ }
+
+}
+
+XMLBackgroundImageContext::XMLBackgroundImageContext(
+ SvXMLImport& rImport, sal_Int32 nElement,
+ const Reference< xml::sax::XFastAttributeList > & xAttrList,
+ const XMLPropertyState& rProp,
+ sal_Int32 nPosIdx,
+ sal_Int32 nFilterIdx,
+ sal_Int32 nTransparencyIdx,
+ sal_Int32 nBitmapModeIdx,
+ ::std::vector< XMLPropertyState > &rProps ) :
+ XMLElementPropertyContext( rImport, nElement, rProp, rProps ),
+ aPosProp( nPosIdx ),
+ m_nBitmapModeIdx(nBitmapModeIdx),
+ aFilterProp( nFilterIdx ),
+ aTransparencyProp( nTransparencyIdx ),
+ nTransparency( 0 )
+{
+ ProcessAttrs( xAttrList );
+}
+
+XMLBackgroundImageContext::~XMLBackgroundImageContext()
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > XMLBackgroundImageContext::createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& /*xAttrList*/ )
+{
+ if( nElement == XML_ELEMENT(OFFICE, xmloff::token::XML_BINARY_DATA) )
+ {
+ if( m_sURL.isEmpty() && !m_xBase64Stream.is() )
+ {
+ m_xBase64Stream = GetImport().GetStreamForGraphicObjectURLFromBase64();
+ if( m_xBase64Stream.is() )
+ return new XMLBase64ImportContext( GetImport(), m_xBase64Stream );
+ }
+ }
+ XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+ return nullptr;
+}
+
+void XMLBackgroundImageContext::endFastElement(sal_Int32 nElement)
+{
+ uno::Reference<graphic::XGraphic> xGraphic;
+ if (!m_sURL.isEmpty())
+ {
+ xGraphic = GetImport().loadGraphicByURL(m_sURL);
+ }
+ else if (m_xBase64Stream.is())
+ {
+ xGraphic = GetImport().loadGraphicFromBase64(m_xBase64Stream);
+ m_xBase64Stream = nullptr;
+ }
+
+ if (!xGraphic.is())
+ ePos = GraphicLocation_NONE;
+ else if (GraphicLocation_NONE == ePos)
+ ePos = GraphicLocation_TILED;
+
+ if (xGraphic.is())
+ aProp.maValue <<= xGraphic;
+ aPosProp.maValue <<= ePos;
+ aFilterProp.maValue <<= sFilter;
+ aTransparencyProp.maValue <<= nTransparency;
+
+ SetInsert( true );
+ XMLElementPropertyContext::endFastElement(nElement);
+
+ if( -1 != aPosProp.mnIndex )
+ {
+ // See if a FillBitmapMode property is already set, in that case
+ // BackGraphicLocation will be ignored.
+ bool bFound = false;
+ if (m_nBitmapModeIdx != -1)
+ {
+ for (XMLPropertyState& rProperty : rProperties)
+ {
+ if (rProperty.mnIndex == m_nBitmapModeIdx)
+ {
+ bFound = true;
+
+ // Found, so map the old property to the new one.
+ switch (ePos)
+ {
+ case GraphicLocation_TILED:
+ rProperty.maValue <<= drawing::BitmapMode_REPEAT;
+ break;
+ case GraphicLocation_AREA:
+ rProperty.maValue <<= drawing::BitmapMode_STRETCH;
+ break;
+ case GraphicLocation_MIDDLE_MIDDLE:
+ rProperty.maValue <<= drawing::BitmapMode_NO_REPEAT;
+ break;
+ default:
+ break;
+ }
+ break;
+ }
+ }
+ }
+ if (!bFound)
+ rProperties.push_back( aPosProp );
+ }
+ if( -1 != aFilterProp.mnIndex )
+ rProperties.push_back( aFilterProp );
+ if( -1 != aTransparencyProp.mnIndex )
+ rProperties.push_back( aTransparencyProp );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/XMLBackgroundImageExport.cxx b/xmloff/source/style/XMLBackgroundImageExport.cxx
new file mode 100644
index 000000000..c3ae8748a
--- /dev/null
+++ b/xmloff/source/style/XMLBackgroundImageExport.cxx
@@ -0,0 +1,165 @@
+/* -*- 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/GraphicLocation.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+
+#include <sax/tools/converter.hxx>
+
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <XMLBackgroundImageExport.hxx>
+
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::style;
+using namespace ::xmloff::token;
+
+XMLBackgroundImageExport::XMLBackgroundImageExport( SvXMLExport& rExp ) :
+ rExport( rExp )
+{
+}
+
+void XMLBackgroundImageExport::exportXML( const Any& rGraphicAny,
+ const Any *pPos,
+ const Any *pFilter,
+ const Any *pTransparency,
+ sal_uInt16 nPrefix,
+ const OUString& rLocalName )
+{
+ GraphicLocation ePos;
+ if( !(pPos && ((*pPos) >>= ePos)) )
+ ePos = GraphicLocation_AREA;
+
+ uno::Reference<graphic::XGraphic> xGraphic;
+ if (rGraphicAny.has<uno::Reference<graphic::XGraphic>>())
+ xGraphic = rGraphicAny.get<uno::Reference<graphic::XGraphic>>();
+
+ if (xGraphic.is() && GraphicLocation_NONE != ePos)
+ {
+ OUString sUsedMimeType;
+ OUString sInternalURL(GetExport().AddEmbeddedXGraphic(xGraphic, sUsedMimeType));
+
+ if (!sInternalURL.isEmpty())
+ {
+ GetExport().AddAttribute(XML_NAMESPACE_XLINK, XML_HREF, sInternalURL);
+ GetExport().AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+ GetExport().AddAttribute(XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD);
+ }
+
+ OUStringBuffer aOut;
+ switch( ePos )
+ {
+ case GraphicLocation_LEFT_TOP:
+ case GraphicLocation_MIDDLE_TOP:
+ case GraphicLocation_RIGHT_TOP:
+ aOut.append( GetXMLToken(XML_TOP) );
+ break;
+ case GraphicLocation_LEFT_MIDDLE:
+ case GraphicLocation_MIDDLE_MIDDLE:
+ case GraphicLocation_RIGHT_MIDDLE:
+ aOut.append( GetXMLToken(XML_CENTER) );
+ break;
+ case GraphicLocation_LEFT_BOTTOM:
+ case GraphicLocation_MIDDLE_BOTTOM:
+ case GraphicLocation_RIGHT_BOTTOM:
+ aOut.append( GetXMLToken(XML_BOTTOM) );
+ break;
+ default:
+ break;
+ }
+
+ if( !aOut.isEmpty() )
+ {
+ aOut.append( ' ' );
+
+ switch( ePos )
+ {
+ case GraphicLocation_LEFT_TOP:
+ case GraphicLocation_LEFT_BOTTOM:
+ case GraphicLocation_LEFT_MIDDLE:
+ aOut.append( GetXMLToken(XML_LEFT) );
+ break;
+ case GraphicLocation_MIDDLE_TOP:
+ case GraphicLocation_MIDDLE_MIDDLE:
+ case GraphicLocation_MIDDLE_BOTTOM:
+ aOut.append( GetXMLToken(XML_CENTER) );
+ break;
+ case GraphicLocation_RIGHT_MIDDLE:
+ case GraphicLocation_RIGHT_TOP:
+ case GraphicLocation_RIGHT_BOTTOM:
+ aOut.append( GetXMLToken(XML_RIGHT) );
+ break;
+ default:
+ break;
+ }
+ }
+ if( !aOut.isEmpty() )
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE,
+ XML_POSITION, aOut.makeStringAndClear() );
+
+ if( GraphicLocation_AREA == ePos )
+ {
+ aOut.append( GetXMLToken(XML_STRETCH) );
+ }
+ else if( GraphicLocation_NONE != ePos && GraphicLocation_TILED != ePos )
+ {
+ aOut.append( GetXMLToken(XML_BACKGROUND_NO_REPEAT) );
+ }
+ if( !aOut.isEmpty() )
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_REPEAT,
+ aOut.makeStringAndClear() );
+
+ if( pFilter )
+ {
+ OUString sFilter;
+ (*pFilter) >>= sFilter;
+ if( !sFilter.isEmpty() )
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_FILTER_NAME,
+ sFilter );
+ }
+
+ if( pTransparency )
+ {
+ sal_Int8 nTransparency = sal_Int8();
+ if( (*pTransparency) >>= nTransparency )
+ {
+ OUStringBuffer aTransOut;
+ ::sax::Converter::convertPercent(aTransOut, 100-nTransparency);
+ GetExport().AddAttribute( XML_NAMESPACE_DRAW, XML_OPACITY,
+ aTransOut.makeStringAndClear() );
+ }
+ }
+ }
+
+ {
+ SvXMLElementExport aElem(GetExport(), nPrefix, rLocalName, true, true);
+ if (xGraphic.is() && GraphicLocation_NONE != ePos)
+ {
+ // optional office:binary-data
+ GetExport().AddEmbeddedXGraphicAsBase64(xGraphic);
+ }
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/XMLBitmapLogicalSizePropertyHandler.cxx b/xmloff/source/style/XMLBitmapLogicalSizePropertyHandler.cxx
new file mode 100644
index 000000000..92d409e8a
--- /dev/null
+++ b/xmloff/source/style/XMLBitmapLogicalSizePropertyHandler.cxx
@@ -0,0 +1,53 @@
+/* -*- 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 <xmloff/xmluconv.hxx>
+#include <com/sun/star/uno/Any.hxx>
+#include <XMLBitmapLogicalSizePropertyHandler.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+
+
+XMLBitmapLogicalSizePropertyHandler::XMLBitmapLogicalSizePropertyHandler()
+{
+}
+
+XMLBitmapLogicalSizePropertyHandler::~XMLBitmapLogicalSizePropertyHandler()
+{
+}
+
+bool XMLBitmapLogicalSizePropertyHandler::importXML(
+ const OUString& rStrImpValue,
+ Any& rValue,
+ const SvXMLUnitConverter& ) const
+{
+ rValue <<= ( rStrImpValue.indexOf( '%' ) == -1 );
+ return true;
+}
+
+bool XMLBitmapLogicalSizePropertyHandler::exportXML(
+ OUString&,
+ const Any&,
+ const SvXMLUnitConverter& ) const
+{
+ return false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/XMLBitmapRepeatOffsetPropertyHandler.cxx b/xmloff/source/style/XMLBitmapRepeatOffsetPropertyHandler.cxx
new file mode 100644
index 000000000..29e743dfa
--- /dev/null
+++ b/xmloff/source/style/XMLBitmapRepeatOffsetPropertyHandler.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 <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <sax/tools/converter.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <com/sun/star/uno/Any.hxx>
+#include <XMLBitmapRepeatOffsetPropertyHandler.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+
+
+using ::xmloff::token::GetXMLToken;
+using ::xmloff::token::XML_VERTICAL;
+using ::xmloff::token::XML_HORIZONTAL;
+
+
+XMLBitmapRepeatOffsetPropertyHandler::XMLBitmapRepeatOffsetPropertyHandler( bool bX )
+: mbX( bX ),
+ msVertical( GetXMLToken(XML_VERTICAL) ),
+ msHorizontal( GetXMLToken(XML_HORIZONTAL) )
+{
+}
+
+XMLBitmapRepeatOffsetPropertyHandler::~XMLBitmapRepeatOffsetPropertyHandler()
+{
+}
+
+bool XMLBitmapRepeatOffsetPropertyHandler::importXML(
+ const OUString& rStrImpValue,
+ Any& rValue,
+ const SvXMLUnitConverter& ) const
+{
+ SvXMLTokenEnumerator aTokenEnum( rStrImpValue );
+ std::u16string_view aToken;
+ if( aTokenEnum.getNextToken( aToken ) )
+ {
+ sal_Int32 nValue;
+ if (::sax::Converter::convertPercent( nValue, aToken ))
+ {
+ if( aTokenEnum.getNextToken( aToken ) )
+ {
+ if( ( mbX && ( aToken == msHorizontal ) ) || ( !mbX && ( aToken == msVertical ) ) )
+ {
+ rValue <<= nValue;
+ return true;
+ }
+ }
+ }
+ }
+
+ return false;
+
+}
+
+bool XMLBitmapRepeatOffsetPropertyHandler::exportXML(
+ OUString& rStrExpValue,
+ const Any& rValue,
+ const SvXMLUnitConverter& ) const
+{
+ sal_Int32 nValue = 0;
+ if( rValue >>= nValue )
+ {
+ OUStringBuffer aOut;
+ ::sax::Converter::convertPercent( aOut, nValue );
+ aOut.append( ' ' );
+ aOut.append( mbX ? msHorizontal : msVertical );
+ rStrExpValue = aOut.makeStringAndClear();
+
+ return true;
+ }
+
+ return false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/XMLClipPropertyHandler.cxx b/xmloff/source/style/XMLClipPropertyHandler.cxx
new file mode 100644
index 000000000..4bfa563d2
--- /dev/null
+++ b/xmloff/source/style/XMLClipPropertyHandler.cxx
@@ -0,0 +1,141 @@
+/* -*- 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 <XMLClipPropertyHandler.hxx>
+#include <com/sun/star/uno/Any.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <sal/log.hxx>
+#include <com/sun/star/text/GraphicCrop.hpp>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmltoken.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::text;
+using namespace ::xmloff::token;
+
+
+
+
+XMLClipPropertyHandler::XMLClipPropertyHandler( bool bODF11 ) :
+ m_bODF11( bODF11 )
+{
+}
+
+XMLClipPropertyHandler::~XMLClipPropertyHandler()
+{
+ // nothing to do
+}
+
+bool XMLClipPropertyHandler::equals(
+ const Any& r1,
+ const Any& r2 ) const
+{
+ GraphicCrop aCrop1, aCrop2;
+ r1 >>= aCrop1;
+ r2 >>= aCrop2;
+
+ return aCrop1.Top == aCrop2.Top &&
+ aCrop1.Bottom == aCrop2.Bottom &&
+ aCrop1.Left == aCrop2.Left &&
+ aCrop1.Right == aCrop2.Right;
+}
+
+bool XMLClipPropertyHandler::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
+{
+ bool bRet = false;
+ sal_Int32 nLen = rStrImpValue.getLength();
+ if( nLen > 6 &&
+ rStrImpValue.startsWith( GetXMLToken(XML_RECT)) &&
+ rStrImpValue[4] == '(' &&
+ rStrImpValue[nLen-1] == ')' )
+ {
+ GraphicCrop aCrop;
+ OUString sTmp( rStrImpValue.copy( 5, nLen-6 ) );
+
+ bool bHasComma = sTmp.indexOf( ',' ) != -1;
+ SvXMLTokenEnumerator aTokenEnum( sTmp, bHasComma ? ',' : ' ' );
+
+ sal_uInt16 nPos = 0;
+ std::u16string_view aToken;
+ while( aTokenEnum.getNextToken( aToken ) )
+ {
+ sal_Int32 nVal = 0;
+ if( !IsXMLToken(aToken, XML_AUTO) &&
+ !rUnitConverter.convertMeasureToCore( nVal, aToken ) )
+ break;
+
+ // fdo#80009 such nonsense could be written via WW8 import fdo#77454
+ if (abs(nVal) > 400000)
+ {
+ SAL_INFO("xmloff.style", "ignoring excessive clip " << OUString(aToken));
+ nVal = 0;
+ }
+
+ switch( nPos )
+ {
+ case 0: aCrop.Top = nVal; break;
+ case 1: aCrop.Right = nVal; break;
+ case 2: aCrop.Bottom = nVal; break;
+ case 3: aCrop.Left = nVal; break;
+ }
+ nPos++;
+ }
+
+ bRet = (4 == nPos );
+ if( bRet )
+ rValue <<= aCrop;
+ }
+
+ return bRet;
+}
+
+bool XMLClipPropertyHandler::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
+{
+ bool bRet = false;
+ OUStringBuffer aOut(30);
+ GraphicCrop aCrop;
+
+ if( rValue >>= aCrop )
+ {
+ aOut.append( GetXMLToken(XML_RECT) );
+ aOut.append( '(' );
+ rUnitConverter.convertMeasureToXML( aOut, aCrop.Top );
+ if( !m_bODF11 )
+ aOut.append( ',' );
+ aOut.append( ' ' );
+ rUnitConverter.convertMeasureToXML( aOut, aCrop.Right );
+ if( !m_bODF11 )
+ aOut.append( ',' );
+ aOut.append( ' ' );
+ rUnitConverter.convertMeasureToXML( aOut, aCrop.Bottom );
+ if( !m_bODF11 )
+ aOut.append( ',' );
+ aOut.append( ' ' );
+ rUnitConverter.convertMeasureToXML( aOut, aCrop.Left );
+ aOut.append( ')' );
+ rStrExpValue = aOut.makeStringAndClear();
+
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/XMLConstantsPropertyHandler.cxx b/xmloff/source/style/XMLConstantsPropertyHandler.cxx
new file mode 100644
index 000000000..a5467f247
--- /dev/null
+++ b/xmloff/source/style/XMLConstantsPropertyHandler.cxx
@@ -0,0 +1,91 @@
+/* -*- 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 <xmloff/xmluconv.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <osl/diagnose.h>
+#include <com/sun/star/uno/Any.hxx>
+#include <xmloff/XMLConstantsPropertyHandler.hxx>
+
+using namespace ::com::sun::star::uno;
+
+XMLConstantsPropertyHandler::~XMLConstantsPropertyHandler()
+{
+}
+
+bool XMLConstantsPropertyHandler::importXML(
+ const OUString& rStrImpValue,
+ Any& rValue,
+ const SvXMLUnitConverter& ) const
+{
+ sal_uInt16 nEnum;
+ bool bRet = SvXMLUnitConverter::convertEnum(
+ nEnum, rStrImpValue, pMap );
+
+ if( bRet )
+ rValue <<= static_cast<sal_Int16>(nEnum);
+
+ return bRet;
+}
+
+bool XMLConstantsPropertyHandler::exportXML(
+ OUString& rStrExpValue,
+ const Any& rValue,
+ const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+
+ sal_Int32 nEnum = 0;
+
+ if( rValue.hasValue() && (rValue.getValueTypeClass() == TypeClass_ENUM))
+ {
+ nEnum = *static_cast<sal_Int32 const *>(rValue.getValue());
+ bRet = true;
+ }
+ else
+ {
+ bRet = (rValue >>= nEnum );
+ }
+
+ if( bRet )
+ {
+ if( (nEnum >= 0) && (nEnum <= 0xffff) )
+ {
+ sal_uInt16 nConst = static_cast<sal_uInt16>( nEnum );
+ OUStringBuffer aOut;
+
+ bRet = SvXMLUnitConverter::convertEnum(
+ aOut, nConst, pMap, eDefault );
+
+ rStrExpValue = aOut.makeStringAndClear();
+ }
+ else
+ {
+ OSL_FAIL("XMLConstantsPropertyHandler::exportXML() constant is out of range for implementation using sal_uInt16");
+ }
+ }
+ else
+ {
+ OSL_FAIL("XMLConstantsPropertyHandler::exportXML() could not convert any to sal_Int32");
+ }
+
+ return bRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/XMLElementPropertyContext.cxx b/xmloff/source/style/XMLElementPropertyContext.cxx
new file mode 100644
index 000000000..f065e081d
--- /dev/null
+++ b/xmloff/source/style/XMLElementPropertyContext.cxx
@@ -0,0 +1,44 @@
+/* -*- 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 <XMLElementPropertyContext.hxx>
+
+
+XMLElementPropertyContext::XMLElementPropertyContext (
+ SvXMLImport& rImport, sal_Int32 /*nElement*/,
+ const XMLPropertyState& rProp,
+ ::std::vector< XMLPropertyState > &rProps ) :
+ SvXMLImportContext( rImport ),
+ bInsert( false ),
+ rProperties( rProps ),
+ aProp( rProp )
+{
+}
+
+XMLElementPropertyContext::~XMLElementPropertyContext()
+{
+}
+
+void XMLElementPropertyContext::endFastElement(sal_Int32 )
+{
+ if( bInsert )
+ rProperties.push_back( aProp );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/XMLFillBitmapSizePropertyHandler.cxx b/xmloff/source/style/XMLFillBitmapSizePropertyHandler.cxx
new file mode 100644
index 000000000..4dded1859
--- /dev/null
+++ b/xmloff/source/style/XMLFillBitmapSizePropertyHandler.cxx
@@ -0,0 +1,88 @@
+/* -*- 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 <XMLFillBitmapSizePropertyHandler.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <com/sun/star/uno/Any.hxx>
+#include <sax/tools/converter.hxx>
+#include <xmloff/xmluconv.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+
+
+XMLFillBitmapSizePropertyHandler::XMLFillBitmapSizePropertyHandler()
+{
+}
+
+XMLFillBitmapSizePropertyHandler::~XMLFillBitmapSizePropertyHandler()
+{
+}
+
+bool XMLFillBitmapSizePropertyHandler::importXML(
+ const OUString& rStrImpValue,
+ Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter ) const
+{
+ sal_Int32 nValue;
+ bool bRet;
+
+ if( rStrImpValue.indexOf( '%' ) != -1 )
+ {
+ bRet = ::sax::Converter::convertPercent( nValue, rStrImpValue );
+ nValue *= -1;
+ }
+ else
+ {
+ bRet = rUnitConverter.convertMeasureToCore( nValue, rStrImpValue );
+ }
+
+ if( bRet )
+ rValue <<= nValue;
+
+ return bRet;
+}
+
+bool XMLFillBitmapSizePropertyHandler::exportXML(
+ OUString& rStrExpValue,
+ const Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter ) const
+{
+ sal_Int32 nValue = 0;
+ if( rValue >>= nValue )
+ {
+ OUStringBuffer aOut;
+ if( nValue < 0 )
+ {
+ ::sax::Converter::convertPercent( aOut, -nValue );
+ }
+ else
+ {
+ rUnitConverter.convertMeasureToXML( aOut, nValue );
+ }
+
+ rStrExpValue = aOut.makeStringAndClear();
+ return true;
+ }
+
+ return false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/XMLFontAutoStylePool.cxx b/xmloff/source/style/XMLFontAutoStylePool.cxx
new file mode 100644
index 000000000..543b3670f
--- /dev/null
+++ b/xmloff/source/style/XMLFontAutoStylePool.cxx
@@ -0,0 +1,680 @@
+/* -*- 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 <o3tl/sorted_vector.hxx>
+#include <tools/fontenum.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include "fonthdl.hxx"
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/XMLFontAutoStylePool.hxx>
+#include <vcl/embeddedfontshelper.hxx>
+#include <osl/file.hxx>
+#include <sal/log.hxx>
+#include <tools/diagnose_ex.h>
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/embed/ElementModes.hpp>
+#include <com/sun/star/embed/XTransactedObject.hpp>
+#include <com/sun/star/embed/XStorage.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/ucb/SimpleFileAccess.hpp>
+#include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
+#include <com/sun/star/style/XStyle.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+
+#include <XMLBase64Export.hxx>
+#include <AutoStyleEntry.hxx>
+#include <comphelper/hash.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::xmloff::token;
+
+namespace {
+
+class XMLFontAutoStylePoolEntry_Impl
+{
+ OUString sName;
+ OUString sFamilyName;
+ OUString sStyleName;
+ FontFamily nFamily;
+ FontPitch nPitch;
+ rtl_TextEncoding eEnc;
+
+public:
+
+ inline XMLFontAutoStylePoolEntry_Impl(
+ const OUString& rName,
+ const OUString& rFamilyName,
+ const OUString& rStyleName,
+ FontFamily nFamily,
+ FontPitch nPitch,
+ rtl_TextEncoding eEnc );
+
+ inline XMLFontAutoStylePoolEntry_Impl(
+ const OUString& rFamilyName,
+ const OUString& rStyleName,
+ FontFamily nFamily,
+ FontPitch nPitch,
+ rtl_TextEncoding eEnc );
+
+ const OUString& GetName() const { return sName; }
+ const OUString& GetFamilyName() const { return sFamilyName; }
+ const OUString& GetStyleName() const { return sStyleName; }
+ FontFamily GetFamily() const { return nFamily; }
+ FontPitch GetPitch() const { return nPitch; }
+ rtl_TextEncoding GetEncoding() const { return eEnc; }
+};
+
+}
+
+inline XMLFontAutoStylePoolEntry_Impl::XMLFontAutoStylePoolEntry_Impl(
+ const OUString& rName,
+ const OUString& rFamilyName,
+ const OUString& rStyleName,
+ FontFamily nFam,
+ FontPitch nP,
+ rtl_TextEncoding eE ) :
+ sName( rName ),
+ sFamilyName( rFamilyName ),
+ sStyleName( rStyleName ),
+ nFamily( nFam ),
+ nPitch( nP ),
+ eEnc( eE )
+{
+}
+
+inline XMLFontAutoStylePoolEntry_Impl::XMLFontAutoStylePoolEntry_Impl(
+ const OUString& rFamilyName,
+ const OUString& rStyleName,
+ FontFamily nFam,
+ FontPitch nP,
+ rtl_TextEncoding eE ) :
+ sFamilyName( rFamilyName ),
+ sStyleName( rStyleName ),
+ nFamily( nFam ),
+ nPitch( nP ),
+ eEnc( eE )
+{
+}
+
+namespace {
+
+struct XMLFontAutoStylePoolEntryCmp_Impl {
+ bool operator()(
+ std::unique_ptr<XMLFontAutoStylePoolEntry_Impl> const& r1,
+ std::unique_ptr<XMLFontAutoStylePoolEntry_Impl> const& r2 ) const
+ {
+ bool bEnc1(r1->GetEncoding() != RTL_TEXTENCODING_SYMBOL);
+ bool bEnc2(r2->GetEncoding() != RTL_TEXTENCODING_SYMBOL);
+ if( bEnc1 != bEnc2 )
+ return bEnc1 < bEnc2;
+ else if( r1->GetPitch() != r2->GetPitch() )
+ return r1->GetPitch() < r2->GetPitch();
+ else if( r1->GetFamily() != r2->GetFamily() )
+ return r1->GetFamily() < r2->GetFamily();
+ else
+ {
+ sal_Int32 nCmp = r1->GetFamilyName().compareTo( r2->GetFamilyName() );
+ if( 0 == nCmp )
+ return r1->GetStyleName().compareTo( r2->GetStyleName() ) < 0;
+ else
+ return nCmp < 0;
+ }
+ }
+};
+
+}
+
+class XMLFontAutoStylePool_Impl : public o3tl::sorted_vector<std::unique_ptr<XMLFontAutoStylePoolEntry_Impl>, XMLFontAutoStylePoolEntryCmp_Impl>
+{
+};
+
+XMLFontAutoStylePool::XMLFontAutoStylePool(SvXMLExport& rExp, bool bTryToEmbedFonts) :
+ rExport( rExp ),
+ m_pFontAutoStylePool( new XMLFontAutoStylePool_Impl ),
+ m_bTryToEmbedFonts( bTryToEmbedFonts ),
+ m_bEmbedUsedOnly(false),
+ m_bEmbedLatinScript(true),
+ m_bEmbedAsianScript(true),
+ m_bEmbedComplexScript(true)
+{
+}
+
+XMLFontAutoStylePool::~XMLFontAutoStylePool()
+{
+}
+
+OUString XMLFontAutoStylePool::Add(
+ const OUString& rFamilyName,
+ const OUString& rStyleName,
+ FontFamily nFamily,
+ FontPitch nPitch,
+ rtl_TextEncoding eEnc )
+{
+ OUString sPoolName;
+ XMLFontAutoStylePoolEntry_Impl aTmp( rFamilyName, rStyleName, nFamily,
+ nPitch, eEnc );
+ XMLFontAutoStylePool_Impl::const_iterator it = m_pFontAutoStylePool->find( &aTmp );
+ if( it != m_pFontAutoStylePool->end() )
+ {
+ sPoolName = (*it)->GetName();
+ }
+ else
+ {
+ OUString sName;
+ sal_Int32 nLen = rFamilyName.indexOf( ';' );
+ if( -1 == nLen )
+ {
+ sName = rFamilyName;
+ }
+ else if( nLen > 0 )
+ {
+ sName = rFamilyName.copy( 0, nLen );
+ sName = sName.trim();
+ }
+
+ if( sName.isEmpty() )
+ sName = "F";
+
+ if( m_aNames.find(sName) != m_aNames.end() )
+ {
+ sal_Int32 nCount = 1;
+ OUString sPrefix( sName );
+ sName = sPrefix + OUString::number( nCount );
+ while( m_aNames.find(sName) != m_aNames.end() )
+ {
+ sName = sPrefix + OUString::number( ++nCount );
+ }
+ }
+
+ std::unique_ptr<XMLFontAutoStylePoolEntry_Impl> pEntry(
+ new XMLFontAutoStylePoolEntry_Impl( sName, rFamilyName, rStyleName,
+ nFamily, nPitch, eEnc ));
+ m_pFontAutoStylePool->insert( std::move(pEntry) );
+ m_aNames.insert(sName);
+ }
+
+ return sPoolName;
+}
+
+OUString XMLFontAutoStylePool::Find(
+ const OUString& rFamilyName,
+ const OUString& rStyleName,
+ FontFamily nFamily,
+ FontPitch nPitch,
+ rtl_TextEncoding eEnc ) const
+{
+ OUString sName;
+ XMLFontAutoStylePoolEntry_Impl aTmp( rFamilyName, rStyleName, nFamily,
+ nPitch, eEnc );
+ XMLFontAutoStylePool_Impl::const_iterator it = m_pFontAutoStylePool->find( &aTmp );
+ if( it != m_pFontAutoStylePool->end() )
+ {
+ sName = (*it)->GetName();
+ }
+
+ return sName;
+}
+
+namespace
+{
+
+OUString lcl_checkFontFile( const OUString &fileUrl )
+{
+ osl::DirectoryItem aDirItem;
+ if( osl::DirectoryItem::get( fileUrl, aDirItem ) == osl::File::E_None )
+ {
+ osl::FileStatus aStatus( osl_FileStatus_Mask_Type );
+ if( aDirItem.getFileStatus( aStatus ) == osl::File::E_None )
+ {
+ if( !aStatus.isDirectory() )
+ return fileUrl;
+ }
+ }
+ return OUString();
+}
+
+/// Contains information about a single variant of an embedded font.
+struct EmbeddedFontInfo
+{
+ OUString aURL;
+ FontWeight eWeight = WEIGHT_NORMAL;
+ FontItalic eItalic = ITALIC_NONE;
+};
+
+/// Converts FontWeight to CSS-compatible string representation.
+OUString FontWeightToString(FontWeight eWeight)
+{
+ OUString aRet;
+
+ switch (eWeight)
+ {
+ case WEIGHT_BOLD:
+ aRet = "bold";
+ break;
+ default:
+ aRet = "normal";
+ break;
+ }
+
+ return aRet;
+}
+
+/// Converts FontItalic to CSS-compatible string representation.
+OUString FontItalicToString(FontItalic eWeight)
+{
+ OUString aRet;
+
+ switch (eWeight)
+ {
+ case ITALIC_NORMAL:
+ aRet = "italic";
+ break;
+ default:
+ aRet = "normal";
+ break;
+ }
+
+ return aRet;
+}
+
+}
+
+std::unordered_set<OUString> XMLFontAutoStylePool::getUsedFontList()
+{
+ std::unordered_set<OUString> aReturnSet;
+
+ uno::Reference<style::XStyleFamiliesSupplier> xFamiliesSupp(GetExport().GetModel(), UNO_QUERY);
+ if (!xFamiliesSupp.is())
+ return aReturnSet;
+
+ // Check styles first
+ uno::Reference<container::XNameAccess> xFamilies(xFamiliesSupp->getStyleFamilies());
+ if (xFamilies.is())
+ {
+ const uno::Sequence<OUString> aFamilyNames = xFamilies->getElementNames();
+ for (OUString const & sFamilyName : aFamilyNames)
+ {
+ uno::Reference<container::XNameAccess> xStyleContainer;
+ xFamilies->getByName(sFamilyName) >>= xStyleContainer;
+
+ if (xStyleContainer.is())
+ {
+ const uno::Sequence<OUString> aStyleNames = xStyleContainer->getElementNames();
+ for (OUString const & rName : aStyleNames)
+ {
+ uno::Reference<style::XStyle> xStyle;
+ xStyleContainer->getByName(rName) >>= xStyle;
+ if (xStyle->isInUse())
+ {
+ uno::Reference<beans::XPropertySet> xPropertySet(xStyle, UNO_QUERY);
+ if (xPropertySet.is())
+ {
+ uno::Reference<beans::XPropertySetInfo> xInfo(xPropertySet->getPropertySetInfo());
+ if (m_bEmbedLatinScript && xInfo->hasPropertyByName("CharFontName"))
+ {
+ OUString sCharFontName;
+ Any aFontAny = xPropertySet->getPropertyValue("CharFontName");
+ aFontAny >>= sCharFontName;
+ if (!sCharFontName.isEmpty())
+ aReturnSet.insert(sCharFontName);
+ }
+ if (m_bEmbedAsianScript && xInfo->hasPropertyByName("CharFontNameAsian"))
+ {
+ OUString sCharFontNameAsian;
+ Any aFontAny = xPropertySet->getPropertyValue("CharFontNameAsian");
+ aFontAny >>= sCharFontNameAsian;
+ if (!sCharFontNameAsian.isEmpty())
+ aReturnSet.insert(sCharFontNameAsian);
+ }
+ if (m_bEmbedComplexScript && xInfo->hasPropertyByName("CharFontNameComplex"))
+ {
+ OUString sCharFontNameComplex;
+ Any aFontAny = xPropertySet->getPropertyValue("CharFontNameComplex");
+ aFontAny >>= sCharFontNameComplex;
+ if (!sCharFontNameComplex.isEmpty())
+ aReturnSet.insert(sCharFontNameComplex);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // make sure auto-styles are collected
+ GetExport().collectAutoStyles();
+
+ // Check auto-styles for fonts
+ std::vector<xmloff::AutoStyleEntry> aAutoStyleEntries = GetExport().GetAutoStylePool()->GetAutoStyleEntries();
+ for (auto const & rAutoStyleEntry : aAutoStyleEntries)
+ {
+ for (auto const & rPair : rAutoStyleEntry.m_aXmlProperties)
+ {
+ if (rPair.first == "font-name" ||
+ rPair.first == "font-weight-asian" ||
+ rPair.first == "font-weight-complex")
+ {
+ if (rPair.second.has<OUString>())
+ {
+ OUString sFontName = rPair.second.get<OUString>();
+ if (!sFontName.isEmpty())
+ aReturnSet.insert(sFontName);
+ }
+ }
+ }
+ }
+
+ return aReturnSet;
+}
+
+void XMLFontAutoStylePool::exportXML()
+{
+ SvXMLElementExport aElem(GetExport(), XML_NAMESPACE_OFFICE,
+ XML_FONT_FACE_DECLS,
+ true, true);
+ Any aAny;
+ OUString sTmp;
+ XMLFontFamilyNamePropHdl aFamilyNameHdl;
+ XMLFontFamilyPropHdl aFamilyHdl;
+ XMLFontPitchPropHdl aPitchHdl;
+ XMLFontEncodingPropHdl aEncHdl;
+ const SvXMLUnitConverter& rUnitConv = GetExport().GetMM100UnitConverter();
+
+ std::map<OUString, OUString> fontFilesMap; // our url to document url
+
+ std::unordered_set<OUString> aUsedFontNames;
+ if (m_bEmbedUsedOnly)
+ aUsedFontNames = getUsedFontList();
+
+ // Sort <style:font-face> elements based on their style:name attribute.
+ std::vector<XMLFontAutoStylePoolEntry_Impl*> aFontAutoStyles;
+ for (const auto& pEntry : *m_pFontAutoStylePool)
+ {
+ aFontAutoStyles.push_back(pEntry.get());
+ }
+ std::sort(
+ aFontAutoStyles.begin(), aFontAutoStyles.end(),
+ [](const XMLFontAutoStylePoolEntry_Impl* pA, XMLFontAutoStylePoolEntry_Impl* pB) -> bool {
+ return pA->GetName() < pB->GetName();
+ });
+
+ for (const auto& pEntry : aFontAutoStyles)
+ {
+ GetExport().AddAttribute(XML_NAMESPACE_STYLE, XML_NAME, pEntry->GetName());
+
+ aAny <<= pEntry->GetFamilyName();
+ if (aFamilyNameHdl.exportXML(sTmp, aAny, rUnitConv))
+ GetExport().AddAttribute(XML_NAMESPACE_SVG,
+ XML_FONT_FAMILY, sTmp);
+
+ const OUString& rStyleName = pEntry->GetStyleName();
+ if (!rStyleName.isEmpty())
+ GetExport().AddAttribute(XML_NAMESPACE_STYLE,
+ XML_FONT_ADORNMENTS,
+ rStyleName);
+
+ aAny <<= static_cast<sal_Int16>(pEntry->GetFamily());
+ if (aFamilyHdl.exportXML(sTmp, aAny, rUnitConv))
+ {
+ GetExport().AddAttribute(XML_NAMESPACE_STYLE,
+ XML_FONT_FAMILY_GENERIC, sTmp);
+ }
+ aAny <<= static_cast<sal_Int16>(pEntry->GetPitch());
+ if (aPitchHdl.exportXML(sTmp, aAny, rUnitConv))
+ {
+ GetExport().AddAttribute(XML_NAMESPACE_STYLE,
+ XML_FONT_PITCH, sTmp);
+ }
+
+ aAny <<= static_cast<sal_Int16>(pEntry->GetEncoding());
+ if (aEncHdl.exportXML( sTmp, aAny, rUnitConv))
+ {
+ GetExport().AddAttribute(XML_NAMESPACE_STYLE,
+ XML_FONT_CHARSET, sTmp);
+ }
+
+ SvXMLElementExport aElement(GetExport(), XML_NAMESPACE_STYLE,
+ XML_FONT_FACE, true, true);
+
+ if (m_bTryToEmbedFonts)
+ {
+ const bool bExportFlat(GetExport().getExportFlags() & SvXMLExportFlags::EMBEDDED);
+ std::vector<EmbeddedFontInfo> aEmbeddedFonts;
+ static const std::vector<std::pair<FontWeight, FontItalic>> aCombinations =
+ {
+ { WEIGHT_NORMAL, ITALIC_NONE },
+ { WEIGHT_BOLD, ITALIC_NONE },
+ { WEIGHT_NORMAL, ITALIC_NORMAL },
+ { WEIGHT_BOLD, ITALIC_NORMAL },
+ };
+
+ for (auto const & aCombinationPair : aCombinations)
+ {
+ // Embed font if at least viewing is allowed (in which case the opening app must check
+ // the font license rights too and open either read-only or not use the font for editing).
+ OUString sFileUrl = EmbeddedFontsHelper::fontFileUrl(
+ pEntry->GetFamilyName(), pEntry->GetFamily(),
+ aCombinationPair.second, aCombinationPair.first, pEntry->GetPitch(),
+ EmbeddedFontsHelper::FontRights::ViewingAllowed);
+ if (sFileUrl.isEmpty())
+ continue;
+
+ // When embedded only is not set or font is used
+ if (!m_bEmbedUsedOnly ||
+ aUsedFontNames.find(pEntry->GetFamilyName()) != aUsedFontNames.end())
+ {
+ if (!fontFilesMap.count(sFileUrl))
+ {
+ const OUString docUrl = bExportFlat ?
+ lcl_checkFontFile(sFileUrl) : embedFontFile(sFileUrl, pEntry->GetFamilyName());
+ if (!docUrl.isEmpty())
+ fontFilesMap[sFileUrl] = docUrl;
+ else
+ continue; // --> failed to embed
+ }
+ EmbeddedFontInfo aEmbeddedFont;
+ aEmbeddedFont.aURL = sFileUrl;
+ aEmbeddedFont.eWeight = aCombinationPair.first;
+ aEmbeddedFont.eItalic = aCombinationPair.second;
+ aEmbeddedFonts.push_back(aEmbeddedFont);
+ }
+ }
+ if (!aEmbeddedFonts.empty())
+ {
+ SvXMLElementExport fontFaceSrc(GetExport(), XML_NAMESPACE_SVG, XML_FONT_FACE_SRC, true, true);
+ for (EmbeddedFontInfo const & rEmbeddedFont : aEmbeddedFonts)
+ {
+ if (fontFilesMap.count(rEmbeddedFont.aURL))
+ {
+ if (!bExportFlat)
+ {
+ GetExport().AddAttribute(XML_NAMESPACE_XLINK, XML_HREF,
+ fontFilesMap[rEmbeddedFont.aURL]);
+ GetExport().AddAttribute(XML_NAMESPACE_XLINK, XML_TYPE, "simple");
+ }
+
+ // Help consumers of our output by telling them which
+ // font file is which one.
+ GetExport().AddAttribute(XML_NAMESPACE_LO_EXT, XML_FONT_STYLE,
+ FontItalicToString(rEmbeddedFont.eItalic));
+ GetExport().AddAttribute(XML_NAMESPACE_LO_EXT, XML_FONT_WEIGHT,
+ FontWeightToString(rEmbeddedFont.eWeight));
+
+ SvXMLElementExport fontFaceUri(GetExport(), XML_NAMESPACE_SVG,
+ XML_FONT_FACE_URI, true, true);
+
+ if (bExportFlat)
+ {
+ const uno::Reference<ucb::XSimpleFileAccess> xFileAccess(
+ ucb::SimpleFileAccess::create(GetExport().getComponentContext()));
+ try
+ {
+ const uno::Reference<io::XInputStream> xInput(xFileAccess->openFileRead(fontFilesMap[rEmbeddedFont.aURL]));
+ XMLBase64Export aBase64Exp(GetExport());
+ aBase64Exp.exportOfficeBinaryDataElement(xInput);
+ }
+ catch (const uno::Exception &)
+ {
+ // opening the file failed, ignore
+ }
+ }
+
+ GetExport().AddAttribute(XML_NAMESPACE_SVG, XML_STRING, "truetype");
+ SvXMLElementExport fontFaceFormat(GetExport(), XML_NAMESPACE_SVG,
+ XML_FONT_FACE_FORMAT, true, true);
+ }
+ }
+ }
+ }
+ }
+}
+
+static OUString getFreeFontName(uno::Reference<embed::XStorage> const & rxStorage, OUString const & rFamilyName)
+{
+ OUString sName;
+ int nIndex = 1;
+ do
+ {
+ sName = "Font_" +
+ rFamilyName.replaceAll(" ", "_") + "_" +
+ OUString::number(nIndex) + ".ttf";
+ nIndex++;
+ } while (rxStorage->hasByName(sName));
+
+ return sName;
+}
+
+static OString convertToHashString(std::vector<unsigned char> const & rHash)
+{
+ std::stringstream aStringStream;
+ for (auto const & rByte : rHash)
+ {
+ aStringStream << std::setw(2) << std::setfill('0') << std::hex << int(rByte);
+ }
+
+ return aStringStream.str().c_str();
+}
+
+static OString getFileHash(OUString const & rFileUrl)
+{
+ OString aHash;
+ osl::File aFile(rFileUrl);
+ if (aFile.open(osl_File_OpenFlag_Read) != osl::File::E_None)
+ return aHash;
+
+ comphelper::Hash aHashEngine(comphelper::HashType::SHA512);
+ for (;;)
+ {
+ sal_Int8 aBuffer[4096];
+ sal_uInt64 nReadSize;
+ sal_Bool bEof;
+ if (aFile.isEndOfFile(&bEof) != osl::File::E_None)
+ {
+ SAL_WARN("xmloff", "Error reading font file " << rFileUrl);
+ return aHash;
+ }
+ if (bEof)
+ break;
+ if (aFile.read(aBuffer, 4096, nReadSize) != osl::File::E_None)
+ {
+ SAL_WARN("xmloff", "Error reading font file " << rFileUrl);
+ return aHash;
+ }
+ if (nReadSize == 0)
+ break;
+ aHashEngine.update(reinterpret_cast<unsigned char*>(aBuffer), nReadSize);
+ }
+ return convertToHashString(aHashEngine.finalize());
+}
+
+OUString XMLFontAutoStylePool::embedFontFile(OUString const & fileUrl, OUString const & rFamilyName)
+{
+ try
+ {
+ OString sHashString = getFileHash(fileUrl);
+ if (m_aEmbeddedFontFiles.find(sHashString) != m_aEmbeddedFontFiles.end())
+ return m_aEmbeddedFontFiles.at(sHashString);
+
+ osl::File file( fileUrl );
+ if( file.open( osl_File_OpenFlag_Read ) != osl::File::E_None )
+ return OUString();
+
+ if ( !GetExport().GetTargetStorage().is() )
+ return OUString();
+
+ uno::Reference< embed::XStorage > storage;
+ storage.set( GetExport().GetTargetStorage()->openStorageElement( "Fonts",
+ ::embed::ElementModes::WRITE ), uno::UNO_SET_THROW );
+
+ OUString name = getFreeFontName(storage, rFamilyName);
+
+ uno::Reference< io::XOutputStream > outputStream;
+ outputStream.set( storage->openStreamElement( name, ::embed::ElementModes::WRITE ), UNO_QUERY_THROW );
+ uno::Reference < beans::XPropertySet > propertySet( outputStream, uno::UNO_QUERY );
+ assert( propertySet.is());
+ propertySet->setPropertyValue( "MediaType", uno::Any( OUString( "application/x-font-ttf" ))); // TODO
+ for(;;)
+ {
+ sal_Int8 buffer[ 4096 ];
+ sal_uInt64 readSize;
+ sal_Bool eof;
+ if( file.isEndOfFile( &eof ) != osl::File::E_None )
+ {
+ SAL_WARN( "xmloff", "Error reading font file " << fileUrl );
+ outputStream->closeOutput();
+ return OUString();
+ }
+ if( eof )
+ break;
+ if( file.read( buffer, 4096, readSize ) != osl::File::E_None )
+ {
+ SAL_WARN( "xmloff", "Error reading font file " << fileUrl );
+ outputStream->closeOutput();
+ return OUString();
+ }
+ if( readSize == 0 )
+ break;
+ // coverity[overrun-buffer-arg : FALSE] - coverity has difficulty with css::uno::Sequence
+ outputStream->writeBytes(uno::Sequence<sal_Int8>(buffer, readSize));
+ }
+ outputStream->closeOutput();
+ if( storage.is() )
+ {
+ Reference< embed::XTransactedObject > transaction( storage, UNO_QUERY );
+ if( transaction.is())
+ {
+ transaction->commit();
+ OUString sInternalName = "Fonts/" + name;
+ m_aEmbeddedFontFiles.emplace(sHashString, sInternalName);
+ return sInternalName;
+ }
+ }
+ } catch( const Exception& )
+ {
+ TOOLS_WARN_EXCEPTION( "xmloff", "Exception when embedding a font file" );
+ }
+ return OUString();
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/XMLFontStylesContext.cxx b/xmloff/source/style/XMLFontStylesContext.cxx
new file mode 100644
index 000000000..56d87c02c
--- /dev/null
+++ b/xmloff/source/style/XMLFontStylesContext.cxx
@@ -0,0 +1,352 @@
+/* -*- 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 <xmloff/XMLFontStylesContext.hxx>
+#include "XMLFontStylesContext_impl.hxx"
+
+#include <com/sun/star/awt/FontFamily.hpp>
+#include <com/sun/star/awt/FontPitch.hpp>
+#include <com/sun/star/embed/ElementModes.hpp>
+#include <com/sun/star/embed/XStorage.hpp>
+
+#include <comphelper/seqstream.hxx>
+
+#include <sal/log.hxx>
+
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include "fonthdl.hxx"
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/maptype.hxx>
+#include <xmloff/XMLBase64ImportContext.hxx>
+
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::xml::sax;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::awt;
+using namespace ::xmloff::token;
+
+
+#define XML_STYLE_FAMILY_FONT XmlStyleFamily::PAGE_MASTER
+
+XMLFontStyleContextFontFace::XMLFontStyleContextFontFace( SvXMLImport& rImport,
+ XMLFontStylesContext& rStyles ) :
+ SvXMLStyleContext( rImport, XML_STYLE_FAMILY_FONT ),
+ xStyles( &rStyles )
+{
+ aFamilyName <<= OUString();
+ aStyleName <<= OUString();
+ aFamily <<= sal_Int16(awt::FontFamily::DONTKNOW);
+ aPitch <<= sal_Int16(awt::FontPitch::DONTKNOW);
+ aEnc <<= static_cast<sal_Int16>(rStyles.GetDfltCharset());
+}
+
+void XMLFontStyleContextFontFace::SetAttribute( sal_Int32 nElement,
+ const OUString& rValue )
+{
+ SvXMLUnitConverter& rUnitConv = GetImport().GetMM100UnitConverter();
+ Any aAny;
+
+ switch(nElement)
+ {
+ case XML_ELEMENT(SVG, XML_FONT_FAMILY):
+ case XML_ELEMENT(SVG_COMPAT, XML_FONT_FAMILY):
+ if( GetStyles()->GetFamilyNameHdl().importXML( rValue, aAny,
+ rUnitConv ) )
+ aFamilyName = aAny;
+ break;
+ case XML_ELEMENT(STYLE, XML_FONT_ADORNMENTS):
+ aStyleName <<= rValue;
+ break;
+ case XML_ELEMENT(STYLE, XML_FONT_FAMILY_GENERIC):
+ if( GetStyles()->GetFamilyHdl().importXML( rValue, aAny,
+ rUnitConv ) )
+ aFamily = aAny;
+ break;
+ case XML_ELEMENT(STYLE, XML_FONT_PITCH):
+ if( GetStyles()->GetPitchHdl().importXML( rValue, aAny,
+ rUnitConv ) )
+ aPitch = aAny;
+ break;
+ case XML_ELEMENT(STYLE, XML_FONT_CHARSET):
+ if( GetStyles()->GetEncodingHdl().importXML( rValue, aAny,
+ rUnitConv ) )
+ aEnc = aAny;
+ break;
+ default:
+ SvXMLStyleContext::SetAttribute( nElement, rValue );
+ break;
+ }
+}
+
+XMLFontStyleContextFontFace::~XMLFontStyleContextFontFace()
+{
+}
+
+void XMLFontStyleContextFontFace::FillProperties(
+ ::std::vector< XMLPropertyState > &rProps,
+ sal_Int32 nFamilyNameIdx,
+ sal_Int32 nStyleNameIdx,
+ sal_Int32 nFamilyIdx,
+ sal_Int32 nPitchIdx,
+ sal_Int32 nCharsetIdx ) const
+{
+ if( nFamilyNameIdx != -1 )
+ {
+ XMLPropertyState aPropState( nFamilyNameIdx, aFamilyName );
+ rProps.push_back( aPropState );
+ }
+ if( nStyleNameIdx != -1 )
+ {
+ XMLPropertyState aPropState( nStyleNameIdx, aStyleName );
+ rProps.push_back( aPropState );
+ }
+ if( nFamilyIdx != -1 )
+ {
+ XMLPropertyState aPropState( nFamilyIdx, aFamily );
+ rProps.push_back( aPropState );
+ }
+ if( nPitchIdx != -1 )
+ {
+ XMLPropertyState aPropState( nPitchIdx, aPitch );
+ rProps.push_back( aPropState );
+ }
+ if( nCharsetIdx != -1 )
+ {
+ XMLPropertyState aPropState( nCharsetIdx, aEnc );
+ rProps.push_back( aPropState );
+ }
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > XMLFontStyleContextFontFace::createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList > & )
+{
+ if( nElement == XML_ELEMENT(SVG, XML_FONT_FACE_SRC) ||
+ nElement == XML_ELEMENT(SVG_COMPAT, XML_FONT_FACE_SRC) )
+ return new XMLFontStyleContextFontFaceSrc( GetImport(), *this );
+ else
+ XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+ return nullptr;
+}
+
+OUString XMLFontStyleContextFontFace::familyName() const
+{
+ OUString ret;
+ aFamilyName >>= ret;
+ return ret;
+}
+
+
+XMLFontStyleContextFontFaceFormat::XMLFontStyleContextFontFaceFormat( SvXMLImport& rImport,
+ XMLFontStyleContextFontFaceUri& _uri )
+ : SvXMLStyleContext( rImport )
+ , uri(_uri)
+{
+}
+
+void XMLFontStyleContextFontFaceFormat::SetAttribute( sal_Int32 nElement,
+ const OUString& rValue )
+{
+ if( nElement == XML_ELEMENT(SVG, XML_STRING) || nElement == XML_ELEMENT(SVG_COMPAT, XML_STRING))
+ uri.SetFormat(rValue);
+ else
+ SvXMLStyleContext::SetAttribute( nElement, rValue );
+}
+
+
+XMLFontStyleContextFontFaceSrc::XMLFontStyleContextFontFaceSrc( SvXMLImport& rImport,
+ const XMLFontStyleContextFontFace& _font )
+ : SvXMLImportContext( rImport )
+ , font( _font )
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > XMLFontStyleContextFontFaceSrc::createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList > & /*xAttrList*/ )
+{
+ if( nElement == XML_ELEMENT(SVG, XML_FONT_FACE_URI) ||
+ nElement == XML_ELEMENT(SVG_COMPAT, XML_FONT_FACE_URI) )
+ return new XMLFontStyleContextFontFaceUri( GetImport(), font );
+ XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+ return nullptr;
+}
+
+
+XMLFontStyleContextFontFaceUri::XMLFontStyleContextFontFaceUri( SvXMLImport& rImport,
+ const XMLFontStyleContextFontFace& _font )
+ : SvXMLStyleContext( rImport )
+ , font( _font )
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > XMLFontStyleContextFontFaceUri::createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList > & /*xAttrList*/ )
+{
+ if( nElement == XML_ELEMENT(SVG, XML_FONT_FACE_FORMAT) )
+ return new XMLFontStyleContextFontFaceFormat( GetImport(), *this );
+ else if( nElement == XML_ELEMENT(OFFICE, XML_BINARY_DATA) )
+ {
+ assert(linkPath.isEmpty());
+ if( linkPath.isEmpty() )
+ {
+ mxBase64Stream.set( new comphelper::OSequenceOutputStream( maFontData ) );
+ if( mxBase64Stream.is() )
+ return new XMLBase64ImportContext( GetImport(), mxBase64Stream );
+ }
+ }
+ else
+ XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+ return nullptr;
+}
+
+void XMLFontStyleContextFontFaceUri::SetAttribute( sal_Int32 nElement,
+ const OUString& rValue )
+{
+ if( nElement == XML_ELEMENT(XLINK, XML_HREF) )
+ linkPath = rValue;
+ else
+ SvXMLStyleContext::SetAttribute( nElement, rValue );
+}
+
+void XMLFontStyleContextFontFaceUri::SetFormat( const OUString& rFormat )
+{
+ format = rFormat;
+}
+
+// the CSS2 standard ( http://www.w3.org/TR/2008/REC-CSS2-20080411/fonts.html#referencing )
+// defines these format strings.
+const char OPENTYPE_FORMAT[] = "opentype";
+const char TRUETYPE_FORMAT[] = "truetype";
+const char EOT_FORMAT[] = "embedded-opentype";
+
+void XMLFontStyleContextFontFaceUri::endFastElement(sal_Int32 )
+{
+ if( ( linkPath.getLength() == 0 ) && ( !maFontData.hasElements() ) )
+ {
+ SAL_WARN( "xmloff", "svg:font-face-uri tag with no link or base64 data; ignoring." );
+ return;
+ }
+ bool eot;
+ // Assume by default that the font is not compressed.
+ if( format.getLength() == 0
+ || format == OPENTYPE_FORMAT
+ || format == TRUETYPE_FORMAT )
+ {
+ eot = false;
+ }
+ else if( format == EOT_FORMAT )
+ {
+ eot = true;
+ }
+ else
+ {
+ SAL_WARN( "xmloff", "Unknown format of embedded font; assuming TTF." );
+ eot = false;
+ }
+ if ( !maFontData.hasElements() )
+ handleEmbeddedFont( linkPath, eot );
+ else
+ handleEmbeddedFont( maFontData, eot );
+}
+
+void XMLFontStyleContextFontFaceUri::handleEmbeddedFont( const OUString& url, bool eot )
+{
+ if( GetImport().embeddedFontAlreadyProcessed( url ))
+ {
+ GetImport().NotifyContainsEmbeddedFont();
+ return;
+ }
+ OUString fontName = font.familyName();
+ // If there's any giveMeStreamForThisURL(), then it's well-hidden for me to find it.
+ if( GetImport().IsPackageURL( url ))
+ {
+ uno::Reference< embed::XStorage > storage;
+ storage.set( GetImport().GetSourceStorage(), UNO_SET_THROW );
+ if( url.indexOf( '/' ) > -1 ) // TODO what if more levels?
+ storage.set( storage->openStorageElement( url.copy( 0, url.indexOf( '/' )),
+ ::embed::ElementModes::READ ), uno::UNO_SET_THROW );
+ uno::Reference< io::XInputStream > inputStream;
+ inputStream.set( storage->openStreamElement( url.copy( url.indexOf( '/' ) + 1 ), ::embed::ElementModes::READ ),
+ UNO_QUERY_THROW );
+ if (GetImport().addEmbeddedFont(inputStream, fontName, "?", std::vector< unsigned char >(), eot))
+ GetImport().NotifyContainsEmbeddedFont();
+ inputStream->closeInput();
+ }
+ else
+ SAL_WARN( "xmloff", "External URL for font file not handled." );
+}
+
+void XMLFontStyleContextFontFaceUri::handleEmbeddedFont( const ::css::uno::Sequence< sal_Int8 >& rData, const bool eot )
+{
+ const uno::Reference< io::XInputStream > xInput( new comphelper::SequenceInputStream( rData ) );
+ const OUString fontName = font.familyName();
+ if (GetImport().addEmbeddedFont(xInput, fontName, "?", std::vector< unsigned char >(), eot))
+ GetImport().NotifyContainsEmbeddedFont();
+ xInput->closeInput();
+}
+
+SvXMLStyleContext *XMLFontStylesContext::CreateStyleChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList > & xAttrList )
+{
+ if( nElement == XML_ELEMENT(STYLE, XML_FONT_FACE) )
+ {
+ return new XMLFontStyleContextFontFace( GetImport(), *this );
+ }
+ return SvXMLStylesContext::CreateStyleChildContext( nElement, xAttrList );
+}
+
+
+XMLFontStylesContext::XMLFontStylesContext( SvXMLImport& rImport,
+ rtl_TextEncoding eDfltEnc ) :
+ SvXMLStylesContext( rImport ),
+ pFamilyNameHdl( new XMLFontFamilyNamePropHdl ),
+ pFamilyHdl( new XMLFontFamilyPropHdl ),
+ pPitchHdl( new XMLFontPitchPropHdl ),
+ pEncHdl( new XMLFontEncodingPropHdl ),
+ eDfltEncoding( eDfltEnc )
+{
+}
+
+XMLFontStylesContext::~XMLFontStylesContext() {}
+
+bool XMLFontStylesContext::FillProperties( const OUString& rName,
+ ::std::vector< XMLPropertyState > &rProps,
+ sal_Int32 nFamilyNameIdx,
+ sal_Int32 nStyleNameIdx,
+ sal_Int32 nFamilyIdx,
+ sal_Int32 nPitchIdx,
+ sal_Int32 nCharsetIdx ) const
+{
+ const SvXMLStyleContext* pStyle = FindStyleChildContext( XML_STYLE_FAMILY_FONT, rName, true );
+ const XMLFontStyleContextFontFace *pFontStyle = dynamic_cast<const XMLFontStyleContextFontFace*>(pStyle);// use temp var, PTR_CAST is a bad macro, FindStyleChildContext will be called twice
+ if( pFontStyle )
+ pFontStyle->FillProperties( rProps, nFamilyNameIdx, nStyleNameIdx,
+ nFamilyIdx, nPitchIdx, nCharsetIdx );
+ return nullptr != pFontStyle;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/XMLFontStylesContext_impl.hxx b/xmloff/source/style/XMLFontStylesContext_impl.hxx
new file mode 100644
index 000000000..b86bedbd1
--- /dev/null
+++ b/xmloff/source/style/XMLFontStylesContext_impl.hxx
@@ -0,0 +1,122 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlstyle.hxx>
+
+namespace com::sun::star::io {
+ class XOutputStream;
+}
+
+/// Handles <style:font-face>
+class XMLFontStyleContextFontFace : public SvXMLStyleContext
+{
+ css::uno::Any aFamilyName;
+ css::uno::Any aStyleName;
+ css::uno::Any aFamily;
+ css::uno::Any aPitch;
+ css::uno::Any aEnc;
+
+ rtl::Reference<XMLFontStylesContext> xStyles;
+
+ XMLFontStylesContext *GetStyles()
+ {
+ return xStyles.get();
+ }
+
+public:
+
+
+ XMLFontStyleContextFontFace( SvXMLImport& rImport,
+ XMLFontStylesContext& rStyles );
+ virtual ~XMLFontStyleContextFontFace() override;
+
+ void SetAttribute( sal_Int32 nElement,
+ const OUString& rValue ) override;
+
+ void FillProperties( ::std::vector< XMLPropertyState > &rProps,
+ sal_Int32 nFamilyNameIdx,
+ sal_Int32 nStyleNameIdx,
+ sal_Int32 nFamilyIdx,
+ sal_Int32 nPitchIdx,
+ sal_Int32 nCharsetIdx ) const;
+
+ OUString familyName() const;
+
+ virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList > & xAttrList ) override;
+};
+
+/// Handles <style:font-face-src>
+class XMLFontStyleContextFontFaceSrc : public SvXMLImportContext
+{
+ const XMLFontStyleContextFontFace& font;
+public:
+
+
+ XMLFontStyleContextFontFaceSrc( SvXMLImport& rImport,
+ const XMLFontStyleContextFontFace& font );
+
+ virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList > & xAttrList ) override;
+};
+
+/// Handles <style:font-face-uri>
+class XMLFontStyleContextFontFaceUri : public SvXMLStyleContext
+{
+ const XMLFontStyleContextFontFace& font;
+ OUString format;
+ OUString linkPath;
+ ::css::uno::Sequence< sal_Int8 > maFontData;
+ ::css::uno::Reference< ::css::io::XOutputStream > mxBase64Stream;
+
+ void handleEmbeddedFont( const OUString& url, bool eot );
+ void handleEmbeddedFont( const ::css::uno::Sequence< sal_Int8 >& rData, bool eot );
+public:
+
+
+ XMLFontStyleContextFontFaceUri( SvXMLImport& rImport,
+ const XMLFontStyleContextFontFace& font );
+
+ virtual void SetAttribute( sal_Int32 nElement,
+ const OUString& rValue ) override;
+ void SetFormat( const OUString& rFormat );
+ void SAL_CALL endFastElement(sal_Int32 nElement) override;
+ virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList > & xAttrList ) override;
+};
+
+/// Handles <svg:font-face-format>
+class XMLFontStyleContextFontFaceFormat : public SvXMLStyleContext
+{
+ XMLFontStyleContextFontFaceUri& uri;
+public:
+
+ XMLFontStyleContextFontFaceFormat( SvXMLImport& rImport,
+ XMLFontStyleContextFontFaceUri& uri );
+
+ void SetAttribute( sal_Int32 nElement,
+ const OUString& rValue ) override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/XMLFootnoteSeparatorExport.cxx b/xmloff/source/style/XMLFootnoteSeparatorExport.cxx
new file mode 100644
index 000000000..c5e160dff
--- /dev/null
+++ b/xmloff/source/style/XMLFootnoteSeparatorExport.cxx
@@ -0,0 +1,179 @@
+/* -*- 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 "XMLFootnoteSeparatorExport.hxx"
+
+#include <sax/tools/converter.hxx>
+
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlprmap.hxx>
+#include <xmloff/xmlement.hxx>
+
+#include <PageMasterStyleMap.hxx>
+#include <com/sun/star/text/HorizontalAdjust.hpp>
+#include <rtl/ustrbuf.hxx>
+
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+using ::std::vector;
+
+XMLFootnoteSeparatorExport::XMLFootnoteSeparatorExport(SvXMLExport& rExp) :
+ rExport(rExp)
+{
+}
+
+void XMLFootnoteSeparatorExport::exportXML(
+ const vector<XMLPropertyState> * pProperties,
+ sal_uInt32 const nIdx,
+ const rtl::Reference<XMLPropertySetMapper> & rMapper)
+{
+ assert(pProperties);
+
+ // initialize values
+ text::HorizontalAdjust eLineAdjust = text::HorizontalAdjust_LEFT;
+ sal_Int32 nLineColor = 0;
+ sal_Int32 nLineDistance = 0;
+ sal_Int8 nLineRelWidth = 0;
+ sal_Int32 nLineTextDistance = 0;
+ sal_Int16 nLineWeight = 0;
+ sal_Int8 nLineStyle = 0;
+
+ // find indices into property map and get values
+ sal_uInt32 nCount = pProperties->size();
+ for(sal_uInt32 i = 0; i < nCount; i++)
+ {
+ const XMLPropertyState& rState = (*pProperties)[i];
+
+ if( rState.mnIndex == -1 )
+ continue;
+
+ switch (rMapper->GetEntryContextId(rState.mnIndex))
+ {
+ case CTF_PM_FTN_LINE_ADJUST:
+ {
+ sal_Int16 nTmp;
+ if (rState.maValue >>= nTmp)
+ eLineAdjust = static_cast<text::HorizontalAdjust>(nTmp);
+ break;
+ }
+ case CTF_PM_FTN_LINE_COLOR:
+ rState.maValue >>= nLineColor;
+ break;
+ case CTF_PM_FTN_DISTANCE:
+ rState.maValue >>= nLineDistance;
+ break;
+ case CTF_PM_FTN_LINE_WIDTH:
+ rState.maValue >>= nLineRelWidth;
+ break;
+ case CTF_PM_FTN_LINE_DISTANCE:
+ rState.maValue >>= nLineTextDistance;
+ break;
+ case CTF_PM_FTN_LINE_WEIGHT:
+ (void) nIdx;
+ assert(i == nIdx && "received wrong property state index");
+ rState.maValue >>= nLineWeight;
+ break;
+ case CTF_PM_FTN_LINE_STYLE:
+ rState.maValue >>= nLineStyle;
+ break;
+ }
+ }
+
+ OUStringBuffer sBuf;
+
+ // weight/width
+ if (nLineWeight > 0)
+ {
+ rExport.GetMM100UnitConverter().convertMeasureToXML(sBuf, nLineWeight);
+ rExport.AddAttribute(XML_NAMESPACE_STYLE, XML_WIDTH,
+ sBuf.makeStringAndClear());
+ }
+
+ // line text distance
+ if (nLineTextDistance > 0)
+ {
+ rExport.GetMM100UnitConverter().convertMeasureToXML(sBuf,
+ nLineTextDistance);
+ rExport.AddAttribute(XML_NAMESPACE_STYLE, XML_DISTANCE_BEFORE_SEP,
+ sBuf.makeStringAndClear());
+ }
+
+ // line distance
+ if (nLineDistance > 0)
+ {
+ rExport.GetMM100UnitConverter().convertMeasureToXML(sBuf,
+ nLineDistance);
+ rExport.AddAttribute(XML_NAMESPACE_STYLE, XML_DISTANCE_AFTER_SEP,
+ sBuf.makeStringAndClear());
+ }
+
+ // line style
+ static const SvXMLEnumMapEntry<sal_Int8> aXML_LineStyle_Enum[] =
+ {
+ { XML_NONE, 0 },
+ { XML_SOLID, 1 },
+ { XML_DOTTED, 2 },
+ { XML_DASH, 3 },
+ { XML_TOKEN_INVALID, 0 }
+ };
+ if (SvXMLUnitConverter::convertEnum(
+ sBuf, nLineStyle, aXML_LineStyle_Enum ) )
+ {
+ rExport.AddAttribute(XML_NAMESPACE_STYLE, XML_LINE_STYLE,
+ sBuf.makeStringAndClear());
+ }
+
+ // adjustment
+ static const SvXMLEnumMapEntry<text::HorizontalAdjust> aXML_HorizontalAdjust_Enum[] =
+ {
+ { XML_LEFT, text::HorizontalAdjust_LEFT },
+ { XML_CENTER, text::HorizontalAdjust_CENTER },
+ { XML_RIGHT, text::HorizontalAdjust_RIGHT },
+ { XML_TOKEN_INVALID, text::HorizontalAdjust(0) }
+ };
+
+ if (SvXMLUnitConverter::convertEnum(
+ sBuf, eLineAdjust, aXML_HorizontalAdjust_Enum))
+ {
+ rExport.AddAttribute(XML_NAMESPACE_STYLE, XML_ADJUSTMENT,
+ sBuf.makeStringAndClear());
+ }
+
+ // relative line width
+ ::sax::Converter::convertPercent(sBuf, nLineRelWidth);
+ rExport.AddAttribute(XML_NAMESPACE_STYLE, XML_REL_WIDTH,
+ sBuf.makeStringAndClear());
+
+ // color
+ ::sax::Converter::convertColor(sBuf, nLineColor);
+ rExport.AddAttribute(XML_NAMESPACE_STYLE, XML_COLOR,
+ sBuf.makeStringAndClear());
+
+ // line-style
+
+ SvXMLElementExport aElem(rExport, XML_NAMESPACE_STYLE,
+ XML_FOOTNOTE_SEP, true, true);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/XMLFootnoteSeparatorExport.hxx b/xmloff/source/style/XMLFootnoteSeparatorExport.hxx
new file mode 100644
index 000000000..2784e291b
--- /dev/null
+++ b/xmloff/source/style/XMLFootnoteSeparatorExport.hxx
@@ -0,0 +1,50 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <sal/types.h>
+#include <vector>
+
+class SvXMLExport;
+class XMLPropertySetMapper;
+struct XMLPropertyState;
+namespace rtl {
+ template<class X> class Reference;
+}
+
+/**
+ * export footnote separator element in page styles
+ */
+class XMLFootnoteSeparatorExport
+{
+ SvXMLExport& rExport;
+
+public:
+
+ explicit XMLFootnoteSeparatorExport(SvXMLExport& rExp);
+
+ void exportXML(
+ const ::std::vector<XMLPropertyState> * pProperties,
+ sal_uInt32 nIdx,
+ /// used only for debugging
+ const rtl::Reference<XMLPropertySetMapper> & rMapper);
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/XMLFootnoteSeparatorImport.cxx b/xmloff/source/style/XMLFootnoteSeparatorImport.cxx
new file mode 100644
index 000000000..399741023
--- /dev/null
+++ b/xmloff/source/style/XMLFootnoteSeparatorImport.cxx
@@ -0,0 +1,198 @@
+/* -*- 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 "XMLFootnoteSeparatorImport.hxx"
+
+#include <rtl/ustring.hxx>
+#include <sal/log.hxx>
+
+#include <com/sun/star/uno/Reference.h>
+#include <com/sun/star/xml/sax/XAttributeList.hpp>
+#include <com/sun/star/text/HorizontalAdjust.hpp>
+
+
+#include <sax/tools/converter.hxx>
+
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlprmap.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/maptype.hxx>
+#include <xmloff/xmlement.hxx>
+
+#include <PageMasterStyleMap.hxx>
+
+#include <vector>
+
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+using ::std::vector;
+using ::com::sun::star::uno::Any;
+using ::com::sun::star::uno::Reference;
+using ::com::sun::star::xml::sax::XAttributeList;
+
+
+XMLFootnoteSeparatorImport::XMLFootnoteSeparatorImport(
+ SvXMLImport& rImport,
+ sal_Int32 /*nElement*/,
+ vector<XMLPropertyState> & rProps,
+ const rtl::Reference<XMLPropertySetMapper> & rMapperRef,
+ sal_Int32 nIndex) :
+ SvXMLImportContext(rImport),
+ rProperties(rProps),
+ rMapper(rMapperRef),
+ nPropIndex(nIndex)
+{
+}
+
+XMLFootnoteSeparatorImport::~XMLFootnoteSeparatorImport()
+{
+}
+
+void XMLFootnoteSeparatorImport::startFastElement(
+ sal_Int32 /*nElement*/,
+ const Reference<css::xml::sax::XFastAttributeList> & xAttrList)
+{
+ // get the values from the properties
+ sal_Int16 nLineWeight = 0;
+ sal_Int32 nLineColor = 0;
+ sal_Int8 nLineRelWidth = 0;
+ text::HorizontalAdjust eLineAdjust = text::HorizontalAdjust_LEFT;
+ sal_Int32 nLineTextDistance = 0;
+ sal_Int32 nLineDistance = 0;
+
+ // Default separator line style should be SOLID (used to be default before
+ // the choice selector was available)
+ sal_Int8 nLineStyle = 1;
+
+ // iterate over xattribute list and fill values
+ for (auto &aIter : sax_fastparser::castToFastAttributeList(xAttrList))
+ {
+ sal_Int32 nTmp;
+ switch (aIter.getToken())
+ {
+ case XML_ELEMENT(STYLE, XML_WIDTH):
+ {
+ if (GetImport().GetMM100UnitConverter().convertMeasureToCore(
+ nTmp, aIter.toView()))
+ {
+ nLineWeight = static_cast<sal_Int16>(nTmp);
+ }
+ break;
+ }
+ case XML_ELEMENT(STYLE, XML_DISTANCE_BEFORE_SEP):
+ {
+ if (GetImport().GetMM100UnitConverter().convertMeasureToCore(
+ nTmp, aIter.toView()))
+ nLineTextDistance = nTmp;
+ break;
+ }
+ case XML_ELEMENT(STYLE, XML_DISTANCE_AFTER_SEP):
+ {
+ if (GetImport().GetMM100UnitConverter().convertMeasureToCore(
+ nTmp, aIter.toView()))
+ nLineDistance = nTmp;
+ break;
+ }
+ case XML_ELEMENT(STYLE, XML_ADJUSTMENT ):
+ {
+ static const SvXMLEnumMapEntry<text::HorizontalAdjust> aXML_HorizontalAdjust_Enum[] =
+ {
+ { XML_LEFT, text::HorizontalAdjust_LEFT },
+ { XML_CENTER, text::HorizontalAdjust_CENTER },
+ { XML_RIGHT, text::HorizontalAdjust_RIGHT },
+ { XML_TOKEN_INVALID, text::HorizontalAdjust(0) }
+ };
+
+ SvXMLUnitConverter::convertEnum(
+ eLineAdjust, aIter.toView(), aXML_HorizontalAdjust_Enum);
+ break;
+ }
+ case XML_ELEMENT(STYLE, XML_REL_WIDTH ):
+ {
+ if (::sax::Converter::convertPercent(nTmp, aIter.toView()))
+ nLineRelWidth = static_cast<sal_uInt8>(nTmp);
+ break;
+ }
+ case XML_ELEMENT(STYLE, XML_COLOR):
+ {
+ if (::sax::Converter::convertColor(nTmp, aIter.toView()))
+ {
+ nLineColor = nTmp;
+ }
+ break;
+ }
+ case XML_ELEMENT(STYLE, XML_LINE_STYLE ):
+ {
+ static const SvXMLEnumMapEntry<sal_Int8> aXML_LineStyle_Enum[] =
+ {
+ { XML_NONE, 0 },
+ { XML_SOLID, 1 },
+ { XML_DOTTED, 2 },
+ { XML_DASH, 3 },
+ { XML_TOKEN_INVALID, 0 }
+ };
+
+ SvXMLUnitConverter::convertEnum(nLineStyle, aIter.toView(), aXML_LineStyle_Enum);
+ break;
+ }
+ default:
+ XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+ }
+ }
+
+ // OK, now we have all values and can fill the XMLPropertyState vector
+ sal_Int32 nIndex;
+
+ nIndex = rMapper->FindEntryIndex(CTF_PM_FTN_LINE_ADJUST);
+ XMLPropertyState aLineAdjust( nIndex, uno::Any(sal_Int16(eLineAdjust)) );
+ rProperties.push_back(aLineAdjust);
+
+ nIndex = rMapper->FindEntryIndex(CTF_PM_FTN_LINE_COLOR);
+ XMLPropertyState aLineColor( nIndex, uno::Any(nLineColor) );
+ rProperties.push_back(aLineColor);
+
+ nIndex = rMapper->FindEntryIndex(CTF_PM_FTN_LINE_STYLE);
+ XMLPropertyState aLineStyle( nIndex, uno::Any(nLineStyle) );
+ rProperties.push_back(aLineStyle);
+
+ nIndex = rMapper->FindEntryIndex(CTF_PM_FTN_DISTANCE);
+ XMLPropertyState aLineDistance( nIndex, uno::Any(nLineDistance) );
+ rProperties.push_back(aLineDistance);
+
+ nIndex = rMapper->FindEntryIndex(CTF_PM_FTN_LINE_WIDTH);
+ XMLPropertyState aLineRelWidth( nIndex, uno::Any(nLineRelWidth));
+ rProperties.push_back(aLineRelWidth);
+
+ nIndex = rMapper->FindEntryIndex(CTF_PM_FTN_LINE_DISTANCE);
+ XMLPropertyState aLineTextDistance( nIndex, uno::Any(nLineTextDistance));
+ rProperties.push_back(aLineTextDistance);
+
+ SAL_WARN_IF( rMapper->FindEntryIndex(CTF_PM_FTN_LINE_WEIGHT) != nPropIndex, "xmloff",
+ "Received wrong property map index!" );
+ XMLPropertyState aLineWeight( nPropIndex, uno::Any(nLineWeight) );
+ rProperties.push_back(aLineWeight);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/XMLFootnoteSeparatorImport.hxx b/xmloff/source/style/XMLFootnoteSeparatorImport.hxx
new file mode 100644
index 000000000..be0289f80
--- /dev/null
+++ b/xmloff/source/style/XMLFootnoteSeparatorImport.hxx
@@ -0,0 +1,61 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlictxt.hxx>
+#include <rtl/ref.hxx>
+#include <vector>
+
+
+class SvXMLImport;
+struct XMLPropertyState;
+class XMLPropertySetMapper;
+namespace com::sun::star {
+ namespace uno { template<class X> class Reference; }
+ namespace xml::sax { class XAttributeList; }
+}
+
+
+/**
+ * Import the footnote-separator element in page styles.
+ */
+class XMLFootnoteSeparatorImport : public SvXMLImportContext
+{
+ ::std::vector<XMLPropertyState> & rProperties;
+ rtl::Reference<XMLPropertySetMapper> rMapper;
+ sal_Int32 nPropIndex;
+
+public:
+
+
+ XMLFootnoteSeparatorImport(
+ SvXMLImport& rImport,
+ sal_Int32 nElement,
+ ::std::vector<XMLPropertyState> & rProperties,
+ const rtl::Reference<XMLPropertySetMapper> & rMapperRef,
+ sal_Int32 nIndex);
+
+ virtual ~XMLFootnoteSeparatorImport() override;
+
+ virtual void SAL_CALL startFastElement( sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& ) override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/XMLIsPercentagePropertyHandler.cxx b/xmloff/source/style/XMLIsPercentagePropertyHandler.cxx
new file mode 100644
index 000000000..3d32e8479
--- /dev/null
+++ b/xmloff/source/style/XMLIsPercentagePropertyHandler.cxx
@@ -0,0 +1,50 @@
+/* -*- 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/uno/Any.hxx>
+#include <osl/diagnose.h>
+#include <XMLIsPercentagePropertyHandler.hxx>
+
+using namespace ::com::sun::star;
+using namespace css::uno;
+
+
+XMLIsPercentagePropertyHandler::~XMLIsPercentagePropertyHandler()
+{
+}
+
+bool XMLIsPercentagePropertyHandler::importXML(
+ const OUString& rStrImpValue,
+ Any& rValue,
+ const SvXMLUnitConverter& ) const
+{
+ rValue <<= rStrImpValue.indexOf( '%' ) != -1;
+ return true;
+}
+
+bool XMLIsPercentagePropertyHandler::exportXML(
+ OUString&,
+ const Any&,
+ const SvXMLUnitConverter& ) const
+{
+ OSL_FAIL( "XMLIsPercentagePropertyHandler is not for export!" );
+ return false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/XMLPageExport.cxx b/xmloff/source/style/XMLPageExport.cxx
new file mode 100644
index 000000000..042a70398
--- /dev/null
+++ b/xmloff/source/style/XMLPageExport.cxx
@@ -0,0 +1,319 @@
+/* -*- 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 <xmloff/XMLPageExport.hxx>
+#include <o3tl/any.hxx>
+#include <sal/log.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
+#include <com/sun/star/style/XStyle.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <xmloff/families.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <PageMasterPropHdlFactory.hxx>
+#include <PageMasterStyleMap.hxx>
+#include <PageMasterPropMapper.hxx>
+#include "PageMasterExportPropMapper.hxx"
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::style;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::beans;
+using namespace ::xmloff::token;
+
+constexpr OUStringLiteral gsIsPhysical( u"IsPhysical" );
+constexpr OUStringLiteral gsFollowStyle( u"FollowStyle" );
+
+namespace {
+
+bool findPageMasterNameEntry(
+ ::std::vector<XMLPageExportNameEntry> const& aNameVector,
+ const OUString& rStyleName, XMLPageExportNameEntry & o_rEntry)
+{
+ auto pEntry = std::find_if(aNameVector.cbegin(), aNameVector.cend(),
+ [&rStyleName](const XMLPageExportNameEntry& rEntry) { return rEntry.sStyleName == rStyleName; });
+
+ if( pEntry != aNameVector.cend() )
+ {
+ o_rEntry = *pEntry;
+ return true;
+ }
+
+ return false;
+}
+
+} // namespace
+
+void XMLPageExport::collectPageMasterAutoStyle(
+ const Reference < XPropertySet > & rPropSet,
+ XMLPageExportNameEntry & rEntry)
+{
+ SAL_WARN_IF( !xPageMasterPropSetMapper.is(), "xmloff", "page master family/XMLPageMasterPropSetMapper not found" );
+ if( xPageMasterPropSetMapper.is() )
+ {
+ ::std::vector<XMLPropertyState> aPropStates = xPageMasterExportPropMapper->Filter(rExport, rPropSet);
+ if( !aPropStates.empty())
+ {
+ OUString sParent;
+ rEntry.sPageMasterName = rExport.GetAutoStylePool()->Find( XmlStyleFamily::PAGE_MASTER, sParent, aPropStates );
+ if (rEntry.sPageMasterName.isEmpty())
+ {
+ rEntry.sPageMasterName = rExport.GetAutoStylePool()->Add(XmlStyleFamily::PAGE_MASTER, sParent, std::move(aPropStates));
+ }
+ }
+ }
+ assert(m_xPageMasterDrawingPageExportPropMapper.is());
+ ::std::vector<XMLPropertyState> aPropStates(
+ m_xPageMasterDrawingPageExportPropMapper->Filter(rExport, rPropSet));
+ if (!aPropStates.empty())
+ {
+ OUString sParent;
+ rEntry.sDrawingPageStyleName = rExport.GetAutoStylePool()->Find(XmlStyleFamily::SD_DRAWINGPAGE_ID, sParent, aPropStates);
+ if (rEntry.sDrawingPageStyleName.isEmpty())
+ {
+ rEntry.sDrawingPageStyleName = rExport.GetAutoStylePool()->Add(XmlStyleFamily::SD_DRAWINGPAGE_ID, sParent, std::move(aPropStates));
+ }
+ }
+}
+
+void XMLPageExport::exportMasterPageContent(
+ const Reference < XPropertySet > &,
+ bool /*bAutoStyles*/ )
+{
+
+}
+
+bool XMLPageExport::exportStyle(
+ const Reference< XStyle >& rStyle,
+ bool bAutoStyles )
+{
+ Reference< XPropertySet > xPropSet( rStyle, UNO_QUERY );
+ Reference< XPropertySetInfo > xPropSetInfo = xPropSet->getPropertySetInfo();
+
+ // Don't export styles that aren't existing really. This may be the
+ // case for StarOffice Writer's pool styles.
+ if( xPropSetInfo->hasPropertyByName( gsIsPhysical ) )
+ {
+ Any aAny = xPropSet->getPropertyValue( gsIsPhysical );
+ if( !*o3tl::doAccess<bool>(aAny) )
+ return false;
+ }
+
+ if( bAutoStyles )
+ {
+ XMLPageExportNameEntry aEntry;
+ collectPageMasterAutoStyle(xPropSet, aEntry);
+ aEntry.sStyleName = rStyle->getName();
+ aNameVector.push_back( aEntry );
+
+ exportMasterPageContent( xPropSet, true );
+ }
+ else
+ {
+ OUString sName( rStyle->getName() );
+ bool bEncoded = false;
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_NAME,
+ GetExport().EncodeStyleName( sName, &bEncoded ) );
+
+ if ( xPropSetInfo->hasPropertyByName( "Hidden" ) )
+ {
+ uno::Any aValue = xPropSet->getPropertyValue( "Hidden" );
+ bool bHidden = false;
+ if ((aValue >>= bHidden) && bHidden
+ && GetExport().getSaneDefaultVersion() & SvtSaveOptions::ODFSVER_EXTENDED)
+ {
+ GetExport().AddAttribute(XML_NAMESPACE_LO_EXT, XML_HIDDEN, "true");
+ GetExport().AddAttribute(XML_NAMESPACE_STYLE, XML_HIDDEN, "true"); // FIXME for compatibility
+ }
+ }
+
+ if( bEncoded )
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_DISPLAY_NAME,
+ sName);
+
+ XMLPageExportNameEntry entry;
+ if (findPageMasterNameEntry(aNameVector, sName, entry))
+ {
+ GetExport().AddAttribute(XML_NAMESPACE_STYLE, XML_PAGE_LAYOUT_NAME, GetExport().EncodeStyleName(entry.sPageMasterName));
+ if (!entry.sDrawingPageStyleName.isEmpty())
+ {
+ GetExport().AddAttribute(XML_NAMESPACE_DRAW, XML_STYLE_NAME, GetExport().EncodeStyleName(entry.sDrawingPageStyleName));
+ }
+ }
+
+ Reference<XPropertySetInfo> xInfo = xPropSet->getPropertySetInfo();
+ if ( xInfo.is() && xInfo->hasPropertyByName(gsFollowStyle) )
+ {
+ OUString sNextName;
+ xPropSet->getPropertyValue( gsFollowStyle ) >>= sNextName;
+
+ if( sName != sNextName && !sNextName.isEmpty() )
+ {
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_NEXT_STYLE_NAME,
+ GetExport().EncodeStyleName( sNextName ) );
+ }
+ }
+
+ SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_STYLE,
+ XML_MASTER_PAGE, true, true );
+
+ exportMasterPageContent( xPropSet, false );
+ }
+
+ return true;
+}
+
+XMLPageExport::XMLPageExport(SvXMLExport & rExp)
+ : rExport(rExp)
+ , xPageMasterPropHdlFactory(new XMLPageMasterPropHdlFactory)
+ , xPageMasterPropSetMapper(new XMLPageMasterPropSetMapper(
+ aXMLPageMasterStyleMap,
+ xPageMasterPropHdlFactory))
+ , xPageMasterExportPropMapper(new XMLPageMasterExportPropMapper(
+ xPageMasterPropSetMapper, rExp))
+ , m_xPageMasterDrawingPagePropSetMapper(new XMLPageMasterPropSetMapper(
+ g_XMLPageMasterDrawingPageStyleMap,
+ xPageMasterPropHdlFactory))
+ // use same class but with different map, need its ContextFilter()
+ , m_xPageMasterDrawingPageExportPropMapper(new XMLPageMasterExportPropMapper(
+ m_xPageMasterDrawingPagePropSetMapper, rExp))
+{
+ rExport.GetAutoStylePool()->AddFamily( XmlStyleFamily::PAGE_MASTER, XML_STYLE_FAMILY_PAGE_MASTER_NAME,
+ xPageMasterExportPropMapper, XML_STYLE_FAMILY_PAGE_MASTER_PREFIX, false );
+ rExport.GetAutoStylePool()->AddFamily(XmlStyleFamily::SD_DRAWINGPAGE_ID, XML_STYLE_FAMILY_SD_DRAWINGPAGE_NAME,
+ m_xPageMasterDrawingPageExportPropMapper, XML_STYLE_FAMILY_SD_DRAWINGPAGE_PREFIX);
+
+ Reference< XStyleFamiliesSupplier > xFamiliesSupp( GetExport().GetModel(),
+ UNO_QUERY );
+ SAL_WARN_IF( !xFamiliesSupp.is(), "xmloff",
+ "No XStyleFamiliesSupplier from XModel for export!" );
+ if( !xFamiliesSupp.is() )
+ return;
+
+ Reference< XNameAccess > xFamilies( xFamiliesSupp->getStyleFamilies() );
+ SAL_WARN_IF( !xFamiliesSupp.is(), "xmloff",
+ "getStyleFamilies() from XModel failed for export!" );
+ if( xFamilies.is() )
+ {
+ static const OUStringLiteral aPageStyleName(u"PageStyles");
+
+ if( xFamilies->hasByName( aPageStyleName ) )
+ {
+ xPageStyles.set(xFamilies->getByName( aPageStyleName ),uno::UNO_QUERY);
+
+ SAL_WARN_IF( !xPageStyles.is(), "xmloff",
+ "Page Styles not found for export!" );
+ }
+ }
+
+ if (GetExport().GetModelType() != SvtModuleOptions::EFactory::WRITER)
+ return;
+
+ uno::Reference<lang::XMultiServiceFactory> xFac(GetExport().GetModel(), uno::UNO_QUERY);
+ if (!xFac.is())
+ return;
+
+ uno::Reference<beans::XPropertySet> xProps(
+ xFac->createInstance("com.sun.star.document.Settings"), uno::UNO_QUERY);
+ if (!xProps.is())
+ return;
+
+ bool bGutterAtTop{};
+ xProps->getPropertyValue("GutterAtTop") >>= bGutterAtTop;
+ if (bGutterAtTop)
+ {
+ static_cast<XMLPageMasterExportPropMapper*>(xPageMasterExportPropMapper.get())
+ ->SetGutterAtTop(true);
+ }
+}
+
+XMLPageExport::~XMLPageExport()
+{
+}
+
+void XMLPageExport::exportStyles( bool bUsed, bool bAutoStyles )
+{
+ if( xPageStyles.is() )
+ {
+ const uno::Sequence< OUString> aSeq = xPageStyles->getElementNames();
+ for(const auto& rName : aSeq)
+ {
+ Reference< XStyle > xStyle(xPageStyles->getByName( rName ),uno::UNO_QUERY);
+ if( !bUsed || xStyle->isInUse() )
+ exportStyle( xStyle, bAutoStyles );
+ }
+ }
+}
+
+void XMLPageExport::exportAutoStyles()
+{
+ rExport.GetAutoStylePool()->exportXML(XmlStyleFamily::PAGE_MASTER);
+ // tdf#103602 this is called by both Writer and Calc but Calc doesn't
+ // have fill properties yet
+ rExport.GetAutoStylePool()->exportXML(XmlStyleFamily::SD_DRAWINGPAGE_ID);
+}
+
+void XMLPageExport::exportDefaultStyle()
+{
+ Reference < lang::XMultiServiceFactory > xFactory (GetExport().GetModel(), UNO_QUERY);
+ if (!xFactory.is())
+ return;
+
+ Reference < XPropertySet > xPropSet (xFactory->createInstance ( "com.sun.star.text.Defaults" ), UNO_QUERY);
+ if (!xPropSet.is())
+ return;
+
+ // <style:default-style ...>
+ GetExport().CheckAttrList();
+
+ ::std::vector< XMLPropertyState > aPropStates =
+ xPageMasterExportPropMapper->FilterDefaults(rExport, xPropSet);
+
+ bool bExport = false;
+ rtl::Reference < XMLPropertySetMapper > aPropMapper(xPageMasterExportPropMapper->getPropertySetMapper());
+ for( const auto& rProp : aPropStates )
+ {
+ sal_Int16 nContextId = aPropMapper->GetEntryContextId( rProp.mnIndex );
+ if( nContextId == CTF_PM_STANDARD_MODE )
+ {
+ bExport = true;
+ break;
+ }
+ }
+
+ if( !bExport )
+ return;
+
+ assert(GetExport().getSaneDefaultVersion()
+ >= SvtSaveOptions::ODFSVER_012);
+
+ //<style:default-page-layout>
+ SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_STYLE,
+ XML_DEFAULT_PAGE_LAYOUT,
+ true, true );
+
+ xPageMasterExportPropMapper->exportXML( GetExport(), aPropStates,
+ SvXmlExportFlags::IGN_WS );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/XMLPercentOrMeasurePropertyHandler.cxx b/xmloff/source/style/XMLPercentOrMeasurePropertyHandler.cxx
new file mode 100644
index 000000000..d49174c35
--- /dev/null
+++ b/xmloff/source/style/XMLPercentOrMeasurePropertyHandler.cxx
@@ -0,0 +1,75 @@
+/* -*- 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 <XMLPercentOrMeasurePropertyHandler.hxx>
+
+#include <rtl/ustrbuf.hxx>
+
+#include <com/sun/star/uno/Any.hxx>
+
+#include <xmloff/xmluconv.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+
+
+XMLPercentOrMeasurePropertyHandler::XMLPercentOrMeasurePropertyHandler()
+{
+}
+
+XMLPercentOrMeasurePropertyHandler::~XMLPercentOrMeasurePropertyHandler()
+{
+}
+
+bool XMLPercentOrMeasurePropertyHandler::importXML(
+ const OUString& rStrImpValue,
+ Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter ) const
+{
+ if( rStrImpValue.indexOf( '%' ) != -1 )
+ return false;
+
+ sal_Int32 nValue;
+
+ if (!rUnitConverter.convertMeasureToCore( nValue, rStrImpValue ))
+ return false;
+
+ rValue <<= nValue;
+ return true;
+}
+
+bool XMLPercentOrMeasurePropertyHandler::exportXML(
+ OUString& rStrExpValue,
+ const Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter ) const
+{
+ OUStringBuffer aOut;
+
+ sal_Int32 nValue = 0;
+ if( !(rValue >>= nValue ) )
+ return false;
+
+ rUnitConverter.convertMeasureToXML( aOut, nValue );
+
+ rStrExpValue = aOut.makeStringAndClear();
+ return true;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/XMLRectangleMembersHandler.cxx b/xmloff/source/style/XMLRectangleMembersHandler.cxx
new file mode 100644
index 000000000..5a80cd0c1
--- /dev/null
+++ b/xmloff/source/style/XMLRectangleMembersHandler.cxx
@@ -0,0 +1,112 @@
+/* -*- 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 <xmloff/xmluconv.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <com/sun/star/uno/Any.hxx>
+
+#include <com/sun/star/awt/Rectangle.hpp>
+#include <XMLRectangleMembersHandler.hxx>
+#include <xmloff/xmltypes.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+
+
+XMLRectangleMembersHdl::XMLRectangleMembersHdl( sal_Int32 nType )
+: mnType( nType )
+{
+}
+
+XMLRectangleMembersHdl::~XMLRectangleMembersHdl()
+{
+}
+
+bool XMLRectangleMembersHdl::importXML(
+ const OUString& rStrImpValue,
+ Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter ) const
+{
+ awt::Rectangle aRect( 0, 0, 0, 0 );
+ if( rValue.hasValue() )
+ rValue >>= aRect;
+
+ sal_Int32 nValue;
+
+ if (rUnitConverter.convertMeasureToCore( nValue, rStrImpValue ))
+ {
+ switch( mnType )
+ {
+ case XML_TYPE_RECTANGLE_LEFT :
+ aRect.X = nValue;
+ break;
+ case XML_TYPE_RECTANGLE_TOP :
+ aRect.Y = nValue;
+ break;
+ case XML_TYPE_RECTANGLE_WIDTH :
+ aRect.Width = nValue;
+ break;
+ case XML_TYPE_RECTANGLE_HEIGHT :
+ aRect.Height = nValue;
+ break;
+ }
+
+ rValue <<= aRect;
+ return true;
+ }
+
+ return false;
+}
+
+bool XMLRectangleMembersHdl::exportXML(
+ OUString& rStrExpValue,
+ const Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter ) const
+{
+ awt::Rectangle aRect( 0, 0, 0, 0 );
+ rValue >>= aRect;
+
+ sal_Int32 nValue;
+
+ switch( mnType )
+ {
+ case XML_TYPE_RECTANGLE_LEFT :
+ nValue = aRect.X;
+ break;
+ case XML_TYPE_RECTANGLE_TOP :
+ nValue = aRect.Y;
+ break;
+ case XML_TYPE_RECTANGLE_WIDTH :
+ nValue = aRect.Width;
+ break;
+ case XML_TYPE_RECTANGLE_HEIGHT :
+ nValue = aRect.Height;
+ break;
+ default:
+ nValue = 0; // TODO What value should this be?
+ break;
+ }
+
+ OUStringBuffer sBuffer;
+ rUnitConverter.convertMeasureToXML( sBuffer, nValue );
+ rStrExpValue = sBuffer.makeStringAndClear();
+ return true;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/XMLRtlGutterPropertyHandler.cxx b/xmloff/source/style/XMLRtlGutterPropertyHandler.cxx
new file mode 100644
index 000000000..651406f0f
--- /dev/null
+++ b/xmloff/source/style/XMLRtlGutterPropertyHandler.cxx
@@ -0,0 +1,51 @@
+/* -*- 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 <XMLRtlGutterPropertyHandler.hxx>
+
+#include <set>
+
+#include <com/sun/star/uno/Any.hxx>
+
+#include <xmloff/xmluconv.hxx>
+
+using namespace com::sun::star;
+
+XMLRtlGutterPropertyHandler::XMLRtlGutterPropertyHandler() = default;
+
+XMLRtlGutterPropertyHandler::~XMLRtlGutterPropertyHandler() = default;
+
+bool XMLRtlGutterPropertyHandler::importXML(const OUString& rStrImpValue, uno::Any& rValue,
+ const SvXMLUnitConverter&) const
+{
+ // Infer RtlGutter from WritingMode.
+ std::set<OUString> aRtlModes = { "rl-tb", "tb-rl", "rl", "tb" };
+ auto it = aRtlModes.find(rStrImpValue);
+ rValue <<= (it != aRtlModes.end());
+ return true;
+}
+
+bool XMLRtlGutterPropertyHandler::exportXML(OUString&, const uno::Any&,
+ const SvXMLUnitConverter&) const
+{
+ // No need to export RtlGutter.
+ return false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/adjushdl.cxx b/xmloff/source/style/adjushdl.cxx
new file mode 100644
index 000000000..41a93d57f
--- /dev/null
+++ b/xmloff/source/style/adjushdl.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 "adjushdl.hxx"
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlement.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <com/sun/star/style/ParagraphAdjust.hpp>
+#include <com/sun/star/uno/Any.hxx>
+
+using namespace ::com::sun::star;
+
+using namespace ::xmloff::token;
+
+SvXMLEnumMapEntry<style::ParagraphAdjust> const pXML_Para_Adjust_Enum[] =
+{
+ { XML_START, style::ParagraphAdjust_LEFT },
+ { XML_END, style::ParagraphAdjust_RIGHT },
+ { XML_CENTER, style::ParagraphAdjust_CENTER },
+ { XML_JUSTIFY, style::ParagraphAdjust_BLOCK },
+ { XML_JUSTIFIED, style::ParagraphAdjust_BLOCK }, // obsolete
+ { XML_LEFT, style::ParagraphAdjust_LEFT },
+ { XML_RIGHT, style::ParagraphAdjust_RIGHT },
+ { XML_TOKEN_INVALID, style::ParagraphAdjust(0) }
+};
+
+SvXMLEnumMapEntry<style::ParagraphAdjust> const pXML_Para_Align_Last_Enum[] =
+{
+ { XML_START, style::ParagraphAdjust_LEFT },
+ { XML_CENTER, style::ParagraphAdjust_CENTER },
+ { XML_JUSTIFY, style::ParagraphAdjust_BLOCK },
+ { XML_JUSTIFIED, style::ParagraphAdjust_BLOCK }, // obsolete
+ { XML_TOKEN_INVALID, style::ParagraphAdjust(0) }
+};
+
+
+
+
+XMLParaAdjustPropHdl::~XMLParaAdjustPropHdl()
+{
+ // nothing to do
+}
+
+bool XMLParaAdjustPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ style::ParagraphAdjust eAdjust;
+ bool bRet = SvXMLUnitConverter::convertEnum( eAdjust, rStrImpValue, pXML_Para_Adjust_Enum );
+ if( bRet )
+ rValue <<= static_cast<sal_Int16>(eAdjust);
+
+ return bRet;
+}
+
+bool XMLParaAdjustPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ if(!rValue.hasValue())
+ return false;
+ OUStringBuffer aOut;
+ sal_Int16 nVal = 0;
+
+ rValue >>= nVal;
+
+ bool bRet = SvXMLUnitConverter::convertEnum( aOut, static_cast<style::ParagraphAdjust>(nVal), pXML_Para_Adjust_Enum, XML_START );
+
+ rStrExpValue = aOut.makeStringAndClear();
+
+ return bRet;
+}
+
+
+
+
+XMLLastLineAdjustPropHdl::~XMLLastLineAdjustPropHdl()
+{
+ // nothing to do
+}
+
+bool XMLLastLineAdjustPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ style::ParagraphAdjust eAdjust;
+ bool bRet = SvXMLUnitConverter::convertEnum( eAdjust, rStrImpValue, pXML_Para_Align_Last_Enum );
+ if( bRet )
+ rValue <<= static_cast<sal_Int16>(eAdjust);
+
+ return bRet;
+}
+
+bool XMLLastLineAdjustPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ OUStringBuffer aOut;
+ sal_Int16 nVal = 0;
+ bool bRet = false;
+
+ rValue >>= nVal;
+
+ if( static_cast<style::ParagraphAdjust>(nVal) != style::ParagraphAdjust_LEFT )
+ bRet = SvXMLUnitConverter::convertEnum( aOut, static_cast<style::ParagraphAdjust>(nVal), pXML_Para_Align_Last_Enum, XML_START );
+
+ rStrExpValue = aOut.makeStringAndClear();
+
+ return bRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/adjushdl.hxx b/xmloff/source/style/adjushdl.hxx
new file mode 100644
index 000000000..5de055163
--- /dev/null
+++ b/xmloff/source/style/adjushdl.hxx
@@ -0,0 +1,48 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLParaAdjustPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLParaAdjustPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLLastLineAdjustPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLLastLineAdjustPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/backhdl.cxx b/xmloff/source/style/backhdl.cxx
new file mode 100644
index 000000000..4df7a2f6e
--- /dev/null
+++ b/xmloff/source/style/backhdl.cxx
@@ -0,0 +1,285 @@
+/* -*- 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 "backhdl.hxx"
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlement.hxx>
+#include <sax/tools/converter.hxx>
+#include <com/sun/star/uno/Any.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <sal/log.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+SvXMLEnumMapEntry<style::GraphicLocation> const pXML_BrushHorizontalPos[] =
+{
+ { XML_LEFT, style::GraphicLocation_LEFT_MIDDLE },
+ { XML_RIGHT, style::GraphicLocation_RIGHT_MIDDLE },
+ { XML_TOKEN_INVALID, style::GraphicLocation(0) }
+};
+
+SvXMLEnumMapEntry<style::GraphicLocation> const pXML_BrushVerticalPos[] =
+{
+ { XML_TOP, style::GraphicLocation_MIDDLE_TOP },
+ { XML_BOTTOM, style::GraphicLocation_MIDDLE_BOTTOM },
+ { XML_TOKEN_INVALID, style::GraphicLocation(0) }
+};
+
+
+
+
+XMLBackGraphicPositionPropHdl::~XMLBackGraphicPositionPropHdl()
+{
+ // Nothing to do
+}
+
+bool XMLBackGraphicPositionPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = true;
+ style::GraphicLocation ePos = style::GraphicLocation_NONE, eTmp;
+ style::GraphicLocation nTmpGraphicLocation;
+ SvXMLTokenEnumerator aTokenEnum( rStrImpValue );
+ std::u16string_view aToken;
+ bool bHori = false, bVert = false;
+
+ while( bRet && aTokenEnum.getNextToken( aToken ) )
+ {
+ if( bHori && bVert )
+ {
+ bRet = false;
+ }
+ else if( std::u16string_view::npos != aToken.find( '%' ) )
+ {
+ sal_Int32 nPrc = 50;
+ if (::sax::Converter::convertPercent( nPrc, aToken ))
+ {
+ if( !bHori )
+ {
+ ePos = nPrc < 25 ? style::GraphicLocation_LEFT_TOP :
+ (nPrc < 75 ? style::GraphicLocation_MIDDLE_MIDDLE :
+ style::GraphicLocation_RIGHT_BOTTOM);
+ bHori = true;
+ }
+ else
+ {
+ eTmp = nPrc < 25 ? style::GraphicLocation_LEFT_TOP:
+ (nPrc < 75 ? style::GraphicLocation_LEFT_MIDDLE :
+ style::GraphicLocation_LEFT_BOTTOM);
+ MergeXMLVertPos( ePos, eTmp );
+ bVert = true;
+ }
+ }
+ else
+ {
+ // wrong percentage
+ bRet = false;
+ }
+ }
+ else if( IsXMLToken( aToken, XML_CENTER ) )
+ {
+ if( bHori )
+ MergeXMLVertPos( ePos, style::GraphicLocation_MIDDLE_MIDDLE );
+ else if ( bVert )
+ MergeXMLHoriPos( ePos, style::GraphicLocation_MIDDLE_MIDDLE );
+ else
+ ePos = style::GraphicLocation_MIDDLE_MIDDLE;
+ }
+ else if( SvXMLUnitConverter::convertEnum( nTmpGraphicLocation, aToken, pXML_BrushHorizontalPos ) )
+ {
+ if( bVert )
+ MergeXMLHoriPos( ePos, nTmpGraphicLocation );
+ else if( !bHori )
+ ePos = nTmpGraphicLocation;
+ else
+ bRet = false;
+
+ bHori = true;
+ }
+ else if( SvXMLUnitConverter::convertEnum( nTmpGraphicLocation, aToken, pXML_BrushVerticalPos ) )
+ {
+ if( bHori )
+ MergeXMLVertPos( ePos, nTmpGraphicLocation );
+ else if( !bVert )
+ ePos = nTmpGraphicLocation;
+ else
+ bRet = false;
+ bVert = true;
+ }
+ else
+ {
+ bRet = false;
+ }
+ }
+
+ bRet &= style::GraphicLocation_NONE != ePos;
+ if( bRet )
+ rValue <<= static_cast<style::GraphicLocation>(static_cast<sal_uInt16>(ePos));
+
+ return bRet;
+}
+
+bool XMLBackGraphicPositionPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = true;
+ OUStringBuffer aOut;
+
+ style::GraphicLocation eLocation;
+ if( !( rValue >>= eLocation ) )
+ {
+ sal_Int32 nValue = 0;
+ if( rValue >>= nValue )
+ eLocation = static_cast<style::GraphicLocation>(nValue);
+ else
+ bRet = false;
+ }
+
+ if( bRet )
+ {
+ bRet = false;
+
+ switch( eLocation )
+ {
+ case style::GraphicLocation_LEFT_TOP:
+ case style::GraphicLocation_MIDDLE_TOP:
+ case style::GraphicLocation_RIGHT_TOP:
+ aOut.append( GetXMLToken(XML_TOP) );
+ bRet = true;
+ break;
+ case style::GraphicLocation_LEFT_MIDDLE:
+ case style::GraphicLocation_MIDDLE_MIDDLE:
+ case style::GraphicLocation_RIGHT_MIDDLE:
+ aOut.append( GetXMLToken(XML_CENTER) );
+ bRet = true;
+ break;
+ case style::GraphicLocation_LEFT_BOTTOM:
+ case style::GraphicLocation_MIDDLE_BOTTOM:
+ case style::GraphicLocation_RIGHT_BOTTOM:
+ aOut.append( GetXMLToken(XML_BOTTOM) );
+ bRet = true;
+ break;
+ default:
+ break;
+ }
+
+ if( bRet )
+ {
+ aOut.append( ' ' );
+
+ switch( eLocation )
+ {
+ case style::GraphicLocation_LEFT_TOP:
+ case style::GraphicLocation_LEFT_BOTTOM:
+ case style::GraphicLocation_LEFT_MIDDLE:
+ aOut.append( GetXMLToken(XML_LEFT) );
+ break;
+ case style::GraphicLocation_MIDDLE_TOP:
+ case style::GraphicLocation_MIDDLE_MIDDLE:
+ case style::GraphicLocation_MIDDLE_BOTTOM:
+ aOut.append( GetXMLToken(XML_CENTER) );
+ break;
+ case style::GraphicLocation_RIGHT_MIDDLE:
+ case style::GraphicLocation_RIGHT_TOP:
+ case style::GraphicLocation_RIGHT_BOTTOM:
+ aOut.append( GetXMLToken(XML_RIGHT) );
+ break;
+ default:
+ break;
+ }
+ }
+ }
+
+ rStrExpValue = aOut.makeStringAndClear();
+
+ return bRet;
+}
+
+void XMLBackGraphicPositionPropHdl::MergeXMLVertPos( style::GraphicLocation& ePos, style::GraphicLocation eVert )
+{
+ switch( ePos )
+ {
+ case style::GraphicLocation_LEFT_TOP:
+ case style::GraphicLocation_LEFT_MIDDLE:
+ case style::GraphicLocation_LEFT_BOTTOM:
+ ePos = style::GraphicLocation_MIDDLE_TOP==eVert ?
+ style::GraphicLocation_LEFT_TOP :
+ (style::GraphicLocation_MIDDLE_MIDDLE==eVert ?
+ style::GraphicLocation_LEFT_MIDDLE :
+ style::GraphicLocation_LEFT_BOTTOM);
+ break;
+
+ case style::GraphicLocation_MIDDLE_TOP:
+ case style::GraphicLocation_MIDDLE_MIDDLE:
+ case style::GraphicLocation_MIDDLE_BOTTOM:
+ ePos = eVert;
+ break;
+
+ case style::GraphicLocation_RIGHT_TOP:
+ case style::GraphicLocation_RIGHT_MIDDLE:
+ case style::GraphicLocation_RIGHT_BOTTOM:
+ ePos = style::GraphicLocation_MIDDLE_TOP==eVert ?
+ style::GraphicLocation_RIGHT_TOP :
+ (style::GraphicLocation_MIDDLE_MIDDLE==eVert ?
+ style::GraphicLocation_RIGHT_MIDDLE :
+ style::GraphicLocation_RIGHT_BOTTOM);
+ break;
+ default:
+ break;
+ }
+}
+
+void XMLBackGraphicPositionPropHdl::MergeXMLHoriPos( style::GraphicLocation& ePos, style::GraphicLocation eHori )
+{
+ SAL_WARN_IF( !(style::GraphicLocation_LEFT_MIDDLE==eHori || style::GraphicLocation_MIDDLE_MIDDLE==eHori || style::GraphicLocation_RIGHT_MIDDLE==eHori), "xmloff",
+ "lcl_frmitems_MergeXMLHoriPos: vertical pos must be middle" );
+
+ switch( ePos )
+ {
+ case style::GraphicLocation_LEFT_TOP:
+ case style::GraphicLocation_MIDDLE_TOP:
+ case style::GraphicLocation_RIGHT_TOP:
+ ePos = style::GraphicLocation_LEFT_MIDDLE==eHori ?
+ style::GraphicLocation_LEFT_TOP :
+ (style::GraphicLocation_MIDDLE_MIDDLE==eHori ?
+ style::GraphicLocation_MIDDLE_TOP :
+ style::GraphicLocation_RIGHT_TOP);
+ break;
+
+ case style::GraphicLocation_LEFT_MIDDLE:
+ case style::GraphicLocation_MIDDLE_MIDDLE:
+ case style::GraphicLocation_RIGHT_MIDDLE:
+ ePos = eHori;
+ break;
+
+ case style::GraphicLocation_LEFT_BOTTOM:
+ case style::GraphicLocation_MIDDLE_BOTTOM:
+ case style::GraphicLocation_RIGHT_BOTTOM:
+ ePos = style::GraphicLocation_LEFT_MIDDLE==eHori ?
+ style::GraphicLocation_LEFT_BOTTOM :
+ (style::GraphicLocation_MIDDLE_MIDDLE==eHori ?
+ style::GraphicLocation_MIDDLE_BOTTOM :
+ style::GraphicLocation_RIGHT_BOTTOM);
+ break;
+ default:
+ break;
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/backhdl.hxx b/xmloff/source/style/backhdl.hxx
new file mode 100644
index 000000000..0392909df
--- /dev/null
+++ b/xmloff/source/style/backhdl.hxx
@@ -0,0 +1,43 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+#include <com/sun/star/style/GraphicLocation.hpp>
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLBackGraphicPositionPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLBackGraphicPositionPropHdl() override;
+
+ /// TabStops will be imported/exported as XML-Elements. So the Import/Export-work must be done at another place.
+ using XMLPropertyHandler::importXML;
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+
+private:
+ static void MergeXMLHoriPos( css::style::GraphicLocation& ePos, css::style::GraphicLocation eHori );
+ static void MergeXMLVertPos( css::style::GraphicLocation& ePos, css::style::GraphicLocation eVert );
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/bordrhdl.cxx b/xmloff/source/style/bordrhdl.cxx
new file mode 100644
index 000000000..4b3a7b666
--- /dev/null
+++ b/xmloff/source/style/bordrhdl.cxx
@@ -0,0 +1,351 @@
+/* -*- 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 "bordrhdl.hxx"
+#include <sax/tools/converter.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlement.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/table/BorderLine2.hpp>
+#include <com/sun/star/table/BorderLineStyle.hpp>
+
+#include <limits.h>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+#define DEF_LINE_WIDTH_0 1
+#define DEF_LINE_WIDTH_1 35
+#define DEF_LINE_WIDTH_2 88
+
+#define SVX_XML_BORDER_WIDTH_THIN 0
+#define SVX_XML_BORDER_WIDTH_MIDDLE 1
+#define SVX_XML_BORDER_WIDTH_THICK 2
+
+SvXMLEnumMapEntry<sal_uInt16> const pXML_BorderStyles[] =
+{
+ { XML_NONE, table::BorderLineStyle::NONE },
+ { XML_HIDDEN, table::BorderLineStyle::NONE },
+ { XML_SOLID, table::BorderLineStyle::SOLID },
+ { XML_DOUBLE, table::BorderLineStyle::DOUBLE },
+ { XML_DOUBLE_THIN, table::BorderLineStyle::DOUBLE_THIN },
+ { XML_DOTTED, table::BorderLineStyle::DOTTED },
+ { XML_DASHED, table::BorderLineStyle::DASHED },
+ { XML_GROOVE, table::BorderLineStyle::ENGRAVED },
+ { XML_RIDGE, table::BorderLineStyle::EMBOSSED },
+ { XML_INSET, table::BorderLineStyle::INSET },
+ { XML_OUTSET, table::BorderLineStyle::OUTSET },
+ { XML_FINE_DASHED, table::BorderLineStyle::FINE_DASHED },
+ { XML_DASH_DOT, table::BorderLineStyle::DASH_DOT },
+ { XML_DASH_DOT_DOT, table::BorderLineStyle::DASH_DOT_DOT },
+ { XML_TOKEN_INVALID, 0 }
+};
+
+SvXMLEnumMapEntry<sal_uInt16> const pXML_NamedBorderWidths[] =
+{
+ { XML_THIN, SVX_XML_BORDER_WIDTH_THIN },
+ { XML_MIDDLE, SVX_XML_BORDER_WIDTH_MIDDLE },
+ { XML_THICK, SVX_XML_BORDER_WIDTH_THICK },
+ { XML_TOKEN_INVALID, 0 }
+};
+// mapping tables to map external xml input to internal box line widths
+
+sal_uInt16 const aBorderWidths[] =
+{
+ DEF_LINE_WIDTH_0,
+ DEF_LINE_WIDTH_1,
+ DEF_LINE_WIDTH_2
+};
+
+static void lcl_frmitems_setXMLBorderStyle( table::BorderLine2 & rBorderLine, sal_uInt16 nStyle )
+{
+ sal_Int16 eStyle = -1; // None
+ if (nStyle != table::BorderLineStyle::NONE)
+ eStyle = sal_Int16( nStyle );
+
+ rBorderLine.LineStyle = eStyle;
+}
+
+
+
+
+XMLBorderWidthHdl::~XMLBorderWidthHdl()
+{
+ // nothing to do
+}
+
+bool XMLBorderWidthHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
+{
+ SvXMLTokenEnumerator aTokenEnum( rStrImpValue );
+
+ sal_Int32 nInWidth, nDistance, nOutWidth;
+
+ std::u16string_view aToken;
+ if( !aTokenEnum.getNextToken( aToken ) )
+ return false;
+
+ if (!rUnitConverter.convertMeasureToCore( nInWidth, aToken, 0, 500 ))
+ return false;
+
+ if( !aTokenEnum.getNextToken( aToken ) )
+ return false;
+
+ if (!rUnitConverter.convertMeasureToCore( nDistance, aToken, 0, 500 ))
+ return false;
+
+ if( !aTokenEnum.getNextToken( aToken ) )
+ return false;
+
+ if (!rUnitConverter.convertMeasureToCore( nOutWidth, aToken, 0, 500 ))
+ return false;
+
+ table::BorderLine2 aBorderLine;
+ if(!(rValue >>= aBorderLine))
+ aBorderLine.Color = 0;
+
+ aBorderLine.InnerLineWidth = sal::static_int_cast< sal_Int16 >(nInWidth);
+ aBorderLine.OuterLineWidth = sal::static_int_cast< sal_Int16 >(nOutWidth);
+ aBorderLine.LineDistance = sal::static_int_cast< sal_Int16 >(nDistance);
+
+ rValue <<= aBorderLine;
+ return true;
+}
+
+bool XMLBorderWidthHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
+{
+ OUStringBuffer aOut;
+
+ table::BorderLine2 aBorderLine;
+ if(!(rValue >>= aBorderLine))
+ return false;
+
+ bool bDouble = false;
+ switch ( aBorderLine.LineStyle )
+ {
+ case table::BorderLineStyle::DOUBLE:
+ case table::BorderLineStyle::DOUBLE_THIN:
+ case table::BorderLineStyle::THINTHICK_SMALLGAP:
+ case table::BorderLineStyle::THINTHICK_MEDIUMGAP:
+ case table::BorderLineStyle::THINTHICK_LARGEGAP:
+ case table::BorderLineStyle::THICKTHIN_SMALLGAP:
+ case table::BorderLineStyle::THICKTHIN_MEDIUMGAP:
+ case table::BorderLineStyle::THICKTHIN_LARGEGAP:
+ bDouble = true;
+ break;
+ default:
+ break;
+ }
+
+ if( ( aBorderLine.LineDistance == 0 && aBorderLine.InnerLineWidth == 0 ) || !bDouble )
+ return false;
+
+ rUnitConverter.convertMeasureToXML( aOut, aBorderLine.InnerLineWidth );
+ aOut.append( ' ' );
+ rUnitConverter.convertMeasureToXML( aOut, aBorderLine.LineDistance );
+ aOut.append( ' ' );
+ rUnitConverter.convertMeasureToXML( aOut, aBorderLine.OuterLineWidth );
+
+ rStrExpValue = aOut.makeStringAndClear();
+ return true;
+}
+
+
+
+
+XMLBorderHdl::~XMLBorderHdl()
+{
+ // nothing to do
+}
+
+bool XMLBorderHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
+{
+ std::u16string_view aToken;
+ SvXMLTokenEnumerator aTokens( rStrImpValue );
+
+ bool bHasStyle = false;
+ bool bHasWidth = false;
+ bool bHasColor = false;
+
+ sal_uInt16 nStyle = USHRT_MAX;
+ sal_uInt16 nWidth = 0;
+ sal_uInt16 nNamedWidth = USHRT_MAX;
+ sal_Int32 nColor = 0;
+
+ sal_Int32 nTemp;
+ while( aTokens.getNextToken( aToken ) && !aToken.empty() )
+ {
+ if( !bHasWidth &&
+ SvXMLUnitConverter::convertEnum( nNamedWidth, aToken,
+ pXML_NamedBorderWidths ) )
+ {
+ bHasWidth = true;
+ }
+ else if( !bHasStyle &&
+ SvXMLUnitConverter::convertEnum( nStyle, aToken,
+ pXML_BorderStyles ) )
+ {
+ bHasStyle = true;
+ }
+ else if (!bHasColor && ::sax::Converter::convertColor(nColor, aToken))
+ {
+ bHasColor = true;
+ }
+ else if( !bHasWidth &&
+ rUnitConverter.convertMeasureToCore( nTemp, aToken, 0,
+ USHRT_MAX ) )
+ {
+ nWidth = static_cast<sal_uInt16>(nTemp);
+ bHasWidth = true;
+ }
+ else
+ {
+ // misformed
+ return false;
+ }
+ }
+
+ // if there is no style or a different style than none but no width,
+ // then the declaration is not valid.
+ if (!bHasStyle || (table::BorderLineStyle::NONE != nStyle && !bHasWidth))
+ return false;
+
+ table::BorderLine2 aBorderLine;
+ if(!(rValue >>= aBorderLine))
+ {
+ aBorderLine.Color = 0;
+ aBorderLine.InnerLineWidth = 0;
+ aBorderLine.OuterLineWidth = 0;
+ aBorderLine.LineDistance = 0;
+ aBorderLine.LineWidth = 0;
+ }
+
+ // first of all, delete an empty line
+ if (table::BorderLineStyle::NONE == nStyle ||
+ (bHasWidth && USHRT_MAX == nNamedWidth && 0 == nWidth) )
+ {
+ aBorderLine.InnerLineWidth = 0;
+ aBorderLine.OuterLineWidth = 0;
+ aBorderLine.LineDistance = 0;
+ aBorderLine.LineWidth = 0;
+ }
+ else
+ {
+ if( USHRT_MAX != nNamedWidth )
+ {
+ aBorderLine.LineWidth = aBorderWidths[nNamedWidth];
+ }
+ else
+ {
+ aBorderLine.LineWidth = nWidth;
+ lcl_frmitems_setXMLBorderStyle( aBorderLine, nStyle );
+ }
+ }
+
+ // set color
+ if( bHasColor )
+ {
+ aBorderLine.Color = nColor;
+ }
+
+ rValue <<= aBorderLine;
+ return true;
+}
+
+bool XMLBorderHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& /* rUnitConverter */ ) const
+{
+ OUStringBuffer aOut;
+
+ table::BorderLine2 aBorderLine;
+ if(!(rValue >>= aBorderLine))
+ return false;
+
+ sal_Int32 nWidth = aBorderLine.LineWidth;
+
+ if( nWidth == 0 )
+ {
+ aOut.append( GetXMLToken( XML_NONE ) );
+ }
+ else
+ {
+ ::sax::Converter::convertMeasure( aOut, nWidth,
+ util::MeasureUnit::MM_100TH, util::MeasureUnit::POINT);
+
+ aOut.append( ' ' );
+
+ XMLTokenEnum eStyleToken = XML_SOLID;
+ switch ( aBorderLine.LineStyle )
+ {
+ case table::BorderLineStyle::DASHED:
+ eStyleToken = XML_DASHED;
+ break;
+ case table::BorderLineStyle::DOTTED:
+ eStyleToken = XML_DOTTED;
+ break;
+ case table::BorderLineStyle::DOUBLE:
+ case table::BorderLineStyle::THINTHICK_SMALLGAP:
+ case table::BorderLineStyle::THINTHICK_MEDIUMGAP:
+ case table::BorderLineStyle::THINTHICK_LARGEGAP:
+ case table::BorderLineStyle::THICKTHIN_SMALLGAP:
+ case table::BorderLineStyle::THICKTHIN_MEDIUMGAP:
+ case table::BorderLineStyle::THICKTHIN_LARGEGAP:
+ eStyleToken = XML_DOUBLE;
+ break;
+ case table::BorderLineStyle::EMBOSSED:
+ eStyleToken = XML_RIDGE;
+ break;
+ case table::BorderLineStyle::ENGRAVED:
+ eStyleToken = XML_GROOVE;
+ break;
+ case table::BorderLineStyle::OUTSET:
+ eStyleToken = XML_OUTSET;
+ break;
+ case table::BorderLineStyle::INSET:
+ eStyleToken = XML_INSET;
+ break;
+ case table::BorderLineStyle::FINE_DASHED:
+ eStyleToken = XML_FINE_DASHED;
+ break;
+ case table::BorderLineStyle::DASH_DOT:
+ eStyleToken = XML_DASH_DOT;
+ break;
+ case table::BorderLineStyle::DASH_DOT_DOT:
+ eStyleToken = XML_DASH_DOT_DOT;
+ break;
+ case table::BorderLineStyle::DOUBLE_THIN:
+ eStyleToken = XML_DOUBLE_THIN;
+ break;
+ case table::BorderLineStyle::SOLID:
+ default:
+ break;
+ }
+ aOut.append( GetXMLToken( eStyleToken ) );
+
+ aOut.append( ' ' );
+
+ ::sax::Converter::convertColor( aOut, aBorderLine.Color );
+ }
+
+ rStrExpValue = aOut.makeStringAndClear();
+
+ return true;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/bordrhdl.hxx b/xmloff/source/style/bordrhdl.hxx
new file mode 100644
index 000000000..3741fc3a7
--- /dev/null
+++ b/xmloff/source/style/bordrhdl.hxx
@@ -0,0 +1,45 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLBorderWidthHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLBorderWidthHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+class XMLBorderHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLBorderHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/breakhdl.cxx b/xmloff/source/style/breakhdl.cxx
new file mode 100644
index 000000000..d1490881f
--- /dev/null
+++ b/xmloff/source/style/breakhdl.cxx
@@ -0,0 +1,179 @@
+/* -*- 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 "breakhdl.hxx"
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlement.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <com/sun/star/style/BreakType.hpp>
+#include <com/sun/star/uno/Any.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+SvXMLEnumMapEntry<sal_uInt16> const pXML_BreakTypes[] =
+{
+ { XML_AUTO, 0 },
+ { XML_COLUMN, 1 },
+ { XML_PAGE, 2 },
+ { XML_EVEN_PAGE, 2 },
+ { XML_ODD_PAGE, 2 },
+ { XML_TOKEN_INVALID, 0}
+};
+
+
+
+
+XMLFmtBreakBeforePropHdl::~XMLFmtBreakBeforePropHdl()
+{
+ // Nothing to do
+}
+
+bool XMLFmtBreakBeforePropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_uInt16 nEnum;
+ bool bRet = SvXMLUnitConverter::convertEnum( nEnum, rStrImpValue, pXML_BreakTypes );
+ if( bRet )
+ {
+ style::BreakType eBreak;
+ switch ( nEnum )
+ {
+ case 0:
+ eBreak = style::BreakType_NONE;
+ break;
+ case 1:
+ eBreak = style::BreakType_COLUMN_BEFORE;
+ break;
+ default:
+ eBreak = style::BreakType_PAGE_BEFORE;
+ break;
+ }
+ rValue <<= eBreak;
+ }
+
+ return bRet;
+}
+
+bool XMLFmtBreakBeforePropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ style::BreakType eBreak;
+
+ if( !( rValue >>= eBreak ) )
+ {
+ sal_Int32 nValue = 0;
+ if( !( rValue >>= nValue ) )
+ return false;
+
+ eBreak = static_cast<style::BreakType>(nValue);
+ }
+
+ sal_uInt16 nEnum = 0;
+ switch( eBreak )
+ {
+ case style::BreakType_COLUMN_BEFORE:
+ nEnum = 1;
+ break;
+ case style::BreakType_PAGE_BEFORE:
+ nEnum = 2;
+ break;
+ case style::BreakType_NONE:
+ nEnum = 0;
+ break;
+ default:
+ return false;
+ }
+
+ OUStringBuffer aOut;
+ /* bool bOk = */ SvXMLUnitConverter::convertEnum( aOut, nEnum, pXML_BreakTypes );
+ rStrExpValue = aOut.makeStringAndClear();
+
+ return true;
+}
+
+
+
+
+XMLFmtBreakAfterPropHdl::~XMLFmtBreakAfterPropHdl()
+{
+ // Nothing to do
+}
+
+bool XMLFmtBreakAfterPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_uInt16 nEnum;
+ bool bRet = SvXMLUnitConverter::convertEnum( nEnum, rStrImpValue, pXML_BreakTypes );
+ if( bRet )
+ {
+ style::BreakType eBreak;
+ switch ( nEnum )
+ {
+ case 0:
+ eBreak = style::BreakType_NONE;
+ break;
+ case 1:
+ eBreak = style::BreakType_COLUMN_AFTER;
+ break;
+ default:
+ eBreak = style::BreakType_PAGE_AFTER;
+ break;
+ }
+ rValue <<= eBreak;
+ }
+
+ return bRet;
+}
+
+bool XMLFmtBreakAfterPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ style::BreakType eBreak;
+
+ if( !( rValue >>= eBreak ) )
+ {
+ sal_Int32 nValue = 0;
+ if( !( rValue >>= nValue ) )
+ return false;
+
+ eBreak = static_cast<style::BreakType>(nValue);
+ }
+
+ sal_uInt16 nEnum = 0;
+ switch( eBreak )
+ {
+ case style::BreakType_COLUMN_AFTER:
+ nEnum = 1;
+ break;
+ case style::BreakType_PAGE_AFTER:
+ nEnum = 2;
+ break;
+ case style::BreakType_NONE:
+ nEnum = 0;
+ break;
+ default:
+ return false;
+ }
+
+ OUStringBuffer aOut;
+ /* bool bOk = */ SvXMLUnitConverter::convertEnum( aOut, nEnum, pXML_BreakTypes );
+ rStrExpValue = aOut.makeStringAndClear();
+
+ return true;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/breakhdl.hxx b/xmloff/source/style/breakhdl.hxx
new file mode 100644
index 000000000..c38e33ba6
--- /dev/null
+++ b/xmloff/source/style/breakhdl.hxx
@@ -0,0 +1,48 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLFmtBreakBeforePropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLFmtBreakBeforePropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLFmtBreakAfterPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLFmtBreakAfterPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/cdouthdl.cxx b/xmloff/source/style/cdouthdl.cxx
new file mode 100644
index 000000000..0b484dcf0
--- /dev/null
+++ b/xmloff/source/style/cdouthdl.cxx
@@ -0,0 +1,305 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include "cdouthdl.hxx"
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlement.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <osl/diagnose.h>
+
+#include <com/sun/star/awt/FontStrikeout.hpp>
+#include <com/sun/star/uno/Any.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::awt;
+using namespace ::xmloff::token;
+
+SvXMLEnumMapEntry<sal_uInt16> const pXML_CrossedoutType_Enum[] =
+{
+ { XML_NONE, awt::FontStrikeout::NONE },
+ { XML_SINGLE, awt::FontStrikeout::SINGLE },
+ { XML_DOUBLE, awt::FontStrikeout::DOUBLE },
+ { XML_SINGLE, awt::FontStrikeout::BOLD },
+ { XML_SINGLE, awt::FontStrikeout::SLASH },
+ { XML_SINGLE, awt::FontStrikeout::X },
+ { XML_TOKEN_INVALID, 0 }
+};
+
+SvXMLEnumMapEntry<sal_uInt16> const pXML_CrossedoutStyle_Enum[] =
+{
+ { XML_NONE, awt::FontStrikeout::NONE },
+ { XML_SOLID, awt::FontStrikeout::SINGLE },
+ { XML_SOLID, awt::FontStrikeout::DOUBLE },
+ { XML_SOLID, awt::FontStrikeout::BOLD },
+ { XML_SOLID, awt::FontStrikeout::SLASH },
+ { XML_SOLID, awt::FontStrikeout::X },
+ { XML_DOTTED, awt::FontStrikeout::SINGLE },
+ { XML_DASH, awt::FontStrikeout::SINGLE },
+ { XML_LONG_DASH, awt::FontStrikeout::SINGLE },
+ { XML_DOT_DASH, awt::FontStrikeout::SINGLE },
+ { XML_DOT_DOT_DASH, awt::FontStrikeout::SINGLE },
+ { XML_WAVE, awt::FontStrikeout::SINGLE },
+ { XML_TOKEN_INVALID, 0 }
+};
+
+SvXMLEnumMapEntry<sal_uInt16> const pXML_CrossedoutWidth_Enum[] =
+{
+ { XML_AUTO, awt::FontStrikeout::NONE },
+ { XML_AUTO, awt::FontStrikeout::SINGLE },
+ { XML_AUTO, awt::FontStrikeout::DOUBLE },
+ { XML_BOLD, awt::FontStrikeout::BOLD },
+ { XML_AUTO, awt::FontStrikeout::SLASH },
+ { XML_AUTO, awt::FontStrikeout::X },
+ { XML_THIN, awt::FontStrikeout::NONE },
+ { XML_MEDIUM, awt::FontStrikeout::NONE },
+ { XML_THICK, awt::FontStrikeout::NONE },
+ { XML_TOKEN_INVALID, 0 }
+};
+
+
+XMLCrossedOutTypePropHdl::~XMLCrossedOutTypePropHdl()
+{
+ // nothing to do
+}
+
+bool XMLCrossedOutTypePropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_uInt16 eNewStrikeout = 0;
+ bool bRet = SvXMLUnitConverter::convertEnum(
+ eNewStrikeout, rStrImpValue, pXML_CrossedoutType_Enum );
+ if( bRet )
+ {
+ // multi property: style and width might be set already.
+ // If the old value is NONE, the new is used unchanged.
+ sal_Int16 eStrikeout = sal_Int16();
+ if( (rValue >>= eStrikeout) && awt::FontStrikeout::NONE!=eStrikeout )
+ {
+ switch( eNewStrikeout )
+ {
+ case awt::FontStrikeout::NONE:
+ case awt::FontStrikeout::SINGLE:
+ // keep existing line style
+ eNewStrikeout = eStrikeout;
+ break;
+ case awt::FontStrikeout::DOUBLE:
+ // A double line style has priority over a solid or a bold
+ // line style,
+ // but not about any other line style
+ switch( eStrikeout )
+ {
+ case awt::FontStrikeout::SINGLE:
+ case awt::FontStrikeout::BOLD:
+ break;
+ default:
+ // If a double line style is not supported for the existing
+ // value, keep the new one
+ eNewStrikeout = eStrikeout;
+ break;
+ }
+ break;
+ default:
+ OSL_ENSURE( bRet, "unexpected line type value" );
+ break;
+ }
+ if( eNewStrikeout != eStrikeout )
+ rValue <<= static_cast<sal_Int16>(eNewStrikeout);
+ }
+ else
+ {
+ rValue <<= static_cast<sal_Int16>(eNewStrikeout);
+ }
+ }
+
+ return bRet;
+}
+
+bool XMLCrossedOutTypePropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_uInt16 nValue = sal_uInt16();
+
+ if (rValue >>= nValue)
+ {
+ OUStringBuffer aOut;
+ bRet = SvXMLUnitConverter::convertEnum(
+ aOut, nValue, pXML_CrossedoutType_Enum );
+ if( bRet )
+ rStrExpValue = aOut.makeStringAndClear();
+ }
+
+ return bRet;
+}
+
+
+XMLCrossedOutStylePropHdl::~XMLCrossedOutStylePropHdl()
+{
+ // nothing to do
+}
+
+bool XMLCrossedOutStylePropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_uInt16 eNewStrikeout(0);
+ bool bRet = SvXMLUnitConverter::convertEnum(
+ eNewStrikeout, rStrImpValue, pXML_CrossedoutStyle_Enum );
+ if( bRet )
+ {
+ // multi property: style and width might be set already.
+ // If the old value is NONE, the new is used unchanged.
+ sal_Int16 eStrikeout = sal_Int16();
+ if( (rValue >>= eStrikeout) && awt::FontStrikeout::NONE!=eStrikeout )
+ {
+ // one NONE a SINGLE are possible new values. For both, the
+ // existing value is kept.
+ }
+ else
+ {
+ rValue <<= static_cast<sal_Int16>(eNewStrikeout);
+ }
+ }
+
+ return bRet;
+}
+
+bool XMLCrossedOutStylePropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_uInt16 nValue = sal_uInt16();
+
+ if( rValue >>= nValue )
+ {
+ OUStringBuffer aOut;
+ bRet = SvXMLUnitConverter::convertEnum(
+ aOut, nValue, pXML_CrossedoutStyle_Enum );
+ if( bRet )
+ rStrExpValue = aOut.makeStringAndClear();
+ }
+
+ return bRet;
+}
+
+
+XMLCrossedOutWidthPropHdl::~XMLCrossedOutWidthPropHdl()
+{
+ // nothing to do
+}
+
+bool XMLCrossedOutWidthPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_uInt16 eNewStrikeout = 0;
+ bool bRet = SvXMLUnitConverter::convertEnum(
+ eNewStrikeout, rStrImpValue, pXML_CrossedoutWidth_Enum );
+ if( bRet )
+ {
+ // multi property: style and width might be set already.
+ // If the old value is NONE, the new is used unchanged.
+ sal_Int16 eStrikeout = sal_Int16();
+ if( (rValue >>= eStrikeout) && awt::FontStrikeout::NONE!=eStrikeout )
+ {
+ switch( eNewStrikeout )
+ {
+ case awt::FontStrikeout::NONE:
+ // keep existing line style
+ eNewStrikeout = eStrikeout;
+ break;
+ case awt::FontStrikeout::BOLD:
+ switch( eStrikeout )
+ {
+ case awt::FontStrikeout::SINGLE:
+ break;
+ default:
+ // If a double line style is not supported for the existing
+ // value, keep the new one
+ eNewStrikeout = eStrikeout;
+ break;
+ }
+ break;
+ default:
+ OSL_ENSURE( bRet, "unexpected line type value" );
+ break;
+ }
+ if( eNewStrikeout != eStrikeout )
+ rValue <<= static_cast<sal_Int16>(eNewStrikeout);
+ }
+ else
+ {
+ rValue <<= static_cast<sal_Int16>(eNewStrikeout);
+ }
+ }
+
+ return bRet;
+}
+
+bool XMLCrossedOutWidthPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_uInt16 nValue = sal_uInt16();
+
+ if( (rValue >>= nValue) && (awt::FontStrikeout::BOLD == nValue) )
+ {
+ OUStringBuffer aOut;
+ bRet = SvXMLUnitConverter::convertEnum(
+ aOut, nValue, pXML_CrossedoutWidth_Enum );
+ if( bRet )
+ rStrExpValue = aOut.makeStringAndClear();
+ }
+
+ return bRet;
+}
+
+
+XMLCrossedOutTextPropHdl::~XMLCrossedOutTextPropHdl()
+{
+ // nothing to do
+}
+
+bool XMLCrossedOutTextPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+
+ if( !rStrImpValue.isEmpty() )
+ {
+ sal_Int16 eStrikeout = ('/' == rStrImpValue[0]
+ ? awt::FontStrikeout::SLASH
+ : awt::FontStrikeout::X);
+ rValue <<= eStrikeout;
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+bool XMLCrossedOutTextPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_Int16 nValue = sal_Int16();
+
+ if( (rValue >>= nValue) &&
+ (awt::FontStrikeout::SLASH == nValue || awt::FontStrikeout::X == nValue) )
+ {
+ rStrExpValue = OUString(
+ static_cast< sal_Unicode>( awt::FontStrikeout::SLASH == nValue ? '/'
+ : 'X' ) );
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/cdouthdl.hxx b/xmloff/source/style/cdouthdl.hxx
new file mode 100644
index 000000000..70f9ddbba
--- /dev/null
+++ b/xmloff/source/style/cdouthdl.hxx
@@ -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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLCrossedOutTypePropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLCrossedOutTypePropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+class XMLCrossedOutStylePropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLCrossedOutStylePropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+class XMLCrossedOutWidthPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLCrossedOutWidthPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+class XMLCrossedOutTextPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLCrossedOutTextPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/chrhghdl.cxx b/xmloff/source/style/chrhghdl.cxx
new file mode 100644
index 000000000..5417800c6
--- /dev/null
+++ b/xmloff/source/style/chrhghdl.cxx
@@ -0,0 +1,150 @@
+/* -*- 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 "chrhghdl.hxx"
+
+#include <rtl/ustrbuf.hxx>
+
+#include <com/sun/star/uno/Any.hxx>
+
+#include <sax/tools/converter.hxx>
+
+#include <xmloff/xmluconv.hxx>
+
+using namespace ::com::sun::star;
+
+
+
+
+XMLCharHeightHdl::~XMLCharHeightHdl()
+{
+ // nothing to do
+}
+
+bool XMLCharHeightHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ if( rStrImpValue.indexOf( '%' ) == -1 )
+ {
+ double fSize;
+ sal_Int16 const eSrcUnit = ::sax::Converter::GetUnitFromString(
+ rStrImpValue, util::MeasureUnit::POINT );
+ if (::sax::Converter::convertDouble(fSize, rStrImpValue,
+ eSrcUnit, util::MeasureUnit::POINT))
+ {
+ fSize = ::std::max<double>(fSize, 1.0); // fdo#49876: 0pt is invalid
+ rValue <<= static_cast<float>(fSize);
+ return true;
+ }
+ }
+
+ return false;
+}
+
+bool XMLCharHeightHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ OUStringBuffer aOut;
+
+ float fSize = 0;
+ if( rValue >>= fSize )
+ {
+ fSize = ::std::max<float>(fSize, 1.0f); // fdo#49876: 0pt is invalid
+ ::sax::Converter::convertDouble(aOut, static_cast<double>(fSize), true,
+ util::MeasureUnit::POINT, util::MeasureUnit::POINT);
+ aOut.append( 'p');
+ aOut.append( 't');
+ }
+
+ rStrExpValue = aOut.makeStringAndClear();
+ return !rStrExpValue.isEmpty();
+}
+
+
+
+
+XMLCharHeightPropHdl::~XMLCharHeightPropHdl()
+{
+ // nothing to do
+}
+
+bool XMLCharHeightPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ if( rStrImpValue.indexOf( '%' ) != -1 )
+ {
+ sal_Int32 nPrc = 100;
+ if (::sax::Converter::convertPercent( nPrc, rStrImpValue ))
+ {
+ rValue <<= static_cast<sal_Int16>(nPrc);
+ return true;
+ }
+ }
+
+ return false;
+}
+
+bool XMLCharHeightPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ OUStringBuffer aOut( rStrExpValue );
+
+ sal_Int16 nValue = sal_Int16();
+ if( rValue >>= nValue )
+ {
+ ::sax::Converter::convertPercent( aOut, nValue );
+ }
+
+ rStrExpValue = aOut.makeStringAndClear();
+ return !rStrExpValue.isEmpty();
+}
+
+
+
+
+XMLCharHeightDiffHdl::~XMLCharHeightDiffHdl()
+{
+ // nothing to do
+}
+
+bool XMLCharHeightDiffHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_Int32 nRel = 0;
+
+ if (::sax::Converter::convertMeasure( nRel, rStrImpValue,
+ util::MeasureUnit::POINT ))
+ {
+ rValue <<= static_cast<float>(nRel);
+ return true;
+ }
+
+ return false;
+}
+
+bool XMLCharHeightDiffHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ float nRel = 0;
+ if( (rValue >>= nRel) && (nRel != 0) )
+ {
+ OUStringBuffer aOut;
+ ::sax::Converter::convertMeasure( aOut, static_cast<sal_Int32>(nRel),
+ util::MeasureUnit::POINT, util::MeasureUnit::POINT );
+ rStrExpValue = aOut.makeStringAndClear();
+ }
+
+ return !rStrExpValue.isEmpty();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/chrhghdl.hxx b/xmloff/source/style/chrhghdl.hxx
new file mode 100644
index 000000000..392ffab6f
--- /dev/null
+++ b/xmloff/source/style/chrhghdl.hxx
@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLCharHeightHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLCharHeightHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+class XMLCharHeightPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLCharHeightPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+class XMLCharHeightDiffHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLCharHeightDiffHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/chrlohdl.cxx b/xmloff/source/style/chrlohdl.cxx
new file mode 100644
index 000000000..05dd6d770
--- /dev/null
+++ b/xmloff/source/style/chrlohdl.cxx
@@ -0,0 +1,423 @@
+/* -*- 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 "chrlohdl.hxx"
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <unotools/saveopt.hxx>
+#include <i18nlangtag/languagetag.hxx>
+#include <sal/log.hxx>
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/lang/Locale.hpp>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+/* TODO-BCP47: this fiddling with Locale is quite ugly and fragile, especially
+ * for the fo:script temporarily stored in Variant, it would be better to use
+ * LanguageTagODF but we have that nasty UNO API requirement here.
+ * => make LanguageTagODF (unpublished) API? */
+
+// For runtime performance, instead of converting back and forth between
+// css::Locale and LanguageTag to decide if script or tag are
+// needed, this code takes advantage of knowledge about the internal
+// representation of BCP 47 language tags in a Locale if present as done in a
+// LanguageTag.
+
+XMLCharLanguageHdl::~XMLCharLanguageHdl()
+{
+ // nothing to do
+}
+
+bool XMLCharLanguageHdl::equals( const css::uno::Any& r1, const css::uno::Any& r2 ) const
+{
+ bool bRet = false;
+ lang::Locale aLocale1, aLocale2;
+
+ if( ( r1 >>= aLocale1 ) && ( r2 >>= aLocale2 ) )
+ {
+ bool bEmptyOrScriptVariant1 = (aLocale1.Variant.isEmpty() || aLocale1.Variant[0] == '-');
+ bool bEmptyOrScriptVariant2 = (aLocale2.Variant.isEmpty() || aLocale2.Variant[0] == '-');
+ if (bEmptyOrScriptVariant1 && bEmptyOrScriptVariant2)
+ bRet = ( aLocale1.Language == aLocale2.Language );
+ else
+ {
+ OUString aLanguage1, aLanguage2;
+ if (bEmptyOrScriptVariant1)
+ aLanguage1 = aLocale1.Language;
+ else
+ aLanguage1 = LanguageTag( aLocale1).getLanguage();
+ if (bEmptyOrScriptVariant2)
+ aLanguage2 = aLocale2.Language;
+ else
+ aLanguage2 = LanguageTag( aLocale2).getLanguage();
+ bRet = ( aLanguage1 == aLanguage2 );
+ }
+ }
+
+ return bRet;
+}
+
+bool XMLCharLanguageHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ lang::Locale aLocale;
+ rValue >>= aLocale;
+
+ if( !IsXMLToken(rStrImpValue, XML_NONE) )
+ {
+ if (aLocale.Variant.isEmpty())
+ aLocale.Language = rStrImpValue;
+ else
+ {
+ if (!aLocale.Language.isEmpty() || aLocale.Variant[0] != '-')
+ {
+ SAL_WARN_IF( aLocale.Language != I18NLANGTAG_QLT, "xmloff.style",
+ "XMLCharLanguageHdl::importXML - attempt to import language twice");
+ }
+ else
+ {
+ aLocale.Variant = rStrImpValue + aLocale.Variant;
+ if (!aLocale.Country.isEmpty())
+ aLocale.Variant += "-" + aLocale.Country;
+ aLocale.Language = I18NLANGTAG_QLT;
+ }
+ }
+ }
+
+ rValue <<= aLocale;
+ return true;
+}
+
+bool XMLCharLanguageHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ lang::Locale aLocale;
+ if(!(rValue >>= aLocale))
+ return false;
+
+ if (aLocale.Variant.isEmpty())
+ rStrExpValue = aLocale.Language;
+ else
+ {
+ LanguageTag aLanguageTag( aLocale);
+ OUString aScript, aCountry;
+ aLanguageTag.getIsoLanguageScriptCountry( rStrExpValue, aScript, aCountry);
+ // Do not write *:language='none' for a non-ISO language with
+ // *:rfc-language-tag that is written if Variant is not empty. If there
+ // is no match do not write this attribute at all.
+ if (rStrExpValue.isEmpty())
+ return false;
+ }
+
+ if( rStrExpValue.isEmpty() )
+ rStrExpValue = GetXMLToken( XML_NONE );
+
+ return true;
+}
+
+XMLCharScriptHdl::~XMLCharScriptHdl()
+{
+ // nothing to do
+}
+
+bool XMLCharScriptHdl::equals( const css::uno::Any& r1, const css::uno::Any& r2 ) const
+{
+ bool bRet = false;
+ lang::Locale aLocale1, aLocale2;
+
+ if( ( r1 >>= aLocale1 ) && ( r2 >>= aLocale2 ) )
+ {
+ bool bEmptyVariant1 = aLocale1.Variant.isEmpty();
+ bool bEmptyVariant2 = aLocale2.Variant.isEmpty();
+ if (bEmptyVariant1 && bEmptyVariant2)
+ bRet = true;
+ else if (bEmptyVariant1 != bEmptyVariant2)
+ ; // stays false
+ else
+ {
+ OUString aScript1, aScript2;
+ if (aLocale1.Variant[0] == '-')
+ aScript1 = aLocale1.Variant.copy(1);
+ else
+ aScript1 = LanguageTag( aLocale1).getScript();
+ if (aLocale2.Variant[0] == '-')
+ aScript2 = aLocale2.Variant.copy(1);
+ else
+ aScript2 = LanguageTag( aLocale2).getScript();
+ bRet = ( aScript1 == aScript2 );
+ }
+ }
+
+ return bRet;
+}
+
+bool XMLCharScriptHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ lang::Locale aLocale;
+ rValue >>= aLocale;
+
+ if( !IsXMLToken( rStrImpValue, XML_NONE ) )
+ {
+ // Import the script only if we don't have a full BCP 47 language tag
+ // in Variant yet.
+ if (aLocale.Variant.isEmpty())
+ {
+ if (aLocale.Language.isEmpty())
+ {
+ SAL_INFO( "xmloff.style", "XMLCharScriptHdl::importXML - script but no language yet");
+ // Temporarily store in Variant and hope the best (we will get
+ // a language later, yes?)
+ aLocale.Variant = "-" + rStrImpValue;
+ }
+ else
+ {
+ aLocale.Variant = aLocale.Language + "-" + rStrImpValue;
+ if (!aLocale.Country.isEmpty())
+ aLocale.Variant += "-" + aLocale.Country;
+ aLocale.Language = I18NLANGTAG_QLT;
+ }
+ }
+ else if (aLocale.Variant[0] == '-')
+ {
+ SAL_WARN( "xmloff.style", "XMLCharScriptHdl::importXML - attempt to insert script twice: "
+ << rStrImpValue << " -> " << aLocale.Variant);
+ }
+ else
+ {
+ // Assume that if there already is a script or anything else BCP 47
+ // it was read by XMLCharRfcLanguageTagHdl() and takes precedence.
+ // On the other hand, an *:rfc-language-tag without script and a
+ // *:script ?!?
+#if OSL_DEBUG_LEVEL > 0 || defined(DBG_UTIL)
+ LanguageTag aLanguageTag( aLocale);
+ if (!aLanguageTag.hasScript())
+ {
+ SAL_WARN( "xmloff.style", "XMLCharScriptHdl::importXML - attempt to insert script over bcp47: "
+ << rStrImpValue << " -> " << aLanguageTag.getBcp47());
+ }
+#endif
+ }
+ }
+
+ rValue <<= aLocale;
+ return true;
+}
+
+bool XMLCharScriptHdl::exportXML(OUString& rStrExpValue,
+ const uno::Any& rValue, const SvXMLUnitConverter& rUnitConv) const
+{
+ lang::Locale aLocale;
+ if(!(rValue >>= aLocale))
+ return false;
+
+ // Do not write script='none' for default script.
+
+ if (aLocale.Variant.isEmpty())
+ return false;
+
+ LanguageTag aLanguageTag( aLocale);
+ if (!aLanguageTag.hasScript())
+ return false;
+
+ if (rUnitConv.getSaneDefaultVersion() < SvtSaveOptions::ODFSVER_012)
+ return false;
+
+ OUString aLanguage, aCountry;
+ aLanguageTag.getIsoLanguageScriptCountry( aLanguage, rStrExpValue, aCountry);
+ // For non-ISO language it does not make sense to write *:script if
+ // *:language is not written either, does it? It's all in
+ // *:rfc-language-tag
+ return !aLanguage.isEmpty() && !rStrExpValue.isEmpty();
+}
+
+XMLCharCountryHdl::~XMLCharCountryHdl()
+{
+ // nothing to do
+}
+
+bool XMLCharCountryHdl::equals( const css::uno::Any& r1, const css::uno::Any& r2 ) const
+{
+ bool bRet = false;
+ lang::Locale aLocale1, aLocale2;
+
+ if( ( r1 >>= aLocale1 ) && ( r2 >>= aLocale2 ) )
+ bRet = ( aLocale1.Country == aLocale2.Country );
+
+ return bRet;
+}
+
+bool XMLCharCountryHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ lang::Locale aLocale;
+ rValue >>= aLocale;
+
+ if( !IsXMLToken( rStrImpValue, XML_NONE ) )
+ {
+ if (aLocale.Country.isEmpty())
+ {
+ aLocale.Country = rStrImpValue;
+ if (aLocale.Variant.getLength() >= 7 && aLocale.Language == I18NLANGTAG_QLT)
+ {
+ // already assembled language tag, at least ll-Ssss and not
+ // ll-CC or lll-CC
+ sal_Int32 i = aLocale.Variant.indexOf('-'); // separator to script
+ if (2 <= i && i < aLocale.Variant.getLength())
+ {
+ i = aLocale.Variant.indexOf( '-', i+1);
+ if (i < 0) // no other separator
+ aLocale.Variant += "-" + rStrImpValue; // append country
+ }
+ }
+ }
+ }
+
+ rValue <<= aLocale;
+ return true;
+}
+
+bool XMLCharCountryHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ lang::Locale aLocale;
+ if(!(rValue >>= aLocale))
+ return false;
+
+ if (aLocale.Variant.isEmpty())
+ rStrExpValue = aLocale.Country;
+ else
+ {
+ LanguageTag aLanguageTag( aLocale);
+ OUString aLanguage, aScript;
+ aLanguageTag.getIsoLanguageScriptCountry( aLanguage, aScript, rStrExpValue);
+ // Do not write *:country='none' for a non-ISO country with
+ // *:rfc-language-tag that is written if Variant is not empty. If there
+ // is no match do not write this attribute at all.
+ if (rStrExpValue.isEmpty())
+ return false;
+ }
+
+ if( rStrExpValue.isEmpty() )
+ rStrExpValue = GetXMLToken( XML_NONE );
+
+ return true;
+}
+
+XMLCharRfcLanguageTagHdl::~XMLCharRfcLanguageTagHdl()
+{
+ // nothing to do
+}
+
+bool XMLCharRfcLanguageTagHdl::equals( const css::uno::Any& r1, const css::uno::Any& r2 ) const
+{
+ bool bRet = false;
+ lang::Locale aLocale1, aLocale2;
+
+ if( ( r1 >>= aLocale1 ) && ( r2 >>= aLocale2 ) )
+ bRet = ( aLocale1.Variant == aLocale2.Variant );
+
+ return bRet;
+}
+
+bool XMLCharRfcLanguageTagHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ lang::Locale aLocale;
+ rValue >>= aLocale;
+
+ if( !IsXMLToken( rStrImpValue, XML_NONE ) )
+ {
+ // Stored may be a *:rfc-language-tag in violation of ODF v1.3
+ // 19.516 style:rfc-language-tag "It shall only be used if its value
+ // cannot be expressed as a valid combination of the fo:language
+ // 19.871, fo:script 19.242 and fo:country 19.234 attributes".
+ // That could override a more detailed fo:* and we also don't want an
+ // unjustified I18NLANGTAG_QLT extended locale tag, but fetch the
+ // values in case fo:* doesn't follow.
+ // Rule out the obvious.
+ if (rStrImpValue.getLength() < 7)
+ {
+ SAL_WARN("xmloff.style","rfc-language-tag too short: {" << rStrImpValue << "} Set: "
+ << aLocale.Language <<","<< aLocale.Country <<","<< aLocale.Variant);
+ // Ignore empty and keep Ssss or any earlier qlt already set.
+ if (!rStrImpValue.isEmpty() && aLocale.Language != I18NLANGTAG_QLT)
+ {
+ // Shorter than ll-Ssss, so try ll-CC or lll-CC or ll or lll
+ sal_Int32 h = rStrImpValue.indexOf('-');
+ OUString aLang;
+ if (2 <= h && h <= 3)
+ aLang = rStrImpValue.copy(0, h);
+ else if (h < 0 && 2 <= rStrImpValue.getLength() && rStrImpValue.getLength() <= 3)
+ aLang = rStrImpValue;
+ OUString aCoun;
+ if (!aLang.isEmpty() && aLang.getLength() + 3 == rStrImpValue.getLength())
+ aCoun = rStrImpValue.copy( aLang.getLength() + 1);
+ // Ignore identical value or less information.
+ if ((!aLang.isEmpty() && aLang != aLocale.Language) ||
+ (!aCoun.isEmpty() && aCoun != aLocale.Country))
+ {
+ // Do not override existing values.
+ if (aLocale.Language.isEmpty())
+ aLocale.Language = aLang;
+ if (aLocale.Country.isEmpty())
+ aLocale.Country = aCoun;
+ if (aLang != aLocale.Language || aCoun != aLocale.Country)
+ {
+ // No match, so we still need the qlt anyway. Whatever..
+ aLocale.Variant = rStrImpValue;
+ aLocale.Language = I18NLANGTAG_QLT;
+ }
+ }
+ else if (aLang.isEmpty() && aCoun.isEmpty())
+ {
+ // Both empty, some other tag.
+ aLocale.Variant = rStrImpValue;
+ aLocale.Language = I18NLANGTAG_QLT;
+ }
+ }
+ SAL_WARN("xmloff.style","rfc-language-tag too short: now set: "
+ << aLocale.Language <<","<< aLocale.Country <<","<< aLocale.Variant);
+ }
+ else
+ {
+ aLocale.Variant = rStrImpValue;
+ aLocale.Language = I18NLANGTAG_QLT;
+ }
+ }
+
+ rValue <<= aLocale;
+ return true;
+}
+
+bool XMLCharRfcLanguageTagHdl::exportXML(OUString& rStrExpValue,
+ const uno::Any& rValue, const SvXMLUnitConverter& rUnitConv) const
+{
+ lang::Locale aLocale;
+ if(!(rValue >>= aLocale))
+ return false;
+
+ // Do not write rfc-language-tag='none' if BCP 47 is not needed.
+ if (aLocale.Variant.isEmpty())
+ return false;
+
+ if (rUnitConv.getSaneDefaultVersion() < SvtSaveOptions::ODFSVER_012)
+ return false;
+
+ rStrExpValue = aLocale.Variant;
+
+ return true;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/chrlohdl.hxx b/xmloff/source/style/chrlohdl.hxx
new file mode 100644
index 000000000..a6e710b26
--- /dev/null
+++ b/xmloff/source/style/chrlohdl.hxx
@@ -0,0 +1,71 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLCharLanguageHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLCharLanguageHdl() override;
+
+ virtual bool equals( const css::uno::Any& r1, const css::uno::Any& r2 ) const override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+class XMLCharScriptHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLCharScriptHdl() override;
+
+ virtual bool equals( const css::uno::Any& r1, const css::uno::Any& r2 ) const override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+class XMLCharCountryHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLCharCountryHdl() override;
+
+ virtual bool equals( const css::uno::Any& r1, const css::uno::Any& r2 ) const override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+class XMLCharRfcLanguageTagHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLCharRfcLanguageTagHdl() override;
+
+ virtual bool equals( const css::uno::Any& r1, const css::uno::Any& r2 ) const override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/csmaphdl.cxx b/xmloff/source/style/csmaphdl.cxx
new file mode 100644
index 000000000..4e760a6c9
--- /dev/null
+++ b/xmloff/source/style/csmaphdl.cxx
@@ -0,0 +1,120 @@
+/* -*- 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 "csmaphdl.hxx"
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlement.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <com/sun/star/style/CaseMap.hpp>
+#include <com/sun/star/uno/Any.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+const SvXMLEnumMapEntry<sal_uInt16> pXML_Casemap_Enum[] =
+{
+ { XML_NONE, style::CaseMap::NONE },
+ { XML_CASEMAP_LOWERCASE, style::CaseMap::LOWERCASE },
+ { XML_CASEMAP_UPPERCASE, style::CaseMap::UPPERCASE },
+ { XML_CASEMAP_CAPITALIZE, style::CaseMap::TITLE },
+ { XML_TOKEN_INVALID, 0 }
+};
+
+
+XMLCaseMapPropHdl::~XMLCaseMapPropHdl()
+{
+ // nothing to do
+}
+
+bool XMLCaseMapPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_uInt16 nVal;
+ bool bRet = SvXMLUnitConverter::convertEnum(
+ nVal, rStrImpValue, pXML_Casemap_Enum );
+ if( bRet )
+ rValue <<= nVal;
+
+ return bRet;
+}
+
+bool XMLCaseMapPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_uInt16 nValue = sal_uInt16();
+
+ if( rValue >>= nValue )
+ {
+ OUStringBuffer aOut;
+ bRet = SvXMLUnitConverter::convertEnum(
+ aOut, nValue, pXML_Casemap_Enum );
+ if( bRet )
+ rStrExpValue = aOut.makeStringAndClear();
+ }
+
+ return bRet;
+}
+
+
+XMLCaseMapVariantHdl::~XMLCaseMapVariantHdl()
+{
+ // nothing to do
+}
+
+bool XMLCaseMapVariantHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+
+ if( IsXMLToken( rStrImpValue, XML_CASEMAP_SMALL_CAPS ) )
+ {
+ rValue <<= sal_Int16(style::CaseMap::SMALLCAPS);
+ bRet = true;
+ }
+ else if( IsXMLToken( rStrImpValue, XML_NORMAL ) )
+ {
+ rValue <<= sal_Int16(style::CaseMap::NONE);
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+bool XMLCaseMapVariantHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_uInt16 nValue = sal_uInt16();
+ OUStringBuffer aOut;
+
+ if( rValue >>= nValue )
+ {
+ switch( nValue )
+ {
+ case style::CaseMap::NONE:
+ aOut.append( GetXMLToken(XML_NORMAL) );
+ break;
+ case style::CaseMap::SMALLCAPS:
+ aOut.append( GetXMLToken(XML_CASEMAP_SMALL_CAPS) );
+ break;
+ }
+ }
+
+ rStrExpValue = aOut.makeStringAndClear();
+ return !rStrExpValue.isEmpty();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/csmaphdl.hxx b/xmloff/source/style/csmaphdl.hxx
new file mode 100644
index 000000000..1d80d676a
--- /dev/null
+++ b/xmloff/source/style/csmaphdl.hxx
@@ -0,0 +1,45 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLCaseMapPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLCaseMapPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+class XMLCaseMapVariantHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLCaseMapVariantHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/durationhdl.cxx b/xmloff/source/style/durationhdl.cxx
new file mode 100644
index 000000000..a58181027
--- /dev/null
+++ b/xmloff/source/style/durationhdl.cxx
@@ -0,0 +1,71 @@
+/* -*- 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 "durationhdl.hxx"
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/util/Duration.hpp>
+#include <rtl/ustrbuf.hxx>
+#include <sax/tools/converter.hxx>
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::util;
+
+bool XMLDurationMS16PropHdl_Impl::importXML(
+ const OUString& rStrImpValue,
+ Any& rValue,
+ const SvXMLUnitConverter& ) const
+{
+ Duration aDuration;
+ if (!::sax::Converter::convertDuration( aDuration, rStrImpValue ))
+ return false;
+
+ // TODO FIXME why is this in centiseconds? Should it be nanoseconds?
+ // This overflows... 24h == 8640000cs >> 0x7FFF cs == 32767
+ // 32767cs = approx 5 minutes and 27.67s
+ const sal_Int16 nMS = ((aDuration.Hours * 60 + aDuration.Minutes) * 60
+ + aDuration.Seconds) * 100 + (aDuration.NanoSeconds / (10*1000*1000));
+ rValue <<= nMS;
+
+ return true;
+}
+
+bool XMLDurationMS16PropHdl_Impl::exportXML(
+ OUString& rStrExpValue,
+ const Any& rValue,
+ const SvXMLUnitConverter& ) const
+{
+ sal_Int16 nMS = sal_Int16();
+
+ if(rValue >>= nMS)
+ {
+ OUStringBuffer aOut;
+ Duration aDuration(false, 0, 0, 0, 0, 0, 0, nMS * 10);
+ ::sax::Converter::convertDuration(aOut, aDuration);
+ rStrExpValue = aOut.makeStringAndClear();
+ return true;
+ }
+
+ return false;
+}
+
+XMLDurationMS16PropHdl_Impl::~XMLDurationMS16PropHdl_Impl()
+{
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/durationhdl.hxx b/xmloff/source/style/durationhdl.hxx
new file mode 100644
index 000000000..de5193f60
--- /dev/null
+++ b/xmloff/source/style/durationhdl.hxx
@@ -0,0 +1,36 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+ PropertyHandler for a sal_int16 duration in ms:
+*/
+class XMLDurationMS16PropHdl_Impl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLDurationMS16PropHdl_Impl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/escphdl.cxx b/xmloff/source/style/escphdl.cxx
new file mode 100644
index 000000000..8148fb69a
--- /dev/null
+++ b/xmloff/source/style/escphdl.cxx
@@ -0,0 +1,156 @@
+/* -*- 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 "escphdl.hxx"
+
+#include <editeng/escapementitem.hxx>
+#include <sax/tools/converter.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <com/sun/star/uno/Any.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+
+
+
+XMLEscapementPropHdl::~XMLEscapementPropHdl()
+{
+ // nothing to do
+}
+
+bool XMLEscapementPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_Int16 nVal;
+
+ SvXMLTokenEnumerator aTokens( rStrImpValue );
+
+ std::u16string_view aToken;
+ if( ! aTokens.getNextToken( aToken ) )
+ return false;
+
+ if( IsXMLToken( aToken, XML_ESCAPEMENT_SUB ) )
+ {
+ nVal = DFLT_ESC_AUTO_SUB;
+ }
+ else if( IsXMLToken( aToken, XML_ESCAPEMENT_SUPER ) )
+ {
+ nVal = DFLT_ESC_AUTO_SUPER;
+ }
+ else
+ {
+ sal_Int32 nNewEsc;
+ if (!::sax::Converter::convertPercent( nNewEsc, aToken ))
+ return false;
+
+ nVal = static_cast<sal_Int16>(nNewEsc);
+ }
+
+ rValue <<= nVal;
+ return true;
+}
+
+bool XMLEscapementPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_Int32 nValue = 0;
+ OUStringBuffer aOut;
+
+ if( rValue >>= nValue )
+ {
+ if( nValue == DFLT_ESC_AUTO_SUPER )
+ {
+ aOut.append( GetXMLToken(XML_ESCAPEMENT_SUPER) );
+ }
+ else if( nValue == DFLT_ESC_AUTO_SUB )
+ {
+ aOut.append( GetXMLToken(XML_ESCAPEMENT_SUB) );
+ }
+ else
+ {
+ ::sax::Converter::convertPercent( aOut, nValue );
+ }
+ }
+
+ rStrExpValue = aOut.makeStringAndClear();
+ return !rStrExpValue.isEmpty();
+}
+
+
+
+
+XMLEscapementHeightPropHdl::~XMLEscapementHeightPropHdl()
+{
+ // nothing to do
+}
+
+bool XMLEscapementHeightPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ if( IsXMLToken( rStrImpValue, XML_CASEMAP_SMALL_CAPS ) )
+ return false;
+
+ SvXMLTokenEnumerator aTokens( rStrImpValue );
+
+ std::u16string_view aToken;
+ if( ! aTokens.getNextToken( aToken ) )
+ return false;
+
+ sal_Int8 nProp;
+ if( aTokens.getNextToken( aToken ) )
+ {
+ sal_Int32 nNewProp;
+ if (!::sax::Converter::convertPercent( nNewProp, aToken ))
+ return false;
+ nProp = static_cast<sal_Int8>(nNewProp);
+ }
+ else
+ {
+ sal_Int32 nEscapementPosition=0;
+ if (::sax::Converter::convertPercent( nEscapementPosition, aToken )
+ && (nEscapementPosition == 0))
+ {
+ nProp = 100; //if escapement position is zero and no escapement height is given the default height should be 100percent and not something smaller (#i91800#)
+ }
+ else
+ nProp = sal_Int8(DFLT_ESC_PROP);
+ }
+
+ rValue <<= nProp;
+ return true;
+}
+
+bool XMLEscapementHeightPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ OUStringBuffer aOut( rStrExpValue );
+
+ sal_Int32 nValue = 0;
+ if( rValue >>= nValue )
+ {
+ if( !rStrExpValue.isEmpty() )
+ aOut.append( ' ');
+
+ ::sax::Converter::convertPercent( aOut, nValue );
+ }
+
+ rStrExpValue = aOut.makeStringAndClear();
+ return !rStrExpValue.isEmpty();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/escphdl.hxx b/xmloff/source/style/escphdl.hxx
new file mode 100644
index 000000000..d52e20f71
--- /dev/null
+++ b/xmloff/source/style/escphdl.hxx
@@ -0,0 +1,45 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLEscapementPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLEscapementPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+class XMLEscapementHeightPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLEscapementHeightPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/fonthdl.cxx b/xmloff/source/style/fonthdl.cxx
new file mode 100644
index 000000000..144de999c
--- /dev/null
+++ b/xmloff/source/style/fonthdl.cxx
@@ -0,0 +1,291 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <string_view>
+
+#include "fonthdl.hxx"
+
+#include <sax/tools/converter.hxx>
+
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlement.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <com/sun/star/uno/Any.hxx>
+#include <tools/fontenum.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+static const SvXMLEnumMapEntry<FontFamily>* lcl_getFontFamilyGenericMapping()
+{
+ static SvXMLEnumMapEntry<FontFamily> const aFontFamilyGenericMapping[] =
+ {
+ { XML_DECORATIVE, FAMILY_DECORATIVE },
+
+ { XML_MODERN, FAMILY_MODERN },
+ { XML_ROMAN, FAMILY_ROMAN },
+ { XML_SCRIPT, FAMILY_SCRIPT },
+ { XML_SWISS, FAMILY_SWISS },
+ { XML_SYSTEM, FAMILY_SYSTEM },
+ { XML_TOKEN_INVALID, FontFamily(0) }
+ };
+ return aFontFamilyGenericMapping;
+}
+
+SvXMLEnumMapEntry<FontPitch> const aFontPitchMapping[] =
+{
+ { XML_FIXED, PITCH_FIXED },
+ { XML_VARIABLE, PITCH_VARIABLE },
+ { XML_TOKEN_INVALID, FontPitch(0) }
+};
+
+
+XMLFontFamilyNamePropHdl::~XMLFontFamilyNamePropHdl()
+{
+ // Nothing to do
+}
+
+bool XMLFontFamilyNamePropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ OUStringBuffer sValue;
+ sal_Int32 nPos = 0;
+
+ do
+ {
+ sal_Int32 nFirst = nPos;
+ nPos = ::sax::Converter::indexOfComma( rStrImpValue, nPos );
+ sal_Int32 nLast = (-1 == nPos ? rStrImpValue.getLength() - 1 : nPos - 1);
+
+ // skip trailing blanks
+ while( nLast > nFirst && ' ' == rStrImpValue[nLast] )
+ nLast--;
+
+ // skip leading blanks
+ while(nFirst <= nLast && ' ' == rStrImpValue[nFirst])
+ nFirst++;
+
+ // remove quotes
+ sal_Unicode c = nFirst > nLast ? 0 : rStrImpValue[nFirst];
+ if( nFirst < nLast && ('\'' == c || '\"' == c) && rStrImpValue[nLast] == c )
+ {
+ nFirst++;
+ nLast--;
+ }
+
+ if( nFirst <= nLast )
+ {
+ if( !sValue.isEmpty() )
+ sValue.append(';');
+
+ sValue.append(rStrImpValue.subView(nFirst, nLast-nFirst+1));
+ }
+
+ if( -1 != nPos )
+ nPos++;
+ }
+ while( -1 != nPos );
+
+ if (!sValue.isEmpty())
+ {
+ rValue <<= sValue.makeStringAndClear();
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+bool XMLFontFamilyNamePropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ OUString aStrFamilyName;
+
+ if( rValue >>= aStrFamilyName )
+ {
+ OUStringBuffer sValue( aStrFamilyName.getLength() + 2 );
+ sal_Int32 nPos = 0;
+ do
+ {
+ sal_Int32 nFirst = nPos;
+ nPos = aStrFamilyName.indexOf( ';', nPos );
+ sal_Int32 nLast = (-1 == nPos ? aStrFamilyName.getLength() : nPos);
+
+ // Set position to the character behind the ';', so we won't
+ // forget this.
+ if( -1 != nPos )
+ nPos++;
+
+ // If the property value was empty, we stop now.
+ // If there is a ';' at the first position, the empty name
+ // at the start will be removed.
+ if( 0 == nLast )
+ continue;
+
+ // nFirst and nLast now denote the first and last character of
+ // one font name.
+ nLast--;
+
+ // skip trailing blanks
+ while( nLast > nFirst && ' ' == aStrFamilyName[nLast] )
+ nLast--;
+
+ // skip leading blanks
+ while( nFirst <= nLast && ' ' == aStrFamilyName[nFirst] )
+ nFirst++;
+
+ if( nFirst <= nLast )
+ {
+ if( !sValue.isEmpty() )
+ {
+ sValue.append( ',' );
+ sValue.append( ' ' );
+ }
+ sal_Int32 nLen = nLast-nFirst+1;
+ OUString sFamily( aStrFamilyName.copy( nFirst, nLen ) );
+ bool bQuote = false;
+ for( sal_Int32 i=0; i < nLen; i++ )
+ {
+ sal_Unicode c = sFamily[i];
+ if( ' ' == c || ',' == c )
+ {
+ bQuote = true;
+ break;
+ }
+ }
+ if( bQuote )
+ sValue.append( '\'' );
+ sValue.append( sFamily );
+ if( bQuote )
+ sValue.append( '\'' );
+ }
+ }
+ while( -1 != nPos );
+
+ rStrExpValue = sValue.makeStringAndClear();
+
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+
+XMLFontFamilyPropHdl::~XMLFontFamilyPropHdl()
+{
+ // Nothing to do
+}
+
+bool XMLFontFamilyPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ FontFamily eNewFamily;
+ bool bRet = SvXMLUnitConverter::convertEnum( eNewFamily, rStrImpValue, lcl_getFontFamilyGenericMapping() );
+ if( bRet )
+ rValue <<= static_cast<sal_Int16>(eNewFamily);
+
+ return bRet;
+}
+
+bool XMLFontFamilyPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ OUStringBuffer aOut;
+
+ sal_Int16 nFamily = sal_Int16();
+ if( rValue >>= nFamily )
+ {
+ FontFamily eFamily = static_cast<FontFamily>(nFamily);
+ if( eFamily != FAMILY_DONTKNOW )
+ bRet = SvXMLUnitConverter::convertEnum( aOut, eFamily, lcl_getFontFamilyGenericMapping() );
+ }
+
+ rStrExpValue = aOut.makeStringAndClear();
+
+ return bRet;
+}
+
+
+XMLFontEncodingPropHdl::~XMLFontEncodingPropHdl()
+{
+ // Nothing to do
+}
+
+bool XMLFontEncodingPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ if( IsXMLToken( rStrImpValue, XML_X_SYMBOL ) )
+ rValue <<= sal_Int16(RTL_TEXTENCODING_SYMBOL);
+
+ return true;
+}
+
+bool XMLFontEncodingPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_Int16 nSet = sal_Int16();
+
+ if( rValue >>= nSet )
+ {
+ if( static_cast<rtl_TextEncoding>(nSet) == RTL_TEXTENCODING_SYMBOL )
+ {
+ rStrExpValue = GetXMLToken(XML_X_SYMBOL);
+ bRet = true;
+ }
+ }
+
+ return bRet;
+}
+
+
+XMLFontPitchPropHdl::~XMLFontPitchPropHdl()
+{
+ // Nothing to do
+}
+
+bool XMLFontPitchPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ FontPitch eNewPitch;
+ bool bRet = SvXMLUnitConverter::convertEnum( eNewPitch, rStrImpValue, aFontPitchMapping );
+ if( bRet )
+ rValue <<= static_cast<sal_Int16>(eNewPitch);
+
+ return bRet;
+}
+
+bool XMLFontPitchPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_Int16 nPitch = sal_Int16();
+
+ FontPitch ePitch = PITCH_DONTKNOW;
+ if( rValue >>= nPitch )
+ ePitch = static_cast<FontPitch>(nPitch);
+
+ if( PITCH_DONTKNOW != ePitch )
+ {
+ OUStringBuffer aOut;
+ bRet = SvXMLUnitConverter::convertEnum( aOut, ePitch, aFontPitchMapping, XML_FIXED );
+ rStrExpValue = aOut.makeStringAndClear();
+ }
+
+ return bRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/fonthdl.hxx b/xmloff/source/style/fonthdl.hxx
new file mode 100644
index 000000000..970cbc273
--- /dev/null
+++ b/xmloff/source/style/fonthdl.hxx
@@ -0,0 +1,73 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLFontFamilyNamePropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLFontFamilyNamePropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLFontFamilyPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLFontFamilyPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLFontEncodingPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLFontEncodingPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLFontPitchPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLFontPitchPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/impastpl.cxx b/xmloff/source/style/impastpl.cxx
new file mode 100644
index 000000000..42565e08c
--- /dev/null
+++ b/xmloff/source/style/impastpl.cxx
@@ -0,0 +1,716 @@
+/* -*- 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 <algorithm>
+
+#include <rtl/ustrbuf.hxx>
+#include <sal/log.hxx>
+#include <tools/solar.h>
+#include <PageMasterStyleMap.hxx>
+#include <xmloff/families.hxx>
+#include <xmloff/xmlaustp.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/xmlexppr.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmlprmap.hxx>
+#include <xmloff/xmltoken.hxx>
+
+#include "impastpl.hxx"
+
+using namespace ::std;
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+// Class XMLAutoStyleFamily
+// ctor/dtor class XMLAutoStyleFamily
+
+XMLAutoStyleFamily::XMLAutoStyleFamily(
+ XmlStyleFamily nFamily,
+ const OUString& rStrName,
+ const rtl::Reference < SvXMLExportPropertyMapper > &rMapper,
+ const OUString& rStrPrefix,
+ bool bAsFamily ) :
+ mnFamily( nFamily ), maStrFamilyName( rStrName), mxMapper( rMapper ),
+ mnCount( 0 ), mnName( 0 ), maStrPrefix( rStrPrefix ), mbAsFamily( bAsFamily )
+{}
+
+XMLAutoStyleFamily::XMLAutoStyleFamily( XmlStyleFamily nFamily ) :
+ mnFamily(nFamily), mnCount(0), mnName(0), mbAsFamily(false) {}
+
+void XMLAutoStyleFamily::ClearEntries()
+{
+ m_ParentSet.clear();
+}
+
+static OUString
+data2string(void *data,
+ const typelib_TypeDescriptionReference *type);
+
+static OUString
+struct2string(void *data,
+ const typelib_TypeDescription *type)
+{
+ assert(type->eTypeClass == typelib_TypeClass_STRUCT);
+
+ OUStringBuffer result;
+
+ result.append("{");
+
+ const typelib_CompoundTypeDescription *compoundType =
+ &reinterpret_cast<const typelib_StructTypeDescription*>(type)->aBase;
+
+ for (int i = 0; i < compoundType->nMembers; i++)
+ {
+ if (i > 0)
+ result.append(":");
+ result.append(compoundType->ppMemberNames[i]);
+ result.append("=");
+ result.append(data2string(static_cast<char *>(data)+compoundType->pMemberOffsets[i],
+ compoundType->ppTypeRefs[i]));
+ }
+
+ result.append("}");
+
+ return result.makeStringAndClear();
+}
+
+static OUString
+data2string(void *data,
+ const typelib_TypeDescriptionReference *type)
+{
+ switch (type->eTypeClass)
+ {
+ case typelib_TypeClass_VOID:
+ return "";
+ case typelib_TypeClass_BOOLEAN:
+ return *static_cast<const sal_Bool*>(data) ? OUString("true") : OUString("false");
+ case typelib_TypeClass_BYTE:
+ return OUString::number(*static_cast<const sal_Int8*>(data));
+ case typelib_TypeClass_SHORT:
+ return OUString::number(*static_cast<const sal_Int16*>(data));
+ case typelib_TypeClass_LONG:
+ return OUString::number(*static_cast<const sal_Int32*>(data));
+ case typelib_TypeClass_HYPER:
+ return OUString::number(*static_cast<const sal_Int64*>(data));
+ case typelib_TypeClass_UNSIGNED_SHORT:
+ return OUString::number(*static_cast<const sal_uInt16*>(data));
+ case typelib_TypeClass_UNSIGNED_LONG:
+ return OUString::number((*static_cast<const sal_uInt32*>(data)), 16);
+ case typelib_TypeClass_UNSIGNED_HYPER:
+ return OUString::number((*static_cast<const sal_uInt64*>(data)), 16);
+ case typelib_TypeClass_FLOAT:
+ return OUString::number(*static_cast<const float*>(data));
+ case typelib_TypeClass_DOUBLE:
+ return OUString::number(*static_cast<const double*>(data));
+ case typelib_TypeClass_CHAR:
+ return ("U+" + OUString::number(*static_cast<const sal_uInt16*>(data)));
+ case typelib_TypeClass_STRING:
+ return *static_cast<OUString*>(data);
+ case typelib_TypeClass_TYPE:
+ case typelib_TypeClass_SEQUENCE:
+ case typelib_TypeClass_EXCEPTION:
+ case typelib_TypeClass_INTERFACE:
+ return "wtf";
+ case typelib_TypeClass_STRUCT:
+ return struct2string(data, type->pType);
+ case typelib_TypeClass_ENUM:
+ return OUString::number(*static_cast<const sal_Int32*>(data));
+ default:
+ assert(false); // this cannot happen I hope
+ break;
+ }
+ return "";
+}
+
+static OUString any2string(const uno::Any& any)
+{
+ return data2string(const_cast<void*>(any.getValue()), any.pType);
+}
+
+// Class SvXMLAutoStylePoolProperties_Impl
+// ctor class SvXMLAutoStylePoolProperties_Impl
+
+XMLAutoStylePoolProperties::XMLAutoStylePoolProperties( XMLAutoStyleFamily& rFamilyData, vector< XMLPropertyState >&& rProperties, OUString const & rParentName )
+: maProperties( std::move(rProperties) ),
+ mnPos ( rFamilyData.mnCount )
+{
+ static bool bHack = (getenv("LIBO_ONEWAY_STABLE_ODF_EXPORT") != nullptr);
+
+ if (bHack)
+ {
+ OUStringBuffer aStemBuffer(32);
+ aStemBuffer.append( rFamilyData.maStrPrefix );
+
+ if (!rParentName.isEmpty())
+ {
+ aStemBuffer.append("-");
+ aStemBuffer.append(rParentName);
+ }
+
+ // Create a name based on the properties used
+ for(XMLPropertyState const & rState : maProperties)
+ {
+ if (rState.mnIndex == -1)
+ continue;
+ OUString sXMLName(rFamilyData.mxMapper->getPropertySetMapper()->GetEntryXMLName(rState.mnIndex));
+ if (sXMLName.isEmpty())
+ continue;
+ aStemBuffer.append("-");
+ aStemBuffer.append(static_cast<sal_Int32>(rFamilyData.mxMapper->getPropertySetMapper()->GetEntryNameSpace(rState.mnIndex)));
+ aStemBuffer.append(":");
+ aStemBuffer.append(sXMLName);
+ aStemBuffer.append("=");
+ aStemBuffer.append(any2string(rState.maValue));
+ }
+
+#if 0
+ // Finally append an incremental counter in an attempt to make identical
+ // styles always come out in the same order. Will see if this works.
+ aStemBuffer.append("-z");
+ static sal_Int32 nCounter = 0;
+ aStemBuffer.append(nCounter++));
+#endif
+
+ // create a name that hasn't been used before. The created name has not
+ // to be added to the array, because it will never tried again
+ OUStringBuffer aTry( aStemBuffer );
+
+ msName = aTry.makeStringAndClear();
+ bool bWarned = false;
+ while (rFamilyData.maNameSet.find(msName) !=
+ rFamilyData.maNameSet.end())
+ {
+ if (!bWarned)
+ SAL_WARN("xmloff", "Overlapping style name for " << msName);
+ bWarned = true;
+ rFamilyData.mnName++;
+ aTry.append( aStemBuffer );
+ aTry.append( "-" );
+ aTry.append( static_cast<sal_Int64>(rFamilyData.mnName) );
+ msName = aTry.makeStringAndClear();
+ }
+ rFamilyData.maNameSet.insert(msName);
+ }
+ else
+ {
+ // create a name that hasn't been used before. The created name has not
+ // to be added to the array, because it will never tried again
+ OUStringBuffer sBuffer( 7 );
+ do
+ {
+ rFamilyData.mnName++;
+ sBuffer.append( rFamilyData.maStrPrefix );
+ sBuffer.append( static_cast<sal_Int64>(rFamilyData.mnName) );
+ msName = sBuffer.makeStringAndClear();
+ }
+ while (rFamilyData.maNameSet.find(msName) != rFamilyData.maNameSet.end() || rFamilyData.maReservedNameSet.find(msName) != rFamilyData.maReservedNameSet.end());
+ }
+
+#if OSL_DEBUG_LEVEL > 0
+ std::set<sal_Int32> DebugProperties;
+ for (XMLPropertyState const & rPropState : maProperties)
+ {
+ sal_Int32 const property(rPropState.mnIndex);
+ // serious bug: will cause duplicate attributes to be exported
+ assert(DebugProperties.find(property) == DebugProperties.end());
+ if (-1 != property)
+ {
+ DebugProperties.insert(property);
+ }
+ }
+#endif
+}
+
+bool operator<( const XMLAutoStyleFamily& r1, const XMLAutoStyleFamily& r2)
+{
+ return r1.mnFamily < r2.mnFamily;
+}
+
+
+XMLAutoStylePoolParent::~XMLAutoStylePoolParent()
+{
+}
+
+namespace {
+
+struct ComparePartial
+{
+ const XMLAutoStyleFamily& rFamilyData;
+
+ bool operator()(const vector< XMLPropertyState >& lhs,
+ const std::unique_ptr<XMLAutoStylePoolProperties>& rhs) const
+ {
+ return rFamilyData.mxMapper->LessPartial(lhs, rhs->GetProperties());
+ }
+ bool operator()(const std::unique_ptr<XMLAutoStylePoolProperties>& lhs,
+ const vector< XMLPropertyState >& rhs ) const
+ {
+ return rFamilyData.mxMapper->LessPartial(lhs->GetProperties(), rhs);
+ }
+};
+
+}
+
+// Adds an array of XMLPropertyState ( vector< XMLPropertyState > ) to list
+// if not added, yet.
+
+bool XMLAutoStylePoolParent::Add( XMLAutoStyleFamily& rFamilyData, vector< XMLPropertyState >&& rProperties, OUString& rName, bool bDontSeek )
+{
+ XMLAutoStylePoolProperties *pProperties = nullptr;
+ auto [itBegin, itEnd] = std::equal_range(m_PropertiesList.begin(), m_PropertiesList.end(), rProperties, ComparePartial{rFamilyData});
+ if (!bDontSeek)
+ for (auto it = itBegin; it != itEnd; ++it)
+ if (rFamilyData.mxMapper->Equals((*it)->GetProperties(), rProperties))
+ pProperties = it->get();
+
+ bool bAdded = false;
+ if( bDontSeek || !pProperties )
+ {
+ pProperties = new XMLAutoStylePoolProperties( rFamilyData, std::move(rProperties), msParent );
+ m_PropertiesList.insert(itBegin, std::unique_ptr<XMLAutoStylePoolProperties>(pProperties));
+ bAdded = true;
+ }
+
+ rName = pProperties->GetName();
+
+ return bAdded;
+}
+
+
+// Adds an array of XMLPropertyState ( vector< XMLPropertyState > ) with a given name.
+// If the name exists already, nothing is done. If a style with a different name and
+// the same properties exists, a new one is added (like with bDontSeek).
+
+
+bool XMLAutoStylePoolParent::AddNamed( XMLAutoStyleFamily& rFamilyData, vector< XMLPropertyState >&& rProperties, const OUString& rName )
+{
+ if (rFamilyData.maNameSet.find(rName) != rFamilyData.maNameSet.end())
+ return false;
+
+ auto it = std::lower_bound(m_PropertiesList.begin(), m_PropertiesList.end(), rProperties, ComparePartial{rFamilyData});
+
+ std::unique_ptr<XMLAutoStylePoolProperties> pProperties(
+ new XMLAutoStylePoolProperties(rFamilyData, std::move(rProperties), msParent));
+ // ignore the generated name
+ pProperties->SetName( rName );
+ m_PropertiesList.insert(it, std::move(pProperties));
+ return true;
+}
+
+
+// Search for an array of XMLPropertyState ( vector< XMLPropertyState > ) in list
+
+
+OUString XMLAutoStylePoolParent::Find( const XMLAutoStyleFamily& rFamilyData, const vector< XMLPropertyState >& rProperties ) const
+{
+ OUString sName;
+ auto [itBegin,itEnd] = std::equal_range(m_PropertiesList.begin(), m_PropertiesList.end(), rProperties, ComparePartial{rFamilyData});
+ for (auto it = itBegin; it != itEnd; ++it)
+ if (rFamilyData.mxMapper->Equals((*it)->GetProperties(), rProperties))
+ sName = (*it)->GetName();
+
+ return sName;
+}
+
+bool XMLAutoStylePoolParent::operator< (const XMLAutoStylePoolParent& rOther) const
+{
+ return msParent < rOther.msParent;
+}
+
+// Class SvXMLAutoStylePool_Impl
+// ctor/dtor class SvXMLAutoStylePool_Impl
+
+SvXMLAutoStylePoolP_Impl::SvXMLAutoStylePoolP_Impl( SvXMLExport& rExp)
+ : rExport( rExp )
+{
+}
+
+SvXMLAutoStylePoolP_Impl::~SvXMLAutoStylePoolP_Impl()
+{
+}
+
+// Adds stylefamily-information to sorted list
+
+void SvXMLAutoStylePoolP_Impl::AddFamily(
+ XmlStyleFamily nFamily,
+ const OUString& rStrName,
+ const rtl::Reference < SvXMLExportPropertyMapper > & rMapper,
+ const OUString& rStrPrefix,
+ bool bAsFamily )
+{
+ // store family in a list if not already stored
+ SvXMLExportFlags nExportFlags = GetExport().getExportFlags();
+ bool bStylesOnly = (nExportFlags & SvXMLExportFlags::STYLES) && !(nExportFlags & SvXMLExportFlags::CONTENT);
+
+ OUString aPrefix( rStrPrefix );
+ if( bStylesOnly )
+ {
+ aPrefix = "M" + rStrPrefix;
+ }
+
+#if OSL_DEBUG_LEVEL > 0
+ XMLAutoStyleFamily aTemp(nFamily);
+ auto const iter = m_FamilySet.find(aTemp);
+ if (iter != m_FamilySet.end())
+ {
+ // FIXME: do we really intend to replace the previous nFamily
+ // entry in this case ?
+ SAL_WARN_IF( (*iter)->mxMapper != rMapper, "xmloff",
+ "Adding duplicate family " << rStrName <<
+ " with mismatching mapper ! " <<
+ typeid((*iter)->mxMapper.get()).name() << " " <<
+ typeid(*rMapper).name() );
+ }
+#endif
+
+ m_FamilySet.insert(std::make_unique<XMLAutoStyleFamily>(nFamily, rStrName, rMapper, aPrefix, bAsFamily));
+}
+
+void SvXMLAutoStylePoolP_Impl::SetFamilyPropSetMapper(
+ XmlStyleFamily nFamily,
+ const rtl::Reference < SvXMLExportPropertyMapper > & rMapper )
+{
+ XMLAutoStyleFamily aTemp(nFamily);
+ auto const iter = m_FamilySet.find(aTemp);
+ if (iter != m_FamilySet.end())
+ (*iter)->mxMapper = rMapper;
+}
+
+// Adds a name to list
+void SvXMLAutoStylePoolP_Impl::RegisterName( XmlStyleFamily nFamily, const OUString& rName )
+{
+ XMLAutoStyleFamily aTemp(nFamily);
+ auto const iter = m_FamilySet.find(aTemp);
+ assert(iter != m_FamilySet.end()); // family must be known
+ (*iter)->maNameSet.insert(rName);
+}
+
+// Adds a name to list
+void SvXMLAutoStylePoolP_Impl::RegisterDefinedName( XmlStyleFamily nFamily, const OUString& rName )
+{
+ XMLAutoStyleFamily aTemp(nFamily);
+ auto const iter = m_FamilySet.find(aTemp);
+ assert(iter != m_FamilySet.end()); // family must be known
+ (*iter)->maReservedNameSet.insert(rName);
+}
+
+
+// Retrieve the list of registered names
+
+
+void SvXMLAutoStylePoolP_Impl::GetRegisteredNames(
+ uno::Sequence<sal_Int32>& rFamilies,
+ uno::Sequence<OUString>& rNames )
+{
+ // collect registered names + families
+ vector<sal_Int32> aFamilies;
+ vector<OUString> aNames;
+
+ // iterate over families
+ for (auto const& aJ : m_FamilySet)
+ {
+ XMLAutoStyleFamily &rFamily = *aJ;
+
+ // iterate over names
+ for (const auto& rName : rFamily.maNameSet)
+ {
+ aFamilies.push_back( static_cast<sal_Int32>(rFamily.mnFamily) );
+ aNames.push_back( rName );
+ }
+ }
+
+ // copy the families + names into the sequence types
+ assert(aFamilies.size() == aNames.size());
+
+ rFamilies.realloc( aFamilies.size() );
+ std::copy( aFamilies.begin(), aFamilies.end(), rFamilies.getArray() );
+
+ rNames.realloc( aNames.size() );
+ std::copy( aNames.begin(), aNames.end(), rNames.getArray() );
+}
+
+// Adds an array of XMLPropertyState ( vector< XMLPropertyState > ) to list
+// if not added, yet.
+
+bool SvXMLAutoStylePoolP_Impl::Add(
+ OUString& rName, XmlStyleFamily nFamily, const OUString& rParentName,
+ ::std::vector< XMLPropertyState >&& rProperties, bool bDontSeek )
+{
+ XMLAutoStyleFamily aTemp(nFamily);
+ auto const iter = m_FamilySet.find(aTemp);
+ assert(iter != m_FamilySet.end()); // family must be known
+
+ XMLAutoStyleFamily &rFamily = **iter;
+
+ auto itPair = rFamily.m_ParentSet.insert(std::make_unique<XMLAutoStylePoolParent>(
+ rParentName));
+ XMLAutoStylePoolParent& rParent = **itPair.first;
+
+ bool bRet = false;
+ if (rParent.Add(rFamily, std::move(rProperties), rName, bDontSeek))
+ {
+ rFamily.mnCount++;
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+bool SvXMLAutoStylePoolP_Impl::AddNamed(
+ const OUString& rName, XmlStyleFamily nFamily, const OUString& rParentName,
+ std::vector< XMLPropertyState >&& rProperties )
+{
+ // get family and parent the same way as in Add()
+
+ XMLAutoStyleFamily aTemp(nFamily);
+ auto const iter = m_FamilySet.find(aTemp);
+ assert(iter != m_FamilySet.end()); // family must be known
+
+ XMLAutoStyleFamily &rFamily = **iter;
+
+ auto itPair = rFamily.m_ParentSet.insert(std::make_unique<XMLAutoStylePoolParent>(
+ rParentName));
+ XMLAutoStylePoolParent& rParent = **itPair.first;
+
+ bool bRet = false;
+ if (rParent.AddNamed(rFamily, std::move(rProperties), rName))
+ {
+ rFamily.mnCount++;
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+
+// Search for an array of XMLPropertyState ( vector< XMLPropertyState > ) in list
+
+
+OUString SvXMLAutoStylePoolP_Impl::Find( XmlStyleFamily nFamily,
+ const OUString& rParent,
+ const vector< XMLPropertyState >& rProperties ) const
+{
+ OUString sName;
+
+ XMLAutoStyleFamily aTemp(nFamily);
+ auto const iter = m_FamilySet.find(aTemp);
+ assert(iter != m_FamilySet.end()); // family must be known
+
+ XMLAutoStyleFamily const& rFamily = **iter;
+ XMLAutoStylePoolParent aTmp(rParent);
+ auto const it2 = rFamily.m_ParentSet.find(aTmp);
+ if (it2 != rFamily.m_ParentSet.end())
+ {
+ sName = (*it2)->Find(rFamily, rProperties);
+ }
+
+ return sName;
+}
+
+std::vector<xmloff::AutoStyleEntry> SvXMLAutoStylePoolP_Impl::GetAutoStyleEntries() const
+{
+ std::vector<xmloff::AutoStyleEntry> rReturnVector;
+
+ for (std::unique_ptr<XMLAutoStyleFamily> const & rFamily : m_FamilySet)
+ {
+ rtl::Reference<XMLPropertySetMapper> aPropertyMapper = rFamily->mxMapper->getPropertySetMapper();
+ for (auto const & rParent : rFamily->m_ParentSet)
+ {
+ for (auto const & rProperty : rParent->GetPropertiesList())
+ {
+ rReturnVector.emplace_back();
+ xmloff::AutoStyleEntry & rEntry = rReturnVector.back();
+ for (XMLPropertyState const & rPropertyState : rProperty->GetProperties())
+ {
+ if (rPropertyState.mnIndex >= 0)
+ {
+ OUString sXmlName = aPropertyMapper->GetEntryXMLName(rPropertyState.mnIndex);
+ rEntry.m_aXmlProperties.emplace_back(sXmlName, rPropertyState.maValue);
+ }
+ }
+ }
+ }
+ }
+ return rReturnVector;
+}
+
+namespace {
+
+struct AutoStylePoolExport
+{
+ const OUString* mpParent;
+ XMLAutoStylePoolProperties* mpProperties;
+
+ AutoStylePoolExport() : mpParent(nullptr), mpProperties(nullptr) {}
+};
+
+struct StyleComparator
+{
+ bool operator() (const AutoStylePoolExport& a, const AutoStylePoolExport& b)
+ {
+ return (a.mpProperties->GetName() < b.mpProperties->GetName() ||
+ (a.mpProperties->GetName() == b.mpProperties->GetName() && *a.mpParent < *b.mpParent));
+ }
+};
+
+}
+
+void SvXMLAutoStylePoolP_Impl::exportXML(
+ XmlStyleFamily nFamily,
+ const SvXMLAutoStylePoolP *pAntiImpl) const
+{
+ // Get list of parents for current family (nFamily)
+ XMLAutoStyleFamily aTemp(nFamily);
+ auto const iter = m_FamilySet.find(aTemp);
+ assert(iter != m_FamilySet.end()); // family must be known
+
+ const XMLAutoStyleFamily &rFamily = **iter;
+ sal_uInt32 nCount = rFamily.mnCount;
+
+ if (!nCount)
+ return;
+
+ // create, initialize and fill helper-structure (SvXMLAutoStylePoolProperties_Impl)
+ // which contains a parent-name and a SvXMLAutoStylePoolProperties_Impl
+ std::vector<AutoStylePoolExport> aExpStyles(nCount);
+
+ for (auto const& it : rFamily.m_ParentSet)
+ {
+ XMLAutoStylePoolParent& rParent = *it;
+ size_t nProperties = rParent.GetPropertiesList().size();
+ for( size_t j = 0; j < nProperties; j++ )
+ {
+ XMLAutoStylePoolProperties *const pProperties =
+ rParent.GetPropertiesList()[j].get();
+ sal_uInt32 nPos = pProperties->GetPos();
+ assert(nPos < nCount);
+ assert(!aExpStyles[nPos].mpProperties);
+ aExpStyles[nPos].mpProperties = pProperties;
+ aExpStyles[nPos].mpParent = &rParent.GetParent();
+ }
+ }
+
+ static bool bHack = (getenv("LIBO_ONEWAY_STABLE_ODF_EXPORT") != nullptr);
+
+ if (bHack)
+ {
+
+ std::sort(aExpStyles.begin(), aExpStyles.end(), StyleComparator());
+
+ for (size_t i = 0; i < nCount; i++)
+ {
+ OUString oldName = aExpStyles[i].mpProperties->GetName();
+ sal_Int32 dashIx = oldName.indexOf('-');
+ OUString newName = (dashIx > 0 ? oldName.copy(0, dashIx) : oldName) + OUString::number(i);
+ aExpStyles[i].mpProperties->SetName(newName);
+ }
+ }
+
+
+ // create string to export for each XML-style. That means for each property-list
+
+ OUString aStrFamilyName = rFamily.maStrFamilyName;
+
+ for( size_t i = 0; i < nCount; i++ )
+ {
+ assert(aExpStyles[i].mpProperties);
+
+ if( aExpStyles[i].mpProperties )
+ {
+ GetExport().AddAttribute(
+ XML_NAMESPACE_STYLE, XML_NAME,
+ aExpStyles[i].mpProperties->GetName() );
+
+ bool bExtensionNamespace = false;
+ if( rFamily.mbAsFamily )
+ {
+ GetExport().AddAttribute(
+ XML_NAMESPACE_STYLE, XML_FAMILY, aStrFamilyName );
+ if(aStrFamilyName != "graphic" &&
+ aStrFamilyName != "drawing-page" &&
+ aStrFamilyName != "presentation" &&
+ aStrFamilyName != "chart" )
+ bExtensionNamespace = true;
+ }
+
+ if( !aExpStyles[i].mpParent->isEmpty() )
+ {
+ GetExport().AddAttribute(
+ XML_NAMESPACE_STYLE, XML_PARENT_STYLE_NAME,
+ GetExport().EncodeStyleName(
+ *aExpStyles[i].mpParent ) );
+ }
+
+ OUString sName;
+ if( rFamily.mbAsFamily )
+ sName = GetXMLToken(XML_STYLE);
+ else
+ sName = rFamily.maStrFamilyName;
+
+ pAntiImpl->exportStyleAttributes(GetExport().GetAttrList(), nFamily,
+ aExpStyles[i].mpProperties->GetProperties(),
+ *rFamily.mxMapper, GetExport().GetMM100UnitConverter(),
+ GetExport().GetNamespaceMap());
+
+ SvXMLElementExport aElem( GetExport(),
+ XML_NAMESPACE_STYLE, sName,
+ true, true );
+
+ sal_Int32 nStart(-1);
+ sal_Int32 nEnd(-1);
+ if (nFamily == XmlStyleFamily::PAGE_MASTER)
+ {
+ nStart = 0;
+ sal_Int32 nIndex = 0;
+ rtl::Reference< XMLPropertySetMapper > aPropMapper =
+ rFamily.mxMapper->getPropertySetMapper();
+ sal_Int16 nContextID;
+ while(nIndex < aPropMapper->GetEntryCount() && nEnd == -1)
+ {
+ nContextID = aPropMapper->GetEntryContextId( nIndex );
+ if (nContextID && ((nContextID & CTF_PM_FLAGMASK) != XML_PM_CTF_START))
+ nEnd = nIndex;
+ nIndex++;
+ }
+ if (nEnd == -1)
+ nEnd = nIndex;
+ }
+
+ rFamily.mxMapper->exportXML(
+ GetExport(),
+ aExpStyles[i].mpProperties->GetProperties(),
+ nStart, nEnd, SvXmlExportFlags::IGN_WS, bExtensionNamespace );
+
+ pAntiImpl->exportStyleContent(GetExport().GetDocHandler(), nFamily,
+ aExpStyles[i].mpProperties->GetProperties(),
+ *rFamily.mxMapper, GetExport().GetMM100UnitConverter(),
+ GetExport().GetNamespaceMap());
+ }
+ }
+}
+
+void SvXMLAutoStylePoolP_Impl::ClearEntries()
+{
+ for (auto & aI : m_FamilySet)
+ aI->ClearEntries();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/impastpl.hxx b/xmloff/source/style/impastpl.hxx
new file mode 100644
index 000000000..4645305e1
--- /dev/null
+++ b/xmloff/source/style/impastpl.hxx
@@ -0,0 +1,180 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <sal/types.h>
+#include <rtl/ustring.hxx>
+#include <rtl/ref.hxx>
+#include <set>
+#include <memory>
+#include <vector>
+
+#include <comphelper/stl_types.hxx>
+
+#include <xmloff/maptype.hxx>
+#include <xmloff/xmlexppr.hxx>
+#include <AutoStyleEntry.hxx>
+
+class SvXMLAutoStylePoolP;
+class XMLAutoStylePoolParent;
+struct XMLAutoStyleFamily;
+class SvXMLExportPropertyMapper;
+class SvXMLExport;
+enum class XmlStyleFamily;
+
+// Properties of a pool
+
+class XMLAutoStylePoolProperties
+{
+ OUString msName;
+ ::std::vector< XMLPropertyState > maProperties;
+ sal_uInt32 mnPos;
+
+public:
+
+ XMLAutoStylePoolProperties( XMLAutoStyleFamily& rFamilyData, std::vector< XMLPropertyState >&& rProperties, OUString const & rParentname );
+
+ const OUString& GetName() const { return msName; }
+ const ::std::vector< XMLPropertyState >& GetProperties() const { return maProperties; }
+ sal_uInt32 GetPos() const { return mnPos; }
+
+ void SetName( const OUString& rNew ) { msName = rNew; }
+};
+
+// Parents of AutoStylePool's
+class XMLAutoStylePoolParent
+{
+public:
+ typedef std::vector<std::unique_ptr<XMLAutoStylePoolProperties>> PropertiesListType;
+
+private:
+ OUString msParent;
+ PropertiesListType m_PropertiesList;
+
+public:
+
+ explicit XMLAutoStylePoolParent( const OUString & rParent ) :
+ msParent( rParent )
+ {
+ }
+
+ ~XMLAutoStylePoolParent();
+
+ bool Add( XMLAutoStyleFamily& rFamilyData, std::vector< XMLPropertyState >&& rProperties, OUString& rName, bool bDontSeek );
+
+ bool AddNamed( XMLAutoStyleFamily& rFamilyData, std::vector< XMLPropertyState >&& rProperties, const OUString& rName );
+
+ OUString Find( const XMLAutoStyleFamily& rFamilyData, const ::std::vector< XMLPropertyState >& rProperties ) const;
+
+ const OUString& GetParent() const { return msParent; }
+
+ PropertiesListType& GetPropertiesList()
+ {
+ return m_PropertiesList;
+ }
+
+ bool operator< (const XMLAutoStylePoolParent& rOther) const;
+};
+
+// Implementationclass for stylefamily-information
+
+struct XMLAutoStyleFamily
+{
+ typedef std::set<std::unique_ptr<XMLAutoStylePoolParent>,
+ comphelper::UniquePtrValueLess<XMLAutoStylePoolParent>> ParentSetType;
+
+ XmlStyleFamily mnFamily;
+ OUString maStrFamilyName;
+ rtl::Reference<SvXMLExportPropertyMapper> mxMapper;
+
+ ParentSetType m_ParentSet;
+ std::set<OUString> maNameSet;
+ std::set<OUString> maReservedNameSet;
+ sal_uInt32 mnCount;
+ sal_uInt32 mnName;
+ OUString maStrPrefix;
+ bool mbAsFamily;
+
+ XMLAutoStyleFamily( XmlStyleFamily nFamily, const OUString& rStrName,
+ const rtl::Reference<SvXMLExportPropertyMapper>& rMapper,
+ const OUString& rStrPrefix, bool bAsFamily );
+
+ explicit XMLAutoStyleFamily( XmlStyleFamily nFamily );
+
+ XMLAutoStyleFamily(const XMLAutoStyleFamily&) = delete;
+ XMLAutoStyleFamily& operator=(const XMLAutoStyleFamily&) = delete;
+
+ friend bool operator<(const XMLAutoStyleFamily& r1, const XMLAutoStyleFamily& r2);
+
+ void ClearEntries();
+};
+
+// Implementationclass of SvXMLAutoStylePool
+
+class SvXMLAutoStylePoolP_Impl
+{
+ // A set that finds and sorts based only on mnFamily
+ typedef std::set<std::unique_ptr<XMLAutoStyleFamily>,
+ comphelper::UniquePtrValueLess<XMLAutoStyleFamily>> FamilySetType;
+
+ SvXMLExport& rExport;
+ FamilySetType m_FamilySet;
+
+public:
+
+ explicit SvXMLAutoStylePoolP_Impl( SvXMLExport& rExport );
+ ~SvXMLAutoStylePoolP_Impl();
+
+ SvXMLExport& GetExport() const { return rExport; }
+
+ void AddFamily( XmlStyleFamily nFamily, const OUString& rStrName,
+ const rtl::Reference < SvXMLExportPropertyMapper > & rMapper,
+ const OUString& rStrPrefix, bool bAsFamily );
+ void SetFamilyPropSetMapper( XmlStyleFamily nFamily,
+ const rtl::Reference < SvXMLExportPropertyMapper > & rMapper );
+ void RegisterName( XmlStyleFamily nFamily, const OUString& rName );
+ void RegisterDefinedName( XmlStyleFamily nFamily, const OUString& rName );
+ void GetRegisteredNames(
+ css::uno::Sequence<sal_Int32>& aFamilies,
+ css::uno::Sequence<OUString>& aNames );
+
+ bool Add(
+ OUString& rName, XmlStyleFamily nFamily,
+ const OUString& rParentName,
+ std::vector< XMLPropertyState >&& rProperties,
+ bool bDontSeek = false );
+
+ bool AddNamed(
+ const OUString& rName, XmlStyleFamily nFamily,
+ const OUString& rParentName,
+ std::vector< XMLPropertyState >&& rProperties );
+
+ OUString Find( XmlStyleFamily nFamily, const OUString& rParent,
+ const ::std::vector< XMLPropertyState >& rProperties ) const;
+
+ void exportXML( XmlStyleFamily nFamily,
+ const SvXMLAutoStylePoolP *pAntiImpl) const;
+
+ void ClearEntries();
+
+ std::vector<xmloff::AutoStyleEntry> GetAutoStyleEntries() const;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/kernihdl.cxx b/xmloff/source/style/kernihdl.cxx
new file mode 100644
index 000000000..cee24fe20
--- /dev/null
+++ b/xmloff/source/style/kernihdl.cxx
@@ -0,0 +1,78 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include "kernihdl.hxx"
+#include <com/sun/star/uno/Any.hxx>
+#include <rtl/ustrbuf.hxx>
+
+
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+
+using namespace ::com::sun::star::uno;
+using namespace ::xmloff::token;
+
+
+
+
+XMLKerningPropHdl::~XMLKerningPropHdl()
+{
+ // nothing to do
+}
+
+bool XMLKerningPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
+{
+ bool bRet = true;
+ sal_Int32 nKerning = 0;
+
+ if( ! IsXMLToken( rStrImpValue, XML_NORMAL ) )
+ {
+ bRet = rUnitConverter.convertMeasureToCore( nKerning, rStrImpValue );
+ }
+
+ rValue <<= static_cast<sal_Int16>(nKerning);
+
+ return bRet;
+}
+
+bool XMLKerningPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
+{
+ bool bRet = false;
+ sal_Int16 nValue = sal_Int16();
+
+ if( rValue >>= nValue )
+ {
+ OUStringBuffer aOut;
+
+ if( nValue == 0 )
+ aOut.append( GetXMLToken(XML_NORMAL) );
+ else
+ {
+ rUnitConverter.convertMeasureToXML( aOut, nValue );
+ }
+
+ rStrExpValue = aOut.makeStringAndClear();
+
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/kernihdl.hxx b/xmloff/source/style/kernihdl.hxx
new file mode 100644
index 000000000..3f4a7b4f8
--- /dev/null
+++ b/xmloff/source/style/kernihdl.hxx
@@ -0,0 +1,36 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLKerningPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLKerningPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/lspachdl.cxx b/xmloff/source/style/lspachdl.cxx
new file mode 100644
index 000000000..21a3e7dac
--- /dev/null
+++ b/xmloff/source/style/lspachdl.cxx
@@ -0,0 +1,173 @@
+/* -*- 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 "lspachdl.hxx"
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <sax/tools/converter.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/style/LineSpacing.hpp>
+#include <com/sun/star/style/LineSpacingMode.hpp>
+
+using namespace ::com::sun::star;
+using ::xmloff::token::IsXMLToken;
+using ::xmloff::token::XML_NORMAL;
+
+
+
+
+XMLLineHeightHdl::~XMLLineHeightHdl()
+{
+ // nothing to do
+}
+
+bool XMLLineHeightHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
+{
+ style::LineSpacing aLSp;
+ sal_Int32 nTemp = 0;
+
+ if( -1 != rStrImpValue.indexOf( '%' ) )
+ {
+ aLSp.Mode = style::LineSpacingMode::PROP;
+ if (!::sax::Converter::convertPercent( nTemp, rStrImpValue ))
+ return false;
+ aLSp.Height = sal::static_int_cast< sal_Int16 >(nTemp);
+ }
+ else if( IsXMLToken( rStrImpValue, XML_NORMAL) )
+ {
+ aLSp.Mode = style::LineSpacingMode::PROP;
+ aLSp.Height = 100;
+ }
+ else
+ {
+ aLSp.Mode = style::LineSpacingMode::FIX;
+ if (!rUnitConverter.convertMeasureToCore(
+ nTemp, rStrImpValue, 0x0000, 0xffff))
+ return false;
+ aLSp.Height = sal::static_int_cast< sal_Int16 >(nTemp);
+ }
+
+ rValue <<= aLSp;
+ return true;
+}
+
+bool XMLLineHeightHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
+{
+ OUStringBuffer aOut;
+
+ style::LineSpacing aLSp;
+ if(!(rValue >>= aLSp))
+ return false;
+
+ if( style::LineSpacingMode::PROP != aLSp.Mode && style::LineSpacingMode::FIX != aLSp.Mode )
+ return false;
+
+ if( style::LineSpacingMode::PROP == aLSp.Mode )
+ {
+ ::sax::Converter::convertPercent( aOut, aLSp.Height );
+ }
+ else
+ {
+ rUnitConverter.convertMeasureToXML( aOut, aLSp.Height );
+ }
+
+ rStrExpValue = aOut.makeStringAndClear();
+ return !rStrExpValue.isEmpty();
+}
+
+
+
+
+XMLLineHeightAtLeastHdl::~XMLLineHeightAtLeastHdl()
+{
+ // nothing to do
+}
+
+bool XMLLineHeightAtLeastHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
+{
+ style::LineSpacing aLSp;
+
+ sal_Int32 nTemp;
+ aLSp.Mode = style::LineSpacingMode::MINIMUM;
+ if (!rUnitConverter.convertMeasureToCore( nTemp, rStrImpValue, 0, 0xffff))
+ return false;
+ aLSp.Height = sal::static_int_cast< sal_Int16 >(nTemp);
+
+ rValue <<= aLSp;
+ return true;
+}
+
+bool XMLLineHeightAtLeastHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
+{
+ OUStringBuffer aOut;
+
+ style::LineSpacing aLSp;
+ if(!(rValue >>= aLSp))
+ return false;
+
+ if( style::LineSpacingMode::MINIMUM != aLSp.Mode )
+ return false;
+
+ rUnitConverter.convertMeasureToXML( aOut, aLSp.Height );
+
+ rStrExpValue = aOut.makeStringAndClear();
+ return !rStrExpValue.isEmpty();
+}
+
+
+
+
+XMLLineSpacingHdl::~XMLLineSpacingHdl()
+{
+ // nothing to do
+}
+
+bool XMLLineSpacingHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
+{
+ style::LineSpacing aLSp;
+ sal_Int32 nTemp;
+
+ aLSp.Mode = style::LineSpacingMode::LEADING;
+ if (!rUnitConverter.convertMeasureToCore( nTemp, rStrImpValue, 0, 0xffff))
+ return false;
+ aLSp.Height = sal::static_int_cast< sal_Int16 >(nTemp);
+
+ rValue <<= aLSp;
+ return true;
+}
+
+bool XMLLineSpacingHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
+{
+ OUStringBuffer aOut;
+
+ style::LineSpacing aLSp;
+ if(!(rValue >>= aLSp))
+ return false;
+
+ if( style::LineSpacingMode::LEADING != aLSp.Mode )
+ return false;
+
+ rUnitConverter.convertMeasureToXML( aOut, aLSp.Height );
+
+ rStrExpValue = aOut.makeStringAndClear();
+ return !rStrExpValue.isEmpty();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/lspachdl.hxx b/xmloff/source/style/lspachdl.hxx
new file mode 100644
index 000000000..b0b4d41d7
--- /dev/null
+++ b/xmloff/source/style/lspachdl.hxx
@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLLineHeightHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLLineHeightHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+class XMLLineHeightAtLeastHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLLineHeightAtLeastHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+class XMLLineSpacingHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLLineSpacingHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/numehelp.cxx b/xmloff/source/style/numehelp.cxx
new file mode 100644
index 000000000..c375fe3e6
--- /dev/null
+++ b/xmloff/source/style/numehelp.cxx
@@ -0,0 +1,510 @@
+/* -*- 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 <xmloff/numehelp.hxx>
+
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <com/sun/star/uno/Reference.h>
+#include <rtl/ustring.hxx>
+#include <svl/zforlist.hxx>
+#include <com/sun/star/util/NumberFormat.hpp>
+#include <com/sun/star/util/XNumberFormatsSupplier.hpp>
+#include <sax/tools/converter.hxx>
+#include <rtl/math.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <osl/diagnose.h>
+
+using namespace com::sun::star;
+using namespace xmloff::token;
+
+constexpr OUStringLiteral gsStandardFormat(u"StandardFormat");
+constexpr OUStringLiteral gsType(u"Type");
+constexpr OUStringLiteral gsCurrencySymbol(u"CurrencySymbol");
+constexpr OUStringLiteral gsCurrencyAbbreviation(u"CurrencyAbbreviation");
+
+XMLNumberFormatAttributesExportHelper::XMLNumberFormatAttributesExportHelper(
+ css::uno::Reference< css::util::XNumberFormatsSupplier > const & xTempNumberFormatsSupplier)
+ : xNumberFormats(xTempNumberFormatsSupplier.is() ? xTempNumberFormatsSupplier->getNumberFormats() : css::uno::Reference< css::util::XNumberFormats > ()),
+ pExport(nullptr)
+{
+}
+
+XMLNumberFormatAttributesExportHelper::XMLNumberFormatAttributesExportHelper(
+ css::uno::Reference< css::util::XNumberFormatsSupplier > const & xTempNumberFormatsSupplier,
+ SvXMLExport& rTempExport )
+: xNumberFormats(xTempNumberFormatsSupplier.is() ? xTempNumberFormatsSupplier->getNumberFormats() : css::uno::Reference< css::util::XNumberFormats > ()),
+ pExport(&rTempExport),
+ sAttrValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_VALUE))),
+ sAttrDateValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_DATE_VALUE))),
+ sAttrTimeValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_TIME_VALUE))),
+ sAttrBooleanValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_BOOLEAN_VALUE))),
+ sAttrStringValue(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_STRING_VALUE))),
+ sAttrCurrency(rTempExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OFFICE, GetXMLToken(XML_CURRENCY)))
+{
+}
+
+XMLNumberFormatAttributesExportHelper::~XMLNumberFormatAttributesExportHelper()
+{
+}
+
+sal_Int16 XMLNumberFormatAttributesExportHelper::GetCellType(const sal_Int32 nNumberFormat, OUString& sCurrency, bool& bIsStandard)
+{
+ XMLNumberFormat aFormat(nNumberFormat);
+ XMLNumberFormatSet::iterator aItr(aNumberFormats.find(aFormat));
+ XMLNumberFormatSet::iterator aEndItr(aNumberFormats.end());
+ if (aItr != aEndItr)
+ {
+ bIsStandard = aItr->bIsStandard;
+ sCurrency = aItr->sCurrency;
+ return aItr->nType;
+ }
+ else
+ {
+ aFormat.nType = GetCellType(nNumberFormat, bIsStandard);
+ aFormat.bIsStandard = bIsStandard;
+ if ((aFormat.nType & ~util::NumberFormat::DEFINED) == util::NumberFormat::CURRENCY)
+ if (GetCurrencySymbol(nNumberFormat, aFormat.sCurrency))
+ sCurrency = aFormat.sCurrency;
+ aNumberFormats.insert(aFormat);
+ return aFormat.nType;
+ }
+}
+
+void XMLNumberFormatAttributesExportHelper::WriteAttributes(SvXMLExport& rXMLExport,
+ const sal_Int16 nTypeKey,
+ const double& rValue,
+ const OUString& rCurrency,
+ bool bExportValue)
+{
+ bool bWasSetTypeAttribute = false;
+ switch(nTypeKey & ~util::NumberFormat::DEFINED)
+ {
+ case 0:
+ case util::NumberFormat::NUMBER:
+ case util::NumberFormat::SCIENTIFIC:
+ case util::NumberFormat::FRACTION:
+ {
+ rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_FLOAT);
+ bWasSetTypeAttribute = true;
+ [[fallthrough]];
+ }
+ case util::NumberFormat::PERCENT:
+ {
+ if (!bWasSetTypeAttribute)
+ {
+ rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_PERCENTAGE);
+ bWasSetTypeAttribute = true;
+ }
+ [[fallthrough]];
+ }
+ case util::NumberFormat::CURRENCY:
+ {
+ if (!bWasSetTypeAttribute)
+ {
+ rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_CURRENCY);
+ if (!rCurrency.isEmpty())
+ rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_CURRENCY, rCurrency);
+ }
+
+ if (bExportValue)
+ {
+ OUString sValue( ::rtl::math::doubleToUString( rValue,
+ rtl_math_StringFormat_Automatic,
+ rtl_math_DecimalPlaces_Max, '.', true));
+ rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE, sValue);
+ }
+ }
+ break;
+ case util::NumberFormat::DATE:
+ case util::NumberFormat::DATETIME:
+ {
+ rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_DATE);
+ if (bExportValue)
+ {
+ if ( rXMLExport.SetNullDateOnUnitConverter() )
+ {
+ OUStringBuffer sBuffer;
+ rXMLExport.GetMM100UnitConverter().convertDateTime(sBuffer, rValue);
+ rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_DATE_VALUE, sBuffer.makeStringAndClear());
+ }
+ }
+ }
+ break;
+ case util::NumberFormat::TIME:
+ {
+ rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_TIME);
+ if (bExportValue)
+ {
+ OUStringBuffer sBuffer;
+ ::sax::Converter::convertDuration(sBuffer, rValue);
+ rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_TIME_VALUE, sBuffer.makeStringAndClear());
+ }
+ }
+ break;
+ case util::NumberFormat::LOGICAL:
+ {
+ rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_BOOLEAN);
+ if (bExportValue)
+ {
+ double fTempValue = rValue;
+ if (::rtl::math::approxEqual( fTempValue, 1.0 ))
+ {
+ rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_BOOLEAN_VALUE, XML_TRUE);
+ }
+ else
+ {
+ if (rValue == 0.0)
+ {
+ rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_BOOLEAN_VALUE, XML_FALSE);
+ }
+ else
+ {
+ OUString sValue( ::rtl::math::doubleToUString(
+ fTempValue,
+ rtl_math_StringFormat_Automatic,
+ rtl_math_DecimalPlaces_Max, '.',
+ true));
+ rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_BOOLEAN_VALUE, sValue);
+ }
+ }
+ }
+ }
+ break;
+ case util::NumberFormat::TEXT:
+ {
+ rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_FLOAT);
+ if (bExportValue)
+ {
+ OUString sValue( ::rtl::math::doubleToUString( rValue,
+ rtl_math_StringFormat_Automatic,
+ rtl_math_DecimalPlaces_Max, '.', true));
+ rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE, sValue);
+ }
+ }
+ break;
+ }
+}
+
+bool XMLNumberFormatAttributesExportHelper::GetCurrencySymbol(const sal_Int32 nNumberFormat, OUString& sCurrencySymbol,
+ uno::Reference <util::XNumberFormatsSupplier> const & xNumberFormatsSupplier)
+{
+ if (xNumberFormatsSupplier.is())
+ {
+ uno::Reference <util::XNumberFormats> xNumberFormats(xNumberFormatsSupplier->getNumberFormats());
+ if (xNumberFormats.is())
+ {
+ try
+ {
+ uno::Reference <beans::XPropertySet> xNumberPropertySet(xNumberFormats->getByKey(nNumberFormat));
+ if ( xNumberPropertySet->getPropertyValue(gsCurrencySymbol) >>= sCurrencySymbol)
+ {
+ OUString sCurrencyAbbreviation;
+ if ( xNumberPropertySet->getPropertyValue(gsCurrencyAbbreviation) >>= sCurrencyAbbreviation)
+ {
+ if ( !sCurrencyAbbreviation.isEmpty())
+ sCurrencySymbol = sCurrencyAbbreviation;
+ else
+ {
+ if ( sCurrencySymbol.getLength() == 1 && sCurrencySymbol.toChar() == NfCurrencyEntry::GetEuroSymbol() )
+ sCurrencySymbol = "EUR";
+ }
+ }
+ return true;
+ }
+ }
+ catch ( uno::Exception& )
+ {
+ OSL_FAIL("Numberformat not found");
+ }
+ }
+ }
+ return false;
+}
+
+
+sal_Int16 XMLNumberFormatAttributesExportHelper::GetCellType(const sal_Int32 nNumberFormat, bool& bIsStandard,
+ uno::Reference <util::XNumberFormatsSupplier> const & xNumberFormatsSupplier)
+{
+ if (xNumberFormatsSupplier.is())
+ {
+ uno::Reference <util::XNumberFormats> xNumberFormats(xNumberFormatsSupplier->getNumberFormats());
+ if (xNumberFormats.is())
+ {
+ try
+ {
+ uno::Reference <beans::XPropertySet> xNumberPropertySet(xNumberFormats->getByKey(nNumberFormat));
+ xNumberPropertySet->getPropertyValue(gsStandardFormat) >>= bIsStandard;
+ sal_Int16 nNumberType = sal_Int16();
+ if ( xNumberPropertySet->getPropertyValue(gsType) >>= nNumberType )
+ {
+ return nNumberType;
+ }
+ }
+ catch ( uno::Exception& )
+ {
+ OSL_FAIL("Numberformat not found");
+ }
+ }
+ }
+ return 0;
+}
+
+void XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes(SvXMLExport& rXMLExport,
+ const sal_Int32 nNumberFormat, const double& rValue, bool bExportValue)
+{
+ bool bIsStandard;
+ sal_Int16 nTypeKey = GetCellType(nNumberFormat, bIsStandard, rXMLExport.GetNumberFormatsSupplier());
+ OUString sCurrency;
+ if ((nTypeKey & ~util::NumberFormat::DEFINED) == util::NumberFormat::CURRENCY)
+ GetCurrencySymbol(nNumberFormat, sCurrency, rXMLExport.GetNumberFormatsSupplier());
+ WriteAttributes(rXMLExport, nTypeKey, rValue, sCurrency, bExportValue);
+}
+
+void XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes(SvXMLExport& rXMLExport,
+ const OUString& rValue, std::u16string_view rCharacters,
+ bool bExportValue, bool bExportTypeAttribute)
+{
+ if (bExportTypeAttribute)
+ rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_VALUE_TYPE, XML_STRING);
+ if (bExportValue && !rValue.isEmpty() && (rValue != rCharacters))
+ rXMLExport.AddAttribute(XML_NAMESPACE_OFFICE, XML_STRING_VALUE, rValue);
+}
+
+bool XMLNumberFormatAttributesExportHelper::GetCurrencySymbol(const sal_Int32 nNumberFormat, OUString& rCurrencySymbol)
+{
+ if (!xNumberFormats.is() && pExport && pExport->GetNumberFormatsSupplier().is())
+ xNumberFormats.set(pExport->GetNumberFormatsSupplier()->getNumberFormats());
+
+ if (xNumberFormats.is())
+ {
+ try
+ {
+ uno::Reference <beans::XPropertySet> xNumberPropertySet(xNumberFormats->getByKey(nNumberFormat));
+ if ( xNumberPropertySet->getPropertyValue(gsCurrencySymbol) >>= rCurrencySymbol)
+ {
+ OUString sCurrencyAbbreviation;
+ if ( xNumberPropertySet->getPropertyValue(gsCurrencyAbbreviation) >>= sCurrencyAbbreviation)
+ {
+ if ( !sCurrencyAbbreviation.isEmpty())
+ rCurrencySymbol = sCurrencyAbbreviation;
+ else
+ {
+ if ( rCurrencySymbol.getLength() == 1 && rCurrencySymbol.toChar() == NfCurrencyEntry::GetEuroSymbol() )
+ rCurrencySymbol = "EUR";
+ }
+ }
+ return true;
+ }
+ }
+ catch ( uno::Exception& )
+ {
+ OSL_FAIL("Numberformat not found");
+ }
+ }
+ return false;
+}
+
+sal_Int16 XMLNumberFormatAttributesExportHelper::GetCellType(const sal_Int32 nNumberFormat, bool& bIsStandard)
+{
+ if (!xNumberFormats.is() && pExport && pExport->GetNumberFormatsSupplier().is())
+ xNumberFormats.set(pExport->GetNumberFormatsSupplier()->getNumberFormats());
+
+ if (xNumberFormats.is())
+ {
+ try
+ {
+ uno::Reference <beans::XPropertySet> xNumberPropertySet(xNumberFormats->getByKey(nNumberFormat));
+ if (xNumberPropertySet.is())
+ {
+ xNumberPropertySet->getPropertyValue(gsStandardFormat) >>= bIsStandard;
+ sal_Int16 nNumberType = sal_Int16();
+ if ( xNumberPropertySet->getPropertyValue(gsType) >>= nNumberType )
+ {
+ return nNumberType;
+ }
+ }
+ }
+ catch ( uno::Exception& )
+ {
+ OSL_FAIL("Numberformat not found");
+ }
+ }
+ return 0;
+}
+
+void XMLNumberFormatAttributesExportHelper::WriteAttributes(
+ const sal_Int16 nTypeKey,
+ const double& rValue,
+ const OUString& rCurrency,
+ bool bExportValue, sal_uInt16 nNamespace)
+{
+ if (!pExport)
+ return;
+
+ bool bWasSetTypeAttribute = false;
+ OUString sAttrValType = pExport->GetNamespaceMap().GetQNameByKey( nNamespace, GetXMLToken(XML_VALUE_TYPE));
+ switch(nTypeKey & ~util::NumberFormat::DEFINED)
+ {
+ case 0:
+ case util::NumberFormat::NUMBER:
+ case util::NumberFormat::SCIENTIFIC:
+ case util::NumberFormat::FRACTION:
+ {
+ pExport->AddAttribute(sAttrValType, XML_FLOAT);
+ bWasSetTypeAttribute = true;
+ [[fallthrough]];
+ }
+ case util::NumberFormat::PERCENT:
+ {
+ if (!bWasSetTypeAttribute)
+ {
+ pExport->AddAttribute(sAttrValType, XML_PERCENTAGE);
+ bWasSetTypeAttribute = true;
+ }
+ [[fallthrough]];
+ }
+ case util::NumberFormat::CURRENCY:
+ {
+ if (!bWasSetTypeAttribute)
+ {
+ pExport->AddAttribute(sAttrValType, XML_CURRENCY);
+ if (!rCurrency.isEmpty())
+ pExport->AddAttribute(sAttrCurrency, rCurrency);
+ }
+
+ if (bExportValue)
+ {
+ OUString sValue( ::rtl::math::doubleToUString( rValue,
+ rtl_math_StringFormat_Automatic,
+ rtl_math_DecimalPlaces_Max, '.', true));
+ pExport->AddAttribute(sAttrValue, sValue);
+ }
+ }
+ break;
+ case util::NumberFormat::DATE:
+ case util::NumberFormat::DATETIME:
+ {
+ pExport->AddAttribute(sAttrValType, XML_DATE);
+ if (bExportValue)
+ {
+ if ( pExport->SetNullDateOnUnitConverter() )
+ {
+ OUStringBuffer sBuffer;
+ pExport->GetMM100UnitConverter().convertDateTime(sBuffer, rValue);
+ pExport->AddAttribute(sAttrDateValue, sBuffer.makeStringAndClear());
+ }
+ }
+ }
+ break;
+ case util::NumberFormat::TIME:
+ {
+ pExport->AddAttribute(sAttrValType, XML_TIME);
+ if (bExportValue)
+ {
+ OUStringBuffer sBuffer;
+ ::sax::Converter::convertDuration(sBuffer, rValue);
+ pExport->AddAttribute(sAttrTimeValue, sBuffer.makeStringAndClear());
+ }
+ }
+ break;
+ case util::NumberFormat::LOGICAL:
+ {
+ pExport->AddAttribute(sAttrValType, XML_BOOLEAN);
+ if (bExportValue)
+ {
+ double fTempValue = rValue;
+ if (::rtl::math::approxEqual( fTempValue, 1.0 ))
+ {
+ pExport->AddAttribute(sAttrBooleanValue, XML_TRUE);
+ }
+ else
+ {
+ if (rValue == 0.0)
+ {
+ pExport->AddAttribute(sAttrBooleanValue, XML_FALSE);
+ }
+ else
+ {
+ OUString sValue( ::rtl::math::doubleToUString(
+ fTempValue,
+ rtl_math_StringFormat_Automatic,
+ rtl_math_DecimalPlaces_Max, '.',
+ true));
+ pExport->AddAttribute(sAttrBooleanValue, sValue);
+ }
+ }
+ }
+ }
+ break;
+ case util::NumberFormat::TEXT:
+ {
+ pExport->AddAttribute(sAttrValType, XML_FLOAT);
+ if (bExportValue)
+ {
+ OUString sValue( ::rtl::math::doubleToUString( rValue,
+ rtl_math_StringFormat_Automatic,
+ rtl_math_DecimalPlaces_Max, '.', true));
+ pExport->AddAttribute(sAttrValue, sValue);
+ }
+ }
+ break;
+ }
+}
+
+void XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes(
+ const sal_Int32 nNumberFormat, const double& rValue, bool bExportValue,
+ sal_uInt16 nNamespace, bool bExportCurrencySymbol)
+{
+ if (pExport)
+ {
+ bool bIsStandard;
+ OUString sCurrency;
+ sal_Int16 nTypeKey = GetCellType(nNumberFormat, sCurrency, bIsStandard);
+ if(!bExportCurrencySymbol)
+ sCurrency.clear();
+
+ WriteAttributes(nTypeKey, rValue, sCurrency, bExportValue, nNamespace);
+ }
+ else {
+ OSL_FAIL("no SvXMLExport given");
+ }
+}
+
+void XMLNumberFormatAttributesExportHelper::SetNumberFormatAttributes(
+ const OUString& rValue, std::u16string_view rCharacters,
+ bool bExportValue,
+ sal_uInt16 nNamespace)
+{
+ if (pExport)
+ {
+ pExport->AddAttribute(nNamespace, XML_VALUE_TYPE, XML_STRING);
+ if (bExportValue && !rValue.isEmpty() && (rValue != rCharacters))
+ pExport->AddAttribute(sAttrStringValue, rValue);
+ }
+ else {
+ OSL_FAIL("no SvXMLExport given");
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/opaquhdl.cxx b/xmloff/source/style/opaquhdl.cxx
new file mode 100644
index 000000000..c710d67c6
--- /dev/null
+++ b/xmloff/source/style/opaquhdl.cxx
@@ -0,0 +1,61 @@
+/* -*- 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 "opaquhdl.hxx"
+#include <com/sun/star/uno/Any.hxx>
+
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+
+using namespace ::com::sun::star::uno;
+using namespace ::xmloff::token;
+
+
+XMLOpaquePropHdl::~XMLOpaquePropHdl()
+{
+ // nothing to do
+}
+
+bool XMLOpaquePropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bValue = IsXMLToken( rStrImpValue, XML_FOREGROUND );
+ rValue <<= bValue;
+
+ return true;
+}
+
+bool XMLOpaquePropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ bool bValue;
+
+ if (rValue >>= bValue)
+ {
+ if( bValue )
+ rStrExpValue = GetXMLToken( XML_FOREGROUND );
+ else
+ rStrExpValue = GetXMLToken( XML_BACKGROUND );
+
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/opaquhdl.hxx b/xmloff/source/style/opaquhdl.hxx
new file mode 100644
index 000000000..1d4c193a9
--- /dev/null
+++ b/xmloff/source/style/opaquhdl.hxx
@@ -0,0 +1,36 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLOpaquePropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLOpaquePropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/postuhdl.cxx b/xmloff/source/style/postuhdl.cxx
new file mode 100644
index 000000000..5e0d5bfbc
--- /dev/null
+++ b/xmloff/source/style/postuhdl.cxx
@@ -0,0 +1,81 @@
+/* -*- 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 "postuhdl.hxx"
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlement.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/awt/FontSlant.hpp>
+#include <tools/fontenum.hxx>
+#include <vcl/unohelp.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+SvXMLEnumMapEntry<FontItalic> const aPostureGenericMapping[] =
+{
+ { XML_NORMAL, ITALIC_NONE },
+ { XML_ITALIC, ITALIC_NORMAL },
+ { XML_POSTURE_OBLIQUE, ITALIC_OBLIQUE },
+ { XML_TOKEN_INVALID, FontItalic(0) }
+};
+
+
+
+
+XMLPosturePropHdl::~XMLPosturePropHdl()
+{
+ // nothing to do
+}
+
+bool XMLPosturePropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ FontItalic ePosture;
+ bool bRet = SvXMLUnitConverter::convertEnum( ePosture, rStrImpValue, aPostureGenericMapping );
+ if( bRet )
+ rValue <<= vcl::unohelper::ConvertFontSlant(ePosture);
+
+ return bRet;
+}
+
+bool XMLPosturePropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ awt::FontSlant eSlant;
+
+ if( !( rValue >>= eSlant ) )
+ {
+ sal_Int32 nValue = 0;
+
+ if( !( rValue >>= nValue ) )
+ return false;
+
+ eSlant = static_cast<awt::FontSlant>(nValue);
+ }
+
+ OUStringBuffer aOut;
+ bool bRet = SvXMLUnitConverter::convertEnum(aOut, vcl::unohelper::ConvertFontSlant(eSlant), aPostureGenericMapping);
+ if( bRet )
+ rStrExpValue = aOut.makeStringAndClear();
+
+ return bRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/postuhdl.hxx b/xmloff/source/style/postuhdl.hxx
new file mode 100644
index 000000000..b63abd607
--- /dev/null
+++ b/xmloff/source/style/postuhdl.hxx
@@ -0,0 +1,36 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLPosturePropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLPosturePropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/prhdlfac.cxx b/xmloff/source/style/prhdlfac.cxx
new file mode 100644
index 000000000..ca96e0421
--- /dev/null
+++ b/xmloff/source/style/prhdlfac.cxx
@@ -0,0 +1,475 @@
+/* -*- 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 <xmloff/prhdlfac.hxx>
+
+#include <com/sun/star/drawing/ColorMode.hpp>
+#include <com/sun/star/text/HorizontalAdjust.hpp>
+#include <com/sun/star/text/WritingMode2.hpp>
+#include <com/sun/star/text/VertOrientation.hpp>
+
+
+#include <sal/log.hxx>
+#include <xmloff/xmlement.hxx>
+#include <xmloff/xmltypes.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlprhdl.hxx>
+#include "xmlbahdl.hxx"
+#include <xmloff/NamedBoolPropertyHdl.hxx>
+#include <xmloff/XMLConstantsPropertyHandler.hxx>
+#include "cdouthdl.hxx"
+#include "csmaphdl.hxx"
+#include "fonthdl.hxx"
+#include "kernihdl.hxx"
+#include "postuhdl.hxx"
+#include "shadwhdl.hxx"
+#include "shdwdhdl.hxx"
+#include "undlihdl.hxx"
+#include "weighhdl.hxx"
+#include "breakhdl.hxx"
+#include "adjushdl.hxx"
+#include "escphdl.hxx"
+#include "chrhghdl.hxx"
+#include "chrlohdl.hxx"
+#include "lspachdl.hxx"
+#include "bordrhdl.hxx"
+#include "tabsthdl.hxx"
+#include <xmloff/EnumPropertyHdl.hxx>
+#include <AttributeContainerHandler.hxx>
+#include "durationhdl.hxx"
+#include <XMLRectangleMembersHandler.hxx>
+#include <XMLNumberWithAutoForVoidPropHdl.hxx>
+#include "DrawAspectHdl.hxx"
+
+#include <map>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+SvXMLEnumMapEntry<drawing::ColorMode> const aXML_ColorMode_EnumMap[] =
+{
+ { XML_GREYSCALE, drawing::ColorMode_GREYS },
+ { XML_MONO, drawing::ColorMode_MONO },
+ { XML_WATERMARK, drawing::ColorMode_WATERMARK },
+ { XML_STANDARD, drawing::ColorMode_STANDARD },
+ { XML_TOKEN_INVALID, drawing::ColorMode(0) }
+};
+
+SvXMLEnumMapEntry<text::HorizontalAdjust> const aXML_HorizontalAdjust_Enum[] =
+{
+ { XML_LEFT, text::HorizontalAdjust_LEFT },
+ { XML_CENTER, text::HorizontalAdjust_CENTER },
+ { XML_RIGHT, text::HorizontalAdjust_RIGHT },
+ { XML_TOKEN_INVALID, text::HorizontalAdjust(0) }
+};
+
+// aXML_WritingDirection_Enum is used with and without 'page'
+// attribute, so you'll find uses of aXML_WritingDirection_Enum
+// directly, as well as &(aXML_WritingDirection_Enum[1])
+SvXMLEnumMapEntry<sal_uInt16> const aXML_WritingDirection_Enum[] =
+{
+ // aXML_WritingDirection_Enum
+ { XML_PAGE, text::WritingMode2::PAGE },
+
+ // &(aXML_WritingDirection_Enum[1])
+ { XML_LR_TB, text::WritingMode2::LR_TB },
+ { XML_RL_TB, text::WritingMode2::RL_TB },
+ { XML_TB_RL, text::WritingMode2::TB_RL },
+ { XML_TB_LR, text::WritingMode2::TB_LR },
+ { XML_BT_LR, text::WritingMode2::BT_LR },
+
+ // alternative names of the above, as accepted by XSL
+ { XML_LR, text::WritingMode2::LR_TB },
+ { XML_RL, text::WritingMode2::RL_TB },
+ { XML_TB, text::WritingMode2::TB_RL },
+
+ { XML_TOKEN_INVALID, 0 }
+};
+
+SvXMLEnumMapEntry<sal_uInt16> const pXML_VertPos_Enum[] =
+{
+ { XML_FROM_TOP, text::VertOrientation::NONE },
+ { XML_TOP, text::VertOrientation::TOP },
+ { XML_TOP, text::VertOrientation::CHAR_TOP }, // export only
+ { XML_TOP, text::VertOrientation::LINE_TOP }, // export only
+ { XML_MIDDLE, text::VertOrientation::CENTER },
+ { XML_MIDDLE, text::VertOrientation::CHAR_CENTER }, // export only
+ { XML_MIDDLE, text::VertOrientation::LINE_CENTER }, // export only
+ { XML_BOTTOM, text::VertOrientation::BOTTOM },
+ { XML_BOTTOM, text::VertOrientation::CHAR_BOTTOM }, // export only
+ { XML_BOTTOM, text::VertOrientation::LINE_BOTTOM }, // export only
+ { XML_BELOW, text::VertOrientation::CHAR_BOTTOM }, // import only
+ { XML_TOKEN_INVALID, 0 }
+};
+
+typedef std::map<sal_Int32, const XMLPropertyHandler*> CacheMap;
+
+struct XMLPropertyHandlerFactory::Impl
+{
+ mutable CacheMap maHandlerCache;
+};
+
+XMLPropertyHandlerFactory::XMLPropertyHandlerFactory() :
+ mpImpl(new Impl) {}
+
+XMLPropertyHandlerFactory::~XMLPropertyHandlerFactory()
+{
+ for( const auto& rCacheEntry : mpImpl->maHandlerCache )
+ delete rCacheEntry.second;
+}
+
+// Interface
+const XMLPropertyHandler* XMLPropertyHandlerFactory::GetPropertyHandler( sal_Int32 nType ) const
+{
+ SAL_WARN_IF( (nType & ~(sal_uInt32(MID_FLAG_MASK))) != 0, "xmloff",
+ "GetPropertyHandler called with flags in type" );
+ return GetBasicHandler( nType );
+}
+
+// Helper-methods to create and cache PropertyHandler
+const XMLPropertyHandler* XMLPropertyHandlerFactory::GetHdlCache( sal_Int32 nType ) const
+{
+ const XMLPropertyHandler* pRet = nullptr;
+
+ if( mpImpl->maHandlerCache.find( nType ) != mpImpl->maHandlerCache.end() )
+ pRet = mpImpl->maHandlerCache.find( nType )->second;
+
+ return pRet;
+}
+
+void XMLPropertyHandlerFactory::PutHdlCache( sal_Int32 nType, const XMLPropertyHandler* pHdl ) const
+{
+ mpImpl->maHandlerCache[nType] = pHdl;
+}
+
+const XMLPropertyHandler* XMLPropertyHandlerFactory::GetBasicHandler( sal_Int32 nType ) const
+{
+ const XMLPropertyHandler* pPropHdl = GetHdlCache( nType );
+ if( pPropHdl )
+ return pPropHdl;
+
+ std::unique_ptr<XMLPropertyHandler> pNewPropHdl = CreatePropertyHandler( nType );
+ if( pNewPropHdl )
+ PutHdlCache( nType, pNewPropHdl.get() );
+ return pNewPropHdl.release();
+}
+
+std::unique_ptr<XMLPropertyHandler> XMLPropertyHandlerFactory::CreatePropertyHandler( sal_Int32 nType )
+{
+ std::unique_ptr<XMLPropertyHandler> pPropHdl;
+
+ switch( nType )
+ {
+ case XML_TYPE_BOOL :
+ pPropHdl.reset(new XMLBoolPropHdl);
+ break;
+ case XML_TYPE_BOOL_FALSE :
+ pPropHdl.reset(new XMLBoolFalsePropHdl);
+ break;
+ case XML_TYPE_MEASURE :
+ pPropHdl.reset(new XMLMeasurePropHdl( 4 ));
+ break;
+ case XML_TYPE_MEASURE8 :
+ pPropHdl.reset(new XMLMeasurePropHdl( 1 ));
+ break;
+ case XML_TYPE_MEASURE16:
+ pPropHdl.reset(new XMLMeasurePropHdl( 2 ));
+ break;
+ case XML_TYPE_PERCENT :
+ pPropHdl.reset(new XMLPercentPropHdl( 4 ));
+ break;
+ case XML_TYPE_PERCENT8 :
+ pPropHdl.reset(new XMLPercentPropHdl( 1 ));
+ break;
+ case XML_TYPE_PERCENT16 :
+ pPropHdl.reset(new XMLPercentPropHdl( 2 ));
+ break;
+ case XML_TYPE_PERCENT100:
+ pPropHdl.reset(new XML100thPercentPropHdl);
+ break;
+ case XML_TYPE_DOUBLE_PERCENT :
+ pPropHdl.reset(new XMLDoublePercentPropHdl);
+ break;
+ case XML_TYPE_NEG_PERCENT :
+ pPropHdl.reset(new XMLNegPercentPropHdl( 4 ));
+ break;
+ case XML_TYPE_NEG_PERCENT8 :
+ pPropHdl.reset(new XMLNegPercentPropHdl( 1 ));
+ break;
+ case XML_TYPE_NEG_PERCENT16 :
+ pPropHdl.reset(new XMLNegPercentPropHdl( 2 ));
+ break;
+ case XML_TYPE_MEASURE_PX :
+ pPropHdl.reset(new XMLMeasurePxPropHdl( 4 ));
+ break;
+ case XML_TYPE_STRING :
+ pPropHdl.reset(new XMLStringPropHdl);
+ break;
+ case XML_TYPE_COLOR :
+ pPropHdl.reset(new XMLColorPropHdl);
+ break;
+ case XML_TYPE_HEX :
+ pPropHdl.reset(new XMLHexPropHdl);
+ break;
+ case XML_TYPE_NUMBER :
+ pPropHdl.reset(new XMLNumberPropHdl( 4 ));
+ break;
+ case XML_TYPE_NUMBER8 :
+ pPropHdl.reset(new XMLNumberPropHdl( 1 ));
+ break;
+ case XML_TYPE_NUMBER16:
+ pPropHdl.reset(new XMLNumberPropHdl( 2 ));
+ break;
+ case XML_TYPE_NUMBER_NONE :
+ pPropHdl.reset(new XMLNumberNonePropHdl);
+ break;
+ case XML_TYPE_NUMBER8_NONE :
+ pPropHdl.reset(new XMLNumberNonePropHdl( 1 ));
+ break;
+ case XML_TYPE_NUMBER16_NONE :
+ pPropHdl.reset(new XMLNumberNonePropHdl( 2 ));
+ break;
+ case XML_TYPE_DOUBLE :
+ pPropHdl.reset(new XMLDoublePropHdl);
+ break;
+ case XML_TYPE_NBOOL :
+ pPropHdl.reset(new XMLNBoolPropHdl);
+ break;
+ case XML_TYPE_COLORTRANSPARENT :
+ pPropHdl.reset(new XMLColorTransparentPropHdl);
+ break;
+ case XML_TYPE_ISTRANSPARENT :
+ pPropHdl.reset(new XMLIsTransparentPropHdl);
+ break;
+ case XML_TYPE_COLORAUTO :
+ pPropHdl.reset(new XMLColorAutoPropHdl);
+ break;
+ case XML_TYPE_ISAUTOCOLOR :
+ pPropHdl.reset(new XMLIsAutoColorPropHdl);
+ break;
+ case XML_TYPE_BUILDIN_CMP_ONLY :
+ pPropHdl.reset(new XMLCompareOnlyPropHdl);
+ break;
+
+ case XML_TYPE_RECTANGLE_LEFT :
+ case XML_TYPE_RECTANGLE_TOP :
+ case XML_TYPE_RECTANGLE_WIDTH :
+ case XML_TYPE_RECTANGLE_HEIGHT :
+ pPropHdl.reset(new XMLRectangleMembersHdl( nType ));
+ break;
+
+ case XML_TYPE_TEXT_CROSSEDOUT_TYPE:
+ pPropHdl.reset(new XMLCrossedOutTypePropHdl) ;
+ break;
+ case XML_TYPE_TEXT_CROSSEDOUT_STYLE:
+ pPropHdl.reset(new XMLCrossedOutStylePropHdl) ;
+ break;
+ case XML_TYPE_TEXT_CROSSEDOUT_WIDTH:
+ pPropHdl.reset(new XMLCrossedOutWidthPropHdl) ;
+ break;
+ case XML_TYPE_TEXT_CROSSEDOUT_TEXT:
+ pPropHdl.reset(new XMLCrossedOutTextPropHdl) ;
+ break;
+ case XML_TYPE_TEXT_BOOLCROSSEDOUT:
+ pPropHdl.reset(new XMLNamedBoolPropertyHdl(
+ GetXMLToken(XML_SOLID),
+ GetXMLToken(XML_NONE) ));
+ break;
+ case XML_TYPE_TEXT_ESCAPEMENT:
+ pPropHdl.reset(new XMLEscapementPropHdl);
+ break;
+ case XML_TYPE_TEXT_ESCAPEMENT_HEIGHT:
+ pPropHdl.reset(new XMLEscapementHeightPropHdl);
+ break;
+ case XML_TYPE_TEXT_CASEMAP:
+ pPropHdl.reset(new XMLCaseMapPropHdl);
+ break;
+ case XML_TYPE_TEXT_CASEMAP_VAR:
+ pPropHdl.reset(new XMLCaseMapVariantHdl);
+ break;
+ case XML_TYPE_TEXT_FONTFAMILYNAME:
+ pPropHdl.reset(new XMLFontFamilyNamePropHdl);
+ break;
+ case XML_TYPE_TEXT_FONTFAMILY:
+ pPropHdl.reset(new XMLFontFamilyPropHdl);
+ break;
+ case XML_TYPE_TEXT_FONTENCODING:
+ pPropHdl.reset(new XMLFontEncodingPropHdl);
+ break;
+ case XML_TYPE_TEXT_FONTPITCH:
+ pPropHdl.reset(new XMLFontPitchPropHdl);
+ break;
+ case XML_TYPE_TEXT_KERNING:
+ pPropHdl.reset(new XMLKerningPropHdl);
+ break;
+ case XML_TYPE_TEXT_POSTURE:
+ pPropHdl.reset(new XMLPosturePropHdl);
+ break;
+ case XML_TYPE_TEXT_SHADOWED:
+ pPropHdl.reset(new XMLShadowedPropHdl);
+ break;
+ case XML_TYPE_TEXT_UNDERLINE_TYPE:
+ pPropHdl.reset(new XMLUnderlineTypePropHdl);
+ break;
+ case XML_TYPE_TEXT_UNDERLINE_STYLE:
+ pPropHdl.reset(new XMLUnderlineStylePropHdl);
+ break;
+ case XML_TYPE_TEXT_UNDERLINE_WIDTH:
+ pPropHdl.reset(new XMLUnderlineWidthPropHdl);
+ break;
+ case XML_TYPE_TEXT_UNDERLINE_COLOR:
+ pPropHdl.reset(new XMLColorTransparentPropHdl( XML_FONT_COLOR ));
+ break;
+ case XML_TYPE_TEXT_UNDERLINE_HASCOLOR:
+ pPropHdl.reset(new XMLIsTransparentPropHdl( XML_FONT_COLOR,
+ false ));
+ break;
+ case XML_TYPE_TEXT_OVERLINE_TYPE:
+ pPropHdl.reset(new XMLUnderlineTypePropHdl);
+ break;
+ case XML_TYPE_TEXT_OVERLINE_STYLE:
+ pPropHdl.reset(new XMLUnderlineStylePropHdl);
+ break;
+ case XML_TYPE_TEXT_OVERLINE_WIDTH:
+ pPropHdl.reset(new XMLUnderlineWidthPropHdl);
+ break;
+ case XML_TYPE_TEXT_OVERLINE_COLOR:
+ pPropHdl.reset(new XMLColorTransparentPropHdl( XML_FONT_COLOR ));
+ break;
+ case XML_TYPE_TEXT_OVERLINE_HASCOLOR:
+ pPropHdl.reset(new XMLIsTransparentPropHdl( XML_FONT_COLOR,
+ false ));
+ break;
+ case XML_TYPE_TEXT_WEIGHT:
+ pPropHdl.reset(new XMLFontWeightPropHdl);
+ break;
+ case XML_TYPE_TEXT_SPLIT:
+ pPropHdl.reset(new XMLNamedBoolPropertyHdl(
+ GetXMLToken(XML_AUTO),
+ GetXMLToken(XML_ALWAYS) ));
+ break;
+ case XML_TYPE_TEXT_BREAKBEFORE:
+ pPropHdl.reset(new XMLFmtBreakBeforePropHdl);
+ break;
+ case XML_TYPE_TEXT_BREAKAFTER:
+ pPropHdl.reset(new XMLFmtBreakAfterPropHdl);
+ break;
+ case XML_TYPE_TEXT_SHADOW:
+ pPropHdl.reset(new XMLShadowPropHdl);
+ break;
+ case XML_TYPE_TEXT_ADJUST:
+ pPropHdl.reset(new XMLParaAdjustPropHdl);
+ break;
+ case XML_TYPE_TEXT_ADJUSTLAST:
+ pPropHdl.reset(new XMLLastLineAdjustPropHdl);
+ break;
+ case XML_TYPE_CHAR_HEIGHT:
+ pPropHdl.reset(new XMLCharHeightHdl);
+ break;
+ case XML_TYPE_CHAR_HEIGHT_PROP:
+ pPropHdl.reset(new XMLCharHeightPropHdl);
+ break;
+ case XML_TYPE_CHAR_HEIGHT_DIFF:
+ pPropHdl.reset(new XMLCharHeightDiffHdl);
+ break;
+ case XML_TYPE_CHAR_RFC_LANGUAGE_TAG:
+ pPropHdl.reset(new XMLCharRfcLanguageTagHdl);
+ break;
+ case XML_TYPE_CHAR_LANGUAGE:
+ pPropHdl.reset(new XMLCharLanguageHdl);
+ break;
+ case XML_TYPE_CHAR_SCRIPT:
+ pPropHdl.reset(new XMLCharScriptHdl);
+ break;
+ case XML_TYPE_CHAR_COUNTRY:
+ pPropHdl.reset(new XMLCharCountryHdl);
+ break;
+ case XML_TYPE_LINE_SPACE_FIXED:
+ pPropHdl.reset(new XMLLineHeightHdl);
+ break;
+ case XML_TYPE_LINE_SPACE_MINIMUM:
+ pPropHdl.reset(new XMLLineHeightAtLeastHdl);
+ break;
+ case XML_TYPE_LINE_SPACE_DISTANCE:
+ pPropHdl.reset(new XMLLineSpacingHdl);
+ break;
+ case XML_TYPE_BORDER_WIDTH:
+ pPropHdl.reset(new XMLBorderWidthHdl);
+ break;
+ case XML_TYPE_BORDER:
+ pPropHdl.reset(new XMLBorderHdl);
+ break;
+ case XML_TYPE_TEXT_TABSTOP:
+ pPropHdl.reset(new XMLTabStopPropHdl);
+ break;
+ case XML_TYPE_ATTRIBUTE_CONTAINER:
+ pPropHdl.reset(new XMLAttributeContainerHandler);
+ break;
+ case XML_TYPE_COLOR_MODE:
+ pPropHdl.reset(new XMLEnumPropertyHdl(aXML_ColorMode_EnumMap));
+ break;
+ case XML_TYPE_DURATION16_MS:
+ pPropHdl.reset(new XMLDurationMS16PropHdl_Impl);
+ break;
+ case XML_TYPE_TEXT_HORIZONTAL_ADJUST:
+ pPropHdl.reset(new XMLEnumPropertyHdl(aXML_HorizontalAdjust_Enum));
+ break;
+ case XML_TYPE_TEXT_DRAW_ASPECT:
+ pPropHdl.reset(new DrawAspectHdl);
+ break;
+ case XML_TYPE_TEXT_WRITING_MODE:
+ pPropHdl.reset(new XMLConstantsPropertyHandler(
+ &(aXML_WritingDirection_Enum[1]),
+ XML_LR_TB));
+ break;
+ case XML_TYPE_TEXT_WRITING_MODE_WITH_DEFAULT:
+ pPropHdl.reset(new XMLConstantsPropertyHandler(
+ aXML_WritingDirection_Enum,
+ XML_PAGE));
+ break;
+ case XML_TYPE_TEXT_HIDDEN_AS_DISPLAY:
+ pPropHdl.reset(new XMLNamedBoolPropertyHdl(
+ GetXMLToken(XML_NONE),
+ GetXMLToken(XML_TRUE) ));
+ break;
+ case XML_TYPE_STYLENAME :
+ pPropHdl.reset(new XMLStyleNamePropHdl);
+ break;
+ case XML_TYPE_NUMBER_NO_ZERO:
+ pPropHdl.reset(new XMLNumberWithoutZeroPropHdl( 4 ));
+ break;
+ case XML_TYPE_NUMBER8_NO_ZERO:
+ pPropHdl.reset(new XMLNumberWithoutZeroPropHdl( 1 ));
+ break;
+ case XML_TYPE_NUMBER16_NO_ZERO:
+ pPropHdl.reset(new XMLNumberWithoutZeroPropHdl( 2 ));
+ break;
+ case XML_TYPE_NUMBER16_AUTO:
+ pPropHdl.reset(new XMLNumberWithAutoForVoidPropHdl);
+ break;
+ case XML_TYPE_TEXT_VERTICAL_POS:
+ pPropHdl.reset(new XMLConstantsPropertyHandler( pXML_VertPos_Enum, XML_TOKEN_INVALID ));
+ break;
+
+ }
+
+ return pPropHdl;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/prstylecond.cxx b/xmloff/source/style/prstylecond.cxx
new file mode 100644
index 000000000..4da002488
--- /dev/null
+++ b/xmloff/source/style/prstylecond.cxx
@@ -0,0 +1,91 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <rtl/ustring.hxx>
+#include <prstylecond.hxx>
+#include <xmloff/xmltoken.hxx>
+
+using namespace ::xmloff::token;
+
+// note: keep this in sync with the list of conditions in sw/source/uibase/chrdlg/ccoll.cxx
+
+namespace {
+
+struct ConditionMap
+{
+ char const* aInternal;
+ XMLTokenEnum nExternal;
+ int aValue;
+};
+
+}
+
+const ConditionMap g_ConditionMap[] =
+{
+ { "TableHeader", XML_TABLE_HEADER, -1 },
+ { "Table", XML_TABLE, -1 },
+ { "Frame", XML_TEXT_BOX, -1 }, // FIXME - Not in ODF spec
+ { "Section", XML_SECTION, -1 },
+ { "Footnote", XML_FOOTNOTE, -1 },
+ { "Endnote", XML_ENDNOTE, -1 },
+ { "Header", XML_HEADER, -1 },
+ { "Footer", XML_FOOTER, -1 },
+ { "OutlineLevel1", XML_OUTLINE_LEVEL, 1 },
+ { "OutlineLevel2", XML_OUTLINE_LEVEL, 2 },
+ { "OutlineLevel3", XML_OUTLINE_LEVEL, 3 },
+ { "OutlineLevel4", XML_OUTLINE_LEVEL, 4 },
+ { "OutlineLevel5", XML_OUTLINE_LEVEL, 5 },
+ { "OutlineLevel6", XML_OUTLINE_LEVEL, 6 },
+ { "OutlineLevel7", XML_OUTLINE_LEVEL, 7 },
+ { "OutlineLevel8", XML_OUTLINE_LEVEL, 8 },
+ { "OutlineLevel9", XML_OUTLINE_LEVEL, 9 },
+ { "OutlineLevel10", XML_OUTLINE_LEVEL, 10 },
+ { "NumberingLevel1", XML_LIST_LEVEL, 1 },
+ { "NumberingLevel2", XML_LIST_LEVEL, 2 },
+ { "NumberingLevel3", XML_LIST_LEVEL, 3 },
+ { "NumberingLevel4", XML_LIST_LEVEL, 4 },
+ { "NumberingLevel5", XML_LIST_LEVEL, 5 },
+ { "NumberingLevel6", XML_LIST_LEVEL, 6 },
+ { "NumberingLevel7", XML_LIST_LEVEL, 7 },
+ { "NumberingLevel8", XML_LIST_LEVEL, 8 },
+ { "NumberingLevel9", XML_LIST_LEVEL, 9 },
+ { "NumberingLevel10", XML_LIST_LEVEL, 10 }
+};
+
+OUString GetParaStyleCondExternal( OUString const &internal)
+{
+ for (size_t i = 0; i < SAL_N_ELEMENTS(g_ConditionMap); ++i)
+ {
+ if (internal.compareToAscii( g_ConditionMap[i].aInternal ) == 0)
+ {
+ OUString aResult = GetXMLToken( g_ConditionMap[i].nExternal ) +
+ "()";
+ if (g_ConditionMap[i].aValue != -1)
+ {
+ aResult += "=" +
+ OUString::number( g_ConditionMap[i].aValue );
+ }
+ return aResult;
+ }
+ }
+ assert(!"GetParaStyleCondExternal: model has unknown style condition");
+ return OUString();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/prstylei.cxx b/xmloff/source/style/prstylei.cxx
new file mode 100644
index 000000000..aae787d49
--- /dev/null
+++ b/xmloff/source/style/prstylei.cxx
@@ -0,0 +1,664 @@
+/* -*- 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 <o3tl/any.hxx>
+#include <osl/diagnose.h>
+#include <sal/log.hxx>
+#include <set>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlprcon.hxx>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/style/XStyle.hpp>
+#include <com/sun/star/style/XAutoStyleFamily.hpp>
+#include <com/sun/star/container/XNameContainer.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/beans/XPropertyState.hpp>
+#include <com/sun/star/beans/XMultiPropertyStates.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/prstylei.hxx>
+#include <xmloff/xmlerror.hxx>
+#include <xmloff/xmltypes.hxx>
+#include <xmloff/maptype.hxx>
+#include <xmloff/xmlimppr.hxx>
+#include <xmloff/xmlprmap.hxx>
+#include <comphelper/sequence.hxx>
+#include <com/sun/star/drawing/FillStyle.hpp>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::xml::sax;
+using namespace ::com::sun::star::style;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::lang;
+using namespace ::xmloff::token;
+using namespace com::sun::star::drawing;
+
+void XMLPropStyleContext::SetAttribute( sal_Int32 nElement,
+ const OUString& rValue )
+{
+ if( nElement == XML_ELEMENT(STYLE, XML_FAMILY) )
+ {
+ SAL_WARN_IF( GetFamily() != SvXMLStylesContext::GetFamily( rValue ), "xmloff", "unexpected style family" );
+ }
+ else
+ {
+ SvXMLStyleContext::SetAttribute( nElement, rValue );
+ }
+}
+
+
+namespace
+{
+ struct theStandardSet :
+ public rtl::StaticWithInit<OldFillStyleDefinitionSet, theStandardSet>
+ {
+ OldFillStyleDefinitionSet operator () ()
+ {
+ OldFillStyleDefinitionSet aSet;
+ aSet.insert("BackColorRGB");
+ aSet.insert("BackTransparent");
+ aSet.insert("BackColorTransparency");
+ aSet.insert("BackGraphic");
+ aSet.insert("BackGraphicFilter");
+ aSet.insert("BackGraphicLocation");
+ aSet.insert("BackGraphicTransparency");
+ return aSet;
+ }
+ };
+ struct theHeaderSet :
+ public rtl::StaticWithInit<OldFillStyleDefinitionSet, theHeaderSet>
+ {
+ OldFillStyleDefinitionSet operator () ()
+ {
+ OldFillStyleDefinitionSet aSet;
+ aSet.insert("HeaderBackColorRGB");
+ aSet.insert("HeaderBackTransparent");
+ aSet.insert("HeaderBackColorTransparency");
+ aSet.insert("HeaderBackGraphic");
+ aSet.insert("HeaderBackGraphicFilter");
+ aSet.insert("HeaderBackGraphicLocation");
+ aSet.insert("HeaderBackGraphicTransparency");
+ return aSet;
+ }
+ };
+ struct theFooterSet :
+ public rtl::StaticWithInit<OldFillStyleDefinitionSet, theFooterSet>
+ {
+ OldFillStyleDefinitionSet operator () ()
+ {
+ OldFillStyleDefinitionSet aSet;
+ aSet.insert("FooterBackColorRGB");
+ aSet.insert("FooterBackTransparent");
+ aSet.insert("FooterBackColorTransparency");
+ aSet.insert("FooterBackGraphic");
+ aSet.insert("FooterBackGraphicFilter");
+ aSet.insert("FooterBackGraphicLocation");
+ aSet.insert("FooterBackGraphicTransparency");
+ return aSet;
+ }
+ };
+ struct theParaSet :
+ public rtl::StaticWithInit<OldFillStyleDefinitionSet, theParaSet>
+ {
+ OldFillStyleDefinitionSet operator () ()
+ {
+ OldFillStyleDefinitionSet aSet;
+ // Caution: here it is *not* 'ParaBackColorRGB' as it should be, but indeed
+ // 'ParaBackColor' is used, see aXMLParaPropMap definition (line 313)
+ aSet.insert("ParaBackColor");
+ aSet.insert("ParaBackTransparent");
+ aSet.insert("ParaBackGraphicLocation");
+ aSet.insert("ParaBackGraphicFilter");
+ aSet.insert("ParaBackGraphic");
+
+ // These are not used in aXMLParaPropMap definition, thus not needed here
+ // aSet.insert("ParaBackColorTransparency");
+ // aSet.insert("ParaBackGraphicTransparency");
+ return aSet;
+ }
+ };
+}
+
+
+
+constexpr OUStringLiteral gsIsPhysical( u"IsPhysical" );
+constexpr OUStringLiteral gsFollowStyle( u"FollowStyle" );
+
+XMLPropStyleContext::XMLPropStyleContext( SvXMLImport& rImport,
+ SvXMLStylesContext& rStyles, XmlStyleFamily nFamily,
+ bool bDefault )
+: SvXMLStyleContext( rImport, nFamily, bDefault )
+, mxStyles( &rStyles )
+{
+}
+
+XMLPropStyleContext::~XMLPropStyleContext()
+{
+}
+
+const OldFillStyleDefinitionSet& XMLPropStyleContext::getStandardSet()
+{
+ return theStandardSet::get();
+}
+
+const OldFillStyleDefinitionSet& XMLPropStyleContext::getHeaderSet()
+{
+ return theHeaderSet::get();
+}
+
+const OldFillStyleDefinitionSet& XMLPropStyleContext::getFooterSet()
+{
+ return theFooterSet::get();
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > XMLPropStyleContext::createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+ sal_uInt32 nFamily = 0;
+ if( IsTokenInNamespace(nElement, XML_NAMESPACE_STYLE) ||
+ IsTokenInNamespace(nElement, XML_NAMESPACE_LO_EXT) )
+ {
+ sal_Int32 nLocalName = nElement & TOKEN_MASK;
+ if( nLocalName == XML_GRAPHIC_PROPERTIES )
+ nFamily = XML_TYPE_PROP_GRAPHIC;
+ else if( nLocalName == XML_DRAWING_PAGE_PROPERTIES )
+ nFamily = XML_TYPE_PROP_DRAWING_PAGE;
+ else if( nLocalName == XML_TEXT_PROPERTIES )
+ nFamily = XML_TYPE_PROP_TEXT;
+ else if( nLocalName == XML_PARAGRAPH_PROPERTIES )
+ nFamily = XML_TYPE_PROP_PARAGRAPH;
+ else if( nLocalName == XML_RUBY_PROPERTIES )
+ nFamily = XML_TYPE_PROP_RUBY;
+ else if( nLocalName == XML_SECTION_PROPERTIES )
+ nFamily = XML_TYPE_PROP_SECTION;
+ else if( nLocalName == XML_TABLE_PROPERTIES )
+ nFamily = XML_TYPE_PROP_TABLE;
+ else if( nLocalName == XML_TABLE_COLUMN_PROPERTIES )
+ nFamily = XML_TYPE_PROP_TABLE_COLUMN;
+ else if( nLocalName ==XML_TABLE_ROW_PROPERTIES )
+ nFamily = XML_TYPE_PROP_TABLE_ROW;
+ else if( nLocalName == XML_TABLE_CELL_PROPERTIES )
+ nFamily = XML_TYPE_PROP_TABLE_CELL;
+ else if( nLocalName == XML_CHART_PROPERTIES )
+ nFamily = XML_TYPE_PROP_CHART;
+ }
+ if( nFamily )
+ {
+ rtl::Reference < SvXMLImportPropertyMapper > xImpPrMap =
+ mxStyles->GetImportPropertyMapper( GetFamily() );
+ if( xImpPrMap.is() )
+ return new SvXMLPropertySetContext( GetImport(), nElement,
+ xAttrList,
+ nFamily,
+ maProperties,
+ xImpPrMap );
+ }
+ XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+ return nullptr;
+}
+
+void XMLPropStyleContext::FillPropertySet(
+ const Reference< XPropertySet > & rPropSet )
+{
+ rtl::Reference < SvXMLImportPropertyMapper > xImpPrMap =
+ mxStyles->GetImportPropertyMapper( GetFamily() );
+ SAL_WARN_IF( !xImpPrMap.is(), "xmloff", "There is the import prop mapper" );
+ if( xImpPrMap.is() )
+ xImpPrMap->FillPropertySet( maProperties, rPropSet );
+}
+
+void XMLPropStyleContext::SetDefaults()
+{
+}
+
+Reference < XStyle > XMLPropStyleContext::Create()
+{
+ Reference < XStyle > xNewStyle;
+
+ OUString sServiceName = mxStyles->GetServiceName( GetFamily() );
+ if( !sServiceName.isEmpty() )
+ {
+ Reference< XMultiServiceFactory > xFactory( GetImport().GetModel(),
+ UNO_QUERY );
+ if( xFactory.is() )
+ {
+ Reference < XInterface > xIfc =
+ xFactory->createInstance( sServiceName );
+ if( xIfc.is() )
+ xNewStyle.set( xIfc, UNO_QUERY );
+ }
+ }
+
+ return xNewStyle;
+}
+
+void XMLPropStyleContext::CreateAndInsert( bool bOverwrite )
+{
+ SvXMLStylesContext* pSvXMLStylesContext = mxStyles.get();
+ rtl::Reference < SvXMLImportPropertyMapper > xImpPrMap = pSvXMLStylesContext->GetImportPropertyMapper(GetFamily());
+ OSL_ENSURE(xImpPrMap.is(), "There is no import prop mapper");
+
+ // need to filter out old fill definitions when the new ones are used. The new
+ // ones are used when a FillStyle is defined
+ const bool bTakeCareOfDrawingLayerFillStyle(xImpPrMap.is() && GetFamily() == XmlStyleFamily::TEXT_PARAGRAPH);
+ bool bDrawingLayerFillStylesUsed(false);
+
+ if(bTakeCareOfDrawingLayerFillStyle)
+ {
+ // check if new FillStyles are used and if so mark old ones with -1
+ static OUString s_FillStyle("FillStyle");
+
+ if(doNewDrawingLayerFillStyleDefinitionsExist(s_FillStyle))
+ {
+ deactivateOldFillStyleDefinitions(theParaSet::get());
+ bDrawingLayerFillStylesUsed = true;
+ }
+ }
+
+ if( pSvXMLStylesContext->IsAutomaticStyle()
+ && ( GetFamily() == XmlStyleFamily::TEXT_TEXT || GetFamily() == XmlStyleFamily::TEXT_PARAGRAPH ) )
+ {
+ // Need to translate StyleName from temp MapNames to names
+ // used in already imported items (already exist in the pool). This
+ // is required for AutomaticStyles since these do *not* use FillPropertySet
+ // and thus just trigger CheckSpecialContext in XMLTextStyleContext::FillPropertySet
+ // (which may be double action anyways). The mechanism there to use _ContextID_Index_Pair
+ // is not working for AutomaticStyles and is already too late, too (this
+ // method is already called before XMLTextStyleContext::FillPropertySet gets called)
+ if(bDrawingLayerFillStylesUsed)
+ {
+ translateNameBasedDrawingLayerFillStyleDefinitionsToStyleDisplayNames();
+ }
+
+ Reference < XAutoStyleFamily > xAutoFamily = pSvXMLStylesContext->GetAutoStyles( GetFamily() );
+ if( !xAutoFamily.is() )
+ return;
+ if( xImpPrMap.is() )
+ {
+ Sequence< PropertyValue > aValues;
+ xImpPrMap->FillPropertySequence( maProperties, aValues );
+
+ sal_Int32 nLen = aValues.getLength();
+ if( nLen )
+ {
+ if( GetFamily() == XmlStyleFamily::TEXT_PARAGRAPH )
+ {
+ aValues.realloc( nLen + 2 );
+ PropertyValue *pProps = aValues.getArray() + nLen;
+ pProps->Name = "ParaStyleName";
+ OUString sParent( GetParentName() );
+ if( !sParent.isEmpty() )
+ {
+ sParent = GetImport().GetStyleDisplayName( GetFamily(), sParent );
+ Reference < XNameContainer > xFamilies = pSvXMLStylesContext->GetStylesContainer( GetFamily() );
+ if(xFamilies.is() && xFamilies->hasByName( sParent ) )
+ {
+ css::uno::Reference< css::style::XStyle > xStyle;
+ Any aAny = xFamilies->getByName( sParent );
+ aAny >>= xStyle;
+ sParent = xStyle->getName() ;
+ }
+ }
+ else
+ sParent = "Standard";
+ pProps->Value <<= sParent;
+ ++pProps;
+ pProps->Name = "ParaConditionalStyleName";
+ pProps->Value <<= sParent;
+ }
+
+ Reference < XAutoStyle > xAutoStyle = xAutoFamily->insertStyle( aValues );
+ if( xAutoStyle.is() )
+ {
+ Sequence< OUString > aPropNames
+ {
+ (GetFamily() == XmlStyleFamily::TEXT_PARAGRAPH)?
+ OUString("ParaAutoStyleName"):
+ OUString("CharAutoStyleName")
+ };
+ Sequence< Any > aAny = xAutoStyle->getPropertyValues( aPropNames );
+ if( aAny.hasElements() )
+ {
+ OUString aName;
+ aAny[0] >>= aName;
+ SetAutoName( aName );
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ const OUString& rName = GetDisplayName();
+ if( rName.isEmpty() || IsDefaultStyle() )
+ return;
+
+ Reference < XNameContainer > xFamilies = pSvXMLStylesContext->GetStylesContainer( GetFamily() );
+ if( !xFamilies.is() )
+ {
+ SAL_WARN("xmloff", "no styles container for family " << static_cast<int>(GetFamily()));
+ return;
+ }
+
+ bool bNew = false;
+ if( xFamilies->hasByName( rName ) )
+ {
+ Any aAny = xFamilies->getByName( rName );
+ aAny >>= mxStyle;
+ }
+ else
+ {
+ mxStyle = Create();
+ if( !mxStyle.is() )
+ return;
+
+ xFamilies->insertByName( rName, Any(mxStyle) );
+ bNew = true;
+ }
+
+ Reference < XPropertySet > xPropSet( mxStyle, UNO_QUERY );
+ Reference< XPropertySetInfo > xPropSetInfo =
+ xPropSet->getPropertySetInfo();
+ if( !bNew && xPropSetInfo->hasPropertyByName( gsIsPhysical ) )
+ {
+ Any aAny = xPropSet->getPropertyValue( gsIsPhysical );
+ bNew = !*o3tl::doAccess<bool>(aAny);
+ }
+ SetNew( bNew );
+ if( rName != GetName() )
+ GetImport().AddStyleDisplayName( GetFamily(), GetName(), rName );
+
+
+ if( bOverwrite || bNew )
+ {
+ rtl::Reference < XMLPropertySetMapper > xPrMap;
+ if( xImpPrMap.is() )
+ xPrMap = xImpPrMap->getPropertySetMapper();
+ if( xPrMap.is() )
+ {
+ Reference < XMultiPropertyStates > xMultiStates( xPropSet,
+ UNO_QUERY );
+ if( xMultiStates.is() )
+ {
+ xMultiStates->setAllPropertiesToDefault();
+ }
+ else
+ {
+ std::set < OUString > aNameSet;
+ sal_Int32 nCount = xPrMap->GetEntryCount();
+ sal_Int32 i;
+ for( i = 0; i < nCount; i++ )
+ {
+ const OUString& rPrName = xPrMap->GetEntryAPIName( i );
+ if( xPropSetInfo->hasPropertyByName( rPrName ) )
+ aNameSet.insert( rPrName );
+ }
+ Reference< XPropertyState > xPropState( xPropSet, uno::UNO_QUERY );
+ if (xPropState.is())
+ {
+ nCount = aNameSet.size();
+ Sequence<OUString> aNames( comphelper::containerToSequence(aNameSet) );
+ Sequence < PropertyState > aStates( xPropState->getPropertyStates(aNames) );
+ const PropertyState *pStates = aStates.getConstArray();
+ OUString* pNames = aNames.getArray();
+
+ for( i = 0; i < nCount; i++ )
+ {
+ if( PropertyState_DIRECT_VALUE == *pStates++ )
+ xPropState->setPropertyToDefault( pNames[i] );
+ }
+ }
+ }
+ }
+
+ if (mxStyle.is())
+ mxStyle->setParentStyle(OUString());
+
+ FillPropertySet( xPropSet );
+ }
+ else
+ {
+ SetValid( false );
+ }
+ }
+}
+
+void XMLPropStyleContext::Finish( bool bOverwrite )
+{
+ if( !mxStyle.is() || !(IsNew() || bOverwrite) )
+ return;
+
+ // The families container must exist
+ Reference < XNameContainer > xFamilies = mxStyles->GetStylesContainer( GetFamily() );
+ SAL_WARN_IF( !xFamilies.is(), "xmloff", "Families lost" );
+ if( !xFamilies.is() )
+ return;
+
+ // connect parent
+ OUString sParent( GetParentName() );
+ if( !sParent.isEmpty() )
+ sParent = GetImport().GetStyleDisplayName( GetFamily(), sParent );
+ if( !sParent.isEmpty() && !xFamilies->hasByName( sParent ) )
+ sParent.clear();
+
+ if( sParent != mxStyle->getParentStyle() )
+ {
+ // this may except if setting the parent style forms a
+ // circle in the style dependencies; especially if the parent
+ // style is the same as the current style
+ try
+ {
+ mxStyle->setParentStyle( sParent );
+ }
+ catch(const uno::Exception& e)
+ {
+ // according to the API definition, I would expect a
+ // container::NoSuchElementException. But it throws an
+ // uno::RuntimeException instead. I catch
+ // uno::Exception in order to process both of them.
+
+ // We can't set the parent style. For a proper
+ // Error-Message, we should pass in the name of the
+ // style, as well as the desired parent style.
+
+ // getName() throws no non-Runtime exception:
+ GetImport().SetError(
+ XMLERROR_FLAG_ERROR | XMLERROR_PARENT_STYLE_NOT_ALLOWED,
+ { mxStyle->getName(), sParent }, e.Message, nullptr );
+ }
+ }
+
+ // connect follow
+ OUString sFollow( GetFollow() );
+ if( !sFollow.isEmpty() )
+ sFollow = GetImport().GetStyleDisplayName( GetFamily(), sFollow );
+ if( sFollow.isEmpty() || !xFamilies->hasByName( sFollow ) )
+ sFollow = mxStyle->getName();
+
+ Reference < XPropertySet > xPropSet( mxStyle, UNO_QUERY );
+ Reference< XPropertySetInfo > xPropSetInfo =
+ xPropSet->getPropertySetInfo();
+ if( xPropSetInfo->hasPropertyByName( gsFollowStyle ) )
+ {
+ Any aAny = xPropSet->getPropertyValue( gsFollowStyle );
+ OUString sCurrFollow;
+ aAny >>= sCurrFollow;
+ if( sCurrFollow != sFollow )
+ {
+ xPropSet->setPropertyValue( gsFollowStyle, Any(sFollow) );
+ }
+ }
+
+ // Connect linked style.
+ OUString aLinked(GetLinked());
+ if (!aLinked.isEmpty())
+ {
+ if (GetFamily() == XmlStyleFamily::TEXT_PARAGRAPH)
+ {
+ aLinked = GetImport().GetStyleDisplayName(XmlStyleFamily::TEXT_TEXT, aLinked);
+ }
+ else if (GetFamily() == XmlStyleFamily::TEXT_TEXT)
+ {
+ aLinked = GetImport().GetStyleDisplayName(XmlStyleFamily::TEXT_PARAGRAPH, aLinked);
+ }
+ }
+ if (!aLinked.isEmpty() && xPropSetInfo->hasPropertyByName("LinkStyle"))
+ {
+ uno::Any aAny = xPropSet->getPropertyValue("LinkStyle");
+ OUString aCurrentLinked;
+ aAny >>= aCurrentLinked;
+ if (aCurrentLinked != aLinked)
+ {
+ xPropSet->setPropertyValue("LinkStyle", uno::Any(aLinked));
+ }
+ }
+
+ if ( xPropSetInfo->hasPropertyByName( "Hidden" ) )
+ {
+ xPropSet->setPropertyValue( "Hidden", uno::Any( IsHidden( ) ) );
+ }
+
+}
+
+bool XMLPropStyleContext::doNewDrawingLayerFillStyleDefinitionsExist(
+ const OUString& rFillStyleTag) const
+{
+ if(!maProperties.empty() && rFillStyleTag.getLength())
+ {
+ // no & to avoid non-obvious UAF due to the 2nd temp Reference
+ const rtl::Reference<XMLPropertySetMapper> rMapper = GetStyles()->GetImportPropertyMapper(GetFamily())->getPropertySetMapper();
+
+ if(rMapper.is())
+ {
+ for(const auto& a : maProperties)
+ {
+ if(a.mnIndex != -1)
+ {
+ const OUString& rPropName = rMapper->GetEntryAPIName(a.mnIndex);
+
+ if(rPropName == rFillStyleTag)
+ {
+ FillStyle eFillStyle(FillStyle_NONE);
+
+ if(a.maValue >>= eFillStyle)
+ {
+ // okay, type was good, FillStyle is set
+ }
+ else
+ {
+ // also try an int (see XFillStyleItem::PutValue)
+ sal_Int32 nFillStyle(0);
+
+ if(a.maValue >>= nFillStyle)
+ {
+ eFillStyle = static_cast< FillStyle >(nFillStyle);
+ }
+ }
+
+ // we found the entry, check it
+ return FillStyle_NONE != eFillStyle;
+ }
+ }
+ }
+ }
+ }
+
+ return false;
+}
+
+void XMLPropStyleContext::deactivateOldFillStyleDefinitions(
+ const OldFillStyleDefinitionSet& rHashSetOfTags)
+{
+ if(rHashSetOfTags.empty() || maProperties.empty())
+ return;
+
+ const rtl::Reference< XMLPropertySetMapper >& rMapper = GetStyles()->GetImportPropertyMapper(GetFamily())->getPropertySetMapper();
+
+ if(!rMapper.is())
+ return;
+
+ for(auto& a : maProperties)
+ {
+ if(a.mnIndex != -1)
+ {
+ const OUString& rPropName = rMapper->GetEntryAPIName(a.mnIndex);
+
+ if(rHashSetOfTags.find(rPropName) != rHashSetOfTags.end())
+ {
+ // mark entry as inactive
+ a.mnIndex = -1;
+ }
+ }
+ }
+}
+
+void XMLPropStyleContext::translateNameBasedDrawingLayerFillStyleDefinitionsToStyleDisplayNames()
+{
+ if(maProperties.empty())
+ return;
+
+ const rtl::Reference< XMLPropertySetMapper >& rMapper = GetStyles()->GetImportPropertyMapper(GetFamily())->getPropertySetMapper();
+
+ if(!rMapper.is())
+ return;
+
+ static constexpr OUStringLiteral s_FillGradientName(u"FillGradientName");
+ static constexpr OUStringLiteral s_FillHatchName(u"FillHatchName");
+ static constexpr OUStringLiteral s_FillBitmapName(u"FillBitmapName");
+ static constexpr OUStringLiteral s_FillTransparenceGradientName(u"FillTransparenceGradientName");
+
+ for(auto& a : maProperties)
+ {
+ if(a.mnIndex != -1)
+ {
+ const OUString& rPropName = rMapper->GetEntryAPIName(a.mnIndex);
+ XmlStyleFamily aStyleFamily(XmlStyleFamily::DATA_STYLE);
+
+ if(rPropName == s_FillGradientName || rPropName == s_FillTransparenceGradientName)
+ {
+ aStyleFamily = XmlStyleFamily::SD_GRADIENT_ID;
+ }
+ else if(rPropName == s_FillHatchName)
+ {
+ aStyleFamily = XmlStyleFamily::SD_HATCH_ID;
+ }
+ else if(rPropName == s_FillBitmapName)
+ {
+ aStyleFamily = XmlStyleFamily::SD_FILL_IMAGE_ID;
+ }
+
+ if(aStyleFamily != XmlStyleFamily::DATA_STYLE)
+ {
+ OUString sStyleName;
+
+ a.maValue >>= sStyleName;
+ sStyleName = GetImport().GetStyleDisplayName( aStyleFamily, sStyleName );
+ a.maValue <<= sStyleName;
+ }
+ }
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/shadwhdl.cxx b/xmloff/source/style/shadwhdl.cxx
new file mode 100644
index 000000000..b80db3a8d
--- /dev/null
+++ b/xmloff/source/style/shadwhdl.cxx
@@ -0,0 +1,167 @@
+/* -*- 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 "shadwhdl.hxx"
+#include <com/sun/star/uno/Any.hxx>
+#include <rtl/ustrbuf.hxx>
+
+
+#include <com/sun/star/table/ShadowFormat.hpp>
+#include <o3tl/safeint.hxx>
+#include <tools/color.hxx>
+#include <sax/tools/converter.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmltoken.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+
+
+
+XMLShadowPropHdl::~XMLShadowPropHdl()
+{
+ // nothing to do
+}
+
+bool XMLShadowPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
+{
+ bool bRet = false;
+ table::ShadowFormat aShadow;
+ aShadow.Location = table::ShadowLocation_BOTTOM_RIGHT;
+
+ bool bColorFound = false;
+ bool bOffsetFound = false;
+ SvXMLTokenEnumerator aTokenEnum( rStrImpValue );
+ Color aColor( 128,128, 128 );
+ std::u16string_view aToken;
+
+ while( aTokenEnum.getNextToken( aToken ) )
+ {
+ if( IsXMLToken( aToken, XML_NONE ) )
+ {
+ aShadow.Location = table::ShadowLocation_NONE;
+ bRet = true;
+ break;
+ }
+ else if( !bColorFound && aToken.substr(0,1) == u"#" )
+ {
+ bRet = ::sax::Converter::convertColor( aColor, aToken );
+ if( !bRet )
+ return false;
+ bColorFound = true;
+ }
+ else if( !bOffsetFound )
+ {
+ sal_Int32 nX = 0, nY = 0;
+
+ bRet = rUnitConverter.convertMeasureToCore( nX, aToken );
+ if( bRet && aTokenEnum.getNextToken( aToken ) )
+ bRet = rUnitConverter.convertMeasureToCore( nY, aToken );
+
+ if( bRet )
+ {
+ if( nX < 0 )
+ {
+ if( nY < 0 )
+ aShadow.Location = table::ShadowLocation_TOP_LEFT;
+ else
+ aShadow.Location = table::ShadowLocation_BOTTOM_LEFT;
+ }
+ else
+ {
+ if( nY < 0 )
+ aShadow.Location = table::ShadowLocation_TOP_RIGHT;
+ else
+ aShadow.Location = table::ShadowLocation_BOTTOM_RIGHT;
+ }
+
+ if (nX < 0)
+ nX = o3tl::saturating_toggle_sign(nX);
+ if (nY < 0)
+ nY = o3tl::saturating_toggle_sign(nY);
+
+ sal_Int32 nWidth;
+ bRet = !o3tl::checked_add(nX, nY, nWidth);
+ if (bRet)
+ aShadow.ShadowWidth = sal::static_int_cast<sal_Int16>(nWidth >> 1);
+ }
+ }
+ }
+
+ if( bRet && ( bColorFound || bOffsetFound ) )
+ {
+ aShadow.IsTransparent = aColor.IsTransparent();
+ aShadow.Color = sal_Int32(aColor);
+ bRet = true;
+ }
+
+ rValue <<= aShadow;
+
+ return bRet;
+}
+
+bool XMLShadowPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
+{
+ bool bRet = false;
+ table::ShadowFormat aShadow;
+
+ if( rValue >>= aShadow )
+ {
+ sal_Int32 nX = 1, nY = 1;
+
+ switch( aShadow.Location )
+ {
+ case table::ShadowLocation_TOP_LEFT:
+ nX = -1;
+ nY = -1;
+ break;
+ case table::ShadowLocation_TOP_RIGHT:
+ nY = -1;
+ break;
+ case table::ShadowLocation_BOTTOM_LEFT:
+ nX = -1;
+ break;
+ case table::ShadowLocation_BOTTOM_RIGHT:
+ break;
+ case table::ShadowLocation_NONE:
+ default:
+ rStrExpValue = GetXMLToken(XML_NONE);
+ return true;
+ }
+
+ nX *= aShadow.ShadowWidth;
+ nY *= aShadow.ShadowWidth;
+
+ OUStringBuffer aOut;
+ ::sax::Converter::convertColor( aOut, aShadow.Color );
+ aOut.append( ' ' );
+ rUnitConverter.convertMeasureToXML( aOut, nX );
+ aOut.append( ' ' );
+ rUnitConverter.convertMeasureToXML( aOut, nY );
+
+ rStrExpValue = aOut.makeStringAndClear();
+
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/shadwhdl.hxx b/xmloff/source/style/shadwhdl.hxx
new file mode 100644
index 000000000..8b0a7762f
--- /dev/null
+++ b/xmloff/source/style/shadwhdl.hxx
@@ -0,0 +1,36 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLShadowPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLShadowPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/shdwdhdl.cxx b/xmloff/source/style/shdwdhdl.cxx
new file mode 100644
index 000000000..41b1b4574
--- /dev/null
+++ b/xmloff/source/style/shdwdhdl.cxx
@@ -0,0 +1,67 @@
+/* -*- 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 "shdwdhdl.hxx"
+#include <com/sun/star/uno/Any.hxx>
+
+
+#include <xmloff/xmltoken.hxx>
+
+using namespace ::com::sun::star::uno;
+using namespace ::xmloff::token;
+
+
+
+
+XMLShadowedPropHdl::~XMLShadowedPropHdl()
+{
+ // nothing to do
+}
+
+bool XMLShadowedPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bValue = ! IsXMLToken( rStrImpValue, XML_NONE );
+ rValue <<= bValue;
+
+ return true;
+}
+
+bool XMLShadowedPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ bool bValue;
+
+ if (rValue >>= bValue)
+ {
+ if( bValue )
+ {
+ rStrExpValue = "1pt 1pt";
+ }
+ else
+ {
+ rStrExpValue = GetXMLToken( XML_NONE );
+ }
+
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/shdwdhdl.hxx b/xmloff/source/style/shdwdhdl.hxx
new file mode 100644
index 000000000..e7397f80c
--- /dev/null
+++ b/xmloff/source/style/shdwdhdl.hxx
@@ -0,0 +1,36 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLShadowedPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLShadowedPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/styleexp.cxx b/xmloff/source/style/styleexp.cxx
new file mode 100644
index 000000000..b311dbdf6
--- /dev/null
+++ b/xmloff/source/style/styleexp.cxx
@@ -0,0 +1,592 @@
+/* -*- 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 <o3tl/any.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlexppr.hxx>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
+#include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
+#include <com/sun/star/style/XStyle.hpp>
+#include <com/sun/star/beans/NamedValue.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/beans/XPropertyState.hpp>
+#include <com/sun/star/document/XEventsSupplier.hpp>
+#include <com/sun/star/text/XChapterNumberingSupplier.hpp>
+#include <xmloff/xmlaustp.hxx>
+#include <xmloff/styleexp.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/XMLEventExport.hxx>
+#include <xmloff/maptype.hxx>
+#include <memory>
+#include <set>
+#include <prstylecond.hxx>
+#include <sal/log.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::style;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::text;
+using namespace ::xmloff::token;
+
+using ::com::sun::star::document::XEventsSupplier;
+
+constexpr OUStringLiteral gsIsPhysical( u"IsPhysical" );
+constexpr OUStringLiteral gsIsAutoUpdate( u"IsAutoUpdate" );
+constexpr OUStringLiteral gsFollowStyle( u"FollowStyle" );
+constexpr OUStringLiteral gsNumberingStyleName( u"NumberingStyleName" );
+constexpr OUStringLiteral gsOutlineLevel( u"OutlineLevel" );
+
+XMLStyleExport::XMLStyleExport(
+ SvXMLExport& rExp,
+ SvXMLAutoStylePoolP *pAutoStyleP ) :
+ rExport( rExp ),
+ pAutoStylePool( pAutoStyleP )
+{
+}
+
+XMLStyleExport::~XMLStyleExport()
+{
+}
+
+void XMLStyleExport::exportStyleAttributes( const Reference< XStyle >& )
+{
+}
+
+void XMLStyleExport::exportStyleContent( const Reference< XStyle >& rStyle )
+{
+ Reference< XPropertySet > xPropSet( rStyle, UNO_QUERY );
+ assert(xPropSet.is());
+
+ try
+ {
+ uno::Any aProperty = xPropSet->getPropertyValue( "ParaStyleConditions" );
+ uno::Sequence< beans::NamedValue > aSeq;
+
+ aProperty >>= aSeq;
+
+ for (beans::NamedValue const& rNamedCond : std::as_const(aSeq))
+ {
+ OUString aStyleName;
+
+ if (rNamedCond.Value >>= aStyleName)
+ {
+ if (!aStyleName.isEmpty())
+ {
+ OUString aExternal = GetParaStyleCondExternal(rNamedCond.Name);
+
+ if (!aExternal.isEmpty())
+ {
+ bool bEncoded;
+
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE,
+ XML_CONDITION,
+ aExternal);
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE,
+ XML_APPLY_STYLE_NAME,
+ GetExport().EncodeStyleName( aStyleName,
+ &bEncoded ) );
+ SvXMLElementExport aElem( GetExport(),
+ XML_NAMESPACE_STYLE,
+ XML_MAP,
+ true,
+ true );
+ }
+ }
+ }
+ }
+ }
+ catch( const beans::UnknownPropertyException& )
+ {
+ }
+}
+
+namespace
+{
+/// Writes <style:style style:list-level="..."> for Writer paragraph styles.
+void ExportStyleListlevel(const uno::Reference<beans::XPropertySetInfo>& xPropSetInfo,
+ const uno::Reference<beans::XPropertyState>& xPropState,
+ const uno::Reference<beans::XPropertySet>& xPropSet, SvXMLExport& rExport)
+{
+ if (!xPropSetInfo->hasPropertyByName("NumberingLevel"))
+ {
+ SAL_WARN("xmloff", "ExportStyleListlevel: no NumberingLevel for a Writer paragraph style");
+ return;
+ }
+
+ if (xPropState->getPropertyState("NumberingLevel") != beans::PropertyState_DIRECT_VALUE)
+ {
+ return;
+ }
+
+ sal_Int16 nNumberingLevel{};
+ if (!(xPropSet->getPropertyValue("NumberingLevel") >>= nNumberingLevel))
+ {
+ return;
+ }
+
+ // The spec is positiveInteger (1-based), but the implementation is 0-based.
+ rExport.AddAttribute(XML_NAMESPACE_STYLE, XML_LIST_LEVEL, OUString::number(++nNumberingLevel));
+}
+}
+
+bool XMLStyleExport::exportStyle(
+ const Reference< XStyle >& rStyle,
+ const OUString& rXMLFamily,
+ const rtl::Reference < SvXMLExportPropertyMapper >& rPropMapper,
+ const Reference< XNameAccess >& xStyles,
+ const OUString* pPrefix )
+{
+ Reference< XPropertySet > xPropSet( rStyle, UNO_QUERY );
+ if (!xPropSet)
+ return false;
+
+ Reference< XPropertySetInfo > xPropSetInfo =
+ xPropSet->getPropertySetInfo();
+ Any aAny;
+
+ // Don't export styles that aren't existing really. This may be the
+ // case for StarOffice Writer's pool styles.
+ if( xPropSetInfo->hasPropertyByName( gsIsPhysical ) )
+ {
+ aAny = xPropSet->getPropertyValue( gsIsPhysical );
+ if( !*o3tl::doAccess<bool>(aAny) )
+ return false;
+ }
+
+ // <style:style ...>
+ GetExport().CheckAttrList();
+
+ // style:name="..."
+ OUString sName;
+
+ if(pPrefix)
+ sName = *pPrefix;
+ sName += rStyle->getName();
+
+ bool bEncoded = false;
+ const OUString sEncodedStyleName(GetExport().EncodeStyleName( sName, &bEncoded ));
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_NAME, sEncodedStyleName );
+
+ if( bEncoded )
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_DISPLAY_NAME,
+ sName);
+
+ // style:family="..."
+ if( !rXMLFamily.isEmpty() )
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_FAMILY, rXMLFamily);
+
+ if ( xPropSetInfo->hasPropertyByName( "Hidden" ) )
+ {
+ aAny = xPropSet->getPropertyValue( "Hidden" );
+ bool bHidden = false;
+ if ((aAny >>= bHidden) && bHidden
+ && GetExport().getSaneDefaultVersion() & SvtSaveOptions::ODFSVER_EXTENDED)
+ {
+ GetExport().AddAttribute(XML_NAMESPACE_LO_EXT, XML_HIDDEN, "true");
+ GetExport().AddAttribute(XML_NAMESPACE_STYLE, XML_HIDDEN, "true"); // FIXME for compatibility
+ }
+ }
+
+ // style:parent-style-name="..."
+ OUString sParentString(rStyle->getParentStyle());
+ OUString sParent;
+
+ if(!sParentString.isEmpty())
+ {
+ if(pPrefix)
+ sParent = *pPrefix;
+ sParent += sParentString;
+ }
+
+ if( !sParent.isEmpty() )
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_PARENT_STYLE_NAME,
+ GetExport().EncodeStyleName( sParent ) );
+
+ // style:next-style-name="..." (paragraph styles only)
+ if( xPropSetInfo->hasPropertyByName( gsFollowStyle ) )
+ {
+ aAny = xPropSet->getPropertyValue( gsFollowStyle );
+ OUString sNextName;
+ aAny >>= sNextName;
+ if( sName != sNextName )
+ {
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_NEXT_STYLE_NAME,
+ GetExport().EncodeStyleName( sNextName ) );
+ }
+ }
+
+ // style:linked-style-name="..." (SW paragraph and character styles only)
+ if (xPropSetInfo->hasPropertyByName("LinkStyle"))
+ {
+ aAny = xPropSet->getPropertyValue("LinkStyle");
+ OUString sLinkName;
+ aAny >>= sLinkName;
+ if (!sLinkName.isEmpty()
+ && (GetExport().getSaneDefaultVersion() & SvtSaveOptions::ODFSVER_EXTENDED))
+ {
+ GetExport().AddAttribute(XML_NAMESPACE_LO_EXT, XML_LINKED_STYLE_NAME,
+ GetExport().EncodeStyleName(sLinkName));
+ }
+ }
+
+ // style:auto-update="..." (SW only)
+ if( xPropSetInfo->hasPropertyByName( gsIsAutoUpdate ) )
+ {
+ aAny = xPropSet->getPropertyValue( gsIsAutoUpdate );
+ if( *o3tl::doAccess<bool>(aAny) )
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_AUTO_UPDATE,
+ XML_TRUE );
+ }
+
+ // style:default-outline-level"..."
+ sal_Int32 nOutlineLevel = 0;
+ if( xPropSetInfo->hasPropertyByName( gsOutlineLevel ) )
+ {
+ Reference< XPropertyState > xPropState( xPropSet, uno::UNO_QUERY );
+ if( PropertyState_DIRECT_VALUE == xPropState->getPropertyState( gsOutlineLevel ) )
+ {
+ aAny = xPropSet->getPropertyValue( gsOutlineLevel );
+ aAny >>= nOutlineLevel;
+ if( nOutlineLevel > 0 )
+ {
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE,
+ XML_DEFAULT_OUTLINE_LEVEL,
+ OUString::number(nOutlineLevel) );
+ }
+ else
+ {
+ /* Empty value for style:default-outline-level does exist
+ since ODF 1.2. Thus, suppress its export for former versions. (#i104889#)
+ */
+ if ( ( GetExport().getExportFlags() & SvXMLExportFlags::OASIS ) &&
+ GetExport().getSaneDefaultVersion() >= SvtSaveOptions::ODFSVER_012)
+ {
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE,
+ XML_DEFAULT_OUTLINE_LEVEL,
+ OUString( "" ));
+ }
+ }
+ }
+ }
+
+ // style:list-style-name="..." (SW paragraph styles only)
+ if( xPropSetInfo->hasPropertyByName( gsNumberingStyleName ) )
+ {
+ Reference< XPropertyState > xPropState( xPropSet, uno::UNO_QUERY );
+ if( PropertyState_DIRECT_VALUE ==
+ xPropState->getPropertyState( gsNumberingStyleName ) )
+ {
+ aAny = xPropSet->getPropertyValue( gsNumberingStyleName );
+ if( aAny.hasValue() )
+ {
+ OUString sListName;
+ aAny >>= sListName;
+
+ /* A direct set empty list style has to be written. Otherwise,
+ this information is lost and causes an error, if the parent
+ style has a list style set. (#i69523#)
+ */
+ if ( sListName.isEmpty() )
+ {
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE,
+ XML_LIST_STYLE_NAME,
+ sListName /* empty string */);
+ }
+ else
+ {
+ // Written OpenDocument file format doesn't fit to the created text document (#i69627#)
+ bool bSuppressListStyle( false );
+ {
+ if ( !GetExport().writeOutlineStyleAsNormalListStyle() )
+ {
+ Reference< XChapterNumberingSupplier > xCNSupplier
+ (GetExport().GetModel(), UNO_QUERY);
+
+ if (xCNSupplier.is())
+ {
+ Reference< XIndexReplace > xNumRule
+ ( xCNSupplier->getChapterNumberingRules() );
+ assert(xNumRule.is());
+
+ Reference< XPropertySet > xNumRulePropSet
+ (xNumRule, UNO_QUERY);
+ OUString sOutlineName;
+ xNumRulePropSet->getPropertyValue("Name")
+ >>= sOutlineName;
+ bSuppressListStyle = sListName == sOutlineName;
+ }
+ }
+ }
+
+ if ( !sListName.isEmpty() && !bSuppressListStyle )
+ {
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE,
+ XML_LIST_STYLE_NAME,
+ GetExport().EncodeStyleName( sListName ) );
+
+ ExportStyleListlevel(xPropSetInfo, xPropState, xPropSet, GetExport());
+ }
+ }
+ }
+ }
+ else if( nOutlineLevel > 0 )
+ {
+
+ bool bNoInheritedListStyle( true );
+
+ Reference<XStyle> xStyle( xPropState, UNO_QUERY );
+ while ( xStyle.is() )
+ {
+ OUString aParentStyle( xStyle->getParentStyle() );
+ if ( aParentStyle.isEmpty() || !xStyles->hasByName( aParentStyle ) )
+ {
+ break;
+ }
+ else
+ {
+ xPropState.set( xStyles->getByName( aParentStyle ), UNO_QUERY );
+ if ( !xPropState.is() )
+ {
+ break;
+ }
+ if ( xPropState->getPropertyState( gsNumberingStyleName ) == PropertyState_DIRECT_VALUE )
+ {
+ bNoInheritedListStyle = false;
+ break;
+ }
+ else
+ {
+ xStyle.set( xPropState, UNO_QUERY );
+ }
+ }
+ }
+ if ( bNoInheritedListStyle )
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE,
+ XML_LIST_STYLE_NAME,
+ OUString( "" ));
+ }
+ }
+
+ // style:pool-id="..." is not required any longer since we use
+ // english style names only
+ exportStyleAttributes( rStyle );
+
+ // TODO: style:help-file-name="..." and style:help-id="..." can neither
+ // be modified by UI nor by API and that for, have not to be exported
+ // currently.
+
+ {
+ // <style:style>
+ SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_STYLE, XML_STYLE,
+ true, true );
+
+ rPropMapper->SetStyleName( sName );
+
+ // <style:properties>
+ ::std::vector< XMLPropertyState > aPropStates =
+ rPropMapper->Filter(GetExport(), xPropSet, true);
+ bool const bUseExtensionNamespaceForGraphicProperties(
+ rXMLFamily != "drawing-page" &&
+ rXMLFamily != "graphic" &&
+ rXMLFamily != "presentation" &&
+ rXMLFamily != "chart");
+ rPropMapper->exportXML( GetExport(), aPropStates,
+ SvXmlExportFlags::IGN_WS,
+ bUseExtensionNamespaceForGraphicProperties );
+
+ rPropMapper->SetStyleName( OUString() );
+
+ exportStyleContent( rStyle );
+
+ // <script:events>, if they are supported by this style
+ Reference<XEventsSupplier> xEventsSupp(rStyle, UNO_QUERY);
+ GetExport().GetEventExport().Export(xEventsSupp);
+ }
+ return true;
+}
+
+void XMLStyleExport::exportDefaultStyle(
+ const Reference< XPropertySet >& xPropSet,
+ const OUString& rXMLFamily,
+ const rtl::Reference < SvXMLExportPropertyMapper >& rPropMapper )
+{
+ // <style:default-style ...>
+ GetExport().CheckAttrList();
+
+ {
+ // style:family="..."
+ if( !rXMLFamily.isEmpty() )
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_FAMILY,
+ rXMLFamily );
+ // <style:style>
+ SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_STYLE,
+ XML_DEFAULT_STYLE,
+ true, true );
+ // <style:properties>
+ ::std::vector< XMLPropertyState > aPropStates =
+ rPropMapper->FilterDefaults(GetExport(), xPropSet);
+ rPropMapper->exportXML( GetExport(), aPropStates,
+ SvXmlExportFlags::IGN_WS );
+ }
+}
+
+void XMLStyleExport::exportStyleFamily(
+ const char *pFamily,
+ const OUString& rXMLFamily,
+ const rtl::Reference < SvXMLExportPropertyMapper >& rPropMapper,
+ bool bUsed, XmlStyleFamily nFamily, const OUString* pPrefix)
+{
+ const OUString sFamily(OUString::createFromAscii(pFamily ));
+ exportStyleFamily( sFamily, rXMLFamily, rPropMapper, bUsed, nFamily,
+ pPrefix);
+}
+
+void XMLStyleExport::exportStyleFamily(
+ const OUString& rFamily, const OUString& rXMLFamily,
+ const rtl::Reference < SvXMLExportPropertyMapper >& rPropMapper,
+ bool bUsed, XmlStyleFamily nFamily, const OUString* pPrefix)
+{
+ assert(GetExport().GetModel().is());
+ Reference< XStyleFamiliesSupplier > xFamiliesSupp( GetExport().GetModel(), UNO_QUERY );
+ if( !xFamiliesSupp.is() )
+ return; // family not available in current model
+
+ Reference< XNameAccess > xStyleCont;
+
+ Reference< XNameAccess > xFamilies( xFamiliesSupp->getStyleFamilies() );
+ if( xFamilies->hasByName( rFamily ) )
+ xFamilies->getByName( rFamily ) >>= xStyleCont;
+
+ if( !xStyleCont.is() )
+ return;
+
+ // If next styles are supported and used styles should be exported only,
+ // the next style may be unused but has to be exported, too. In this case
+ // the names of all exported styles are remembered.
+ std::optional<std::set<OUString> > xExportedStyles;
+ bool bFirstStyle = true;
+
+ const uno::Sequence< OUString> aSeq = xStyleCont->getElementNames();
+ for(const auto& rName : aSeq)
+ {
+ Reference< XStyle > xStyle;
+ try
+ {
+ xStyleCont->getByName( rName ) >>= xStyle;
+ }
+ catch(const lang::IndexOutOfBoundsException&)
+ {
+ // due to bugs in prior versions it is possible that
+ // a binary file is missing some critical styles.
+ // The only possible way to deal with this is to
+ // not export them here and remain silent.
+ continue;
+ }
+ catch(css::container::NoSuchElementException&)
+ {
+ continue;
+ }
+
+ assert(xStyle.is());
+ if (!bUsed || xStyle->isInUse())
+ {
+ bool bExported = exportStyle( xStyle, rXMLFamily, rPropMapper,
+ xStyleCont,pPrefix );
+ if (bUsed && bFirstStyle && bExported)
+ {
+ // If this is the first style, find out whether next styles
+ // are supported.
+ Reference< XPropertySet > xPropSet( xStyle, UNO_QUERY );
+ Reference< XPropertySetInfo > xPropSetInfo =
+ xPropSet->getPropertySetInfo();
+
+ if (xPropSetInfo->hasPropertyByName( gsFollowStyle ))
+ xExportedStyles.emplace();
+ bFirstStyle = false;
+ }
+
+ if (xExportedStyles && bExported)
+ {
+ // If next styles are supported, remember this style's name.
+ xExportedStyles->insert( xStyle->getName() );
+ }
+ }
+
+ // if an auto style pool is given, remember this style's name as a
+ // style name that must not be used by automatic styles.
+ if (pAutoStylePool)
+ pAutoStylePool->RegisterName( nFamily, xStyle->getName() );
+ }
+
+ if( !xExportedStyles )
+ return;
+
+ // if next styles are supported, export all next styles that are
+ // unused and that for, haven't been exported in the first loop.
+ for(const auto& rName : aSeq)
+ {
+ Reference< XStyle > xStyle;
+ xStyleCont->getByName( rName ) >>= xStyle;
+
+ assert(xStyle.is());
+
+ Reference< XPropertySet > xPropSet( xStyle, UNO_QUERY );
+ Reference< XPropertySetInfo > xPropSetInfo( xPropSet->getPropertySetInfo() );
+
+ // styles that aren't existing really are ignored.
+ if (xPropSetInfo->hasPropertyByName( gsIsPhysical ))
+ {
+ Any aAny( xPropSet->getPropertyValue( gsIsPhysical ) );
+ if (!*o3tl::doAccess<bool>(aAny))
+ continue;
+ }
+
+ if (!xStyle->isInUse())
+ continue;
+
+ if (!xPropSetInfo->hasPropertyByName( gsFollowStyle ))
+ {
+ continue;
+ }
+
+ OUString sNextName;
+ xPropSet->getPropertyValue( gsFollowStyle ) >>= sNextName;
+ OUString sTmp( sNextName );
+ // if the next style hasn't been exported by now, export it now
+ // and remember its name.
+ if (xStyle->getName() != sNextName &&
+ 0 == xExportedStyles->count( sTmp ))
+ {
+ xStyleCont->getByName( sNextName ) >>= xStyle;
+ assert(xStyle.is());
+
+ if (exportStyle(xStyle, rXMLFamily, rPropMapper, xStyleCont, pPrefix))
+ xExportedStyles->insert( sTmp );
+ }
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/tabsthdl.cxx b/xmloff/source/style/tabsthdl.cxx
new file mode 100644
index 000000000..2e497f3ea
--- /dev/null
+++ b/xmloff/source/style/tabsthdl.cxx
@@ -0,0 +1,65 @@
+/* -*- 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 "tabsthdl.hxx"
+#include <com/sun/star/uno/Sequence.hxx>
+#include <com/sun/star/style/TabStop.hpp>
+
+using namespace ::com::sun::star;
+
+
+
+
+XMLTabStopPropHdl::~XMLTabStopPropHdl()
+{
+ // Nothing to do
+}
+
+bool XMLTabStopPropHdl::equals( const uno::Any& r1, const uno::Any& r2 ) const
+{
+ uno::Sequence< style::TabStop> aSeq1;
+ if( r1 >>= aSeq1 )
+ {
+ uno::Sequence< style::TabStop> aSeq2;
+ if( r2 >>= aSeq2 )
+ {
+ return std::equal(std::cbegin(aSeq1), std::cend(aSeq1), std::cbegin(aSeq2), std::cend(aSeq2),
+ [](const style::TabStop& a, const style::TabStop& b) {
+ return a.Position == b.Position
+ && a.Alignment == b.Alignment
+ && a.DecimalChar == b.DecimalChar
+ && a.FillChar == b.FillChar;
+ });
+ }
+ }
+
+ return false;
+}
+
+bool XMLTabStopPropHdl::importXML( const OUString&, css::uno::Any&, const SvXMLUnitConverter& ) const
+{
+ return false;
+}
+
+bool XMLTabStopPropHdl::exportXML( OUString&, const css::uno::Any&, const SvXMLUnitConverter& ) const
+{
+ return false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/tabsthdl.hxx b/xmloff/source/style/tabsthdl.hxx
new file mode 100644
index 000000000..755790e8f
--- /dev/null
+++ b/xmloff/source/style/tabsthdl.hxx
@@ -0,0 +1,39 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLTabStopPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLTabStopPropHdl() override;
+
+ virtual bool equals( const css::uno::Any& r1, const css::uno::Any& r2 ) const override;
+
+ /// TabStops will be imported/exported as XML-Elements. So the Import/Export-work must be done at another place.
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/undlihdl.cxx b/xmloff/source/style/undlihdl.cxx
new file mode 100644
index 000000000..4d6482c4f
--- /dev/null
+++ b/xmloff/source/style/undlihdl.cxx
@@ -0,0 +1,365 @@
+/* -*- 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 "undlihdl.hxx"
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlement.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <osl/diagnose.h>
+
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/awt/FontUnderline.hpp>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::awt;
+using namespace ::xmloff::token;
+
+SvXMLEnumMapEntry<sal_uInt16> const pXML_UnderlineType_Enum[] =
+{
+ { XML_NONE, awt::FontUnderline::NONE },
+ { XML_SINGLE, awt::FontUnderline::SINGLE },
+ { XML_DOUBLE, awt::FontUnderline::DOUBLE },
+ { XML_SINGLE, awt::FontUnderline::DOTTED },
+ { XML_SINGLE, awt::FontUnderline::DASH },
+ { XML_SINGLE, awt::FontUnderline::LONGDASH },
+ { XML_SINGLE, awt::FontUnderline::DASHDOT },
+ { XML_SINGLE, awt::FontUnderline::DASHDOTDOT },
+ { XML_SINGLE, awt::FontUnderline::WAVE },
+ { XML_SINGLE, awt::FontUnderline::BOLD },
+ { XML_SINGLE, awt::FontUnderline::BOLDDOTTED },
+ { XML_SINGLE, awt::FontUnderline::BOLDDASH },
+ { XML_SINGLE, awt::FontUnderline::BOLDLONGDASH },
+ { XML_SINGLE, awt::FontUnderline::BOLDDASHDOT },
+ { XML_SINGLE, awt::FontUnderline::BOLDDASHDOTDOT },
+ { XML_SINGLE, awt::FontUnderline::BOLDWAVE },
+ { XML_DOUBLE, awt::FontUnderline::DOUBLEWAVE },
+ { XML_SINGLE, awt::FontUnderline::SMALLWAVE },
+ { XML_TOKEN_INVALID, 0 }
+};
+
+SvXMLEnumMapEntry<sal_uInt16> const pXML_UnderlineStyle_Enum[] =
+{
+ { XML_NONE, awt::FontUnderline::NONE },
+ { XML_SOLID, awt::FontUnderline::SINGLE },
+ { XML_SOLID, awt::FontUnderline::DOUBLE },
+ { XML_DOTTED, awt::FontUnderline::DOTTED },
+ { XML_DASH, awt::FontUnderline::DASH },
+ { XML_LONG_DASH, awt::FontUnderline::LONGDASH },
+ { XML_DOT_DASH, awt::FontUnderline::DASHDOT },
+ { XML_DOT_DOT_DASH, awt::FontUnderline::DASHDOTDOT },
+ { XML_WAVE, awt::FontUnderline::WAVE },
+ { XML_SOLID, awt::FontUnderline::BOLD },
+ { XML_DOTTED, awt::FontUnderline::BOLDDOTTED },
+ { XML_DASH, awt::FontUnderline::BOLDDASH },
+ { XML_LONG_DASH, awt::FontUnderline::BOLDLONGDASH },
+ { XML_DOT_DASH, awt::FontUnderline::BOLDDASHDOT },
+ { XML_DOT_DOT_DASH, awt::FontUnderline::BOLDDASHDOTDOT },
+ { XML_WAVE, awt::FontUnderline::BOLDWAVE },
+ { XML_WAVE, awt::FontUnderline::DOUBLEWAVE },
+ { XML_SMALL_WAVE, awt::FontUnderline::SMALLWAVE },
+ { XML_TOKEN_INVALID, 0 }
+};
+
+SvXMLEnumMapEntry<sal_uInt16> const pXML_UnderlineWidth_Enum[] =
+{
+ { XML_AUTO, awt::FontUnderline::NONE },
+ { XML_AUTO, awt::FontUnderline::SINGLE },
+ { XML_AUTO, awt::FontUnderline::DOUBLE },
+ { XML_AUTO, awt::FontUnderline::DOTTED },
+ { XML_AUTO, awt::FontUnderline::DASH },
+ { XML_AUTO, awt::FontUnderline::LONGDASH },
+ { XML_AUTO, awt::FontUnderline::DASHDOT },
+ { XML_AUTO, awt::FontUnderline::DASHDOTDOT },
+ { XML_AUTO, awt::FontUnderline::WAVE },
+ { XML_BOLD, awt::FontUnderline::BOLD },
+ { XML_BOLD, awt::FontUnderline::BOLDDOTTED },
+ { XML_BOLD, awt::FontUnderline::BOLDDASH },
+ { XML_BOLD, awt::FontUnderline::BOLDLONGDASH },
+ { XML_BOLD, awt::FontUnderline::BOLDDASHDOT },
+ { XML_BOLD, awt::FontUnderline::BOLDDASHDOTDOT },
+ { XML_BOLD, awt::FontUnderline::BOLDWAVE },
+ { XML_AUTO, awt::FontUnderline::DOUBLEWAVE },
+ { XML_THIN, awt::FontUnderline::NONE },
+ { XML_MEDIUM, awt::FontUnderline::NONE },
+ { XML_THICK, awt::FontUnderline::BOLD},
+ { XML_TOKEN_INVALID, 0 }
+};
+
+
+
+
+XMLUnderlineTypePropHdl::~XMLUnderlineTypePropHdl()
+{
+ // nothing to do
+}
+
+bool XMLUnderlineTypePropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_uInt16 eNewUnderline(0);
+ bool bRet = SvXMLUnitConverter::convertEnum(
+ eNewUnderline, rStrImpValue, pXML_UnderlineType_Enum );
+ if( bRet )
+ {
+ // multi property: style and width might be set already.
+ // If the old value is NONE, the new is used unchanged.
+ sal_Int16 eUnderline = sal_Int16();
+ if( (rValue >>= eUnderline) && awt::FontUnderline::NONE!=eUnderline )
+ {
+ switch( eNewUnderline )
+ {
+ case awt::FontUnderline::NONE:
+ case awt::FontUnderline::SINGLE:
+ // keep existing line style
+ eNewUnderline = eUnderline;
+ break;
+ case awt::FontUnderline::DOUBLE:
+ // A double line style has priority over a bold line style,
+ // but not over the line style itself.
+ switch( eUnderline )
+ {
+ case awt::FontUnderline::SINGLE:
+ case awt::FontUnderline::BOLD:
+ break;
+ case awt::FontUnderline::WAVE:
+ case awt::FontUnderline::BOLDWAVE:
+ eNewUnderline = awt::FontUnderline::DOUBLEWAVE;
+ break;
+ default:
+ // If a double line style is not supported for the existing
+ // value, keep the new one
+ eNewUnderline = eUnderline;
+ break;
+ }
+ break;
+ default:
+ OSL_ENSURE( bRet, "unexpected line type value" );
+ break;
+ }
+ if( eNewUnderline != eUnderline )
+ rValue <<= static_cast<sal_Int16>(eNewUnderline);
+ }
+ else
+ {
+ rValue <<= static_cast<sal_Int16>(eNewUnderline);
+ }
+ }
+
+ return bRet;
+}
+
+bool XMLUnderlineTypePropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_uInt16 nValue = sal_uInt16();
+
+ if( (rValue >>= nValue) &&
+ (awt::FontUnderline::DOUBLE == nValue ||
+ awt::FontUnderline::DOUBLEWAVE == nValue) )
+ {
+ OUStringBuffer aOut;
+ bRet = SvXMLUnitConverter::convertEnum(
+ aOut, nValue, pXML_UnderlineType_Enum );
+ if( bRet )
+ rStrExpValue = aOut.makeStringAndClear();
+ }
+
+ return bRet;
+}
+
+
+
+
+XMLUnderlineStylePropHdl::~XMLUnderlineStylePropHdl()
+{
+ // nothing to do
+}
+
+bool XMLUnderlineStylePropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_uInt16 eNewUnderline(0);
+ bool bRet = SvXMLUnitConverter::convertEnum(
+ eNewUnderline, rStrImpValue, pXML_UnderlineStyle_Enum );
+ if( bRet )
+ {
+ // multi property: style and width might be set already.
+ // If the old value is NONE, the new is used unchanged.
+ sal_Int16 eUnderline = sal_Int16();
+ if( (rValue >>= eUnderline) && awt::FontUnderline::NONE!=eUnderline )
+ {
+ switch( eNewUnderline )
+ {
+ case awt::FontUnderline::NONE:
+ case awt::FontUnderline::SINGLE:
+ // keep double or bold line style
+ eNewUnderline = eUnderline;
+ break;
+ case awt::FontUnderline::DOTTED:
+ // The line style has priority over a double type.
+ if( awt::FontUnderline::BOLD == eUnderline )
+ eNewUnderline = awt::FontUnderline::BOLDDOTTED;
+ break;
+ case awt::FontUnderline::DASH:
+ if( awt::FontUnderline::BOLD == eUnderline )
+ eNewUnderline = awt::FontUnderline::BOLDDASH;
+ break;
+ case awt::FontUnderline::LONGDASH:
+ if( awt::FontUnderline::BOLD == eUnderline )
+ eNewUnderline = awt::FontUnderline::BOLDLONGDASH;
+ break;
+ case awt::FontUnderline::DASHDOT:
+ if( awt::FontUnderline::BOLD == eUnderline )
+ eNewUnderline = awt::FontUnderline::BOLDDASHDOT;
+ break;
+ case awt::FontUnderline::DASHDOTDOT:
+ if( awt::FontUnderline::BOLD == eUnderline )
+ eNewUnderline = awt::FontUnderline::BOLDDASHDOTDOT;
+ break;
+ case awt::FontUnderline::WAVE:
+ if( awt::FontUnderline::DOUBLE == eUnderline )
+ eNewUnderline = awt::FontUnderline::DOUBLEWAVE;
+ else if( awt::FontUnderline::BOLD == eUnderline )
+ eNewUnderline = awt::FontUnderline::BOLDWAVE;
+ break;
+ case awt::FontUnderline::SMALLWAVE:
+ // SMALLWAVE is not used
+ default:
+ OSL_ENSURE( bRet, "unexpected line style value" );
+ break;
+ }
+ if( eNewUnderline != eUnderline )
+ rValue <<= static_cast<sal_Int16>(eNewUnderline);
+ }
+ else
+ {
+ rValue <<= static_cast<sal_Int16>(eNewUnderline);
+ }
+ }
+
+ return bRet;
+}
+
+bool XMLUnderlineStylePropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_uInt16 nValue = sal_uInt16();
+
+ if( rValue >>= nValue )
+ {
+ OUStringBuffer aOut;
+ bRet = SvXMLUnitConverter::convertEnum(
+ aOut, nValue, pXML_UnderlineStyle_Enum );
+ if( bRet )
+ rStrExpValue = aOut.makeStringAndClear();
+ }
+
+ return bRet;
+}
+
+
+
+
+XMLUnderlineWidthPropHdl::~XMLUnderlineWidthPropHdl()
+{
+ // nothing to do
+}
+
+bool XMLUnderlineWidthPropHdl::importXML( const OUString& rStrImpValue, uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_uInt16 eNewUnderline(0);
+ bool bRet = SvXMLUnitConverter::convertEnum(
+ eNewUnderline, rStrImpValue, pXML_UnderlineWidth_Enum );
+ if( bRet )
+ {
+ // multi property: style and width might be set already.
+ // If the old value is NONE, the new is used unchanged.
+ sal_Int16 eUnderline = sal_Int16();
+ if( (rValue >>= eUnderline) && awt::FontUnderline::NONE!=eUnderline )
+ {
+ switch( eNewUnderline )
+ {
+ case awt::FontUnderline::NONE:
+ // keep existing line style
+ eNewUnderline = eUnderline;
+ break;
+ case awt::FontUnderline::BOLD:
+ // A double line style has priority over a bold line style,
+ // but not over the line style itself.
+ switch( eUnderline )
+ {
+ case awt::FontUnderline::SINGLE:
+ break;
+ case awt::FontUnderline::DOTTED:
+ eNewUnderline = awt::FontUnderline::BOLDDOTTED;
+ break;
+ case awt::FontUnderline::DASH:
+ eNewUnderline = awt::FontUnderline::BOLDDASH;
+ break;
+ case awt::FontUnderline::LONGDASH:
+ eNewUnderline = awt::FontUnderline::BOLDLONGDASH;
+ break;
+ case awt::FontUnderline::DASHDOT:
+ eNewUnderline = awt::FontUnderline::BOLDDASHDOT;
+ break;
+ case awt::FontUnderline::DASHDOTDOT:
+ eNewUnderline = awt::FontUnderline::BOLDDASHDOTDOT;
+ break;
+ case awt::FontUnderline::WAVE:
+ eNewUnderline = awt::FontUnderline::BOLDWAVE;
+ break;
+ default:
+ // a double line style overwrites a bold one
+ eNewUnderline = eUnderline;
+ break;
+ }
+ break;
+ default:
+ OSL_ENSURE( bRet, "unexpected line width value" );
+ break;
+ }
+ if( eNewUnderline != eUnderline )
+ rValue <<= static_cast<sal_Int16>(eNewUnderline);
+ }
+ else
+ {
+ rValue <<= static_cast<sal_Int16>(eNewUnderline);
+ }
+ }
+
+ return bRet;
+}
+
+bool XMLUnderlineWidthPropHdl::exportXML( OUString& rStrExpValue, const uno::Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_uInt16 nValue = sal_uInt16();
+
+ if( (rValue >>= nValue) && (awt::FontUnderline::NONE != nValue) )
+ {
+ OUStringBuffer aOut;
+ bRet = SvXMLUnitConverter::convertEnum(
+ aOut, nValue, pXML_UnderlineWidth_Enum );
+ if( bRet )
+ rStrExpValue = aOut.makeStringAndClear();
+ }
+
+ return bRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/undlihdl.hxx b/xmloff/source/style/undlihdl.hxx
new file mode 100644
index 000000000..4b9ad1b50
--- /dev/null
+++ b/xmloff/source/style/undlihdl.hxx
@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLUnderlineTypePropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLUnderlineTypePropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+class XMLUnderlineStylePropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLUnderlineStylePropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+class XMLUnderlineWidthPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLUnderlineWidthPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/weighhdl.cxx b/xmloff/source/style/weighhdl.cxx
new file mode 100644
index 000000000..a069dbd30
--- /dev/null
+++ b/xmloff/source/style/weighhdl.cxx
@@ -0,0 +1,154 @@
+/* -*- 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 "weighhdl.hxx"
+
+#include <sax/tools/converter.hxx>
+
+#include <xmloff/xmltoken.hxx>
+
+#include <rtl/ustring.hxx>
+
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/awt/FontWeight.hpp>
+
+using namespace ::com::sun::star::uno;
+using namespace ::xmloff::token;
+
+namespace {
+
+struct FontWeightMapper
+{
+ float fWeight;
+ sal_uInt16 nValue;
+};
+
+}
+
+FontWeightMapper const aFontWeightMap[] =
+{
+ { css::awt::FontWeight::DONTKNOW, 0 },
+ { css::awt::FontWeight::THIN, 100 },
+ { css::awt::FontWeight::ULTRALIGHT, 150 },
+ { css::awt::FontWeight::LIGHT, 250 },
+ { css::awt::FontWeight::SEMILIGHT, 350 },
+ { css::awt::FontWeight::NORMAL, 400 },
+ { css::awt::FontWeight::NORMAL, 450 },
+ { css::awt::FontWeight::SEMIBOLD, 600 },
+ { css::awt::FontWeight::BOLD, 700 },
+ { css::awt::FontWeight::ULTRABOLD, 800 },
+ { css::awt::FontWeight::BLACK, 900 },
+ { css::awt::FontWeight::DONTKNOW, 1000 }
+};
+
+
+XMLFontWeightPropHdl::~XMLFontWeightPropHdl()
+{
+ // Nothing to do
+}
+
+bool XMLFontWeightPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_uInt16 nWeight = 0;
+
+ if( IsXMLToken( rStrImpValue, XML_NORMAL ) )
+ {
+ nWeight = 400;
+ bRet = true;
+ }
+ else if( IsXMLToken( rStrImpValue, XML_BOLD ) )
+ {
+ nWeight = 700;
+ bRet = true;
+ }
+ else
+ {
+ sal_Int32 nTemp;
+ bRet = ::sax::Converter::convertNumber(nTemp, rStrImpValue, 100, 900);
+ if( bRet )
+ nWeight = sal::static_int_cast< sal_uInt16 >(nTemp);
+ }
+
+ if( bRet )
+ {
+ bRet = false;
+ int const nCount = SAL_N_ELEMENTS(aFontWeightMap);
+ for (int i = 0; i < (nCount-1); ++i)
+ {
+ if( (nWeight >= aFontWeightMap[i].nValue) && (nWeight <= aFontWeightMap[i+1].nValue) )
+ {
+ sal_uInt16 nDiff1 = nWeight - aFontWeightMap[i].nValue;
+ sal_uInt16 nDiff2 = aFontWeightMap[i+1].nValue - nWeight;
+
+ if( nDiff1 < nDiff2 )
+ rValue <<= aFontWeightMap[i].fWeight;
+ else
+ rValue <<= aFontWeightMap[i+1].fWeight;
+
+ bRet = true;
+ break;
+ }
+ }
+ }
+
+ return bRet;
+}
+
+bool XMLFontWeightPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+
+ float fValue = float();
+ if( !( rValue >>= fValue ) )
+ {
+ sal_Int32 nValue = 0;
+ if( rValue >>= nValue )
+ {
+ fValue = static_cast<float>(nValue);
+ bRet = true;
+ }
+ }
+ else
+ bRet = true;
+
+ if( bRet )
+ {
+ sal_uInt16 nWeight = 0;
+ for( auto const & pair : aFontWeightMap )
+ {
+ if( fValue <= pair.fWeight )
+ {
+ nWeight = pair.nValue;
+ break;
+ }
+ }
+
+ if( 400 == nWeight )
+ rStrExpValue = GetXMLToken(XML_NORMAL);
+ else if( 700 == nWeight )
+ rStrExpValue = GetXMLToken(XML_BOLD);
+ else
+ rStrExpValue = OUString::number( nWeight );
+ }
+
+ return bRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/weighhdl.hxx b/xmloff/source/style/weighhdl.hxx
new file mode 100644
index 000000000..e9df03001
--- /dev/null
+++ b/xmloff/source/style/weighhdl.hxx
@@ -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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+
+/**
+ PropertyHandler for the XML-data-type:
+*/
+class XMLFontWeightPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLFontWeightPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/xmlaustp.cxx b/xmloff/source/style/xmlaustp.cxx
new file mode 100644
index 000000000..859477250
--- /dev/null
+++ b/xmloff/source/style/xmlaustp.cxx
@@ -0,0 +1,384 @@
+/* -*- 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/container/XIndexReplace.hpp>
+#include "impastpl.hxx"
+#include <xmloff/xmlaustp.hxx>
+#include <xmloff/families.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/xmlprhdl.hxx>
+#include <xmloff/xmlprmap.hxx>
+#include <xmloff/XMLTextListAutoStylePool.hxx>
+
+#include <PageMasterStyleMap.hxx>
+#include <osl/diagnose.h>
+
+
+using namespace ::std;
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+
+namespace
+{
+ void lcl_exportDataStyle( SvXMLExport& _rExport, const rtl::Reference< XMLPropertySetMapper >& _rxMapper,
+ const XMLPropertyState& _rProperty )
+ {
+ assert(_rxMapper.is());
+ // obtain the data style name
+ OUString sDataStyleName;
+ _rProperty.maValue >>= sDataStyleName;
+ assert(!sDataStyleName.isEmpty() && "xmloff::lcl_exportDataStyle: invalid property value for the data style name!");
+
+ // add the attribute
+ _rExport.AddAttribute(
+ _rxMapper->GetEntryNameSpace( _rProperty.mnIndex ),
+ _rxMapper->GetEntryXMLName( _rProperty.mnIndex ),
+ sDataStyleName );
+ }
+}
+
+void SvXMLAutoStylePoolP::exportStyleAttributes(
+ SvXMLAttributeList&,
+ XmlStyleFamily nFamily,
+ const vector< XMLPropertyState >& rProperties,
+ const SvXMLExportPropertyMapper& rPropExp,
+ const SvXMLUnitConverter&,
+ const SvXMLNamespaceMap&
+ ) const
+{
+ if ( XmlStyleFamily::CONTROL_ID == nFamily )
+ { // it's a control-related style
+ const rtl::Reference< XMLPropertySetMapper >& aPropertyMapper = rPropExp.getPropertySetMapper();
+
+ for (const auto& rProp : rProperties)
+ {
+ if ( ( rProp.mnIndex > -1 )
+ && ( CTF_FORMS_DATA_STYLE == aPropertyMapper->GetEntryContextId( rProp.mnIndex ) )
+ )
+ { // it's the data-style for a grid column
+ lcl_exportDataStyle( GetExport(), aPropertyMapper, rProp );
+ }
+ }
+ }
+
+ if( (XmlStyleFamily::SD_GRAPHICS_ID == nFamily) || (XmlStyleFamily::SD_PRESENTATION_ID == nFamily) )
+ { // it's a graphics style
+ const rtl::Reference< XMLPropertySetMapper >& aPropertyMapper = rPropExp.getPropertySetMapper();
+ assert(aPropertyMapper.is());
+
+ bool bFoundControlShapeDataStyle = false;
+ bool bFoundNumberingRulesName = false;
+
+ for (const auto& rProp : rProperties)
+ {
+ if (rProp.mnIndex > -1)
+ { // it's a valid property
+ switch( aPropertyMapper->GetEntryContextId(rProp.mnIndex) )
+ {
+ case CTF_SD_CONTROL_SHAPE_DATA_STYLE:
+ { // it's the control shape data style property
+
+ if (bFoundControlShapeDataStyle)
+ {
+ OSL_FAIL("SvXMLAutoStylePoolP::exportStyleAttributes: found two properties with the ControlShapeDataStyle context id!");
+ // already added the attribute for the first occurrence
+ break;
+ }
+
+ lcl_exportDataStyle( GetExport(), aPropertyMapper, rProp );
+
+ // check if there is another property with the special context id we're handling here
+ bFoundControlShapeDataStyle = true;
+ break;
+ }
+ case CTF_SD_NUMBERINGRULES_NAME:
+ {
+ if (bFoundNumberingRulesName)
+ {
+ OSL_FAIL("SvXMLAutoStylePoolP::exportStyleAttributes: found two properties with the numbering rules name context id!");
+ // already added the attribute for the first occurrence
+ break;
+ }
+
+ uno::Reference< container::XIndexReplace > xNumRule;
+ rProp.maValue >>= xNumRule;
+ if( xNumRule.is() && (xNumRule->getCount() > 0 ) )
+ {
+ const OUString sName(const_cast<XMLTextListAutoStylePool*>(&GetExport().GetTextParagraphExport()->GetListAutoStylePool())->Add( xNumRule ));
+
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_LIST_STYLE_NAME, GetExport().EncodeStyleName( sName ) );
+ }
+
+ bFoundNumberingRulesName = true;
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ if( nFamily != XmlStyleFamily::PAGE_MASTER )
+ return;
+
+ for( const auto& rProp : rProperties )
+ {
+ if (rProp.mnIndex > -1)
+ {
+ const rtl::Reference< XMLPropertySetMapper >& aPropMapper = rPropExp.getPropertySetMapper();
+ sal_Int32 nIndex = rProp.mnIndex;
+ sal_Int16 nContextID = aPropMapper->GetEntryContextId( nIndex );
+ switch( nContextID )
+ {
+ case CTF_PM_PAGEUSAGE:
+ {
+ OUString sValue;
+ const XMLPropertyHandler* pPropHdl = aPropMapper->GetPropertyHandler( nIndex );
+ if( pPropHdl &&
+ pPropHdl->exportXML( sValue, rProp.maValue,
+ GetExport().GetMM100UnitConverter() ) &&
+ ( ! IsXMLToken( sValue, XML_ALL ) ) )
+ {
+ GetExport().AddAttribute( aPropMapper->GetEntryNameSpace( nIndex ), aPropMapper->GetEntryXMLName( nIndex ), sValue );
+ }
+ }
+ break;
+ }
+ }
+ }
+}
+
+void SvXMLAutoStylePoolP::exportStyleContent(
+ const css::uno::Reference< css::xml::sax::XDocumentHandler > &,
+ XmlStyleFamily nFamily,
+ const vector< XMLPropertyState >& rProperties,
+ const SvXMLExportPropertyMapper& rPropExp,
+ const SvXMLUnitConverter&,
+ const SvXMLNamespaceMap&
+ ) const
+{
+ if( nFamily != XmlStyleFamily::PAGE_MASTER )
+ return;
+
+ sal_Int32 nHeaderStartIndex(-1);
+ sal_Int32 nHeaderEndIndex(-1);
+ sal_Int32 nFooterStartIndex(-1);
+ sal_Int32 nFooterEndIndex(-1);
+ bool bHeaderStartIndex(false);
+ bool bHeaderEndIndex(false);
+ bool bFooterStartIndex(false);
+ bool bFooterEndIndex(false);
+
+ const rtl::Reference< XMLPropertySetMapper >& aPropMapper = rPropExp.getPropertySetMapper();
+
+ sal_Int32 nIndex(0);
+ while(nIndex < aPropMapper->GetEntryCount())
+ {
+ switch( aPropMapper->GetEntryContextId( nIndex ) & CTF_PM_FLAGMASK )
+ {
+ case CTF_PM_HEADERFLAG:
+ {
+ if (!bHeaderStartIndex)
+ {
+ nHeaderStartIndex = nIndex;
+ bHeaderStartIndex = true;
+ }
+ if (bFooterStartIndex && !bFooterEndIndex)
+ {
+ nFooterEndIndex = nIndex;
+ bFooterEndIndex = true;
+ }
+ }
+ break;
+ case CTF_PM_FOOTERFLAG:
+ {
+ if (!bFooterStartIndex)
+ {
+ nFooterStartIndex = nIndex;
+ bFooterStartIndex = true;
+ }
+ if (bHeaderStartIndex && !bHeaderEndIndex)
+ {
+ nHeaderEndIndex = nIndex;
+ bHeaderEndIndex = true;
+ }
+ }
+ break;
+ }
+ nIndex++;
+ }
+ if (!bHeaderEndIndex)
+ nHeaderEndIndex = nIndex;
+ if (!bFooterEndIndex)
+ nFooterEndIndex = nIndex;
+
+ // export header style element
+ {
+ SvXMLElementExport aElem(
+ GetExport(), XML_NAMESPACE_STYLE, XML_HEADER_STYLE,
+ true, true );
+
+ rPropExp.exportXML(
+ GetExport(), rProperties,
+ nHeaderStartIndex, nHeaderEndIndex, SvXmlExportFlags::IGN_WS);
+ }
+
+ // export footer style
+ {
+ SvXMLElementExport aElem(
+ GetExport(), XML_NAMESPACE_STYLE, XML_FOOTER_STYLE,
+ true, true );
+
+ rPropExp.exportXML(
+ GetExport(), rProperties,
+ nFooterStartIndex, nFooterEndIndex, SvXmlExportFlags::IGN_WS);
+ }
+
+}
+
+SvXMLAutoStylePoolP::SvXMLAutoStylePoolP( SvXMLExport& rExport )
+ : pImpl( new SvXMLAutoStylePoolP_Impl( rExport ) )
+{
+}
+
+SvXMLAutoStylePoolP::~SvXMLAutoStylePoolP()
+{
+}
+
+SvXMLExport& SvXMLAutoStylePoolP::GetExport() const
+{
+ return pImpl->GetExport();
+}
+
+// TODO: remove this
+void SvXMLAutoStylePoolP::AddFamily(
+ XmlStyleFamily nFamily,
+ const OUString& rStrName,
+ SvXMLExportPropertyMapper* pMapper,
+ const OUString& aStrPrefix )
+{
+ rtl::Reference <SvXMLExportPropertyMapper> xTmp = pMapper;
+ AddFamily( nFamily, rStrName, xTmp, aStrPrefix );
+}
+
+void SvXMLAutoStylePoolP::AddFamily(
+ XmlStyleFamily nFamily,
+ const OUString& rStrName,
+ const rtl::Reference < SvXMLExportPropertyMapper > & rMapper,
+ const OUString& rStrPrefix,
+ bool bAsFamily )
+{
+ pImpl->AddFamily( nFamily, rStrName, rMapper, rStrPrefix, bAsFamily );
+}
+
+void SvXMLAutoStylePoolP::SetFamilyPropSetMapper(
+ XmlStyleFamily nFamily,
+ const rtl::Reference < SvXMLExportPropertyMapper > & rMapper )
+{
+ pImpl->SetFamilyPropSetMapper( nFamily, rMapper );
+}
+
+void SvXMLAutoStylePoolP::RegisterName( XmlStyleFamily nFamily,
+ const OUString& rName )
+{
+ pImpl->RegisterName( nFamily, rName );
+}
+
+void SvXMLAutoStylePoolP::RegisterDefinedName( XmlStyleFamily nFamily,
+ const OUString& rName )
+{
+ pImpl->RegisterDefinedName( nFamily, rName );
+}
+
+void SvXMLAutoStylePoolP::GetRegisteredNames(
+ uno::Sequence<sal_Int32>& rFamilies,
+ uno::Sequence<OUString>& rNames )
+{
+ pImpl->GetRegisteredNames( rFamilies, rNames );
+}
+
+void SvXMLAutoStylePoolP::RegisterNames(
+ uno::Sequence<sal_Int32> const & aFamilies,
+ uno::Sequence<OUString> const & aNames )
+{
+ assert(aFamilies.getLength() == aNames.getLength());
+
+ // iterate over sequence(s) and call RegisterName(..) for each pair
+ const sal_Int32* pFamilies = aFamilies.getConstArray();
+ const OUString* pNames = aNames.getConstArray();
+ sal_Int32 nCount = min( aFamilies.getLength(), aNames.getLength() );
+ for( sal_Int32 n = 0; n < nCount; n++ )
+ RegisterName( static_cast<XmlStyleFamily>(pFamilies[n]), pNames[n] );
+}
+
+OUString SvXMLAutoStylePoolP::Add( XmlStyleFamily nFamily,
+ vector< XMLPropertyState >&& rProperties )
+{
+ OUString sName;
+ pImpl->Add(sName, nFamily, "", std::move(rProperties) );
+ return sName;
+}
+
+OUString SvXMLAutoStylePoolP::Add( XmlStyleFamily nFamily,
+ const OUString& rParent,
+ vector< XMLPropertyState >&& rProperties, bool bDontSeek )
+{
+ OUString sName;
+ pImpl->Add(sName, nFamily, rParent, std::move(rProperties), bDontSeek);
+ return sName;
+}
+
+bool SvXMLAutoStylePoolP::Add(OUString& rName, XmlStyleFamily nFamily, const OUString& rParent, ::std::vector< XMLPropertyState >&& rProperties )
+{
+ return pImpl->Add(rName, nFamily, rParent, std::move(rProperties));
+}
+
+bool SvXMLAutoStylePoolP::AddNamed( const OUString& rName, XmlStyleFamily nFamily, const OUString& rParent,
+ std::vector< XMLPropertyState >&& rProperties )
+
+{
+ return pImpl->AddNamed(rName, nFamily, rParent, std::move(rProperties));
+}
+
+OUString SvXMLAutoStylePoolP::Find( XmlStyleFamily nFamily,
+ const OUString& rParent,
+ const vector< XMLPropertyState >& rProperties ) const
+{
+ return pImpl->Find( nFamily, rParent, rProperties );
+}
+
+void SvXMLAutoStylePoolP::exportXML( XmlStyleFamily nFamily ) const
+{
+ pImpl->exportXML( nFamily, this );
+}
+
+void SvXMLAutoStylePoolP::ClearEntries()
+{
+ pImpl->ClearEntries();
+}
+
+std::vector<xmloff::AutoStyleEntry> SvXMLAutoStylePoolP::GetAutoStyleEntries() const
+{
+ return pImpl->GetAutoStyleEntries();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/xmlbahdl.cxx b/xmloff/source/style/xmlbahdl.cxx
new file mode 100644
index 000000000..36bc1037c
--- /dev/null
+++ b/xmloff/source/style/xmlbahdl.cxx
@@ -0,0 +1,904 @@
+/* -*- 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 "xmlbahdl.hxx"
+
+#include <XMLNumberWithAutoForVoidPropHdl.hxx>
+#include <sal/log.hxx>
+#include <o3tl/any.hxx>
+#include <o3tl/safeint.hxx>
+#include <o3tl/string_view.hxx>
+#include <sax/tools/converter.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <com/sun/star/uno/Any.hxx>
+#include <xmloff/xmltoken.hxx>
+
+#include <limits.h>
+
+using namespace ::com::sun::star::uno;
+using namespace ::xmloff::token;
+
+static void lcl_xmloff_setAny( Any& rValue, sal_Int32 nValue, sal_Int8 nBytes )
+{
+ switch( nBytes )
+ {
+ case 1:
+ if( nValue < SCHAR_MIN )
+ nValue = SCHAR_MIN;
+ else if( nValue > SCHAR_MAX )
+ nValue = SCHAR_MAX;
+ rValue <<= static_cast<sal_Int8>(nValue);
+ break;
+ case 2:
+ if( nValue < SHRT_MIN )
+ nValue = SHRT_MIN;
+ else if( nValue > SHRT_MAX )
+ nValue = SHRT_MAX;
+ rValue <<= static_cast<sal_Int16>(nValue);
+ break;
+ case 4:
+ rValue <<= nValue;
+ break;
+ }
+}
+
+static bool lcl_xmloff_getAny( const Any& rValue, sal_Int32& nValue,
+ sal_Int8 nBytes )
+{
+ bool bRet = false;
+
+ switch( nBytes )
+ {
+ case 1:
+ {
+ sal_Int8 nValue8 = 0;
+ bRet = rValue >>= nValue8;
+ nValue = nValue8;
+ }
+ break;
+ case 2:
+ {
+ sal_Int16 nValue16 = 0;
+ bRet = rValue >>= nValue16;
+ nValue = nValue16;
+ }
+ break;
+ case 4:
+ bRet = rValue >>= nValue;
+ break;
+ }
+
+ return bRet;
+}
+
+
+XMLNumberPropHdl::~XMLNumberPropHdl()
+{
+ // nothing to do
+}
+
+bool XMLNumberPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_Int32 nValue = 0;
+ bool bRet = ::sax::Converter::convertNumber( nValue, rStrImpValue );
+ lcl_xmloff_setAny( rValue, nValue, nBytes );
+
+ return bRet;
+}
+
+bool XMLNumberPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_Int32 nValue;
+
+ if( lcl_xmloff_getAny( rValue, nValue, nBytes ) )
+ {
+ rStrExpValue = OUString::number( nValue );
+
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+
+XMLNumberNonePropHdl::XMLNumberNonePropHdl( sal_Int8 nB ) :
+ sZeroStr( GetXMLToken(XML_NO_LIMIT) ),
+ nBytes( nB )
+{
+}
+
+XMLNumberNonePropHdl::XMLNumberNonePropHdl( enum XMLTokenEnum eZeroString, sal_Int8 nB ) :
+ sZeroStr( GetXMLToken( eZeroString ) ),
+ nBytes( nB )
+{
+}
+
+XMLNumberNonePropHdl::~XMLNumberNonePropHdl()
+{
+ // nothing to do
+}
+
+bool XMLNumberNonePropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+
+ sal_Int32 nValue = 0;
+ if( rStrImpValue == sZeroStr )
+ {
+ bRet = true;
+ }
+ else
+ {
+ bRet = ::sax::Converter::convertNumber( nValue, rStrImpValue );
+ }
+ lcl_xmloff_setAny( rValue, nValue, nBytes );
+
+ return bRet;
+}
+
+bool XMLNumberNonePropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_Int32 nValue;
+
+ if( lcl_xmloff_getAny( rValue, nValue, nBytes ) )
+ {
+ if( nValue == 0 )
+ {
+ rStrExpValue = sZeroStr;
+ }
+ else
+ {
+ rStrExpValue = OUString::number( nValue );
+ }
+
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+
+XMLMeasurePropHdl::~XMLMeasurePropHdl()
+{
+ // nothing to do
+}
+
+bool XMLMeasurePropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
+{
+ sal_Int32 nValue = 0;
+ bool bRet = rUnitConverter.convertMeasureToCore( nValue, rStrImpValue );
+ lcl_xmloff_setAny( rValue, nValue, nBytes );
+ return bRet;
+}
+
+bool XMLMeasurePropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
+{
+ bool bRet = false;
+ sal_Int32 nValue;
+
+ if( lcl_xmloff_getAny( rValue, nValue, nBytes ) )
+ {
+ OUStringBuffer aOut;
+ rUnitConverter.convertMeasureToXML( aOut, nValue );
+ rStrExpValue = aOut.makeStringAndClear();
+
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+
+XMLBoolFalsePropHdl::~XMLBoolFalsePropHdl()
+{
+ // nothing to do
+}
+
+bool XMLBoolFalsePropHdl::importXML( const OUString&, Any&, const SvXMLUnitConverter& ) const
+{
+ return false;
+}
+
+bool XMLBoolFalsePropHdl::exportXML( OUString& rStrExpValue, const Any& /*rValue*/, const SvXMLUnitConverter& rCnv) const
+{
+ return XMLBoolPropHdl::exportXML( rStrExpValue, Any( false ), rCnv );
+}
+
+
+XMLBoolPropHdl::~XMLBoolPropHdl()
+{
+ // nothing to do
+}
+
+bool XMLBoolPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bValue(false);
+ bool const bRet = ::sax::Converter::convertBool( bValue, rStrImpValue );
+ rValue <<= bValue;
+
+ return bRet;
+}
+
+bool XMLBoolPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ bool bValue;
+
+ if (rValue >>= bValue)
+ {
+ OUStringBuffer aOut;
+ ::sax::Converter::convertBool( aOut, bValue );
+ rStrExpValue = aOut.makeStringAndClear();
+
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+
+XMLNBoolPropHdl::~XMLNBoolPropHdl()
+{
+ // nothing to do
+}
+
+bool XMLNBoolPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bValue(false);
+ bool const bRet = ::sax::Converter::convertBool( bValue, rStrImpValue );
+ rValue <<= !bValue;
+
+ return bRet;
+}
+
+bool XMLNBoolPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ bool bValue;
+
+ if (rValue >>= bValue)
+ {
+ OUStringBuffer aOut;
+ ::sax::Converter::convertBool( aOut, !bValue );
+ rStrExpValue = aOut.makeStringAndClear();
+
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+
+XMLPercentPropHdl::~XMLPercentPropHdl()
+{
+ // nothing to do
+}
+
+bool XMLPercentPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_Int32 nValue = 0;
+ bool const bRet = ::sax::Converter::convertPercent( nValue, rStrImpValue );
+ lcl_xmloff_setAny( rValue, nValue, nBytes );
+
+ return bRet;
+}
+
+bool XMLPercentPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_Int32 nValue;
+
+ if( lcl_xmloff_getAny( rValue, nValue, nBytes ) )
+ {
+ OUStringBuffer aOut;
+ ::sax::Converter::convertPercent( aOut, nValue );
+ rStrExpValue = aOut.makeStringAndClear();
+
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+
+bool XMLDoublePercentPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+
+ double fValue = 1.0;
+
+ if( rStrImpValue.indexOf( '%' ) == -1 )
+ {
+ fValue = rStrImpValue.toDouble();
+ }
+ else
+ {
+ sal_Int32 nValue = 0;
+ bRet = ::sax::Converter::convertPercent( nValue, rStrImpValue );
+ fValue = static_cast<double>(nValue) / 100.0;
+ }
+ rValue <<= fValue;
+
+ return bRet;
+}
+
+bool XMLDoublePercentPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ double fValue = 0;
+
+ if( rValue >>= fValue )
+ {
+ fValue *= 100.0;
+ if( fValue > 0 ) fValue += 0.5; else fValue -= 0.5;
+
+ sal_Int32 nValue = static_cast<sal_Int32>(fValue);
+
+ OUStringBuffer aOut;
+ ::sax::Converter::convertPercent( aOut, nValue );
+ rStrExpValue = aOut.makeStringAndClear();
+
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+bool XML100thPercentPropHdl::importXML(const OUString& rStrImpValue, Any& rValue,
+ const SvXMLUnitConverter&) const
+{
+ bool bRet = false;
+
+ sal_Int32 nValue = 0;
+ bRet = sax::Converter::convertPercent(nValue, rStrImpValue);
+ rValue <<= static_cast<sal_Int16>(nValue * 100);
+
+ return bRet;
+}
+
+bool XML100thPercentPropHdl::exportXML(OUString& rStrExpValue, const Any& rValue,
+ const SvXMLUnitConverter&) const
+{
+ bool bRet = false;
+ sal_Int16 nValue = 0;
+
+ if (rValue >>= nValue)
+ {
+ nValue = std::round(static_cast<double>(nValue) / 100);
+ OUStringBuffer aOut;
+ sax::Converter::convertPercent(aOut, nValue);
+ rStrExpValue = aOut.makeStringAndClear();
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+
+XMLNegPercentPropHdl::~XMLNegPercentPropHdl()
+{
+ // nothing to do
+}
+
+bool XMLNegPercentPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_Int32 nValue = 0;
+ bool bRet = ::sax::Converter::convertPercent( nValue, rStrImpValue );
+ if (bRet)
+ bRet = !o3tl::checked_sub<sal_Int32>(100, nValue, nValue);
+ if (bRet)
+ lcl_xmloff_setAny( rValue, nValue, nBytes );
+ return bRet;
+}
+
+bool XMLNegPercentPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_Int32 nValue;
+
+ if( lcl_xmloff_getAny( rValue, nValue, nBytes ) )
+ {
+ OUStringBuffer aOut;
+ ::sax::Converter::convertPercent( aOut, 100-nValue );
+ rStrExpValue = aOut.makeStringAndClear();
+
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+XMLMeasurePxPropHdl::~XMLMeasurePxPropHdl()
+{
+ // nothing to do
+}
+
+bool XMLMeasurePxPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_Int32 nValue = 0;
+ bool bRet = ::sax::Converter::convertMeasurePx( nValue, rStrImpValue );
+ lcl_xmloff_setAny( rValue, nValue, nBytes );
+ return bRet;
+}
+
+bool XMLMeasurePxPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_Int32 nValue;
+
+ if( lcl_xmloff_getAny( rValue, nValue, nBytes ) )
+ {
+ OUStringBuffer aOut;
+ ::sax::Converter::convertMeasurePx( aOut, nValue );
+ rStrExpValue = aOut.makeStringAndClear();
+
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+
+XMLColorPropHdl::~XMLColorPropHdl()
+{
+ // Nothing to do
+}
+
+bool XMLColorPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+
+ if( rStrImpValue.matchIgnoreAsciiCase( "hsl" ) )
+ {
+ sal_Int32 nOpen = rStrImpValue.indexOf( '(' );
+ sal_Int32 nClose = rStrImpValue.lastIndexOf( ')' );
+
+ if( (nOpen != -1) && (nClose > nOpen) )
+ {
+ const std::u16string_view aTmp( rStrImpValue.subView( nOpen+1, nClose - nOpen-1) );
+
+ sal_Int32 nIndex = 0;
+
+ Sequence< double > aHSL
+ {
+ o3tl::toDouble(o3tl::getToken(aTmp, 0, ',', nIndex )),
+ o3tl::toDouble(o3tl::getToken(aTmp, 0, ',', nIndex )) / 100.0,
+ o3tl::toDouble(o3tl::getToken(aTmp, 0, ',', nIndex )) / 100.0
+ };
+ rValue <<= aHSL;
+ bRet = true;
+ }
+ }
+ else
+ {
+ sal_Int32 nColor(0);
+ bRet = ::sax::Converter::convertColor( nColor, rStrImpValue );
+ rValue <<= nColor;
+ }
+
+ return bRet;
+}
+
+bool XMLColorPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_Int32 nColor = 0;
+
+ OUStringBuffer aOut;
+ if( rValue >>= nColor )
+ {
+ ::sax::Converter::convertColor( aOut, nColor );
+ rStrExpValue = aOut.makeStringAndClear();
+
+ bRet = true;
+ }
+ else
+ {
+ Sequence< double > aHSL;
+ if( (rValue >>= aHSL) && (aHSL.getLength() == 3) )
+ {
+ rStrExpValue = "hsl(" + OUString::number(aHSL[0]) + "," +
+ OUString::number(aHSL[1] * 100.0) + "%," +
+ OUString::number(aHSL[2] * 100.0) + "%)";
+
+ bRet = true;
+ }
+ }
+
+ return bRet;
+}
+
+
+XMLHexPropHdl::~XMLHexPropHdl()
+{
+ // Nothing to do
+}
+
+bool XMLHexPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ sal_uInt32 nRsid;
+ bool bRet = SvXMLUnitConverter::convertHex( nRsid, rStrImpValue );
+ rValue <<= nRsid;
+
+ return bRet;
+}
+
+bool XMLHexPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_uInt32 nRsid = 0;
+
+ if( rValue >>= nRsid )
+ {
+ OUStringBuffer aOut;
+ SvXMLUnitConverter::convertHex( aOut, nRsid );
+ rStrExpValue = aOut.makeStringAndClear();
+
+ bRet = true;
+ }
+ else
+ {
+ bRet = false;
+ }
+
+ return bRet;
+}
+
+
+XMLStringPropHdl::~XMLStringPropHdl()
+{
+ // Nothing to do
+}
+
+bool XMLStringPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ rValue <<= rStrImpValue;
+ return true;
+}
+
+bool XMLStringPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+
+ if( rValue >>= rStrExpValue )
+ bRet = true;
+
+ return bRet;
+}
+
+
+XMLStyleNamePropHdl::~XMLStyleNamePropHdl()
+{
+ // Nothing to do
+}
+
+bool XMLStyleNamePropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const
+{
+ bool bRet = false;
+
+ if( rValue >>= rStrExpValue )
+ {
+ rStrExpValue = rUnitConverter.encodeStyleName( rStrExpValue );
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+
+XMLDoublePropHdl::~XMLDoublePropHdl()
+{
+ // Nothing to do
+}
+
+bool XMLDoublePropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ double fDblValue(0.0);
+ bool const bRet = ::sax::Converter::convertDouble(fDblValue, rStrImpValue);
+ rValue <<= fDblValue;
+ return bRet;
+}
+
+bool XMLDoublePropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+
+ double fValue = 0;
+
+ if( rValue >>= fValue )
+ {
+ OUStringBuffer aOut;
+ ::sax::Converter::convertDouble( aOut, fValue );
+ rStrExpValue = aOut.makeStringAndClear();
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+
+XMLColorTransparentPropHdl::XMLColorTransparentPropHdl(
+ enum XMLTokenEnum eTransparent ) :
+ sTransparent( GetXMLToken(
+ eTransparent != XML_TOKEN_INVALID ? eTransparent : XML_TRANSPARENT ) )
+{
+ // Nothing to do
+}
+
+XMLColorTransparentPropHdl::~XMLColorTransparentPropHdl()
+{
+ // Nothing to do
+}
+
+bool XMLColorTransparentPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+
+ if( rStrImpValue != sTransparent )
+ {
+ sal_Int32 nColor(0);
+ bRet = ::sax::Converter::convertColor( nColor, rStrImpValue );
+ rValue <<= nColor;
+ }
+
+ return bRet;
+}
+
+bool XMLColorTransparentPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_Int32 nColor = 0;
+
+ if( rStrExpValue == sTransparent )
+ bRet = false;
+ else if( rValue >>= nColor )
+ {
+ OUStringBuffer aOut;
+ ::sax::Converter::convertColor( aOut, nColor );
+ rStrExpValue = aOut.makeStringAndClear();
+
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+
+XMLIsTransparentPropHdl::XMLIsTransparentPropHdl(
+ enum XMLTokenEnum eTransparent, bool bTransPropVal ) :
+ sTransparent( GetXMLToken(
+ eTransparent != XML_TOKEN_INVALID ? eTransparent : XML_TRANSPARENT ) ),
+ bTransPropValue( bTransPropVal )
+{
+}
+
+XMLIsTransparentPropHdl::~XMLIsTransparentPropHdl()
+{
+ // Nothing to do
+}
+
+bool XMLIsTransparentPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bValue = ( (rStrImpValue == sTransparent) == bTransPropValue);
+ rValue <<= bValue;
+
+ return true;
+}
+
+bool XMLIsTransparentPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+
+ // MIB: This looks a bit strange, because bTransPropValue == bValue should
+ // do the same, but this only applies if 'true' is represented by the same
+ // 8 bit value in bValue and bTransPropValue. Who will ensure this?
+ bool bValue = *o3tl::doAccess<bool>(rValue);
+ bool bIsTrans = bTransPropValue ? bValue : !bValue;
+
+ if( bIsTrans )
+ {
+ rStrExpValue = sTransparent;
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+
+XMLColorAutoPropHdl::XMLColorAutoPropHdl()
+{
+ // Nothing to do
+}
+
+XMLColorAutoPropHdl::~XMLColorAutoPropHdl()
+{
+ // Nothing to do
+}
+
+bool XMLColorAutoPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+
+ // This is a multi property: the value might be set to AUTO_COLOR
+ // already by the XMLIsAutoColorPropHdl!
+ sal_Int32 nColor = 0;
+ if( !(rValue >>= nColor) || -1 != nColor )
+ {
+ bRet = ::sax::Converter::convertColor( nColor, rStrImpValue );
+ if( bRet )
+ rValue <<= nColor;
+ }
+
+ return bRet;
+}
+
+bool XMLColorAutoPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+
+ sal_Int32 nColor = 0;
+ if( (rValue >>= nColor) && -1 != nColor )
+ {
+ OUStringBuffer aOut;
+ ::sax::Converter::convertColor( aOut, nColor );
+ rStrExpValue = aOut.makeStringAndClear();
+
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+
+XMLIsAutoColorPropHdl::XMLIsAutoColorPropHdl()
+{
+}
+
+XMLIsAutoColorPropHdl::~XMLIsAutoColorPropHdl()
+{
+ // Nothing to do
+}
+
+bool XMLIsAutoColorPropHdl::importXML( const OUString& rStrImpValue, Any& rValue, const SvXMLUnitConverter& ) const
+{
+ // An auto color overrides any other color set!
+ bool bValue;
+ bool const bRet = ::sax::Converter::convertBool( bValue, rStrImpValue );
+ if( bRet && bValue )
+ rValue <<= sal_Int32(-1);
+
+ return true;
+}
+
+bool XMLIsAutoColorPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+ bool bRet = false;
+ sal_Int32 nColor = 0;
+
+ if( (rValue >>= nColor) && -1 == nColor )
+ {
+ OUStringBuffer aOut;
+ ::sax::Converter::convertBool( aOut, true );
+ rStrExpValue = aOut.makeStringAndClear();
+
+ bRet = true;
+ }
+
+ return bRet;
+}
+
+
+XMLCompareOnlyPropHdl::~XMLCompareOnlyPropHdl()
+{
+ // Nothing to do
+}
+
+bool XMLCompareOnlyPropHdl::importXML( const OUString&, Any&, const SvXMLUnitConverter& ) const
+{
+ SAL_WARN( "xmloff", "importXML called for compare-only-property" );
+ return false;
+}
+
+bool XMLCompareOnlyPropHdl::exportXML( OUString&, const Any&, const SvXMLUnitConverter& ) const
+{
+ SAL_WARN( "xmloff", "exportXML called for compare-only-property" );
+ return false;
+}
+
+
+XMLNumberWithoutZeroPropHdl::XMLNumberWithoutZeroPropHdl( sal_Int8 nB ) :
+ nBytes( nB )
+{
+}
+
+XMLNumberWithoutZeroPropHdl::~XMLNumberWithoutZeroPropHdl()
+{
+}
+
+bool XMLNumberWithoutZeroPropHdl::importXML(
+ const OUString& rStrImpValue,
+ Any& rValue,
+ const SvXMLUnitConverter& ) const
+{
+ sal_Int32 nValue = 0;
+ bool const bRet = ::sax::Converter::convertNumber( nValue, rStrImpValue );
+ if( bRet )
+ lcl_xmloff_setAny( rValue, nValue, nBytes );
+ return bRet;
+}
+
+bool XMLNumberWithoutZeroPropHdl::exportXML( OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter& ) const
+{
+
+ sal_Int32 nValue = 0;
+ bool bRet = lcl_xmloff_getAny( rValue, nValue, nBytes );
+ bRet &= nValue != 0;
+
+ if( bRet )
+ {
+ rStrExpValue = OUString::number(nValue);
+ }
+
+ return bRet;
+}
+
+
+XMLNumberWithAutoForVoidPropHdl::~XMLNumberWithAutoForVoidPropHdl()
+{
+}
+
+bool XMLNumberWithAutoForVoidPropHdl::importXML(
+ const OUString& rStrImpValue,
+ Any& rValue,
+ const SvXMLUnitConverter& ) const
+{
+ sal_Int32 nValue = 0;
+ bool bRet = ::sax::Converter::convertNumber( nValue, rStrImpValue );
+ if( bRet )
+ lcl_xmloff_setAny( rValue, nValue, 2 );
+ else if( rStrImpValue == GetXMLToken( XML_AUTO ) )
+ {
+ rValue.clear(); // void
+ bRet = true;
+ }
+ return bRet;
+}
+
+bool XMLNumberWithAutoForVoidPropHdl::exportXML(
+ OUString& rStrExpValue, const Any& rValue, const SvXMLUnitConverter&) const
+{
+
+ sal_Int32 nValue = 0;
+ bool bRet = lcl_xmloff_getAny( rValue, nValue, 2 );
+
+ // note: 0 is a valid value here, see CTF_PAGENUMBEROFFSET for when it isn't
+
+ if (!bRet)
+ rStrExpValue = GetXMLToken( XML_AUTO );
+ else
+ {
+ rStrExpValue = OUString::number(nValue);
+ }
+
+ return true;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/xmlbahdl.hxx b/xmloff/source/style/xmlbahdl.hxx
new file mode 100644
index 000000000..09e392d6c
--- /dev/null
+++ b/xmloff/source/style/xmlbahdl.hxx
@@ -0,0 +1,314 @@
+/* -*- 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 .
+ */
+
+#pragma once
+
+#include <xmloff/xmlprhdl.hxx>
+#include <xmloff/xmltoken.hxx>
+
+
+/**
+ PropertyHandler for the XML-data-type: XML_TYPE_NUMBER
+*/
+class XMLNumberPropHdl : public XMLPropertyHandler
+{
+ sal_Int8 nBytes;
+
+public:
+ explicit XMLNumberPropHdl( sal_Int8 nB ) : nBytes( nB ) {}
+ virtual ~XMLNumberPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type: XML_TYPE_NUMBER_NONE
+*/
+class XMLNumberNonePropHdl : public XMLPropertyHandler
+{
+ OUString sZeroStr;
+ sal_Int8 nBytes;
+public:
+ explicit XMLNumberNonePropHdl( sal_Int8 nB = 4 );
+ XMLNumberNonePropHdl( enum ::xmloff::token::XMLTokenEnum eZeroString, sal_Int8 nB );
+ virtual ~XMLNumberNonePropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type: XML_TYPE_MEASURE
+*/
+class XMLMeasurePropHdl : public XMLPropertyHandler
+{
+ sal_Int8 nBytes;
+public:
+ explicit XMLMeasurePropHdl( sal_Int8 nB ) : nBytes( nB ) {}
+ virtual ~XMLMeasurePropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type: XML_TYPE_PERCENT
+*/
+class XMLPercentPropHdl : public XMLPropertyHandler
+{
+ sal_Int8 nBytes;
+public:
+ explicit XMLPercentPropHdl( sal_Int8 nB ) : nBytes( nB ) {}
+ virtual ~XMLPercentPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type: XML_TYPE_PERCENT
+ that is mapped on a double from 0.0 to 1.0
+*/
+class XMLDoublePercentPropHdl : public XMLPropertyHandler
+{
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/// Maps between XML percentage and our 100th percent ints.
+class XML100thPercentPropHdl : public XMLPropertyHandler
+{
+ virtual bool importXML(const OUString& rStrImpValue, css::uno::Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter) const override;
+ virtual bool exportXML(OUString& rStrExpValue, const css::uno::Any& rValue,
+ const SvXMLUnitConverter& rUnitConverter) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type: XML_TYPE_NEG_PERCENT
+*/
+class XMLNegPercentPropHdl : public XMLPropertyHandler
+{
+ sal_Int8 nBytes;
+public:
+ explicit XMLNegPercentPropHdl( sal_Int8 nB ) : nBytes( nB ) {}
+ virtual ~XMLNegPercentPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type: XML_TYPE_PERCENT
+*/
+class XMLMeasurePxPropHdl : public XMLPropertyHandler
+{
+ sal_Int8 nBytes;
+public:
+ explicit XMLMeasurePxPropHdl( sal_Int8 nB ) : nBytes( nB ) {}
+ virtual ~XMLMeasurePxPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type: XML_TYPE_BOOL
+*/
+class XMLBoolPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLBoolPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+class XMLBoolFalsePropHdl : public XMLBoolPropHdl
+{
+public:
+ virtual ~XMLBoolFalsePropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+
+};
+
+/**
+ PropertyHandler for the XML-data-type: XML_TYPE_COLOR
+*/
+class XMLColorPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLColorPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type: XML_TYPE_HEX
+*/
+class XMLHexPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLHexPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type: XML_TYPE_STRING
+*/
+class XMLStringPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLStringPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type: XML_TYPE_STYLENAME
+*/
+class XMLStyleNamePropHdl : public XMLStringPropHdl
+{
+public:
+ virtual ~XMLStyleNamePropHdl() override;
+
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+
+/**
+ PropertyHandler for the XML-data-type: XML_TYPE_DOUBLE
+*/
+class XMLDoublePropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLDoublePropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type: XML_TYPE_NBOOL
+*/
+class XMLNBoolPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLNBoolPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type: XML_TYPE_COLORTRANSPARENT
+*/
+class XMLColorTransparentPropHdl : public XMLPropertyHandler
+{
+ const OUString sTransparent;
+
+public:
+ explicit XMLColorTransparentPropHdl( enum ::xmloff::token::XMLTokenEnum eTransparent = xmloff::token::XML_TOKEN_INVALID );
+ virtual ~XMLColorTransparentPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type: XML_TYPE_ISTRANSPARENT
+*/
+class XMLIsTransparentPropHdl : public XMLPropertyHandler
+{
+ const OUString sTransparent;
+ bool bTransPropValue;
+
+public:
+ XMLIsTransparentPropHdl( enum ::xmloff::token::XMLTokenEnum eTransparent = xmloff::token::XML_TOKEN_INVALID,
+ bool bTransPropValue = true );
+ virtual ~XMLIsTransparentPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type: XML_TYPE_COLORAUTO
+*/
+class XMLColorAutoPropHdl : public XMLPropertyHandler
+{
+public:
+ XMLColorAutoPropHdl();
+ virtual ~XMLColorAutoPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type: XML_TYPE_COLORISAUTO
+*/
+class XMLIsAutoColorPropHdl : public XMLPropertyHandler
+{
+public:
+ XMLIsAutoColorPropHdl();
+ virtual ~XMLIsAutoColorPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+
+/**
+ PropertyHandler for properties that cannot make use of importXML
+ and exportXML methods, but can make use of the default comparison
+*/
+class XMLCompareOnlyPropHdl : public XMLPropertyHandler
+{
+public:
+ virtual ~XMLCompareOnlyPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/**
+ PropertyHandler for the XML-data-type: XML_TYPE_NUMBER_NO_ZERO
+ Reads/writes numeric properties, but fails for the value zero
+ (i.e., a value 0 property will not be written)
+*/
+class XMLNumberWithoutZeroPropHdl : public XMLPropertyHandler
+{
+ sal_Int8 nBytes;
+public:
+ explicit XMLNumberWithoutZeroPropHdl( sal_Int8 nB );
+ virtual ~XMLNumberWithoutZeroPropHdl() override;
+
+ virtual bool importXML( const OUString& rStrImpValue, css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+ virtual bool exportXML( OUString& rStrExpValue, const css::uno::Any& rValue, const SvXMLUnitConverter& rUnitConverter ) const override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/xmlexppr.cxx b/xmloff/source/style/xmlexppr.cxx
new file mode 100644
index 000000000..d81253238
--- /dev/null
+++ b/xmloff/source/style/xmlexppr.cxx
@@ -0,0 +1,1129 @@
+/* -*- 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 <optional>
+#include <string_view>
+#include <com/sun/star/container/XNameContainer.hpp>
+#include <com/sun/star/xml/AttributeData.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/beans/XPropertyState.hpp>
+#include <com/sun/star/beans/XMultiPropertySet.hpp>
+#include <com/sun/star/beans/XTolerantMultiPropertySet.hpp>
+#include <com/sun/star/beans/TolerantPropertySetResultType.hpp>
+#include <rtl/ustrbuf.hxx>
+#include <comphelper/anycompare.hxx>
+#include <cppuhelper/weakref.hxx>
+#include <osl/diagnose.h>
+#include <list>
+#include <map>
+#include <o3tl/sorted_vector.hxx>
+
+#include <xmloff/xmlexppr.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/attrlist.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/xmlprmap.hxx>
+#include <xmloff/maptype.hxx>
+#include <xmloff/xmltypes.hxx>
+#include <xmloff/xmlprhdl.hxx>
+
+using namespace ::std;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::xmloff::token;
+
+#define GET_PROP_TYPE( f ) static_cast<sal_uInt16>((f & XML_TYPE_PROP_MASK) >> XML_TYPE_PROP_SHIFT)
+#define ENTRY(t) { GET_PROP_TYPE(XML_TYPE_PROP_##t), XML_##t##_PROPERTIES }
+
+namespace {
+
+struct XMLPropTokens_Impl
+{
+ sal_uInt16 nType;
+ XMLTokenEnum eToken;
+};
+
+const sal_uInt16 MAX_PROP_TYPES =
+ (XML_TYPE_PROP_END >> XML_TYPE_PROP_SHIFT) -
+ (XML_TYPE_PROP_START >> XML_TYPE_PROP_SHIFT);
+
+XMLPropTokens_Impl const aPropTokens[MAX_PROP_TYPES] =
+{
+ ENTRY(CHART),
+ ENTRY(GRAPHIC),
+ ENTRY(TABLE),
+ ENTRY(TABLE_COLUMN),
+ ENTRY(TABLE_ROW),
+ ENTRY(TABLE_CELL),
+ ENTRY(LIST_LEVEL),
+ ENTRY(PARAGRAPH),
+ ENTRY(TEXT),
+ ENTRY(DRAWING_PAGE),
+ ENTRY(PAGE_LAYOUT),
+ ENTRY(HEADER_FOOTER),
+ ENTRY(RUBY),
+ ENTRY(SECTION)
+};
+
+// public methods
+
+// Take all properties of the XPropertySet which are also found in the
+// XMLPropertyMapEntry-array and which are not set to their default-value,
+// if a state is available.
+// After that I call the method 'ContextFilter'.
+
+struct ComparePropertyState
+{
+ bool operator()(XMLPropertyState const& lhs, XMLPropertyState const& rhs)
+ {
+ return lhs.mnIndex < rhs.mnIndex;
+ }
+};
+class XMLPropertyStates_Impl
+{
+ o3tl::sorted_vector<XMLPropertyState, ComparePropertyState> aPropStates;
+public:
+ XMLPropertyStates_Impl();
+ void AddPropertyState(const XMLPropertyState& rPropState);
+ void FillPropertyStateVector(std::vector<XMLPropertyState>& rVector);
+};
+
+XMLPropertyStates_Impl::XMLPropertyStates_Impl()
+{
+}
+
+void XMLPropertyStates_Impl::AddPropertyState(
+ const XMLPropertyState& rPropState)
+{
+ aPropStates.insert(rPropState);
+}
+
+void XMLPropertyStates_Impl::FillPropertyStateVector(
+ std::vector<XMLPropertyState>& rVector)
+{
+ rVector.insert( rVector.begin(), aPropStates.begin(), aPropStates.end() );
+}
+
+class FilterPropertyInfo_Impl
+{
+ OUString msApiName;
+ std::vector<sal_uInt32> maIndexes;
+
+public:
+
+ FilterPropertyInfo_Impl( const OUString& rApiName,
+ const sal_uInt32 nIndex);
+
+ const OUString& GetApiName() const { return msApiName; }
+ std::vector<sal_uInt32>& GetIndexes() { return maIndexes; }
+
+ // for sort
+ bool operator< ( const FilterPropertyInfo_Impl& rArg ) const
+ {
+ return (GetApiName() < rArg.GetApiName());
+ }
+};
+
+FilterPropertyInfo_Impl::FilterPropertyInfo_Impl(
+ const OUString& rApiName,
+ const sal_uInt32 nIndex ) :
+ msApiName( rApiName )
+{
+ maIndexes.push_back(nIndex);
+}
+
+typedef std::list<FilterPropertyInfo_Impl> FilterPropertyInfoList_Impl;
+
+class FilterPropertiesInfo_Impl
+{
+ FilterPropertyInfoList_Impl aPropInfos;
+
+ std::optional<Sequence<OUString>> mxApiNames;
+
+public:
+ FilterPropertiesInfo_Impl();
+
+ void AddProperty(const OUString& rApiName, const sal_uInt32 nIndex);
+ const uno::Sequence<OUString>& GetApiNames();
+ void FillPropertyStateArray(
+ vector< XMLPropertyState >& rPropStates,
+ const Reference< XPropertySet >& xPropSet,
+ const rtl::Reference< XMLPropertySetMapper >& maPropMapper,
+ const bool bDefault);
+ sal_uInt32 GetPropertyCount() const { return aPropInfos.size(); }
+};
+
+FilterPropertiesInfo_Impl::FilterPropertiesInfo_Impl()
+{
+}
+
+void FilterPropertiesInfo_Impl::AddProperty(
+ const OUString& rApiName, const sal_uInt32 nIndex)
+{
+ aPropInfos.emplace_back(rApiName, nIndex);
+
+ OSL_ENSURE( !mxApiNames, "performance warning: API names already retrieved" );
+ mxApiNames.reset();
+}
+
+const uno::Sequence<OUString>& FilterPropertiesInfo_Impl::GetApiNames()
+{
+ if( !mxApiNames )
+ {
+ // we have to do three things:
+ // 1) sort API names,
+ // 2) merge duplicates,
+ // 3) construct sequence
+
+ // sort names
+ aPropInfos.sort();
+
+ // merge duplicates
+ if ( aPropInfos.size() > 1 )
+ {
+ FilterPropertyInfoList_Impl::iterator aOld = aPropInfos.begin();
+ FilterPropertyInfoList_Impl::iterator aEnd = aPropInfos.end();
+ FilterPropertyInfoList_Impl::iterator aCurrent = aOld;
+ ++aCurrent;
+
+ while ( aCurrent != aEnd )
+ {
+ // equal to next element?
+ if ( aOld->GetApiName() == aCurrent->GetApiName() )
+ {
+ // if equal: merge index lists
+ std::vector<sal_uInt32> aMerged;
+ std::merge(aOld->GetIndexes().begin(), aOld->GetIndexes().end(),
+ aCurrent->GetIndexes().begin(), aCurrent->GetIndexes().end(),
+ std::back_inserter(aMerged));
+ aOld->GetIndexes() = std::move(aMerged);
+ aCurrent->GetIndexes().clear();
+ // erase element, and continue with next
+ aCurrent = aPropInfos.erase( aCurrent );
+ }
+ else
+ {
+ // remember old element and continue with next
+ aOld = aCurrent;
+ ++aCurrent;
+ }
+ }
+ }
+
+ // construct sequence
+ mxApiNames.emplace( aPropInfos.size() );
+ OUString *pNames = mxApiNames->getArray();
+
+ for (auto const& propInfo : aPropInfos)
+ {
+ *pNames = propInfo.GetApiName();
+ ++pNames;
+ }
+ }
+
+ return *mxApiNames;
+}
+
+void FilterPropertiesInfo_Impl::FillPropertyStateArray(
+ vector< XMLPropertyState >& rPropStates,
+ const Reference< XPropertySet >& rPropSet,
+ const rtl::Reference< XMLPropertySetMapper >& rPropMapper,
+ const bool bDefault )
+{
+ XMLPropertyStates_Impl aPropStates;
+
+ const uno::Sequence<OUString>& rApiNames = GetApiNames();
+
+ Reference < XTolerantMultiPropertySet > xTolPropSet( rPropSet, UNO_QUERY );
+ if (xTolPropSet.is())
+ {
+ if (!bDefault)
+ {
+ Sequence < beans::GetDirectPropertyTolerantResult > aResults(xTolPropSet->getDirectPropertyValuesTolerant(rApiNames));
+ sal_Int32 nResultCount(aResults.getLength());
+ if (nResultCount > 0)
+ {
+ const beans::GetDirectPropertyTolerantResult *pResults = aResults.getConstArray();
+ FilterPropertyInfoList_Impl::iterator aPropIter(aPropInfos.begin());
+ XMLPropertyState aNewProperty( -1 );
+ while (nResultCount > 0 && aPropIter != aPropInfos.end())
+ {
+ if (pResults->Name == aPropIter->GetApiName())
+ {
+ aNewProperty.mnIndex = -1;
+ aNewProperty.maValue = pResults->Value;
+
+ for (auto const& index : aPropIter->GetIndexes())
+ {
+ aNewProperty.mnIndex = index;
+ aPropStates.AddPropertyState( aNewProperty );
+ }
+ ++pResults;
+ --nResultCount;
+ }
+ ++aPropIter;
+ }
+ }
+ }
+ else
+ {
+ const Sequence < beans::GetPropertyTolerantResult > aResults(xTolPropSet->getPropertyValuesTolerant(rApiNames));
+ OSL_ENSURE( rApiNames.getLength() == aResults.getLength(), "wrong implemented XTolerantMultiPropertySet" );
+ FilterPropertyInfoList_Impl::iterator aPropIter(aPropInfos.begin());
+ XMLPropertyState aNewProperty( -1 );
+ OSL_ENSURE( aPropInfos.size() == static_cast<sal_uInt32>(aResults.getLength()), "wrong implemented XTolerantMultiPropertySet??" );
+ for( const auto& rResult : aResults )
+ {
+ if ((rResult.Result == beans::TolerantPropertySetResultType::SUCCESS) &&
+ ((rResult.State == PropertyState_DIRECT_VALUE) || (rResult.State == PropertyState_DEFAULT_VALUE)))
+ {
+ aNewProperty.mnIndex = -1;
+ aNewProperty.maValue = rResult.Value;
+
+ for (auto const& index : aPropIter->GetIndexes())
+ {
+ aNewProperty.mnIndex = index;
+ aPropStates.AddPropertyState( aNewProperty );
+ }
+ }
+ ++aPropIter;
+ }
+ }
+ }
+ else
+ {
+ Sequence < PropertyState > aStates;
+ const PropertyState *pStates = nullptr;
+ Reference< XPropertyState > xPropState( rPropSet, UNO_QUERY );
+ if( xPropState.is() )
+ {
+ aStates = xPropState->getPropertyStates( rApiNames );
+ pStates = aStates.getConstArray();
+ }
+
+ Reference < XMultiPropertySet > xMultiPropSet( rPropSet, UNO_QUERY );
+ if( xMultiPropSet.is() && !bDefault )
+ {
+ Sequence < Any > aValues;
+ if( pStates )
+ {
+ // step 1: get value count
+ sal_uInt32 nValueCount = 0;
+
+ for (size_t i = 0; i < aPropInfos.size(); ++i, ++pStates)
+ {
+ if( *pStates == PropertyState_DIRECT_VALUE )
+ nValueCount++;
+ }
+
+ if( nValueCount )
+ {
+ // step 2: collect property names
+ Sequence < OUString > aAPINames( nValueCount );
+ OUString *pAPINames = aAPINames.getArray();
+
+ ::std::vector< FilterPropertyInfoList_Impl::iterator > aPropIters;
+ aPropIters.reserve( nValueCount );
+
+ FilterPropertyInfoList_Impl::iterator aItr = aPropInfos.begin();
+ OSL_ENSURE(aItr != aPropInfos.end(),"Invalid iterator!");
+
+ pStates = aStates.getConstArray();
+ sal_uInt32 i = 0;
+ while( i < nValueCount )
+ {
+ if( *pStates == PropertyState_DIRECT_VALUE )
+ {
+ *pAPINames++ = aItr->GetApiName();
+ aPropIters.push_back( aItr );
+ ++i;
+ }
+ ++aItr;
+ ++pStates;
+ }
+
+ aValues = xMultiPropSet->getPropertyValues( aAPINames );
+ const Any *pValues = aValues.getConstArray();
+
+ ::std::vector< FilterPropertyInfoList_Impl::iterator >::const_iterator
+ pPropIter = aPropIters.begin();
+
+ XMLPropertyState aNewProperty( -1 );
+ for( i = 0; i < nValueCount; ++i )
+ {
+ aNewProperty.mnIndex = -1;
+ aNewProperty.maValue = *pValues;
+
+ for (auto const& index : (*pPropIter)->GetIndexes())
+ {
+ aNewProperty.mnIndex = index;
+ aPropStates.AddPropertyState( aNewProperty );
+ }
+
+ ++pPropIter;
+ ++pValues;
+ }
+ }
+ }
+ else
+ {
+ aValues = xMultiPropSet->getPropertyValues( rApiNames );
+ const Any *pValues = aValues.getConstArray();
+
+ FilterPropertyInfoList_Impl::iterator aItr = aPropInfos.begin();
+ for (size_t i = 0; i < aPropInfos.size(); ++i)
+ {
+ // The value is stored in the PropertySet itself, add to list.
+ XMLPropertyState aNewProperty( -1 );
+ aNewProperty.maValue = *pValues;
+ ++pValues;
+ for (auto const& index : aItr->GetIndexes())
+ {
+ aNewProperty.mnIndex = index;
+ aPropStates.AddPropertyState( aNewProperty );
+ }
+ ++aItr;
+ }
+ }
+ }
+ else
+ {
+ FilterPropertyInfoList_Impl::iterator aItr = aPropInfos.begin();
+ for (size_t i = 0; i < aPropInfos.size(); ++i)
+ {
+ bool bDirectValue =
+ !pStates || *pStates == PropertyState_DIRECT_VALUE;
+ if( bDirectValue || bDefault )
+ {
+ // The value is stored in the PropertySet itself, add to list.
+ bool bGotValue = false;
+ XMLPropertyState aNewProperty( -1 );
+ for (auto const& index : aItr->GetIndexes())
+ {
+ if( bDirectValue ||
+ (rPropMapper->GetEntryFlags(index) &
+ MID_FLAG_DEFAULT_ITEM_EXPORT) != 0 )
+ {
+ try
+ {
+ if( !bGotValue )
+ {
+ aNewProperty.maValue =
+ rPropSet->getPropertyValue( aItr->GetApiName() );
+ bGotValue = true;
+ }
+ aNewProperty.mnIndex = index;
+ aPropStates.AddPropertyState( aNewProperty );
+ }
+ catch( UnknownPropertyException& )
+ {
+ // might be a problem of getImplementationId
+ OSL_ENSURE( false, "unknown property in getPropertyValue" );
+ }
+
+ }
+ }
+ }
+
+ ++aItr;
+ if( pStates )
+ ++pStates;
+ }
+ }
+ }
+ aPropStates.FillPropertyStateVector(rPropStates);
+}
+
+}
+
+struct SvXMLExportPropertyMapper::Impl
+{
+ typedef std::map<css::uno::Reference<css::beans::XPropertySetInfo>, std::unique_ptr<FilterPropertiesInfo_Impl>> CacheType;
+ CacheType maCache;
+
+ rtl::Reference<SvXMLExportPropertyMapper> mxNextMapper;
+ rtl::Reference<XMLPropertySetMapper> mxPropMapper;
+
+ OUString maStyleName;
+};
+
+// ctor/dtor , class SvXMLExportPropertyMapper
+
+SvXMLExportPropertyMapper::SvXMLExportPropertyMapper(
+ const rtl::Reference< XMLPropertySetMapper >& rMapper ) :
+ mpImpl(new Impl)
+{
+ mpImpl->mxPropMapper = rMapper;
+}
+
+SvXMLExportPropertyMapper::~SvXMLExportPropertyMapper()
+{
+}
+
+void SvXMLExportPropertyMapper::ChainExportMapper(
+ const rtl::Reference< SvXMLExportPropertyMapper>& rMapper )
+{
+ // add map entries from rMapper to current map
+ mpImpl->mxPropMapper->AddMapperEntry( rMapper->getPropertySetMapper() );
+ // rMapper uses the same map as 'this'
+ rMapper->mpImpl->mxPropMapper = mpImpl->mxPropMapper;
+
+ // set rMapper as last mapper in current chain
+ rtl::Reference< SvXMLExportPropertyMapper > xNext = mpImpl->mxNextMapper;
+ if( xNext.is())
+ {
+ while (xNext->mpImpl->mxNextMapper.is())
+ xNext = xNext->mpImpl->mxNextMapper;
+ xNext->mpImpl->mxNextMapper = rMapper;
+ }
+ else
+ mpImpl->mxNextMapper = rMapper;
+
+ // if rMapper was already chained, correct
+ // map pointer of successors
+ xNext = rMapper;
+
+ while (xNext->mpImpl->mxNextMapper.is())
+ {
+ xNext = xNext->mpImpl->mxNextMapper;
+ xNext->mpImpl->mxPropMapper = mpImpl->mxPropMapper;
+ }
+}
+
+std::vector<XMLPropertyState> SvXMLExportPropertyMapper::Filter(
+ SvXMLExport const& rExport,
+ const uno::Reference<beans::XPropertySet>& rPropSet, bool bEnableFoFontFamily ) const
+{
+ return Filter_(rExport, rPropSet, false, bEnableFoFontFamily);
+}
+
+std::vector<XMLPropertyState> SvXMLExportPropertyMapper::FilterDefaults(
+ SvXMLExport const& rExport,
+ const uno::Reference<beans::XPropertySet>& rPropSet ) const
+{
+ return Filter_(rExport, rPropSet, true, false/*bEnableFoFontFamily*/);
+}
+
+vector<XMLPropertyState> SvXMLExportPropertyMapper::Filter_(
+ SvXMLExport const& rExport,
+ const Reference<XPropertySet>& xPropSet, bool bDefault, bool bEnableFoFontFamily ) const
+{
+ vector< XMLPropertyState > aPropStateArray;
+
+ // Retrieve XPropertySetInfo and XPropertyState
+ Reference< XPropertySetInfo > xInfo( xPropSet->getPropertySetInfo() );
+ if( !xInfo.is() )
+ return aPropStateArray;
+
+ sal_Int32 nProps = mpImpl->mxPropMapper->GetEntryCount();
+
+ FilterPropertiesInfo_Impl *pFilterInfo = nullptr;
+
+ Impl::CacheType::iterator aIter = mpImpl->maCache.find(xInfo);
+ if (aIter != mpImpl->maCache.end())
+ pFilterInfo = (*aIter).second.get();
+
+ bool bDelInfo = false;
+ if( !pFilterInfo )
+ {
+ assert(GetODFDefaultVersion() != SvtSaveOptions::ODFVER_UNKNOWN);
+ const SvtSaveOptions::ODFSaneDefaultVersion nCurrentVersion(rExport.getSaneDefaultVersion());
+ pFilterInfo = new FilterPropertiesInfo_Impl;
+ for( sal_Int32 i=0; i < nProps; i++ )
+ {
+ // Are we allowed to ask for the property? (MID_FLAG_NO_PROP..)
+ // Does the PropertySet contain name of mpEntries-array ?
+ const OUString& rAPIName = mpImpl->mxPropMapper->GetEntryAPIName( i );
+ const sal_Int32 nFlags = mpImpl->mxPropMapper->GetEntryFlags( i );
+ if( (0 == (nFlags & MID_FLAG_NO_PROPERTY_EXPORT)) &&
+ ( (0 != (nFlags & MID_FLAG_MUST_EXIST)) ||
+ xInfo->hasPropertyByName( rAPIName ) ) )
+ {
+ const SvtSaveOptions::ODFSaneDefaultVersion nEarliestODFVersionForExport(
+ mpImpl->mxPropMapper->GetEarliestODFVersionForExport(i));
+ // note: only standard ODF versions are allowed here,
+ // only exception is the unknown future
+ assert((nEarliestODFVersionForExport & SvtSaveOptions::ODFSVER_EXTENDED) == 0
+ || nEarliestODFVersionForExport == SvtSaveOptions::ODFSVER_FUTURE_EXTENDED);
+ static_assert(SvtSaveOptions::ODFSVER_LATEST_EXTENDED < SvtSaveOptions::ODFSVER_FUTURE_EXTENDED);
+ /// standard ODF namespaces for elements and attributes
+ static sal_uInt16 s_OdfNs[] = {
+ XML_NAMESPACE_OFFICE,
+ XML_NAMESPACE_STYLE,
+ XML_NAMESPACE_TEXT,
+ XML_NAMESPACE_TABLE,
+ XML_NAMESPACE_DRAW,
+ XML_NAMESPACE_FO,
+ XML_NAMESPACE_XLINK,
+ XML_NAMESPACE_DC,
+ XML_NAMESPACE_META,
+ XML_NAMESPACE_NUMBER,
+ XML_NAMESPACE_PRESENTATION,
+ XML_NAMESPACE_SVG,
+ XML_NAMESPACE_CHART,
+ XML_NAMESPACE_DR3D,
+ XML_NAMESPACE_MATH,
+ XML_NAMESPACE_FORM,
+ XML_NAMESPACE_SCRIPT,
+ XML_NAMESPACE_CONFIG,
+ XML_NAMESPACE_DB,
+ XML_NAMESPACE_XFORMS,
+ XML_NAMESPACE_SMIL,
+ XML_NAMESPACE_ANIMATION,
+ XML_NAMESPACE_XML,
+ XML_NAMESPACE_XHTML,
+ XML_NAMESPACE_GRDDL,
+ };
+ static bool s_Assert(false);
+ if (!s_Assert)
+ {
+ assert(std::is_sorted(std::begin(s_OdfNs), std::end(s_OdfNs)));
+ s_Assert = true;
+ }
+ //static_assert(std::is_sorted(std::begin(s_OdfNs), std::end(s_OdfNs)));
+ auto const ns(mpImpl->mxPropMapper->GetEntryNameSpace(i));
+ auto const iter(std::lower_bound(std::begin(s_OdfNs), std::end(s_OdfNs),
+ ns));
+ bool const isExtension(iter == std::end(s_OdfNs) || *iter != ns
+ // FIXME: very special hack to suppress style:hyperlink
+ || (ns == XML_NAMESPACE_STYLE
+ && mpImpl->mxPropMapper->GetEntryXMLName(i) == GetXMLToken(XML_HYPERLINK)));
+ if (isExtension
+ ? ((nCurrentVersion & SvtSaveOptions::ODFSVER_EXTENDED)
+ // if it's in standard ODF, don't export extension
+ && (nCurrentVersion < nEarliestODFVersionForExport))
+ : (nEarliestODFVersionForExport <= nCurrentVersion))
+ {
+ pFilterInfo->AddProperty(rAPIName, i);
+ }
+ }
+ }
+
+ // Check whether the property set info is destroyed if it is assigned to
+ // a weak reference only; If it is destroyed, then every instance of
+ // getPropertySetInfo returns a new object; such property set infos must
+ // not be cached:
+ WeakReference < XPropertySetInfo > xWeakInfo( xInfo );
+ xInfo.clear();
+ xInfo = xWeakInfo;
+ if( xInfo.is() )
+ {
+ mpImpl->maCache.emplace(xInfo, std::unique_ptr<FilterPropertiesInfo_Impl>(pFilterInfo));
+ }
+ else
+ bDelInfo = true;
+ }
+
+ if( pFilterInfo->GetPropertyCount() )
+ {
+ try
+ {
+ pFilterInfo->FillPropertyStateArray(
+ aPropStateArray, xPropSet, mpImpl->mxPropMapper, bDefault);
+ }
+ catch( UnknownPropertyException& )
+ {
+ // might be a problem of getImplementationId
+ OSL_ENSURE( false, "unknown property in getPropertyStates" );
+ }
+ }
+
+ // Call context-filter
+ if( !aPropStateArray.empty() )
+ ContextFilter(bEnableFoFontFamily, aPropStateArray, xPropSet);
+
+ // Have to do if we change from a vector to a list or something like that
+
+ if( bDelInfo )
+ delete pFilterInfo;
+
+ return aPropStateArray;
+}
+
+void SvXMLExportPropertyMapper::ContextFilter(
+ bool bEnableFoFontFamily,
+ vector< XMLPropertyState >& rProperties,
+ const Reference< XPropertySet >& rPropSet ) const
+{
+ // Derived class could implement this.
+ if (mpImpl->mxNextMapper.is())
+ mpImpl->mxNextMapper->ContextFilter(bEnableFoFontFamily, rProperties, rPropSet);
+}
+
+// Compares two Sequences of XMLPropertyState:
+// 1.Number of elements equal ?
+// 2.Index of each element equal ? (So I know whether the propertynames are the same)
+// 3.Value of each element equal ?
+bool SvXMLExportPropertyMapper::Equals(
+ const vector< XMLPropertyState >& aProperties1,
+ const vector< XMLPropertyState >& aProperties2 ) const
+{
+ if (aProperties1.size() < aProperties2.size())
+ return true;
+ if (aProperties1.size() > aProperties2.size())
+ return false;
+
+ sal_uInt32 nCount = aProperties1.size();
+
+ for (sal_uInt32 nIndex = 0; nIndex < nCount; ++nIndex)
+ {
+ const XMLPropertyState& rProp1 = aProperties1[ nIndex ];
+ const XMLPropertyState& rProp2 = aProperties2[ nIndex ];
+
+ // Compare index. If equal, compare value
+ if( rProp1.mnIndex < rProp2.mnIndex )
+ return true;
+ if( rProp1.mnIndex > rProp2.mnIndex )
+ return false;
+
+ if( rProp1.mnIndex != -1 )
+ {
+ // Now compare values
+ if ( (mpImpl->mxPropMapper->GetEntryType( rProp1.mnIndex ) &
+ XML_TYPE_BUILDIN_CMP ) != 0 )
+ {
+ // simple type ( binary compare )
+ if ( rProp1.maValue != rProp2.maValue)
+ return false;
+ }
+ else
+ {
+ // complex type ( ask for compare-function )
+ if (!mpImpl->mxPropMapper->GetPropertyHandler(
+ rProp1.mnIndex )->equals( rProp1.maValue,
+ rProp2.maValue ))
+ return false;
+ }
+ }
+ }
+
+ return true;
+}
+
+// Compares two Sequences of XMLPropertyState:
+// 1.Number of elements equal ?
+// 2.Index of each element equal ? (So I know whether the propertynames are the same)
+// 3.Value of each element equal ?
+bool SvXMLExportPropertyMapper::LessPartial(
+ const vector< XMLPropertyState >& aProperties1,
+ const vector< XMLPropertyState >& aProperties2 ) const
+{
+ if (aProperties1.size() < aProperties2.size())
+ return true;
+ if (aProperties1.size() > aProperties2.size())
+ return false;
+
+ sal_uInt32 nCount = aProperties1.size();
+
+ for (sal_uInt32 nIndex = 0; nIndex < nCount; ++nIndex)
+ {
+ const XMLPropertyState& rProp1 = aProperties1[ nIndex ];
+ const XMLPropertyState& rProp2 = aProperties2[ nIndex ];
+
+ // Compare index. If equal, compare value
+ if( rProp1.mnIndex < rProp2.mnIndex )
+ return true;
+ if( rProp1.mnIndex > rProp2.mnIndex )
+ return false;
+
+ if( rProp1.mnIndex != -1 )
+ {
+ // Now compare values
+ if ( (mpImpl->mxPropMapper->GetEntryType( rProp1.mnIndex ) &
+ XML_TYPE_BUILDIN_CMP ) != 0 )
+ {
+ // simple type ( binary compare )
+ if ( comphelper::anyLess(rProp1.maValue, rProp2.maValue) )
+ return true;
+ if ( comphelper::anyLess(rProp2.maValue, rProp1.maValue ) )
+ return false;
+ }
+ }
+ }
+
+ return false;
+}
+
+/** fills the given attribute list with the items in the given set
+void SvXMLExportPropertyMapper::exportXML( SvXMLAttributeList& rAttrList,
+ const ::std::vector< XMLPropertyState >& rProperties,
+ const SvXMLUnitConverter& rUnitConverter,
+ const SvXMLNamespaceMap& rNamespaceMap,
+ sal_uInt16 nFlags ) const
+{
+ _exportXML( rAttrList, rProperties, rUnitConverter, rNamespaceMap,
+ nFlags, 0, -1, -1 );
+}
+
+void SvXMLExportPropertyMapper::exportXML( SvXMLAttributeList& rAttrList,
+ const ::std::vector< XMLPropertyState >& rProperties,
+ const SvXMLUnitConverter& rUnitConverter,
+ const SvXMLNamespaceMap& rNamespaceMap,
+ sal_Int32 nPropMapStartIdx, sal_Int32 nPropMapEndIdx,
+ sal_uInt16 nFlags ) const
+{
+ _exportXML( rAttrList, rProperties, rUnitConverter, rNamespaceMap,
+ nFlags, 0, nPropMapStartIdx, nPropMapEndIdx );
+}
+*/
+
+void SvXMLExportPropertyMapper::exportXML(
+ SvXMLExport& rExport,
+ const ::std::vector< XMLPropertyState >& rProperties,
+ SvXmlExportFlags nFlags,
+ bool bUseExtensionNamespaceForGraphicProperties) const
+{
+ exportXML(rExport, rProperties, -1, -1, nFlags, bUseExtensionNamespaceForGraphicProperties);
+}
+
+
+void SvXMLExportPropertyMapper::exportXML(
+ SvXMLExport& rExport,
+ const ::std::vector< XMLPropertyState >& rProperties,
+ sal_Int32 nPropMapStartIdx, sal_Int32 nPropMapEndIdx,
+ SvXmlExportFlags nFlags, bool bUseExtensionNamespaceForGraphicProperties) const
+{
+ sal_uInt16 nPropTypeFlags = 0;
+ for( sal_uInt16 i=0; i<MAX_PROP_TYPES; ++i )
+ {
+ sal_uInt16 nPropType = aPropTokens[i].nType;
+ if( 0==i || (nPropTypeFlags & (1 << nPropType)) != 0 )
+ {
+ sal_uInt16 nNamespace = XML_NAMESPACE_STYLE;
+ if (bUseExtensionNamespaceForGraphicProperties &&
+ aPropTokens[i].eToken == xmloff::token::XML_GRAPHIC_PROPERTIES)
+ {
+ nNamespace = XML_NAMESPACE_LO_EXT;
+ if ((rExport.getSaneDefaultVersion() & SvtSaveOptions::ODFSVER_EXTENDED) == 0)
+ {
+ continue; // don't write for ODF <= 1.2
+ }
+ }
+
+ std::vector<sal_uInt16> aIndexArray;
+
+ _exportXML( nPropType, nPropTypeFlags,
+ rExport.GetAttrList(), rProperties,
+ rExport.GetMM100UnitConverter(),
+ rExport.GetNamespaceMap(),
+ &aIndexArray,
+ nPropMapStartIdx, nPropMapEndIdx );
+
+ if( rExport.GetAttrList().getLength() > 0 ||
+ !aIndexArray.empty() )
+ {
+ SvXMLElementExport aElem( rExport, nNamespace,
+ aPropTokens[i].eToken,
+ bool(nFlags & SvXmlExportFlags::IGN_WS),
+ false );
+
+ exportElementItems( rExport, rProperties, nFlags, aIndexArray );
+ }
+ }
+ }
+}
+
+/** this method is called for every item that has the
+ MID_FLAG_SPECIAL_ITEM_EXPORT flag set */
+void SvXMLExportPropertyMapper::handleSpecialItem(
+ SvXMLAttributeList& rAttrList,
+ const XMLPropertyState& rProperty,
+ const SvXMLUnitConverter& rUnitConverter,
+ const SvXMLNamespaceMap& rNamespaceMap,
+ const ::std::vector< XMLPropertyState > *pProperties,
+ sal_uInt32 nIdx ) const
+{
+ OSL_ENSURE(mpImpl->mxNextMapper.is(), "special item not handled in xml export");
+ if (mpImpl->mxNextMapper.is())
+ mpImpl->mxNextMapper->handleSpecialItem(
+ rAttrList, rProperty, rUnitConverter, rNamespaceMap, pProperties, nIdx);
+}
+
+/** this method is called for every item that has the
+ MID_FLAG_ELEMENT_EXPORT flag set */
+void SvXMLExportPropertyMapper::handleElementItem(
+ SvXMLExport& rExport,
+ const XMLPropertyState& rProperty,
+ SvXmlExportFlags nFlags,
+ const ::std::vector< XMLPropertyState > *pProperties,
+ sal_uInt32 nIdx ) const
+{
+ OSL_ENSURE(mpImpl->mxNextMapper.is(), "element item not handled in xml export");
+ if (mpImpl->mxNextMapper.is())
+ mpImpl->mxNextMapper->handleElementItem(rExport, rProperty, nFlags, pProperties, nIdx);
+}
+
+// protected methods
+
+/** fills the given attribute list with the items in the given set */
+void SvXMLExportPropertyMapper::_exportXML(
+ sal_uInt16 nPropType, sal_uInt16& rPropTypeFlags,
+ SvXMLAttributeList& rAttrList,
+ const ::std::vector< XMLPropertyState >& rProperties,
+ const SvXMLUnitConverter& rUnitConverter,
+ const SvXMLNamespaceMap& rNamespaceMap,
+ std::vector<sal_uInt16>* pIndexArray,
+ sal_Int32 nPropMapStartIdx, sal_Int32 nPropMapEndIdx ) const
+{
+ const sal_uInt32 nCount = rProperties.size();
+ sal_uInt32 nIndex = 0;
+
+ if( -1 == nPropMapStartIdx )
+ nPropMapStartIdx = 0;
+ if( -1 == nPropMapEndIdx )
+ nPropMapEndIdx = mpImpl->mxPropMapper->GetEntryCount();
+
+ while( nIndex < nCount )
+ {
+ sal_Int32 nPropMapIdx = rProperties[nIndex].mnIndex;
+ if( nPropMapIdx >= nPropMapStartIdx &&
+ nPropMapIdx < nPropMapEndIdx )// valid entry?
+ {
+ sal_uInt32 nEFlags = mpImpl->mxPropMapper->GetEntryFlags(nPropMapIdx);
+ sal_uInt16 nEPType = GET_PROP_TYPE(nEFlags);
+ OSL_ENSURE(nEPType >= (XML_TYPE_PROP_START >> XML_TYPE_PROP_SHIFT),
+ "no prop type specified");
+ rPropTypeFlags |= (1 << nEPType);
+ if( nEPType == nPropType )
+ {
+ // we have a valid map entry here, so lets use it...
+ if( ( nEFlags & MID_FLAG_ELEMENT_ITEM_EXPORT ) != 0 )
+ {
+ // element items do not add any properties,
+ // we export it later
+ if( pIndexArray )
+ {
+ pIndexArray->push_back( static_cast<sal_uInt16>(nIndex) );
+ }
+ }
+ else
+ {
+ _exportXML( rAttrList, rProperties[nIndex], rUnitConverter,
+ rNamespaceMap, &rProperties, nIndex );
+ }
+ }
+ }
+
+ nIndex++;
+ }
+}
+
+namespace
+{
+// -1 = Attribute needs extended namespace, but current ODF version is strict.
+// 1 = Attribute needs extended namespace and current ODF version allows it.
+// 0 = Attribute does not need extended namespace
+sal_Int8 CheckExtendedNamespace(std::u16string_view sXMLAttributeName, std::u16string_view sValue,
+ const SvtSaveOptions::ODFSaneDefaultVersion nODFVersion)
+{
+ if (IsXMLToken(sXMLAttributeName, XML_WRITING_MODE) && IsXMLToken(sValue, XML_BT_LR))
+ return nODFVersion & SvtSaveOptions::ODFSVER_EXTENDED ? 1 : -1;
+ else if (IsXMLToken(sXMLAttributeName, XML_VERTICAL_REL)
+ && (IsXMLToken(sValue, XML_PAGE_CONTENT_BOTTOM)
+ || IsXMLToken(sValue, XML_PAGE_CONTENT_TOP)))
+ return nODFVersion & SvtSaveOptions::ODFSVER_EXTENDED ? 1 : -1;
+ return 0;
+}
+}
+
+void SvXMLExportPropertyMapper::_exportXML(
+ SvXMLAttributeList& rAttrList,
+ const XMLPropertyState& rProperty,
+ const SvXMLUnitConverter& rUnitConverter,
+ const SvXMLNamespaceMap& rNamespaceMap,
+ const ::std::vector< XMLPropertyState > *pProperties,
+ sal_uInt32 nIdx ) const
+{
+ if ((mpImpl->mxPropMapper->GetEntryFlags(rProperty.mnIndex) & MID_FLAG_SPECIAL_ITEM_EXPORT) != 0)
+ {
+ uno::Reference< container::XNameContainer > xAttrContainer;
+ if( (rProperty.maValue >>= xAttrContainer) && xAttrContainer.is() )
+ {
+ std::unique_ptr<SvXMLNamespaceMap> pNewNamespaceMap;
+ const SvXMLNamespaceMap *pNamespaceMap = &rNamespaceMap;
+
+ const uno::Sequence< OUString > aAttribNames( xAttrContainer->getElementNames() );
+
+ OUStringBuffer sNameBuffer;
+ xml::AttributeData aData;
+ for( const auto& rAttribName : aAttribNames )
+ {
+ xAttrContainer->getByName( rAttribName ) >>= aData;
+ OUString sAttribName( rAttribName );
+
+ // extract namespace prefix from attribute name if it exists
+ OUString sPrefix;
+ const sal_Int32 nColonPos =
+ rAttribName.indexOf( ':' );
+ if( nColonPos != -1 )
+ sPrefix = rAttribName.copy( 0, nColonPos );
+
+ if( !sPrefix.isEmpty() )
+ {
+ OUString sNamespace( aData.Namespace );
+
+ // if the prefix isn't defined yet or has another meaning,
+ // we have to redefine it now.
+ sal_uInt16 nKey = pNamespaceMap->GetKeyByPrefix( sPrefix );
+ if( USHRT_MAX == nKey || pNamespaceMap->GetNameByKey( nKey ) != sNamespace )
+ {
+ bool bAddNamespace = false;
+ if( USHRT_MAX == nKey )
+ {
+ // The prefix is unused, so it is sufficient
+ // to add it to the namespace map.
+ bAddNamespace = true;
+ }
+ else
+ {
+ // check if there is a prefix registered for the
+ // namespace URI
+ nKey = pNamespaceMap->GetKeyByName( sNamespace );
+ if( XML_NAMESPACE_UNKNOWN == nKey )
+ {
+ // There is no prefix for the namespace, so
+ // we have to generate one and have to add it.
+ sal_Int32 n=0;
+ OUString sOrigPrefix( sPrefix );
+ do
+ {
+ sNameBuffer.append( sOrigPrefix );
+ sNameBuffer.append( ++n );
+ sPrefix = sNameBuffer.makeStringAndClear();
+ nKey = pNamespaceMap->GetKeyByPrefix( sPrefix );
+ }
+ while( nKey != USHRT_MAX );
+
+ bAddNamespace = true;
+ }
+ else
+ {
+ // If there is a prefix for the namespace,
+ // we reuse that.
+ sPrefix = pNamespaceMap->GetPrefixByKey( nKey );
+ }
+ // In any case, the attribute name has to be adapted.
+ sNameBuffer.append(sPrefix + ":" + rAttribName.subView(nColonPos+1));
+ sAttribName = sNameBuffer.makeStringAndClear();
+ }
+
+ if( bAddNamespace )
+ {
+ if( !pNewNamespaceMap )
+ {
+ pNewNamespaceMap.reset(new SvXMLNamespaceMap( rNamespaceMap ));
+ pNamespaceMap = pNewNamespaceMap.get();
+ }
+ pNewNamespaceMap->Add( sPrefix, sNamespace );
+ OUString sAttr = GetXMLToken(XML_XMLNS) + ":" + sPrefix;
+ rAttrList.AddAttribute( sAttr, sNamespace );
+ }
+ }
+ }
+ OUString sOldValue( rAttrList.getValueByName( sAttribName ) );
+ OSL_ENSURE( sOldValue.isEmpty(), "alien attribute exists already" );
+ OSL_ENSURE(aData.Type == GetXMLToken(XML_CDATA), "different type to our default type which should be written out");
+ if( sOldValue.isEmpty() )
+ rAttrList.AddAttribute( sAttribName, aData.Value );
+ }
+ }
+ else
+ {
+ handleSpecialItem( rAttrList, rProperty, rUnitConverter,
+ rNamespaceMap, pProperties, nIdx );
+ }
+ }
+ else if ((mpImpl->mxPropMapper->GetEntryFlags(rProperty.mnIndex) & MID_FLAG_ELEMENT_ITEM_EXPORT ) == 0)
+ {
+ OUString aValue;
+ OUString sName = rNamespaceMap.GetQNameByKey(
+ mpImpl->mxPropMapper->GetEntryNameSpace(rProperty.mnIndex),
+ mpImpl->mxPropMapper->GetEntryXMLName(rProperty.mnIndex));
+
+ bool bRemove = false;
+ if ((mpImpl->mxPropMapper->GetEntryFlags( rProperty.mnIndex ) & MID_FLAG_MERGE_ATTRIBUTE) != 0)
+ {
+ aValue = rAttrList.getValueByName( sName );
+ bRemove = true;
+ }
+
+ if (mpImpl->mxPropMapper->exportXML(aValue, rProperty, rUnitConverter))
+ {
+ if( bRemove )
+ rAttrList.RemoveAttribute( sName );
+
+ // We don't seem to have a generic mechanism to write an attribute in the extension
+ // namespace in case of certain attribute values only, so do this manually.
+ sal_Int8 nExtendedStatus
+ = CheckExtendedNamespace(mpImpl->mxPropMapper->GetEntryXMLName(rProperty.mnIndex),
+ aValue, rUnitConverter.getSaneDefaultVersion());
+ if (nExtendedStatus == -1)
+ return;
+ if (nExtendedStatus == 1)
+ sName = rNamespaceMap.GetQNameByKey(
+ XML_NAMESPACE_LO_EXT, mpImpl->mxPropMapper->GetEntryXMLName(rProperty.mnIndex));
+ rAttrList.AddAttribute( sName, aValue );
+ }
+ }
+}
+
+void SvXMLExportPropertyMapper::exportElementItems(
+ SvXMLExport& rExport,
+ const ::std::vector< XMLPropertyState >& rProperties,
+ SvXmlExportFlags nFlags,
+ const std::vector<sal_uInt16>& rIndexArray ) const
+{
+ bool bItemsExported = false;
+ for (const sal_uInt16 nElement : rIndexArray)
+ {
+ OSL_ENSURE( 0 != (mpImpl->mxPropMapper->GetEntryFlags(
+ rProperties[nElement].mnIndex ) & MID_FLAG_ELEMENT_ITEM_EXPORT),
+ "wrong mid flag!" );
+
+ rExport.IgnorableWhitespace();
+ handleElementItem( rExport, rProperties[nElement],
+ nFlags, &rProperties, nElement );
+ bItemsExported = true;
+ }
+
+ if( bItemsExported )
+ rExport.IgnorableWhitespace();
+}
+
+const rtl::Reference<XMLPropertySetMapper>& SvXMLExportPropertyMapper::getPropertySetMapper() const
+{
+ return mpImpl->mxPropMapper;
+}
+
+void SvXMLExportPropertyMapper::SetStyleName( const OUString& rStyleName )
+{
+ mpImpl->maStyleName = rStyleName;
+}
+
+const OUString& SvXMLExportPropertyMapper::GetStyleName() const
+{
+ return mpImpl->maStyleName;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/xmlimppr.cxx b/xmloff/source/style/xmlimppr.cxx
new file mode 100644
index 000000000..e8ecf4109
--- /dev/null
+++ b/xmloff/source/style/xmlimppr.cxx
@@ -0,0 +1,762 @@
+/* -*- 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/xml/AttributeData.hpp>
+#include <com/sun/star/beans/XMultiPropertySet.hpp>
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+#include <com/sun/star/lang/WrappedTargetException.hpp>
+#include <com/sun/star/beans/UnknownPropertyException.hpp>
+#include <com/sun/star/beans/PropertyVetoException.hpp>
+#include <com/sun/star/beans/TolerantPropertySetResultType.hpp>
+#include <com/sun/star/beans/XTolerantMultiPropertySet.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <rtl/ustrbuf.hxx>
+#include <sal/log.hxx>
+#include <osl/diagnose.h>
+#include <xmloff/xmlprmap.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/xmlimppr.hxx>
+#include <xmloff/xmlimp.hxx>
+
+#include <xmloff/unoatrcn.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlerror.hxx>
+#include <xmloff/contextid.hxx>
+#include <xmloff/xmltypes.hxx>
+#include <xmloff/maptype.hxx>
+
+#include <algorithm>
+#include <utility>
+#include <vector>
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::xml;
+using namespace ::com::sun::star::xml::sax;
+
+using namespace ::std;
+using namespace ::xmloff::token;
+using ::com::sun::star::lang::IllegalArgumentException;
+using ::com::sun::star::lang::WrappedTargetException;
+using ::com::sun::star::beans::UnknownPropertyException;
+using ::com::sun::star::beans::PropertyVetoException;
+
+
+SvXMLImportPropertyMapper::SvXMLImportPropertyMapper(
+ const rtl::Reference< XMLPropertySetMapper >& rMapper,
+ SvXMLImport& rImp ):
+ rImport(rImp),
+ maPropMapper ( rMapper )
+{
+}
+
+SvXMLImportPropertyMapper::~SvXMLImportPropertyMapper()
+{
+ mxNextMapper = nullptr;
+}
+
+void SvXMLImportPropertyMapper::ChainImportMapper(
+ const rtl::Reference< SvXMLImportPropertyMapper>& rMapper )
+{
+ // add map entries from rMapper to current map
+ maPropMapper->AddMapperEntry( rMapper->getPropertySetMapper() );
+ // rMapper uses the same map as 'this'
+ rMapper->maPropMapper = maPropMapper;
+
+ // set rMapper as last mapper in current chain
+ rtl::Reference< SvXMLImportPropertyMapper > xNext = mxNextMapper;
+ if( xNext.is())
+ {
+ while( xNext->mxNextMapper.is())
+ xNext = xNext->mxNextMapper;
+ xNext->mxNextMapper = rMapper;
+ }
+ else
+ mxNextMapper = rMapper;
+
+ // if rMapper was already chained, correct
+ // map pointer of successors
+ xNext = rMapper;
+
+ while( xNext->mxNextMapper.is())
+ {
+ xNext = xNext->mxNextMapper;
+ xNext->maPropMapper = maPropMapper;
+ }
+}
+
+/** fills the given itemset with the attributes in the given list */
+void SvXMLImportPropertyMapper::importXML(
+ vector< XMLPropertyState >& rProperties,
+ const Reference< XFastAttributeList >& xAttrList,
+ const SvXMLUnitConverter& rUnitConverter,
+ const SvXMLNamespaceMap& rNamespaceMap,
+ sal_uInt32 nPropType,
+ sal_Int32 nStartIdx,
+ sal_Int32 nEndIdx ) const
+{
+ Reference< XNameContainer > xAttrContainer;
+
+ if( -1 == nStartIdx )
+ nStartIdx = 0;
+ if( -1 == nEndIdx )
+ nEndIdx = maPropMapper->GetEntryCount();
+
+ for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
+ {
+ sal_Int32 nToken = aIter.getToken();
+ if( IsTokenInNamespace(nToken, XML_NAMESPACE_XMLNS) )
+ continue;
+
+ const OUString aPrefix = SvXMLImport::getNamespacePrefixFromToken(nToken, &rNamespaceMap);
+ const OUString aNamespaceURI = SvXMLImport::getNamespaceURIFromToken(nToken);
+ OUString sAttrName = SvXMLImport::getNameFromToken( nToken );
+ if ( !aPrefix.isEmpty() )
+ sAttrName = aPrefix + SvXMLImport::aNamespaceSeparator + sAttrName;
+
+ const OUString sValue = aIter.toString();
+
+ importXMLAttribute(rProperties, rUnitConverter, rNamespaceMap,
+ nPropType, nStartIdx, nEndIdx, xAttrContainer,
+ sAttrName, aNamespaceURI, sValue);
+ }
+
+ const css::uno::Sequence< css::xml::Attribute > unknownAttribs = xAttrList->getUnknownAttributes();
+ for (const css::xml::Attribute& rAttribute : unknownAttribs)
+ {
+ int nSepIndex = rAttribute.Name.indexOf(SvXMLImport::aNamespaceSeparator);
+ if (nSepIndex != -1)
+ {
+ // If it's an unknown attribute in a known namespace, ignore it.
+ OUString aPrefix = rAttribute.Name.copy(0, nSepIndex);
+ auto nKey = rNamespaceMap.GetKeyByPrefix(aPrefix);
+ if (nKey != USHRT_MAX && !(nKey & XML_NAMESPACE_UNKNOWN_FLAG))
+ continue;
+ }
+
+ importXMLAttribute(rProperties, rUnitConverter, rNamespaceMap,
+ nPropType, nStartIdx, nEndIdx, xAttrContainer,
+ rAttribute.Name, rAttribute.NamespaceURL, rAttribute.Value);
+ }
+
+ finished( rProperties, nStartIdx, nEndIdx );
+}
+
+void SvXMLImportPropertyMapper::importXMLAttribute(
+ vector< XMLPropertyState >& rProperties,
+ const SvXMLUnitConverter& rUnitConverter,
+ const SvXMLNamespaceMap& rNamespaceMap,
+ const sal_uInt32 nPropType,
+ const sal_Int32 nStartIdx,
+ const sal_Int32 nEndIdx,
+ Reference< XNameContainer >& xAttrContainer,
+ const OUString& rAttrName,
+ const OUString& aNamespaceURI,
+ const OUString& sValue) const
+{
+ OUString aLocalName, aPrefix, aNamespace;
+ sal_uInt16 nPrefix = rNamespaceMap.GetKeyByAttrName( rAttrName, &aPrefix,
+ &aLocalName, &aNamespace );
+
+ // index of actual property map entry
+ // This looks very strange, but it works well:
+ // If the start index is 0, the new value will become -1, and
+ // GetEntryIndex will start searching with position 0.
+ // Otherwise GetEntryIndex will start with the next position specified.
+ sal_Int32 nIndex = nStartIdx - 1;
+ sal_uInt32 nFlags = 0; // flags of actual property map entry
+ bool bFound = false;
+
+ // for better error reporting: this should be set true if no
+ // warning is needed
+ bool bNoWarning = false;
+
+ do
+ {
+ // find an entry for this attribute
+ nIndex = maPropMapper->GetEntryIndex( nPrefix, aLocalName,
+ nPropType, nIndex );
+
+ if( nIndex > -1 && nIndex < nEndIdx )
+ {
+ // create a XMLPropertyState with an empty value
+
+ nFlags = maPropMapper->GetEntryFlags( nIndex );
+ if( ( nFlags & MID_FLAG_ELEMENT_ITEM_IMPORT ) == 0 )
+ {
+ XMLPropertyState aNewProperty( nIndex );
+ sal_Int32 nReference = -1;
+
+ // if this is a multi attribute check if another attribute already set
+ // this any. If so use this as an initial value
+ if( ( nFlags & MID_FLAG_MERGE_PROPERTY ) != 0 )
+ {
+ const OUString aAPIName( maPropMapper->GetEntryAPIName( nIndex ) );
+ const sal_Int32 nSize = rProperties.size();
+ for( nReference = 0; nReference < nSize; nReference++ )
+ {
+ sal_Int32 nRefIdx = rProperties[nReference].mnIndex;
+ if( (nRefIdx != -1) && (nIndex != nRefIdx) &&
+ (maPropMapper->GetEntryAPIName( nRefIdx ) == aAPIName ))
+ {
+ aNewProperty = rProperties[nReference];
+ aNewProperty.mnIndex = nIndex;
+ break;
+ }
+ }
+
+ if( nReference == nSize )
+ nReference = -1;
+ }
+
+ bool bSet = false;
+ if( ( nFlags & MID_FLAG_SPECIAL_ITEM_IMPORT ) == 0 )
+ {
+ // let the XMLPropertySetMapper decide how to import the value
+ bSet = maPropMapper->importXML( sValue, aNewProperty,
+ rUnitConverter );
+ }
+ else
+ {
+ sal_uInt32 nOldSize = rProperties.size();
+
+ bSet = handleSpecialItem( aNewProperty, rProperties,
+ sValue, rUnitConverter,
+ rNamespaceMap );
+
+ // no warning if handleSpecialItem added properties
+ bNoWarning |= ( nOldSize != rProperties.size() );
+ }
+
+ // no warning if we found could set the item. This
+ // 'remembers' bSet across multi properties.
+ bNoWarning |= bSet;
+
+ // store the property in the given vector
+ if( bSet )
+ {
+ if( nReference == -1 )
+ rProperties.push_back( aNewProperty );
+ else
+ rProperties[nReference] = aNewProperty;
+ }
+ else
+ {
+ // warn about unknown value. Unless it's a
+ // multi property: Then we get another chance
+ // to set the value.
+ if( !bNoWarning &&
+ ((nFlags & MID_FLAG_MULTI_PROPERTY) == 0) )
+ {
+ rImport.SetError( XMLERROR_FLAG_WARNING |
+ XMLERROR_STYLE_ATTR_VALUE,
+ { rAttrName, sValue } );
+ }
+ }
+ }
+ bFound = true;
+ continue;
+ }
+
+ if( !bFound )
+ {
+ SAL_INFO_IF((XML_NAMESPACE_NONE != nPrefix) &&
+ !(XML_NAMESPACE_UNKNOWN_FLAG & nPrefix),
+ "xmloff.style",
+ "unknown attribute: \"" << rAttrName << "\"");
+ if( (XML_NAMESPACE_UNKNOWN_FLAG & nPrefix) || (XML_NAMESPACE_NONE == nPrefix) )
+ {
+ if( !xAttrContainer.is() )
+ {
+ // add an unknown attribute container to the properties
+ Reference< XNameContainer > xNew( SvUnoAttributeContainer_CreateInstance(), UNO_QUERY );
+ xAttrContainer = xNew;
+
+ // find map entry and create new property state
+ if( -1 == nIndex )
+ {
+ switch( nPropType )
+ {
+ case XML_TYPE_PROP_CHART:
+ nIndex = maPropMapper->FindEntryIndex( "ChartUserDefinedAttributes", XML_NAMESPACE_TEXT, GetXMLToken(XML_XMLNS) );
+ break;
+ case XML_TYPE_PROP_PARAGRAPH:
+ nIndex = maPropMapper->FindEntryIndex( "ParaUserDefinedAttributes", XML_NAMESPACE_TEXT, GetXMLToken(XML_XMLNS) );
+ break;
+ case XML_TYPE_PROP_TEXT:
+ nIndex = maPropMapper->FindEntryIndex( "TextUserDefinedAttributes", XML_NAMESPACE_TEXT, GetXMLToken(XML_XMLNS) );
+ break;
+ default:
+ break;
+ }
+ // other property type or property not found
+ if( -1 == nIndex )
+ nIndex = maPropMapper->FindEntryIndex( "UserDefinedAttributes", XML_NAMESPACE_TEXT, GetXMLToken(XML_XMLNS) );
+ }
+
+ // #106963#; use userdefined attribute only if it is in the specified property range
+ if( nIndex != -1 && nIndex >= nStartIdx && nIndex < nEndIdx)
+ {
+ XMLPropertyState aNewProperty( nIndex, Any(xAttrContainer) );
+
+ // push it on our stack so we export it later
+ rProperties.push_back( aNewProperty );
+ }
+ }
+
+ if( xAttrContainer.is() )
+ {
+ AttributeData aData;
+ aData.Type = GetXMLToken( XML_CDATA );
+ aData.Value = sValue;
+ OUString sName;
+ if( XML_NAMESPACE_NONE != nPrefix )
+ {
+ sName = rAttrName;
+ aData.Namespace = aNamespaceURI;
+ }
+ else
+ sName = aLocalName;
+ xAttrContainer->insertByName( sName, Any(aData) );
+ }
+ }
+ }
+ }
+ while( ( nIndex >= 0 && nIndex + 1 < nEndIdx ) && (( nFlags & MID_FLAG_MULTI_PROPERTY ) != 0 ) );
+}
+
+/** this method is called for every item that has the MID_FLAG_SPECIAL_ITEM_IMPORT flag set */
+bool SvXMLImportPropertyMapper::handleSpecialItem(
+ XMLPropertyState& rProperty,
+ vector< XMLPropertyState >& rProperties,
+ const OUString& rValue,
+ const SvXMLUnitConverter& rUnitConverter,
+ const SvXMLNamespaceMap& rNamespaceMap ) const
+{
+ OSL_ENSURE( mxNextMapper.is(), "unsupported special item in xml import" );
+ if( mxNextMapper.is() )
+ return mxNextMapper->handleSpecialItem( rProperty, rProperties, rValue,
+ rUnitConverter, rNamespaceMap );
+ else
+ return false;
+}
+
+void SvXMLImportPropertyMapper::FillPropertySequence(
+ const ::std::vector< XMLPropertyState >& rProperties,
+ css::uno::Sequence< css::beans::PropertyValue >& rValues )
+ const
+{
+ sal_Int32 nCount = rProperties.size();
+ sal_Int32 nValueCount = 0;
+ rValues.realloc( nCount );
+ PropertyValue *pProps = rValues.getArray();
+ for( sal_Int32 i=0; i < nCount; i++ )
+ {
+ const XMLPropertyState& rProp = rProperties[i];
+ sal_Int32 nIdx = rProp.mnIndex;
+ if( nIdx == -1 )
+ continue;
+ pProps->Name = maPropMapper->GetEntryAPIName( nIdx );
+ if( !pProps->Name.isEmpty() )
+ {
+ pProps->Value = rProp.maValue;
+ ++pProps;
+ ++nValueCount;
+ }
+ }
+ if( nValueCount < nCount )
+ rValues.realloc( nValueCount );
+}
+
+void SvXMLImportPropertyMapper::CheckSpecialContext(
+ const ::std::vector< XMLPropertyState >& aProperties,
+ const css::uno::Reference< css::beans::XPropertySet >& rPropSet,
+ ContextID_Index_Pair* pSpecialContextIds ) const
+{
+ OSL_ENSURE( rPropSet.is(), "need an XPropertySet" );
+ sal_Int32 nCount = aProperties.size();
+
+ for( sal_Int32 i=0; i < nCount; i++ )
+ {
+ const XMLPropertyState& rProp = aProperties[i];
+ sal_Int32 nIdx = rProp.mnIndex;
+
+ // disregard property state if it has an invalid index
+ if( -1 == nIdx )
+ continue;
+
+ const sal_Int32 nPropFlags = maPropMapper->GetEntryFlags( nIdx );
+
+ // handle no-property and special items
+ if( ( pSpecialContextIds != nullptr ) &&
+ ( ( 0 != ( nPropFlags & MID_FLAG_NO_PROPERTY_IMPORT ) ) ||
+ ( 0 != ( nPropFlags & MID_FLAG_SPECIAL_ITEM_IMPORT ) ) ) )
+ {
+ // maybe it's one of our special context ids?
+ sal_Int16 nContextId = maPropMapper->GetEntryContextId(nIdx);
+
+ for ( sal_Int32 n = 0;
+ pSpecialContextIds[n].nContextID != -1;
+ n++ )
+ {
+ // found: set index in pSpecialContextIds array
+ if ( pSpecialContextIds[n].nContextID == nContextId )
+ {
+ pSpecialContextIds[n].nIndex = i;
+ break; // early out
+ }
+ }
+ }
+ }
+
+}
+
+bool SvXMLImportPropertyMapper::FillPropertySet(
+ const vector< XMLPropertyState >& aProperties,
+ const Reference< XPropertySet >& rPropSet,
+ ContextID_Index_Pair* pSpecialContextIds ) const
+{
+ bool bSet = false;
+
+ Reference< XTolerantMultiPropertySet > xTolPropSet( rPropSet, UNO_QUERY );
+ if (xTolPropSet.is())
+ bSet = FillTolerantMultiPropertySet_( aProperties, xTolPropSet, maPropMapper, rImport,
+ pSpecialContextIds );
+
+ if (!bSet)
+ {
+ // get property set info
+ Reference< XPropertySetInfo > xInfo(rPropSet->getPropertySetInfo());
+
+ // check for multi-property set
+ Reference<XMultiPropertySet> xMultiPropSet( rPropSet, UNO_QUERY );
+ if ( xMultiPropSet.is() )
+ {
+ // Try XMultiPropertySet. If that fails, try the regular route.
+ bSet = FillMultiPropertySet_( aProperties, xMultiPropSet,
+ xInfo, maPropMapper,
+ pSpecialContextIds );
+ if ( !bSet )
+ bSet = FillPropertySet_( aProperties, rPropSet,
+ xInfo, maPropMapper, rImport,
+ pSpecialContextIds);
+ }
+ else
+ bSet = FillPropertySet_( aProperties, rPropSet, xInfo,
+ maPropMapper, rImport,
+ pSpecialContextIds );
+ }
+
+ return bSet;
+}
+
+bool SvXMLImportPropertyMapper::FillPropertySet_(
+ const vector<XMLPropertyState> & rProperties,
+ const Reference<XPropertySet> & rPropSet,
+ const Reference<XPropertySetInfo> & rPropSetInfo,
+ const rtl::Reference<XMLPropertySetMapper> & rPropMapper,
+ SvXMLImport& rImport,
+ ContextID_Index_Pair* pSpecialContextIds )
+{
+ OSL_ENSURE( rPropSet.is(), "need an XPropertySet" );
+ OSL_ENSURE( rPropSetInfo.is(), "need an XPropertySetInfo" );
+
+ // preliminaries
+ bool bSet = false;
+ sal_Int32 nCount = rProperties.size();
+
+ // iterate over property states that we want to set
+ for( sal_Int32 i=0; i < nCount; i++ )
+ {
+ const XMLPropertyState& rProp = rProperties[i];
+ sal_Int32 nIdx = rProp.mnIndex;
+
+ // disregard property state if it has an invalid index
+ if( -1 == nIdx )
+ continue;
+
+ const OUString& rPropName = rPropMapper->GetEntryAPIName( nIdx );
+ const sal_Int32 nPropFlags = rPropMapper->GetEntryFlags( nIdx );
+
+ if ( ( 0 == ( nPropFlags & MID_FLAG_NO_PROPERTY ) ) &&
+ ( ( 0 != ( nPropFlags & MID_FLAG_MUST_EXIST ) ) ||
+ rPropSetInfo->hasPropertyByName( rPropName ) ) )
+ {
+ // try setting the property
+ try
+ {
+ rPropSet->setPropertyValue( rPropName, rProp.maValue );
+ bSet = true;
+ }
+ catch ( const IllegalArgumentException& e )
+ {
+ // illegal value: check whether this property is
+ // allowed to throw this exception
+ if ( 0 == ( nPropFlags & MID_FLAG_PROPERTY_MAY_THROW ) )
+ {
+ Sequence<OUString> aSeq { rPropName };
+ rImport.SetError(
+ XMLERROR_STYLE_PROP_VALUE | XMLERROR_FLAG_ERROR,
+ aSeq, e.Message, nullptr );
+ }
+ }
+ catch ( const UnknownPropertyException& e )
+ {
+ // unknown property: This is always an error!
+ Sequence<OUString> aSeq { rPropName };
+ rImport.SetError(
+ XMLERROR_STYLE_PROP_UNKNOWN | XMLERROR_FLAG_ERROR,
+ aSeq, e.Message, nullptr );
+ }
+ catch ( const PropertyVetoException& e )
+ {
+ // property veto: this shouldn't happen
+ Sequence<OUString> aSeq { rPropName };
+ rImport.SetError(
+ XMLERROR_STYLE_PROP_OTHER | XMLERROR_FLAG_ERROR,
+ aSeq, e.Message, nullptr );
+ }
+ catch ( const WrappedTargetException& e )
+ {
+ // wrapped target: this shouldn't happen either
+ Sequence<OUString> aSeq { rPropName };
+ rImport.SetError(
+ XMLERROR_STYLE_PROP_OTHER | XMLERROR_FLAG_ERROR,
+ aSeq, e.Message, nullptr );
+ }
+ }
+
+ // handle no-property and special items
+ if( ( pSpecialContextIds != nullptr ) &&
+ ( ( 0 != ( nPropFlags & MID_FLAG_NO_PROPERTY_IMPORT ) ) ||
+ ( 0 != ( nPropFlags & MID_FLAG_SPECIAL_ITEM_IMPORT ) ) ) )
+ {
+ // maybe it's one of our special context ids?
+ sal_Int16 nContextId = rPropMapper->GetEntryContextId(nIdx);
+
+ for ( sal_Int32 n = 0;
+ pSpecialContextIds[n].nContextID != -1;
+ n++ )
+ {
+ // found: set index in pSpecialContextIds array
+ if ( pSpecialContextIds[n].nContextID == nContextId )
+ {
+ pSpecialContextIds[n].nIndex = i;
+ break; // early out
+ }
+ }
+ }
+ }
+
+ return bSet;
+}
+
+
+typedef pair<const OUString*, const Any* > PropertyPair;
+
+namespace {
+
+struct PropertyPairLessFunctor
+{
+ bool operator()( const PropertyPair& a, const PropertyPair& b ) const
+ {
+ return (*a.first < *b.first);
+ }
+};
+
+}
+
+void SvXMLImportPropertyMapper::PrepareForMultiPropertySet_(
+ const vector<XMLPropertyState> & rProperties,
+ const Reference<XPropertySetInfo> & rPropSetInfo,
+ const rtl::Reference<XMLPropertySetMapper> & rPropMapper,
+ ContextID_Index_Pair* pSpecialContextIds,
+ Sequence<OUString>& rNames,
+ Sequence<Any>& rValues)
+{
+ sal_Int32 nCount = rProperties.size();
+
+ // property pairs structure stores names + values of properties to be set.
+ vector<PropertyPair> aPropertyPairs;
+ aPropertyPairs.reserve( nCount );
+
+ // iterate over property states that we want to set
+ sal_Int32 i;
+ for( i = 0; i < nCount; i++ )
+ {
+ const XMLPropertyState& rProp = rProperties[i];
+ sal_Int32 nIdx = rProp.mnIndex;
+
+ // disregard property state if it has an invalid index
+ if( -1 == nIdx )
+ continue;
+
+ const OUString& rPropName = rPropMapper->GetEntryAPIName( nIdx );
+ const sal_Int32 nPropFlags = rPropMapper->GetEntryFlags( nIdx );
+
+ if ( ( 0 == ( nPropFlags & MID_FLAG_NO_PROPERTY ) ) &&
+ ( ( 0 != ( nPropFlags & MID_FLAG_MUST_EXIST ) ) ||
+ !rPropSetInfo.is() ||
+ rPropSetInfo->hasPropertyByName(rPropName) ) )
+ {
+ // save property into property pair structure
+ aPropertyPairs.emplace_back( &rPropName, &rProp.maValue );
+ }
+
+ // handle no-property and special items
+ if( ( pSpecialContextIds != nullptr ) &&
+ ( ( 0 != ( nPropFlags & MID_FLAG_NO_PROPERTY_IMPORT ) ) ||
+ ( 0 != ( nPropFlags & MID_FLAG_SPECIAL_ITEM_IMPORT ) ) ) )
+ {
+ // maybe it's one of our special context ids?
+ sal_Int16 nContextId = rPropMapper->GetEntryContextId(nIdx);
+ for ( sal_Int32 n = 0;
+ pSpecialContextIds[n].nContextID != -1;
+ n++ )
+ {
+ // found: set index in pSpecialContextIds array
+ if ( pSpecialContextIds[n].nContextID == nContextId )
+ {
+ pSpecialContextIds[n].nIndex = i;
+ break; // early out
+ }
+ }
+ }
+ }
+
+ // We now need to construct the sequences and actually the set
+ // values.
+
+ // sort the property pairs
+ sort( aPropertyPairs.begin(), aPropertyPairs.end(),
+ PropertyPairLessFunctor());
+
+ // create sequences
+ rNames.realloc( aPropertyPairs.size() );
+ OUString* pNamesArray = rNames.getArray();
+ rValues.realloc( aPropertyPairs.size() );
+ Any* pValuesArray = rValues.getArray();
+
+ // copy values into sequences
+ i = 0;
+ for( const auto& rPropertyPair : aPropertyPairs )
+ {
+ pNamesArray[i] = *(rPropertyPair.first);
+ pValuesArray[i++] = *(rPropertyPair.second);
+ }
+}
+
+bool SvXMLImportPropertyMapper::FillMultiPropertySet_(
+ const vector<XMLPropertyState> & rProperties,
+ const Reference<XMultiPropertySet> & rMultiPropSet,
+ const Reference<XPropertySetInfo> & rPropSetInfo,
+ const rtl::Reference<XMLPropertySetMapper> & rPropMapper,
+ ContextID_Index_Pair* pSpecialContextIds )
+{
+ OSL_ENSURE( rMultiPropSet.is(), "Need multi property set. ");
+ OSL_ENSURE( rPropSetInfo.is(), "Need property set info." );
+
+ bool bSuccessful = false;
+
+ Sequence<OUString> aNames;
+ Sequence<Any> aValues;
+
+ PrepareForMultiPropertySet_(rProperties, rPropSetInfo, rPropMapper, pSpecialContextIds,
+ aNames, aValues);
+
+ // and, finally, try to set the values
+ try
+ {
+ rMultiPropSet->setPropertyValues( aNames, aValues );
+ bSuccessful = true;
+ }
+ catch ( ... )
+ {
+ OSL_ENSURE(bSuccessful, "Exception caught; style may not be imported correctly.");
+ }
+
+ return bSuccessful;
+}
+
+bool SvXMLImportPropertyMapper::FillTolerantMultiPropertySet_(
+ const vector<XMLPropertyState> & rProperties,
+ const Reference<XTolerantMultiPropertySet> & rTolMultiPropSet,
+ const rtl::Reference<XMLPropertySetMapper> & rPropMapper,
+ SvXMLImport& rImport,
+ ContextID_Index_Pair* pSpecialContextIds )
+{
+ OSL_ENSURE( rTolMultiPropSet.is(), "Need tolerant multi property set. ");
+
+ bool bSuccessful = false;
+
+ Sequence<OUString> aNames;
+ Sequence<Any> aValues;
+
+ PrepareForMultiPropertySet_(rProperties, Reference<XPropertySetInfo>(nullptr), rPropMapper, pSpecialContextIds,
+ aNames, aValues);
+
+ // and, finally, try to set the values
+ try
+ {
+ const Sequence< SetPropertyTolerantFailed > aResults(rTolMultiPropSet->setPropertyValuesTolerant( aNames, aValues ));
+ bSuccessful = !aResults.hasElements();
+ for( const auto& rResult : aResults)
+ {
+ Sequence<OUString> aSeq { rResult.Name };
+ OUString sMessage;
+ switch (rResult.Result)
+ {
+ case TolerantPropertySetResultType::UNKNOWN_PROPERTY :
+ sMessage = "UNKNOWN_PROPERTY";
+ break;
+ case TolerantPropertySetResultType::ILLEGAL_ARGUMENT :
+ sMessage = "ILLEGAL_ARGUMENT";
+ break;
+ case TolerantPropertySetResultType::PROPERTY_VETO :
+ sMessage = "PROPERTY_VETO";
+ break;
+ case TolerantPropertySetResultType::WRAPPED_TARGET :
+ sMessage = "WRAPPED_TARGET";
+ break;
+ }
+ rImport.SetError(
+ XMLERROR_STYLE_PROP_OTHER | XMLERROR_FLAG_ERROR,
+ aSeq, sMessage, nullptr );
+ }
+ }
+ catch ( ... )
+ {
+ OSL_ENSURE(bSuccessful, "Exception caught; style may not be imported correctly.");
+ }
+
+ return bSuccessful;
+}
+
+void SvXMLImportPropertyMapper::finished(
+ vector< XMLPropertyState >& rProperties,
+ sal_Int32 nStartIndex, sal_Int32 nEndIndex ) const
+{
+ // nothing to do here
+ if( mxNextMapper.is() )
+ mxNextMapper->finished( rProperties, nStartIndex, nEndIndex );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/xmlnume.cxx b/xmloff/source/style/xmlnume.cxx
new file mode 100644
index 000000000..682fc648a
--- /dev/null
+++ b/xmloff/source/style/xmlnume.cxx
@@ -0,0 +1,832 @@
+/* -*- 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 <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
+#include <com/sun/star/style/NumberingType.hpp>
+#include <com/sun/star/style/XStyle.hpp>
+#include <com/sun/star/container/XIndexReplace.hpp>
+#include <com/sun/star/awt/XBitmap.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+#include <com/sun/star/awt/FontDescriptor.hpp>
+#include <com/sun/star/text/HoriOrientation.hpp>
+#include <com/sun/star/text/VertOrientation.hpp>
+#include <com/sun/star/text/XChapterNumberingSupplier.hpp>
+#include <com/sun/star/text/PositionAndSpaceMode.hpp>
+#include <com/sun/star/text/LabelFollow.hpp>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+
+#include <o3tl/any.hxx>
+#include <o3tl/temporary.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <sal/log.hxx>
+
+#include <sax/tools/converter.hxx>
+
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include "fonthdl.hxx"
+#include <xmloff/XMLTextListAutoStylePool.hxx>
+#include <xmloff/xmlnume.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <tools/fontenum.hxx>
+#include <vcl/vclenum.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::style;
+using namespace ::com::sun::star::text;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::beans;
+using namespace ::xmloff::token;
+
+void SvxXMLNumRuleExport::exportLevelStyles( const uno::Reference< css::container::XIndexReplace > & xNumRule,
+ bool bOutline )
+{
+ sal_Int32 nCount = xNumRule ->getCount();
+ for( sal_Int32 i=0; i<nCount; i++ )
+ {
+ uno::Any aEntry( xNumRule->getByIndex( i ) );
+ uno::Sequence<beans::PropertyValue> aSeq;
+ if( aEntry >>= aSeq )
+ {
+ exportLevelStyle( i, aSeq, bOutline );
+ }
+ }
+}
+
+void SvxXMLNumRuleExport::exportLevelStyle( sal_Int32 nLevel,
+ const uno::Sequence<beans::PropertyValue>& rProps,
+ bool bOutline )
+{
+ sal_Int16 eType = NumberingType::CHAR_SPECIAL;
+
+ sal_Int16 eAdjust = HoriOrientation::LEFT;
+ OUString sPrefix, sSuffix, sListFormat;
+ OUString sTextStyleName;
+ bool bHasColor = false;
+ sal_Int32 nColor = 0;
+ sal_Int32 nSpaceBefore = 0, nMinLabelWidth = 0, nMinLabelDist = 0;
+
+ sal_Int16 nStartValue = 1, nDisplayLevels = 1, nBullRelSize = 0;
+
+ sal_UCS4 cBullet = 0xf095;
+ OUString sBulletFontName, sBulletFontStyleName ;
+ FontFamily eBulletFontFamily = FAMILY_DONTKNOW;
+ FontPitch eBulletFontPitch = PITCH_DONTKNOW;
+ rtl_TextEncoding eBulletFontEncoding = RTL_TEXTENCODING_DONTKNOW;
+
+ uno::Reference<graphic::XGraphic> xGraphic;
+
+ sal_Int32 nImageWidth = 0, nImageHeight = 0;
+ sal_Int16 eImageVertOrient = VertOrientation::LINE_CENTER;
+
+ sal_Int16 ePosAndSpaceMode = PositionAndSpaceMode::LABEL_WIDTH_AND_POSITION;
+ sal_Int16 eLabelFollowedBy = LabelFollow::LISTTAB;
+ sal_Int32 nListtabStopPosition( 0 );
+ sal_Int32 nFirstLineIndent( 0 );
+ sal_Int32 nIndentAt( 0 );
+
+ for( const beans::PropertyValue& rProp : rProps )
+ {
+ if( rProp.Name == "NumberingType" )
+ {
+ rProp.Value >>= eType;
+ }
+ else if( rProp.Name == "Prefix" )
+ {
+ rProp.Value >>= sPrefix;
+ }
+ else if( rProp.Name == "Suffix" )
+ {
+ rProp.Value >>= sSuffix;
+ }
+ else if (rProp.Name == "ListFormat")
+ {
+ rProp.Value >>= sListFormat;
+ }
+ else if (rProp.Name == "BulletChar")
+ {
+ OUString sValue;
+ rProp.Value >>= sValue;
+ if( !sValue.isEmpty() )
+ {
+ cBullet = sValue.iterateCodePoints(&o3tl::temporary(sal_Int32(0)));
+ }
+ }
+ else if( rProp.Name == "BulletRelSize" )
+ {
+ rProp.Value >>= nBullRelSize;
+ }
+ else if( rProp.Name == "Adjust" )
+ {
+ sal_Int16 nValue = 0;
+ rProp.Value >>= nValue;
+ eAdjust = nValue;
+ }
+ else if( rProp.Name == "BulletFont" )
+ {
+ awt::FontDescriptor rFDesc;
+ if( rProp.Value >>= rFDesc )
+ {
+ sBulletFontName = rFDesc.Name;
+ sBulletFontStyleName = rFDesc.StyleName;
+ eBulletFontFamily = static_cast< FontFamily >( rFDesc.Family );
+ eBulletFontPitch = static_cast< FontPitch >( rFDesc.Pitch );
+ eBulletFontEncoding = static_cast<rtl_TextEncoding>(rFDesc.CharSet);
+ }
+ }
+ else if( rProp.Name == "GraphicBitmap" )
+ {
+ uno::Reference<awt::XBitmap> xBitmap;
+ rProp.Value >>= xBitmap;
+ xGraphic.set(xBitmap, uno::UNO_QUERY);
+ }
+ else if( rProp.Name == "BulletColor" )
+ {
+ rProp.Value >>= nColor;
+ bHasColor = true;
+ }
+ else if( rProp.Name == "StartWith" )
+ {
+ rProp.Value >>= nStartValue;
+ }
+ else if( rProp.Name == "LeftMargin" )
+ {
+ rProp.Value >>= nSpaceBefore;
+ }
+ else if( rProp.Name == "FirstLineOffset" )
+ {
+ rProp.Value >>= nMinLabelWidth;
+ }
+ else if( rProp.Name == "SymbolTextDistance" )
+ {
+ rProp.Value >>= nMinLabelDist;
+ }
+ else if( rProp.Name == "ParentNumbering" )
+ {
+ rProp.Value >>= nDisplayLevels;
+ if( nDisplayLevels > nLevel+1 )
+ nDisplayLevels = static_cast<sal_Int16>( nLevel )+1;
+ }
+ else if( rProp.Name == "CharStyleName" )
+ {
+ rProp.Value >>= sTextStyleName;
+ }
+ else if( rProp.Name == "GraphicSize" )
+ {
+ awt::Size aSize;
+ if( rProp.Value >>= aSize )
+ {
+ nImageWidth = aSize.Width;
+ nImageHeight = aSize.Height;
+ }
+ }
+ else if( rProp.Name == "VertOrient" )
+ {
+ sal_Int16 nValue = 0;
+ rProp.Value >>= nValue;
+ eImageVertOrient = nValue;
+ }
+ else if( rProp.Name == "PositionAndSpaceMode" )
+ {
+ sal_Int16 nValue = 0;
+ rProp.Value >>= nValue;
+ ePosAndSpaceMode = nValue;
+ }
+ else if( rProp.Name == "LabelFollowedBy" )
+ {
+ sal_Int16 nValue = 0;
+ rProp.Value >>= nValue;
+ eLabelFollowedBy = nValue;
+ }
+ else if( rProp.Name == "ListtabStopPosition" )
+ {
+ rProp.Value >>= nListtabStopPosition;
+ }
+ else if( rProp.Name == "FirstLineIndent" )
+ {
+ rProp.Value >>= nFirstLineIndent;
+ }
+ else if( rProp.Name == "IndentAt" )
+ {
+ rProp.Value >>= nIndentAt;
+ }
+ }
+
+ if( bOutline && (NumberingType::CHAR_SPECIAL == eType ||
+ NumberingType::BITMAP == eType) )
+ {
+ SAL_WARN_IF( bOutline, "xmloff",
+ "SvxXMLNumRuleExport::exportLevelStyle: invalid style for outline" );
+ return;
+ }
+
+ GetExport().CheckAttrList();
+
+ // text:level
+ OUStringBuffer sTmp;
+ GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_LEVEL, OUString::number( nLevel + 1 ) );
+ // #i110694#: no style-name on list-level-style-image
+ // #i116149#: neither prefix/suffix
+ if (NumberingType::BITMAP != eType)
+ {
+ if (!sTextStyleName.isEmpty())
+ {
+ GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_STYLE_NAME,
+ GetExport().EncodeStyleName( sTextStyleName ) );
+ }
+ if (!sListFormat.isEmpty())
+ {
+ if (GetExport().getSaneDefaultVersion() & SvtSaveOptions::ODFSVER_EXTENDED)
+ {
+ // Write only in extended mode: in ODF 1.3 we write only prefix/suffix,
+ // no list format yet available. Praying we did not lost some formatting.
+ GetExport().AddAttribute(XML_NAMESPACE_LO_EXT, XML_NUM_LIST_FORMAT, sListFormat);
+ }
+ }
+ if (!sPrefix.isEmpty())
+ {
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_NUM_PREFIX,
+ sPrefix );
+ }
+ if (!sSuffix.isEmpty())
+ {
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_NUM_SUFFIX,
+ sSuffix );
+ }
+ }
+
+ enum XMLTokenEnum eElem = XML_LIST_LEVEL_STYLE_NUMBER;
+ if( NumberingType::CHAR_SPECIAL == eType )
+ {
+ // <text:list-level-style-bullet>
+ eElem = XML_LIST_LEVEL_STYLE_BULLET;
+
+ if( cBullet )
+ {
+ if( cBullet < ' ' )
+ {
+ cBullet = 0xF000 + 149;
+ }
+ // text:bullet-char="..."
+ sTmp.append(OUString(&cBullet, 1));
+ GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_BULLET_CHAR,
+ sTmp.makeStringAndClear() );
+ }
+ else
+ {
+ // If 'cBullet' is zero, XML_BULLET_CHAR must exist with blank.
+ GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_BULLET_CHAR, "");
+ }
+ }
+ else if( NumberingType::BITMAP == eType )
+ {
+ // <text:list-level-style-image>
+
+ eElem = XML_LIST_LEVEL_STYLE_IMAGE;
+
+ if (xGraphic.is())
+ {
+ OUString sUsedMimeType;
+ OUString sInternalURL = GetExport().AddEmbeddedXGraphic(xGraphic, sUsedMimeType);
+ if (!sInternalURL.isEmpty())
+ {
+ GetExport().AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, sInternalURL);
+ GetExport().AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE, XML_SIMPLE );
+ GetExport().AddAttribute( XML_NAMESPACE_XLINK, XML_SHOW, XML_EMBED );
+ GetExport().AddAttribute( XML_NAMESPACE_XLINK, XML_ACTUATE, XML_ONLOAD );
+ }
+ }
+ else
+ {
+ SAL_WARN_IF(xGraphic.is(), "xmloff", "embedded images are not supported by now");
+ }
+ }
+ else
+ {
+ // <text:list-level-style-number> or <text:outline-level-style>
+ if( bOutline )
+ eElem = XML_OUTLINE_LEVEL_STYLE;
+ else
+ eElem = XML_LIST_LEVEL_STYLE_NUMBER;
+
+ GetExport().GetMM100UnitConverter().convertNumFormat( sTmp, eType );
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_NUM_FORMAT,
+ sTmp.makeStringAndClear() );
+ SvXMLUnitConverter::convertNumLetterSync( sTmp, eType );
+ if( !sTmp.isEmpty() )
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE,
+ XML_NUM_LETTER_SYNC,
+ sTmp.makeStringAndClear() );
+
+ if( nStartValue != 1 )
+ {
+ sTmp.append( static_cast<sal_Int32>(nStartValue) );
+ GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_START_VALUE,
+ sTmp.makeStringAndClear() );
+ }
+ if( nDisplayLevels > 1 && NumberingType::NUMBER_NONE != eType )
+ {
+ sTmp.append( static_cast<sal_Int32>(nDisplayLevels) );
+ GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_DISPLAY_LEVELS,
+ sTmp.makeStringAndClear() );
+ }
+ }
+
+ {
+ SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_TEXT, eElem,
+ true, true );
+
+ if ( ePosAndSpaceMode == PositionAndSpaceMode::LABEL_WIDTH_AND_POSITION )
+ {
+ nSpaceBefore += nMinLabelWidth;
+ nMinLabelWidth = -nMinLabelWidth;
+ if( nSpaceBefore != 0 )
+ {
+ OUString sAttr = GetExport().GetMM100UnitConverter().convertMeasureToXML(
+ nSpaceBefore );
+ GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_SPACE_BEFORE, sAttr );
+ }
+ if( nMinLabelWidth != 0 )
+ {
+ OUString s = GetExport().GetMM100UnitConverter().convertMeasureToXML( nMinLabelWidth );
+ GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_MIN_LABEL_WIDTH, s);
+ }
+ if( nMinLabelDist > 0 )
+ {
+ OUString sAttr = GetExport().GetMM100UnitConverter().convertMeasureToXML(
+ nMinLabelDist );
+ GetExport().AddAttribute( XML_NAMESPACE_TEXT, XML_MIN_LABEL_DISTANCE, sAttr);
+ }
+ }
+ /* Check, if properties for position-and-space-mode LABEL_ALIGNMENT
+ are allowed to be exported. (#i89178#)
+ */
+ else if ( ePosAndSpaceMode == PositionAndSpaceMode::LABEL_ALIGNMENT &&
+ mbExportPositionAndSpaceModeLabelAlignment )
+ {
+ GetExport().AddAttribute( XML_NAMESPACE_TEXT,
+ XML_LIST_LEVEL_POSITION_AND_SPACE_MODE,
+ XML_LABEL_ALIGNMENT );
+ }
+ if( HoriOrientation::LEFT != eAdjust )
+ {
+ enum XMLTokenEnum eValue = XML_TOKEN_INVALID;
+ switch( eAdjust )
+ {
+ case HoriOrientation::RIGHT: eValue = XML_END; break;
+ case HoriOrientation::CENTER: eValue = XML_CENTER; break;
+ }
+ if( eValue != XML_TOKEN_INVALID )
+ GetExport().AddAttribute( XML_NAMESPACE_FO, XML_TEXT_ALIGN, eValue );
+ }
+
+ if( NumberingType::BITMAP == eType )
+ {
+ enum XMLTokenEnum eValue = XML_TOKEN_INVALID;
+ switch( eImageVertOrient )
+ {
+ case VertOrientation::BOTTOM: // yes, it's OK: BOTTOM means that the baseline
+ // hits the frame at its topmost position
+ case VertOrientation::LINE_TOP:
+ case VertOrientation::CHAR_TOP:
+ eValue = XML_TOP;
+ break;
+ case VertOrientation::CENTER:
+ case VertOrientation::LINE_CENTER:
+ case VertOrientation::CHAR_CENTER:
+ eValue = XML_MIDDLE;
+ break;
+ case VertOrientation::TOP: // yes, it's OK: TOP means that the baseline
+ // hits the frame at its bottommost position
+ case VertOrientation::LINE_BOTTOM:
+ case VertOrientation::CHAR_BOTTOM:
+ eValue = XML_BOTTOM;
+ break;
+ }
+ if( eValue != XML_TOKEN_INVALID )
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_VERTICAL_POS, eValue );
+
+ eValue = XML_TOKEN_INVALID;
+ switch( eImageVertOrient )
+ {
+ case VertOrientation::TOP:
+ case VertOrientation::CENTER:
+ case VertOrientation::BOTTOM:
+ eValue = XML_BASELINE;
+ break;
+ case VertOrientation::LINE_TOP:
+ case VertOrientation::LINE_CENTER:
+ case VertOrientation::LINE_BOTTOM:
+ eValue = XML_LINE;
+ break;
+ case VertOrientation::CHAR_TOP:
+ case VertOrientation::CHAR_CENTER:
+ case VertOrientation::CHAR_BOTTOM:
+ eValue = XML_CHAR;
+ break;
+ }
+ if( eValue != XML_TOKEN_INVALID )
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_VERTICAL_REL, eValue );
+
+ if( nImageWidth > 0 )
+ {
+ OUString sAttr = GetExport().GetMM100UnitConverter().convertMeasureToXML(
+ nImageWidth );
+ GetExport().AddAttribute( XML_NAMESPACE_FO, XML_WIDTH, sAttr );
+ }
+
+ if( nImageHeight > 0 )
+ {
+ OUString sAttr = GetExport().GetMM100UnitConverter().convertMeasureToXML(
+ nImageHeight );
+ GetExport().AddAttribute( XML_NAMESPACE_FO, XML_HEIGHT, sAttr );
+ }
+ }
+
+ {
+ SvXMLElementExport aElement( GetExport(), XML_NAMESPACE_STYLE,
+ XML_LIST_LEVEL_PROPERTIES, true, true );
+
+ /* Check, if properties for position-and-space-mode LABEL_ALIGNMENT
+ are allowed to be exported. (#i89178#)
+ */
+ if ( ePosAndSpaceMode == PositionAndSpaceMode::LABEL_ALIGNMENT &&
+ mbExportPositionAndSpaceModeLabelAlignment )
+ {
+ enum XMLTokenEnum eValue = XML_LISTTAB;
+ if ( eLabelFollowedBy == LabelFollow::SPACE )
+ {
+ eValue = XML_SPACE;
+ }
+ else if ( eLabelFollowedBy == LabelFollow::NOTHING )
+ {
+ eValue = XML_NOTHING;
+ }
+ GetExport().AddAttribute( XML_NAMESPACE_TEXT,
+ XML_LABEL_FOLLOWED_BY, eValue );
+
+ if (eLabelFollowedBy == LabelFollow::NEWLINE)
+ {
+ eValue = XML_NEWLINE;
+ GetExport().AddAttribute( XML_NAMESPACE_LO_EXT,
+ XML_LABEL_FOLLOWED_BY, eValue );
+ }
+
+ if ( eLabelFollowedBy == LabelFollow::LISTTAB &&
+ nListtabStopPosition > 0 )
+ {
+ OUString sAttr = GetExport().GetMM100UnitConverter().convertMeasureToXML(
+ nListtabStopPosition );
+ GetExport().AddAttribute( XML_NAMESPACE_TEXT,
+ XML_LIST_TAB_STOP_POSITION,
+ sAttr );
+ }
+
+ if ( nFirstLineIndent != 0 )
+ {
+ OUString sAttr = GetExport().GetMM100UnitConverter().convertMeasureToXML(
+ nFirstLineIndent );
+ GetExport().AddAttribute( XML_NAMESPACE_FO,
+ XML_TEXT_INDENT,
+ sAttr );
+ }
+
+ if ( nIndentAt != 0 )
+ {
+ OUString sAttr = GetExport().GetMM100UnitConverter().convertMeasureToXML(
+ nIndentAt );
+ GetExport().AddAttribute( XML_NAMESPACE_FO,
+ XML_MARGIN_LEFT,
+ sAttr );
+ }
+
+ SvXMLElementExport aLabelAlignmentElement( GetExport(), XML_NAMESPACE_STYLE,
+ XML_LIST_LEVEL_LABEL_ALIGNMENT,
+ true, true );
+ }
+ }
+
+ if( NumberingType::CHAR_SPECIAL == eType )
+ {
+ if( !sBulletFontName.isEmpty() )
+ {
+ OUString sStyleName =
+ GetExport().GetFontAutoStylePool()->Find(
+ sBulletFontName, sBulletFontStyleName,
+ eBulletFontFamily, eBulletFontPitch,
+ eBulletFontEncoding );
+
+ if( !sStyleName.isEmpty() )
+ {
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE,
+ XML_FONT_NAME,
+ sStyleName );
+ }
+ else
+ {
+ OUString sTemp;
+
+ const SvXMLUnitConverter& rUnitConv =
+ GetExport().GetMM100UnitConverter();
+ XMLFontFamilyNamePropHdl aFamilyNameHdl;
+ if( aFamilyNameHdl.exportXML( sTemp, Any(sBulletFontName), rUnitConv ) )
+ GetExport().AddAttribute( XML_NAMESPACE_FO,
+ XML_FONT_FAMILY, sTemp );
+
+ if( !sBulletFontStyleName.isEmpty() )
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE,
+ XML_FONT_STYLE_NAME,
+ sBulletFontStyleName );
+
+ XMLFontFamilyPropHdl aFamilyHdl;
+ if( aFamilyHdl.exportXML( sTemp, Any(static_cast<sal_Int16>(eBulletFontFamily)), rUnitConv ) )
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE,
+ XML_FONT_FAMILY_GENERIC,
+ sTemp );
+
+ XMLFontPitchPropHdl aPitchHdl;
+ if( aPitchHdl.exportXML( sTemp, Any(static_cast<sal_Int16>(eBulletFontPitch)), rUnitConv ) )
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE,
+ XML_FONT_PITCH, sTemp );
+
+ XMLFontEncodingPropHdl aEncHdl;
+ if( aEncHdl.exportXML( sTemp, Any(static_cast<sal_Int16>(eBulletFontEncoding)), rUnitConv ) )
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE,
+ XML_FONT_CHARSET, sTemp );
+ }
+ }
+ }
+ if( NumberingType::BITMAP != eType )
+ {
+ // fo:color = "#..."
+ if( bHasColor )
+ {
+ if (0xffffffff == static_cast<sal_uInt32>(nColor))
+ {
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_USE_WINDOW_FONT_COLOR, XML_TRUE );
+ }
+ else
+ {
+ OUStringBuffer sBuffer;
+ ::sax::Converter::convertColor( sBuffer, nColor );
+ GetExport().AddAttribute( XML_NAMESPACE_FO, XML_COLOR,
+ sBuffer.makeStringAndClear() );
+ }
+ }
+ // fo:height="...%"
+ if( nBullRelSize )
+ {
+ ::sax::Converter::convertPercent( sTmp, nBullRelSize );
+ GetExport().AddAttribute( XML_NAMESPACE_FO, XML_FONT_SIZE,
+ sTmp.makeStringAndClear() );
+ }
+ }
+ if( GetExport().GetAttrList().getLength() > 0 )
+ {
+ SvXMLElementExport aElement( GetExport(), XML_NAMESPACE_STYLE,
+ XML_TEXT_PROPERTIES, true, true );
+ }
+ if (xGraphic.is() && NumberingType::BITMAP == eType)
+ {
+ // optional office:binary-data
+ GetExport().AddEmbeddedXGraphicAsBase64(xGraphic);
+ }
+ }
+}
+
+
+constexpr OUStringLiteral gsNumberingRules( u"NumberingRules" );
+constexpr OUStringLiteral gsIsPhysical( u"IsPhysical" );
+constexpr OUStringLiteral gsIsContinuousNumbering( u"IsContinuousNumbering" );
+
+SvxXMLNumRuleExport::SvxXMLNumRuleExport( SvXMLExport& rExp ) :
+ rExport( rExp ),
+ // Let list style creation depend on Load/Save option "ODF format version" (#i89178#)
+ mbExportPositionAndSpaceModeLabelAlignment( true )
+{
+ switch (GetExport().getSaneDefaultVersion())
+ {
+ case SvtSaveOptions::ODFSVER_010:
+ case SvtSaveOptions::ODFSVER_011:
+ {
+ mbExportPositionAndSpaceModeLabelAlignment = false;
+ }
+ break;
+ default: // >= ODFSVER_012
+ {
+ mbExportPositionAndSpaceModeLabelAlignment = true;
+ }
+ }
+}
+
+void SvxXMLNumRuleExport::exportNumberingRule(
+ const OUString& rName, bool bIsHidden,
+ const Reference< XIndexReplace >& rNumRule )
+{
+ Reference< XPropertySet > xPropSet( rNumRule, UNO_QUERY );
+ Reference< XPropertySetInfo > xPropSetInfo;
+ if( xPropSet.is() )
+ xPropSetInfo = xPropSet->getPropertySetInfo();
+
+ GetExport().CheckAttrList();
+
+ // style:name="..."
+ if( !rName.isEmpty() )
+ {
+ bool bEncoded = false;
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_NAME,
+ GetExport().EncodeStyleName( rName, &bEncoded ) );
+ if( bEncoded )
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_DISPLAY_NAME,
+ rName);
+ }
+
+ // style:hidden="..."
+ if (bIsHidden
+ && GetExport().getSaneDefaultVersion() & SvtSaveOptions::ODFSVER_EXTENDED)
+ {
+ GetExport().AddAttribute(XML_NAMESPACE_LO_EXT, XML_HIDDEN, "true");
+ GetExport().AddAttribute(XML_NAMESPACE_STYLE, XML_HIDDEN, "true"); // FIXME for compatibility
+ }
+
+ // text:consecutive-numbering="..."
+ bool bContNumbering = false;
+ if( xPropSetInfo.is() &&
+ xPropSetInfo->hasPropertyByName( gsIsContinuousNumbering ) )
+ {
+ Any aAny( xPropSet->getPropertyValue( gsIsContinuousNumbering ) );
+ bContNumbering = *o3tl::doAccess<bool>(aAny);
+ }
+ if( bContNumbering )
+ GetExport().AddAttribute( XML_NAMESPACE_TEXT,
+ XML_CONSECUTIVE_NUMBERING, XML_TRUE );
+
+ {
+ SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_TEXT, XML_LIST_STYLE ,
+ true, true );
+ exportLevelStyles( rNumRule );
+ }
+}
+
+void SvxXMLNumRuleExport::exportStyle( const Reference< XStyle >& rStyle )
+{
+ Reference< XPropertySet > xPropSet( rStyle, UNO_QUERY );
+ Reference< XPropertySetInfo > xPropSetInfo = xPropSet->getPropertySetInfo();
+
+ Any aAny;
+
+ // Don't export styles that aren't existing really. This may be the
+ // case for StarOffice Writer's pool styles.
+ if( xPropSetInfo->hasPropertyByName( gsIsPhysical ) )
+ {
+ aAny = xPropSet->getPropertyValue( gsIsPhysical );
+ if( !*o3tl::doAccess<bool>(aAny) )
+ return;
+ }
+
+ aAny = xPropSet->getPropertyValue( gsNumberingRules );
+ Reference<XIndexReplace> xNumRule;
+ aAny >>= xNumRule;
+
+ OUString sName = rStyle->getName();
+
+ bool bHidden = false;
+ if ( xPropSetInfo->hasPropertyByName( "Hidden" ) )
+ {
+ aAny = xPropSet->getPropertyValue( "Hidden" );
+ aAny >>= bHidden;
+ }
+
+ exportNumberingRule( sName, bHidden, xNumRule );
+}
+
+void SvxXMLNumRuleExport::exportOutline()
+{
+ Reference< XChapterNumberingSupplier > xCNSupplier( GetExport().GetModel(),
+ UNO_QUERY );
+ SAL_WARN_IF( !xCNSupplier.is(), "xmloff", "no chapter numbering supplier" );
+
+ if( !xCNSupplier.is() )
+ return;
+
+ Reference< XIndexReplace > xNumRule( xCNSupplier->getChapterNumberingRules() );
+ SAL_WARN_IF( !xNumRule.is(), "xmloff", "no chapter numbering rules" );
+
+ if( !xNumRule.is() )
+ return;
+
+ /* Outline style has property style:name since ODF 1.2
+ Thus, export this property and adjust fix for issue #i69627# (#i90780#)
+ */
+ OUString sOutlineStyleName;
+ {
+ Reference<XPropertySet> xNumRulePropSet(
+ xCNSupplier->getChapterNumberingRules(), UNO_QUERY );
+ if (xNumRulePropSet.is())
+ {
+ xNumRulePropSet->getPropertyValue( "Name" ) >>= sOutlineStyleName;
+ }
+ }
+ const SvtSaveOptions::ODFSaneDefaultVersion nODFVersion =
+ GetExport().getSaneDefaultVersion();
+ if ((nODFVersion == SvtSaveOptions::ODFSVER_010 ||
+ nODFVersion == SvtSaveOptions::ODFSVER_011)
+ && GetExport().writeOutlineStyleAsNormalListStyle())
+ {
+ exportNumberingRule( sOutlineStyleName, false, xNumRule );
+ }
+ else
+ {
+ if (nODFVersion != SvtSaveOptions::ODFSVER_010 &&
+ nODFVersion != SvtSaveOptions::ODFSVER_011)
+ {
+ // style:name="..."
+ GetExport().CheckAttrList();
+ if ( !sOutlineStyleName.isEmpty() )
+ {
+ bool bEncoded = false;
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_NAME,
+ GetExport().EncodeStyleName( sOutlineStyleName,
+ &bEncoded ) );
+ if( bEncoded )
+ GetExport().AddAttribute( XML_NAMESPACE_STYLE,
+ XML_DISPLAY_NAME,
+ sOutlineStyleName );
+ }
+ }
+ SvXMLElementExport aElem( GetExport(), XML_NAMESPACE_TEXT,
+ XML_OUTLINE_STYLE, true, true );
+ exportLevelStyles( xNumRule, true );
+ }
+}
+
+void SvxXMLNumRuleExport::exportStyles( bool bUsed,
+ XMLTextListAutoStylePool *pPool,
+ bool bExportChapterNumbering )
+{
+ if( bExportChapterNumbering )
+ exportOutline();
+
+ Reference< XStyleFamiliesSupplier > xFamiliesSupp( GetExport().GetModel(), UNO_QUERY );
+ SAL_WARN_IF( !xFamiliesSupp.is(), "xmloff", "No XStyleFamiliesSupplier from XModel for export!" );
+ if( !xFamiliesSupp.is() )
+ return;
+
+ Reference< XNameAccess > xFamilies( xFamiliesSupp->getStyleFamilies() );
+ SAL_WARN_IF( !xFamiliesSupp.is(), "xmloff", "getStyleFamilies() from XModel failed for export!" );
+
+ if( !xFamilies.is() )
+ return;
+
+ static const OUStringLiteral aNumberStyleName( u"NumberingStyles" );
+
+ Reference< XIndexAccess > xStyles;
+ if( !xFamilies->hasByName( aNumberStyleName ) )
+ return;
+
+ xFamilies->getByName( aNumberStyleName ) >>= xStyles;
+
+ SAL_WARN_IF( !xStyles.is(), "xmloff", "Style not found for export!" );
+
+ if( !xStyles.is() )
+ return;
+
+ const sal_Int32 nStyles = xStyles->getCount();
+
+ for( sal_Int32 i=0; i < nStyles; i++ )
+ {
+ Reference< XStyle > xStyle;
+ xStyles->getByIndex( i ) >>= xStyle;
+
+ if( !bUsed || xStyle->isInUse() )
+ {
+ exportStyle( xStyle );
+ if( pPool )
+ pPool->RegisterName( xStyle->getName() );
+ }
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/xmlnumfe.cxx b/xmloff/source/style/xmlnumfe.cxx
new file mode 100644
index 000000000..6deeca688
--- /dev/null
+++ b/xmloff/source/style/xmlnumfe.cxx
@@ -0,0 +1,2026 @@
+/* -*- 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 <comphelper/sequence.hxx>
+#include <comphelper/string.hxx>
+#include <svl/numformat.hxx>
+#include <svl/zforlist.hxx>
+#include <svl/zformat.hxx>
+#include <svl/numuno.hxx>
+#include <i18nlangtag/mslangid.hxx>
+#include <i18nlangtag/languagetag.hxx>
+#include <tools/debug.hxx>
+#include <rtl/math.hxx>
+#include <unotools/calendarwrapper.hxx>
+#include <unotools/charclass.hxx>
+#include <com/sun/star/lang/Locale.hpp>
+#include <rtl/ustrbuf.hxx>
+#include <sal/log.hxx>
+#include <osl/diagnose.h>
+#include <tools/color.hxx>
+#include <sax/tools/converter.hxx>
+
+#include <com/sun/star/i18n/NativeNumberXmlAttributes2.hpp>
+
+#include <xmloff/xmlnumfe.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmlnumfi.hxx>
+
+#include <svl/nfsymbol.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <o3tl/string_view.hxx>
+
+#include <float.h>
+#include <set>
+#include <string_view>
+#include <vector>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+using namespace ::svt;
+
+typedef std::set< sal_uInt32 > SvXMLuInt32Set;
+
+namespace {
+
+struct SvXMLEmbeddedTextEntry
+{
+ sal_uInt16 nSourcePos; // position in NumberFormat (to skip later)
+ sal_Int32 nFormatPos; // resulting position in embedded-text element
+ OUString aText;
+
+ SvXMLEmbeddedTextEntry( sal_uInt16 nSP, sal_Int32 nFP, const OUString& rT ) :
+ nSourcePos(nSP), nFormatPos(nFP), aText(rT) {}
+};
+
+}
+
+class SvXMLEmbeddedTextEntryArr
+{
+ typedef std::vector<SvXMLEmbeddedTextEntry> DataType;
+ DataType maData;
+
+public:
+
+ void push_back( SvXMLEmbeddedTextEntry const& r )
+ {
+ maData.push_back(r);
+ }
+
+ const SvXMLEmbeddedTextEntry& operator[] ( size_t i ) const
+ {
+ return maData[i];
+ }
+
+ size_t size() const
+ {
+ return maData.size();
+ }
+};
+
+class SvXMLNumUsedList_Impl
+{
+ SvXMLuInt32Set aUsed;
+ SvXMLuInt32Set aWasUsed;
+ SvXMLuInt32Set::iterator aCurrentUsedPos;
+ sal_uInt32 nUsedCount;
+ sal_uInt32 nWasUsedCount;
+
+public:
+ SvXMLNumUsedList_Impl();
+
+ void SetUsed( sal_uInt32 nKey );
+ bool IsUsed( sal_uInt32 nKey ) const;
+ bool IsWasUsed( sal_uInt32 nKey ) const;
+ void Export();
+
+ bool GetFirstUsed(sal_uInt32& nKey);
+ bool GetNextUsed(sal_uInt32& nKey);
+
+ uno::Sequence<sal_Int32> GetWasUsed() const;
+ void SetWasUsed(const uno::Sequence<sal_Int32>& rWasUsed);
+};
+
+//! SvXMLNumUsedList_Impl should be optimized!
+
+SvXMLNumUsedList_Impl::SvXMLNumUsedList_Impl() :
+ nUsedCount(0),
+ nWasUsedCount(0)
+{
+}
+
+void SvXMLNumUsedList_Impl::SetUsed( sal_uInt32 nKey )
+{
+ if ( !IsWasUsed(nKey) )
+ {
+ std::pair<SvXMLuInt32Set::iterator, bool> aPair = aUsed.insert( nKey );
+ if (aPair.second)
+ nUsedCount++;
+ }
+}
+
+bool SvXMLNumUsedList_Impl::IsUsed( sal_uInt32 nKey ) const
+{
+ SvXMLuInt32Set::const_iterator aItr = aUsed.find(nKey);
+ return (aItr != aUsed.end());
+}
+
+bool SvXMLNumUsedList_Impl::IsWasUsed( sal_uInt32 nKey ) const
+{
+ SvXMLuInt32Set::const_iterator aItr = aWasUsed.find(nKey);
+ return (aItr != aWasUsed.end());
+}
+
+void SvXMLNumUsedList_Impl::Export()
+{
+ SvXMLuInt32Set::const_iterator aItr = aUsed.begin();
+ while (aItr != aUsed.end())
+ {
+ std::pair<SvXMLuInt32Set::const_iterator, bool> aPair = aWasUsed.insert( *aItr );
+ if (aPair.second)
+ nWasUsedCount++;
+ ++aItr;
+ }
+ aUsed.clear();
+ nUsedCount = 0;
+}
+
+bool SvXMLNumUsedList_Impl::GetFirstUsed(sal_uInt32& nKey)
+{
+ bool bRet(false);
+ aCurrentUsedPos = aUsed.begin();
+ if(nUsedCount)
+ {
+ DBG_ASSERT(aCurrentUsedPos != aUsed.end(), "something went wrong");
+ nKey = *aCurrentUsedPos;
+ bRet = true;
+ }
+ return bRet;
+}
+
+bool SvXMLNumUsedList_Impl::GetNextUsed(sal_uInt32& nKey)
+{
+ bool bRet(false);
+ if (aCurrentUsedPos != aUsed.end())
+ {
+ ++aCurrentUsedPos;
+ if (aCurrentUsedPos != aUsed.end())
+ {
+ nKey = *aCurrentUsedPos;
+ bRet = true;
+ }
+ }
+ return bRet;
+}
+
+uno::Sequence<sal_Int32> SvXMLNumUsedList_Impl::GetWasUsed() const
+{
+ return comphelper::containerToSequence<sal_Int32>(aWasUsed);
+}
+
+void SvXMLNumUsedList_Impl::SetWasUsed(const uno::Sequence<sal_Int32>& rWasUsed)
+{
+ DBG_ASSERT(nWasUsedCount == 0, "WasUsed should be empty");
+ for (const auto nWasUsed : rWasUsed)
+ {
+ std::pair<SvXMLuInt32Set::const_iterator, bool> aPair = aWasUsed.insert( nWasUsed );
+ if (aPair.second)
+ nWasUsedCount++;
+ }
+}
+
+SvXMLNumFmtExport::SvXMLNumFmtExport(
+ SvXMLExport& rExp,
+ const uno::Reference< util::XNumberFormatsSupplier >& rSupp ) :
+ rExport( rExp ),
+ sPrefix( OUString("N") ),
+ pFormatter( nullptr ),
+ bHasText( false )
+{
+ // supplier must be SvNumberFormatsSupplierObj
+ SvNumberFormatsSupplierObj* pObj =
+ comphelper::getFromUnoTunnel<SvNumberFormatsSupplierObj>( rSupp );
+ if (pObj)
+ pFormatter = pObj->GetNumberFormatter();
+
+ if ( pFormatter )
+ {
+ pLocaleData.reset( new LocaleDataWrapper( pFormatter->GetComponentContext(),
+ pFormatter->GetLanguageTag() ) );
+ }
+ else
+ {
+ LanguageTag aLanguageTag( MsLangId::getConfiguredSystemLanguage() );
+
+ pLocaleData.reset( new LocaleDataWrapper( rExport.getComponentContext(), std::move(aLanguageTag) ) );
+ }
+
+ pUsedList.reset(new SvXMLNumUsedList_Impl);
+}
+
+SvXMLNumFmtExport::SvXMLNumFmtExport(
+ SvXMLExport& rExp,
+ const css::uno::Reference< css::util::XNumberFormatsSupplier >& rSupp,
+ const OUString& rPrefix ) :
+ rExport( rExp ),
+ sPrefix( rPrefix ),
+ pFormatter( nullptr ),
+ bHasText( false )
+{
+ // supplier must be SvNumberFormatsSupplierObj
+ SvNumberFormatsSupplierObj* pObj =
+ comphelper::getFromUnoTunnel<SvNumberFormatsSupplierObj>( rSupp );
+ if (pObj)
+ pFormatter = pObj->GetNumberFormatter();
+
+ if ( pFormatter )
+ {
+ pLocaleData.reset( new LocaleDataWrapper( pFormatter->GetComponentContext(),
+ pFormatter->GetLanguageTag() ) );
+ }
+ else
+ {
+ LanguageTag aLanguageTag( MsLangId::getConfiguredSystemLanguage() );
+
+ pLocaleData.reset( new LocaleDataWrapper( rExport.getComponentContext(), std::move(aLanguageTag) ) );
+ }
+
+ pUsedList.reset(new SvXMLNumUsedList_Impl);
+}
+
+SvXMLNumFmtExport::~SvXMLNumFmtExport()
+{
+}
+
+// helper methods
+
+static OUString lcl_CreateStyleName( sal_Int32 nKey, sal_Int32 nPart, bool bDefPart, std::u16string_view rPrefix )
+{
+ OUStringBuffer aFmtName(10);
+ aFmtName.append( rPrefix );
+ aFmtName.append( nKey );
+ if (!bDefPart)
+ {
+ aFmtName.append( 'P' );
+ aFmtName.append( nPart );
+ }
+ return aFmtName.makeStringAndClear();
+}
+
+void SvXMLNumFmtExport::AddCalendarAttr_Impl( const OUString& rCalendar )
+{
+ if ( !rCalendar.isEmpty() )
+ {
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_CALENDAR, rCalendar );
+ }
+}
+
+void SvXMLNumFmtExport::AddStyleAttr_Impl( bool bLong )
+{
+ if ( bLong ) // short is default
+ {
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_STYLE, XML_LONG );
+ }
+}
+
+void SvXMLNumFmtExport::AddLanguageAttr_Impl( LanguageType nLang )
+{
+ if ( nLang != LANGUAGE_SYSTEM )
+ {
+ rExport.AddLanguageTagAttributes( XML_NAMESPACE_NUMBER, XML_NAMESPACE_NUMBER,
+ LanguageTag( nLang), false);
+ }
+}
+
+// methods to write individual elements within a format
+
+void SvXMLNumFmtExport::AddToTextElement_Impl( std::u16string_view rString )
+{
+ // append to sTextContent, write element in FinishTextElement_Impl
+ // to avoid several text elements following each other
+
+ sTextContent.append( rString );
+ // Also empty string leads to a number:text element as it may separate
+ // keywords of the same letter (e.g. MM""MMM) that otherwise would be
+ // concatenated when reading back in.
+ bHasText = true;
+}
+
+void SvXMLNumFmtExport::FinishTextElement_Impl(bool bUseExtensionNS)
+{
+ if ( bHasText )
+ {
+ sal_uInt16 nNS = bUseExtensionNS ? XML_NAMESPACE_LO_EXT : XML_NAMESPACE_NUMBER;
+ SvXMLElementExport aElem( rExport, nNS, XML_TEXT,
+ true, false );
+ rExport.Characters( sTextContent.makeStringAndClear() );
+ bHasText = false;
+ }
+}
+
+void SvXMLNumFmtExport::WriteColorElement_Impl( const Color& rColor )
+{
+ FinishTextElement_Impl();
+
+ OUStringBuffer aColStr( 7 );
+ ::sax::Converter::convertColor( aColStr, rColor );
+ rExport.AddAttribute( XML_NAMESPACE_FO, XML_COLOR,
+ aColStr.makeStringAndClear() );
+
+ SvXMLElementExport aElem( rExport, XML_NAMESPACE_STYLE, XML_TEXT_PROPERTIES,
+ true, false );
+}
+
+void SvXMLNumFmtExport::WriteCurrencyElement_Impl( const OUString& rString,
+ std::u16string_view rExt )
+{
+ FinishTextElement_Impl();
+
+ if ( !rExt.empty() )
+ {
+ // rExt should be a 16-bit hex value max FFFF which may contain a
+ // leading "-" separator (that is not a minus sign, but toInt32 can be
+ // used to parse it, with post-processing as necessary):
+ sal_Int32 nLang = o3tl::toInt32(rExt, 16);
+ if ( nLang < 0 )
+ nLang = -nLang;
+ AddLanguageAttr_Impl( LanguageType(nLang) ); // adds to pAttrList
+ }
+
+ SvXMLElementExport aElem( rExport,
+ XML_NAMESPACE_NUMBER, XML_CURRENCY_SYMBOL,
+ true, false );
+ rExport.Characters( rString );
+}
+
+void SvXMLNumFmtExport::WriteBooleanElement_Impl()
+{
+ FinishTextElement_Impl();
+
+ SvXMLElementExport aElem( rExport, XML_NAMESPACE_NUMBER, XML_BOOLEAN,
+ true, false );
+}
+
+void SvXMLNumFmtExport::WriteTextContentElement_Impl()
+{
+ FinishTextElement_Impl();
+
+ SvXMLElementExport aElem( rExport, XML_NAMESPACE_NUMBER, XML_TEXT_CONTENT,
+ true, false );
+}
+
+// date elements
+
+void SvXMLNumFmtExport::WriteDayElement_Impl( const OUString& rCalendar, bool bLong )
+{
+ FinishTextElement_Impl();
+
+ AddCalendarAttr_Impl( rCalendar ); // adds to pAttrList
+ AddStyleAttr_Impl( bLong ); // adds to pAttrList
+
+ SvXMLElementExport aElem( rExport, XML_NAMESPACE_NUMBER, XML_DAY,
+ true, false );
+}
+
+void SvXMLNumFmtExport::WriteMonthElement_Impl( const OUString& rCalendar, bool bLong, bool bText )
+{
+ FinishTextElement_Impl();
+
+ AddCalendarAttr_Impl( rCalendar ); // adds to pAttrList
+ AddStyleAttr_Impl( bLong ); // adds to pAttrList
+ if ( bText )
+ {
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_TEXTUAL, XML_TRUE );
+ }
+
+ SvXMLElementExport aElem( rExport, XML_NAMESPACE_NUMBER, XML_MONTH,
+ true, false );
+}
+
+void SvXMLNumFmtExport::WriteYearElement_Impl( const OUString& rCalendar, bool bLong )
+{
+ FinishTextElement_Impl();
+
+ AddCalendarAttr_Impl( rCalendar ); // adds to pAttrList
+ AddStyleAttr_Impl( bLong ); // adds to pAttrList
+
+ SvXMLElementExport aElem( rExport, XML_NAMESPACE_NUMBER, XML_YEAR,
+ true, false );
+}
+
+void SvXMLNumFmtExport::WriteEraElement_Impl( const OUString& rCalendar, bool bLong )
+{
+ FinishTextElement_Impl();
+
+ AddCalendarAttr_Impl( rCalendar ); // adds to pAttrList
+ AddStyleAttr_Impl( bLong ); // adds to pAttrList
+
+ SvXMLElementExport aElem( rExport, XML_NAMESPACE_NUMBER, XML_ERA,
+ true, false );
+}
+
+void SvXMLNumFmtExport::WriteDayOfWeekElement_Impl( const OUString& rCalendar, bool bLong )
+{
+ FinishTextElement_Impl();
+
+ AddCalendarAttr_Impl( rCalendar ); // adds to pAttrList
+ AddStyleAttr_Impl( bLong ); // adds to pAttrList
+
+ SvXMLElementExport aElem( rExport, XML_NAMESPACE_NUMBER, XML_DAY_OF_WEEK,
+ true, false );
+}
+
+void SvXMLNumFmtExport::WriteWeekElement_Impl( const OUString& rCalendar )
+{
+ FinishTextElement_Impl();
+
+ AddCalendarAttr_Impl( rCalendar ); // adds to pAttrList
+
+ SvXMLElementExport aElem( rExport, XML_NAMESPACE_NUMBER, XML_WEEK_OF_YEAR,
+ true, false );
+}
+
+void SvXMLNumFmtExport::WriteQuarterElement_Impl( const OUString& rCalendar, bool bLong )
+{
+ FinishTextElement_Impl();
+
+ AddCalendarAttr_Impl( rCalendar ); // adds to pAttrList
+ AddStyleAttr_Impl( bLong ); // adds to pAttrList
+
+ SvXMLElementExport aElem( rExport, XML_NAMESPACE_NUMBER, XML_QUARTER,
+ true, false );
+}
+
+// time elements
+
+void SvXMLNumFmtExport::WriteHoursElement_Impl( bool bLong )
+{
+ FinishTextElement_Impl();
+
+ AddStyleAttr_Impl( bLong ); // adds to pAttrList
+
+ SvXMLElementExport aElem( rExport, XML_NAMESPACE_NUMBER, XML_HOURS,
+ true, false );
+}
+
+void SvXMLNumFmtExport::WriteMinutesElement_Impl( bool bLong )
+{
+ FinishTextElement_Impl();
+
+ AddStyleAttr_Impl( bLong ); // adds to pAttrList
+
+ SvXMLElementExport aElem( rExport, XML_NAMESPACE_NUMBER, XML_MINUTES,
+ true, false );
+}
+
+void SvXMLNumFmtExport::WriteRepeatedElement_Impl( sal_Unicode nChar )
+{
+ // Export only for 1.2 with extensions or 1.3 and later.
+ SvtSaveOptions::ODFSaneDefaultVersion eVersion = rExport.getSaneDefaultVersion();
+ if (eVersion > SvtSaveOptions::ODFSVER_012)
+ {
+ FinishTextElement_Impl(eVersion < SvtSaveOptions::ODFSVER_013);
+ // OFFICE-3765 For 1.2+ use loext namespace, for 1.3 use number namespace.
+ SvXMLElementExport aElem( rExport,
+ ((eVersion < SvtSaveOptions::ODFSVER_013) ? XML_NAMESPACE_LO_EXT : XML_NAMESPACE_NUMBER),
+ XML_FILL_CHARACTER, true, false );
+ rExport.Characters( OUString( nChar ) );
+ }
+}
+
+void SvXMLNumFmtExport::WriteSecondsElement_Impl( bool bLong, sal_uInt16 nDecimals )
+{
+ FinishTextElement_Impl();
+
+ AddStyleAttr_Impl( bLong ); // adds to pAttrList
+ if ( nDecimals > 0 )
+ {
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_DECIMAL_PLACES,
+ OUString::number( nDecimals ) );
+ }
+
+ SvXMLElementExport aElem( rExport, XML_NAMESPACE_NUMBER, XML_SECONDS,
+ true, false );
+}
+
+void SvXMLNumFmtExport::WriteAMPMElement_Impl()
+{
+ FinishTextElement_Impl();
+
+ SvXMLElementExport aElem( rExport, XML_NAMESPACE_NUMBER, XML_AM_PM,
+ true, false );
+}
+
+// numbers
+
+void SvXMLNumFmtExport::WriteNumberElement_Impl(
+ sal_Int32 nDecimals, sal_Int32 nMinDecimals,
+ sal_Int32 nInteger, const OUString& rDashStr,
+ bool bGrouping, sal_Int32 nTrailingThousands,
+ const SvXMLEmbeddedTextEntryArr& rEmbeddedEntries )
+{
+ FinishTextElement_Impl();
+
+ // decimals
+ if ( nDecimals >= 0 ) // negative = automatic
+ {
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_DECIMAL_PLACES,
+ OUString::number( nDecimals ) );
+ }
+
+ if ( nMinDecimals >= 0 ) // negative = automatic
+ {
+ // Export only for 1.2 with extensions or 1.3 and later.
+ SvtSaveOptions::ODFSaneDefaultVersion eVersion = rExport.getSaneDefaultVersion();
+ if (eVersion > SvtSaveOptions::ODFSVER_012)
+ {
+ // OFFICE-3860 For 1.2+ use loext namespace, for 1.3 use number namespace.
+ rExport.AddAttribute(
+ ((eVersion < SvtSaveOptions::ODFSVER_013) ? XML_NAMESPACE_LO_EXT : XML_NAMESPACE_NUMBER),
+ XML_MIN_DECIMAL_PLACES,
+ OUString::number( nMinDecimals ) );
+ }
+ }
+
+ // integer digits
+ if ( nInteger >= 0 ) // negative = automatic
+ {
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_MIN_INTEGER_DIGITS,
+ OUString::number( nInteger ) );
+ }
+
+ // decimal replacement (dashes) or variable decimals (#)
+ if ( !rDashStr.isEmpty() || nMinDecimals < nDecimals )
+ {
+ // full variable decimals means an empty replacement string
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_DECIMAL_REPLACEMENT,
+ rDashStr );
+ }
+
+ // (automatic) grouping separator
+ if ( bGrouping )
+ {
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_GROUPING, XML_TRUE );
+ }
+
+ // display-factor if there are trailing thousands separators
+ if ( nTrailingThousands )
+ {
+ // each separator character removes three digits
+ double fFactor = ::rtl::math::pow10Exp( 1.0, 3 * nTrailingThousands );
+
+ OUStringBuffer aFactStr;
+ ::sax::Converter::convertDouble( aFactStr, fFactor );
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_DISPLAY_FACTOR, aFactStr.makeStringAndClear() );
+ }
+
+ SvXMLElementExport aElem( rExport, XML_NAMESPACE_NUMBER, XML_NUMBER,
+ true, true );
+
+ // number:embedded-text as child elements
+
+ auto nEntryCount = rEmbeddedEntries.size();
+ for (decltype(nEntryCount) nEntry=0; nEntry < nEntryCount; ++nEntry)
+ {
+ const SvXMLEmbeddedTextEntry *const pObj = &rEmbeddedEntries[nEntry];
+
+ // position attribute
+ // position == 0 is between first integer digit and decimal separator
+ // position < 0 is inside decimal part
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_POSITION,
+ OUString::number( pObj->nFormatPos ) );
+ SvXMLElementExport aChildElem( rExport, XML_NAMESPACE_NUMBER, XML_EMBEDDED_TEXT,
+ true, false );
+
+ // text as element content
+ OUStringBuffer aContent( pObj->aText );
+ while ( nEntry+1 < nEntryCount && rEmbeddedEntries[nEntry+1].nFormatPos == pObj->nFormatPos )
+ {
+ // The array can contain several elements for the same position in the number
+ // (for example, literal text and space from underscores). They must be merged
+ // into a single embedded-text element.
+ aContent.append(rEmbeddedEntries[nEntry+1].aText);
+ ++nEntry;
+ }
+ rExport.Characters( aContent.makeStringAndClear() );
+ }
+}
+
+void SvXMLNumFmtExport::WriteScientificElement_Impl(
+ sal_Int32 nDecimals, sal_Int32 nMinDecimals, sal_Int32 nInteger,
+ bool bGrouping, sal_Int32 nExp, sal_Int32 nExpInterval, bool bExpSign )
+{
+ FinishTextElement_Impl();
+
+ // decimals
+ if ( nDecimals >= 0 ) // negative = automatic
+ {
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_DECIMAL_PLACES,
+ OUString::number( nDecimals ) );
+ }
+
+ SvtSaveOptions::ODFSaneDefaultVersion eVersion = rExport.getSaneDefaultVersion();
+ if ( nMinDecimals >= 0 ) // negative = automatic
+ {
+ // Export only for 1.2 with extensions or 1.3 and later.
+ if (eVersion > SvtSaveOptions::ODFSVER_012)
+ {
+ // OFFICE-3860 For 1.2+ use loext namespace, for 1.3 use number namespace.
+ rExport.AddAttribute(
+ ((eVersion < SvtSaveOptions::ODFSVER_013) ? XML_NAMESPACE_LO_EXT : XML_NAMESPACE_NUMBER),
+ XML_MIN_DECIMAL_PLACES,
+ OUString::number( nMinDecimals ) );
+ }
+ }
+
+ // integer digits
+ if ( nInteger >= 0 ) // negative = automatic
+ {
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_MIN_INTEGER_DIGITS,
+ OUString::number( nInteger ) );
+ }
+
+ // (automatic) grouping separator
+ if ( bGrouping )
+ {
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_GROUPING, XML_TRUE );
+ }
+
+ // exponent digits
+ if ( nExp >= 0 )
+ {
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_MIN_EXPONENT_DIGITS,
+ OUString::number( nExp ) );
+ }
+
+ // exponent interval for engineering notation
+ if ( nExpInterval >= 0 )
+ {
+ // Export only for 1.2 with extensions or 1.3 and later.
+ if (eVersion > SvtSaveOptions::ODFSVER_012)
+ {
+ // OFFICE-1828 For 1.2+ use loext namespace, for 1.3 use number namespace.
+ rExport.AddAttribute(
+ ((eVersion < SvtSaveOptions::ODFSVER_013) ? XML_NAMESPACE_LO_EXT : XML_NAMESPACE_NUMBER),
+ XML_EXPONENT_INTERVAL, OUString::number( nExpInterval ) );
+ }
+ }
+
+ // exponent sign
+ // Export only for 1.2 with extensions or 1.3 and later.
+ if (eVersion > SvtSaveOptions::ODFSVER_012)
+ {
+ // OFFICE-3860 For 1.2+ use loext namespace, for 1.3 use number namespace.
+ rExport.AddAttribute(
+ ((eVersion < SvtSaveOptions::ODFSVER_013) ? XML_NAMESPACE_LO_EXT : XML_NAMESPACE_NUMBER),
+ XML_FORCED_EXPONENT_SIGN,
+ bExpSign? XML_TRUE : XML_FALSE );
+ }
+
+ SvXMLElementExport aElem( rExport,
+ XML_NAMESPACE_NUMBER, XML_SCIENTIFIC_NUMBER,
+ true, false );
+}
+
+void SvXMLNumFmtExport::WriteFractionElement_Impl(
+ sal_Int32 nInteger, bool bGrouping,
+ const SvNumberformat& rFormat, sal_uInt16 nPart )
+{
+ FinishTextElement_Impl();
+ const OUString aNumeratorString = rFormat.GetNumeratorString( nPart );
+ const OUString aDenominatorString = rFormat.GetDenominatorString( nPart );
+ const OUString aIntegerFractionDelimiterString = rFormat.GetIntegerFractionDelimiterString( nPart );
+ sal_Int32 nMaxNumeratorDigits = aNumeratorString.getLength();
+ // Count '0' as '?'
+ sal_Int32 nMinNumeratorDigits = aNumeratorString.replaceAll("0","?").indexOf('?');
+ sal_Int32 nZerosNumeratorDigits = aNumeratorString.indexOf('0');
+ if ( nMinNumeratorDigits >= 0 )
+ nMinNumeratorDigits = nMaxNumeratorDigits - nMinNumeratorDigits;
+ else
+ nMinNumeratorDigits = 0;
+ if ( nZerosNumeratorDigits >= 0 )
+ nZerosNumeratorDigits = nMaxNumeratorDigits - nZerosNumeratorDigits;
+ else
+ nZerosNumeratorDigits = 0;
+ sal_Int32 nMaxDenominatorDigits = aDenominatorString.getLength();
+ sal_Int32 nMinDenominatorDigits = aDenominatorString.replaceAll("0","?").indexOf('?');
+ sal_Int32 nZerosDenominatorDigits = aDenominatorString.indexOf('0');
+ if ( nMinDenominatorDigits >= 0 )
+ nMinDenominatorDigits = nMaxDenominatorDigits - nMinDenominatorDigits;
+ else
+ nMinDenominatorDigits = 0;
+ if ( nZerosDenominatorDigits >= 0 )
+ nZerosDenominatorDigits = nMaxDenominatorDigits - nZerosDenominatorDigits;
+ else
+ nZerosDenominatorDigits = 0;
+ sal_Int32 nDenominator = aDenominatorString.toInt32();
+
+ // integer digits
+ if ( nInteger >= 0 ) // negative = default (no integer part)
+ {
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_MIN_INTEGER_DIGITS,
+ OUString::number( nInteger ) );
+ }
+
+ // (automatic) grouping separator
+ if ( bGrouping )
+ {
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_GROUPING, XML_TRUE );
+ }
+
+ // integer/fraction delimiter
+ SvtSaveOptions::ODFSaneDefaultVersion eVersion = rExport.getSaneDefaultVersion();
+ if ( !aIntegerFractionDelimiterString.isEmpty() && aIntegerFractionDelimiterString != " "
+ && ((eVersion & SvtSaveOptions::ODFSVER_EXTENDED) != 0) )
+ { // Export only for 1.2/1.3 with extensions.
+ rExport.AddAttribute( XML_NAMESPACE_LO_EXT, XML_INTEGER_FRACTION_DELIMITER,
+ aIntegerFractionDelimiterString );
+ }
+
+ // numerator digits
+ if ( nMinNumeratorDigits == 0 ) // at least one digit to keep compatibility with previous versions
+ nMinNumeratorDigits++;
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_MIN_NUMERATOR_DIGITS,
+ OUString::number( nMinNumeratorDigits ) );
+ // Export only for 1.2/1.3 with extensions.
+ if ((eVersion & SvtSaveOptions::ODFSVER_EXTENDED) != 0)
+ {
+ // For extended ODF use loext namespace
+ rExport.AddAttribute( XML_NAMESPACE_LO_EXT, XML_MAX_NUMERATOR_DIGITS,
+ OUString::number( nMaxNumeratorDigits ) );
+ }
+ if ( nZerosNumeratorDigits && ((eVersion & SvtSaveOptions::ODFSVER_EXTENDED) != 0) )
+ rExport.AddAttribute( XML_NAMESPACE_LO_EXT, XML_ZEROS_NUMERATOR_DIGITS,
+ OUString::number( nZerosNumeratorDigits ) );
+
+ if ( nDenominator )
+ {
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_DENOMINATOR_VALUE,
+ OUString::number( nDenominator) );
+ }
+ // it's not necessary to export nDenominatorDigits
+ // if we have a forced denominator
+ else
+ {
+ if ( nMinDenominatorDigits == 0 ) // at least one digit to keep compatibility with previous versions
+ nMinDenominatorDigits++;
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_MIN_DENOMINATOR_DIGITS,
+ OUString::number( nMinDenominatorDigits ) );
+ if (eVersion > SvtSaveOptions::ODFSVER_012)
+ {
+ // OFFICE-3695 For 1.2+ use loext namespace, for 1.3 use number namespace.
+ rExport.AddAttribute(
+ ((eVersion < SvtSaveOptions::ODFSVER_013) ? XML_NAMESPACE_LO_EXT : XML_NAMESPACE_NUMBER),
+ XML_MAX_DENOMINATOR_VALUE,
+ OUString::number( pow ( 10.0, nMaxDenominatorDigits ) - 1 ) ); // 9, 99 or 999
+ }
+ if ( nZerosDenominatorDigits && ((eVersion & SvtSaveOptions::ODFSVER_EXTENDED) != 0) )
+ rExport.AddAttribute( XML_NAMESPACE_LO_EXT, XML_ZEROS_DENOMINATOR_DIGITS,
+ OUString::number( nZerosDenominatorDigits ) );
+ }
+
+ SvXMLElementExport aElem( rExport, XML_NAMESPACE_NUMBER, XML_FRACTION,
+ true, false );
+}
+
+// mapping (condition)
+
+void SvXMLNumFmtExport::WriteMapElement_Impl( sal_Int32 nOp, double fLimit,
+ sal_Int32 nKey, sal_Int32 nPart )
+{
+ FinishTextElement_Impl();
+
+ if ( nOp == NUMBERFORMAT_OP_NO )
+ return;
+
+ // style namespace
+
+ OUStringBuffer aCondStr(20);
+ aCondStr.append( "value()" ); //! define constant
+ switch ( nOp )
+ {
+ case NUMBERFORMAT_OP_EQ: aCondStr.append( '=' ); break;
+ case NUMBERFORMAT_OP_NE: aCondStr.append( "!=" ); break;
+ case NUMBERFORMAT_OP_LT: aCondStr.append( '<' ); break;
+ case NUMBERFORMAT_OP_LE: aCondStr.append( "<=" ); break;
+ case NUMBERFORMAT_OP_GT: aCondStr.append( '>' ); break;
+ case NUMBERFORMAT_OP_GE: aCondStr.append( ">=" ); break;
+ default:
+ OSL_FAIL("unknown operator");
+ }
+ ::rtl::math::doubleToUStringBuffer( aCondStr, fLimit,
+ rtl_math_StringFormat_Automatic, rtl_math_DecimalPlaces_Max,
+ '.', true );
+
+ rExport.AddAttribute( XML_NAMESPACE_STYLE, XML_CONDITION,
+ aCondStr.makeStringAndClear() );
+
+ rExport.AddAttribute( XML_NAMESPACE_STYLE, XML_APPLY_STYLE_NAME,
+ rExport.EncodeStyleName( lcl_CreateStyleName( nKey, nPart, false,
+ sPrefix ) ) );
+
+ SvXMLElementExport aElem( rExport, XML_NAMESPACE_STYLE, XML_MAP,
+ true, false );
+}
+
+// for old (automatic) currency formats: parse currency symbol from text
+
+static sal_Int32 lcl_FindSymbol( const OUString& sUpperStr, std::u16string_view sCurString )
+{
+ // search for currency symbol
+ // Quoting as in ImpSvNumberformatScan::Symbol_Division
+
+ sal_Int32 nCPos = 0;
+ while (nCPos >= 0)
+ {
+ nCPos = sUpperStr.indexOf( sCurString, nCPos );
+ if (nCPos >= 0)
+ {
+ // in Quotes?
+ sal_Int32 nQ = SvNumberformat::GetQuoteEnd( sUpperStr, nCPos );
+ if ( nQ < 0 )
+ {
+ // dm can be escaped as "dm or \d
+ sal_Unicode c;
+ if ( nCPos == 0 )
+ return nCPos; // found
+ c = sUpperStr[nCPos-1];
+ if ( c != '"' && c != '\\')
+ {
+ return nCPos; // found
+ }
+ else
+ {
+ nCPos++; // continue
+ }
+ }
+ else
+ {
+ nCPos = nQ + 1; // continue after quote end
+ }
+ }
+ }
+ return -1;
+}
+
+bool SvXMLNumFmtExport::WriteTextWithCurrency_Impl( const OUString& rString,
+ const css::lang::Locale& rLocale )
+{
+ // returns true if currency element was written
+
+ bool bRet = false;
+
+ LanguageTag aLanguageTag( rLocale );
+ pFormatter->ChangeIntl( aLanguageTag.getLanguageType( false) );
+ OUString sCurString, sDummy;
+ pFormatter->GetCompatibilityCurrency( sCurString, sDummy );
+
+ OUString sUpperStr = pFormatter->GetCharClass()->uppercase(rString);
+ sal_Int32 nPos = lcl_FindSymbol( sUpperStr, sCurString );
+ if ( nPos >= 0 )
+ {
+ sal_Int32 nLength = rString.getLength();
+ sal_Int32 nCurLen = sCurString.getLength();
+ sal_Int32 nCont = nPos + nCurLen;
+
+ // text before currency symbol
+ if ( nPos > 0 )
+ {
+ AddToTextElement_Impl( rString.subView( 0, nPos ) );
+ }
+ // currency symbol (empty string -> default)
+ WriteCurrencyElement_Impl( "", u"" );
+ bRet = true;
+
+ // text after currency symbol
+ if ( nCont < nLength )
+ {
+ AddToTextElement_Impl( rString.subView( nCont, nLength-nCont ) );
+ }
+ }
+ else
+ {
+ AddToTextElement_Impl( rString ); // simple text
+ }
+
+ return bRet; // true: currency element written
+}
+
+static OUString lcl_GetDefaultCalendar( SvNumberFormatter const * pFormatter, LanguageType nLang )
+{
+ // get name of first non-gregorian calendar for the language
+
+ OUString aCalendar;
+ CalendarWrapper* pCalendar = pFormatter->GetCalendar();
+ if (pCalendar)
+ {
+ lang::Locale aLocale( LanguageTag::convertToLocale( nLang ) );
+
+ const uno::Sequence<OUString> aCals = pCalendar->getAllCalendars( aLocale );
+ auto pCal = std::find_if(aCals.begin(), aCals.end(),
+ [](const OUString& rCal) { return rCal != "gregorian"; });
+ if (pCal != aCals.end())
+ aCalendar = *pCal;
+ }
+ return aCalendar;
+}
+
+static bool lcl_IsInEmbedded( const SvXMLEmbeddedTextEntryArr& rEmbeddedEntries, sal_uInt16 nPos )
+{
+ auto nCount = rEmbeddedEntries.size();
+ for (decltype(nCount) i=0; i<nCount; i++)
+ if ( rEmbeddedEntries[i].nSourcePos == nPos )
+ return true;
+
+ return false; // not found
+}
+
+static bool lcl_IsDefaultDateFormat( const SvNumberformat& rFormat, bool bSystemDate, NfIndexTableOffset eBuiltIn )
+{
+ // make an extra loop to collect date elements, to check if it is a default format
+ // before adding the automatic-order attribute
+
+ SvXMLDateElementAttributes eDateDOW = XML_DEA_NONE;
+ SvXMLDateElementAttributes eDateDay = XML_DEA_NONE;
+ SvXMLDateElementAttributes eDateMonth = XML_DEA_NONE;
+ SvXMLDateElementAttributes eDateYear = XML_DEA_NONE;
+ SvXMLDateElementAttributes eDateHours = XML_DEA_NONE;
+ SvXMLDateElementAttributes eDateMins = XML_DEA_NONE;
+ SvXMLDateElementAttributes eDateSecs = XML_DEA_NONE;
+ bool bDateNoDefault = false;
+
+ sal_uInt16 nPos = 0;
+ bool bEnd = false;
+ short nLastType = 0;
+ while (!bEnd)
+ {
+ short nElemType = rFormat.GetNumForType( 0, nPos );
+ switch ( nElemType )
+ {
+ case 0:
+ if ( nLastType == NF_SYMBOLTYPE_STRING )
+ bDateNoDefault = true; // text at the end -> no default date format
+ bEnd = true; // end of format reached
+ break;
+ case NF_SYMBOLTYPE_STRING:
+ case NF_SYMBOLTYPE_DATESEP:
+ case NF_SYMBOLTYPE_TIMESEP:
+ case NF_SYMBOLTYPE_TIME100SECSEP:
+ // text is ignored, except at the end
+ break;
+ // same mapping as in SvXMLNumFormatContext::AddNfKeyword:
+ case NF_KEY_NN: eDateDOW = XML_DEA_SHORT; break;
+ case NF_KEY_NNN:
+ case NF_KEY_NNNN: eDateDOW = XML_DEA_LONG; break;
+ case NF_KEY_D: eDateDay = XML_DEA_SHORT; break;
+ case NF_KEY_DD: eDateDay = XML_DEA_LONG; break;
+ case NF_KEY_M: eDateMonth = XML_DEA_SHORT; break;
+ case NF_KEY_MM: eDateMonth = XML_DEA_LONG; break;
+ case NF_KEY_MMM: eDateMonth = XML_DEA_TEXTSHORT; break;
+ case NF_KEY_MMMM: eDateMonth = XML_DEA_TEXTLONG; break;
+ case NF_KEY_YY: eDateYear = XML_DEA_SHORT; break;
+ case NF_KEY_YYYY: eDateYear = XML_DEA_LONG; break;
+ case NF_KEY_H: eDateHours = XML_DEA_SHORT; break;
+ case NF_KEY_HH: eDateHours = XML_DEA_LONG; break;
+ case NF_KEY_MI: eDateMins = XML_DEA_SHORT; break;
+ case NF_KEY_MMI: eDateMins = XML_DEA_LONG; break;
+ case NF_KEY_S: eDateSecs = XML_DEA_SHORT; break;
+ case NF_KEY_SS: eDateSecs = XML_DEA_LONG; break;
+ case NF_KEY_AP:
+ case NF_KEY_AMPM: break; // AM/PM may or may not be in date/time formats -> ignore by itself
+ default:
+ bDateNoDefault = true; // any other element -> no default format
+ }
+ nLastType = nElemType;
+ ++nPos;
+ }
+
+ if ( bDateNoDefault )
+ return false; // additional elements
+ else
+ {
+ NfIndexTableOffset eFound = static_cast<NfIndexTableOffset>(SvXMLNumFmtDefaults::GetDefaultDateFormat(
+ eDateDOW, eDateDay, eDateMonth, eDateYear, eDateHours, eDateMins, eDateSecs, bSystemDate ));
+
+ return ( eFound == eBuiltIn );
+ }
+}
+
+// export one part (condition)
+
+void SvXMLNumFmtExport::ExportPart_Impl( const SvNumberformat& rFormat, sal_uInt32 nKey, sal_uInt32 nRealKey,
+ sal_uInt16 nPart, bool bDefPart )
+{
+ //! for the default part, pass the conditions from the other parts!
+
+ // element name
+
+ NfIndexTableOffset eBuiltIn = pFormatter->GetIndexTableOffset( nRealKey );
+
+ SvNumFormatType nFmtType = SvNumFormatType::ALL;
+ bool bThousand = false;
+ sal_uInt16 nPrecision = 0;
+ sal_uInt16 nLeading = 0;
+ rFormat.GetNumForInfo( nPart, nFmtType, bThousand, nPrecision, nLeading);
+ nFmtType &= ~SvNumFormatType::DEFINED;
+
+ // special treatment of builtin formats that aren't detected by normal parsing
+ // (the same formats that get the type set in SvNumberFormatter::ImpGenerateFormats)
+ if ( eBuiltIn == NF_NUMBER_STANDARD )
+ nFmtType = SvNumFormatType::NUMBER;
+ else if ( eBuiltIn == NF_BOOLEAN )
+ nFmtType = SvNumFormatType::LOGICAL;
+ else if ( eBuiltIn == NF_TEXT )
+ nFmtType = SvNumFormatType::TEXT;
+
+ // #101606# An empty subformat is a valid number-style resulting in an
+ // empty display string for the condition of the subformat.
+
+ XMLTokenEnum eType = XML_TOKEN_INVALID;
+ switch ( nFmtType )
+ {
+ // Type UNDEFINED likely is a crappy format string for that we could
+ // not decide on any format type (and maybe could try harder?), but the
+ // resulting XMLTokenEnum should be something valid, so make that
+ // number-style.
+ case SvNumFormatType::UNDEFINED:
+ SAL_WARN("xmloff.style","UNDEFINED number format: '" << rFormat.GetFormatstring() << "'");
+ [[fallthrough]];
+ // Type is 0 if a format contains no recognized elements
+ // (like text only) - this is handled as a number-style.
+ case SvNumFormatType::ALL:
+ case SvNumFormatType::EMPTY:
+ case SvNumFormatType::NUMBER:
+ case SvNumFormatType::SCIENTIFIC:
+ case SvNumFormatType::FRACTION:
+ eType = XML_NUMBER_STYLE;
+ break;
+ case SvNumFormatType::PERCENT:
+ eType = XML_PERCENTAGE_STYLE;
+ break;
+ case SvNumFormatType::CURRENCY:
+ eType = XML_CURRENCY_STYLE;
+ break;
+ case SvNumFormatType::DATE:
+ case SvNumFormatType::DATETIME:
+ eType = XML_DATE_STYLE;
+ break;
+ case SvNumFormatType::TIME:
+ eType = XML_TIME_STYLE;
+ break;
+ case SvNumFormatType::TEXT:
+ eType = XML_TEXT_STYLE;
+ break;
+ case SvNumFormatType::LOGICAL:
+ eType = XML_BOOLEAN_STYLE;
+ break;
+ default: break;
+ }
+ SAL_WARN_IF( eType == XML_TOKEN_INVALID, "xmloff.style", "unknown format type" );
+
+ OUString sAttrValue;
+ bool bUserDef( rFormat.GetType() & SvNumFormatType::DEFINED );
+
+ // common attributes for format
+
+ // format name (generated from key) - style namespace
+ rExport.AddAttribute( XML_NAMESPACE_STYLE, XML_NAME,
+ lcl_CreateStyleName( nKey, nPart, bDefPart, sPrefix ) );
+
+ // "volatile" attribute for styles used only in maps
+ if ( !bDefPart )
+ rExport.AddAttribute( XML_NAMESPACE_STYLE, XML_VOLATILE, XML_TRUE );
+
+ // language / country
+ LanguageType nLang = rFormat.GetLanguage();
+ AddLanguageAttr_Impl( nLang ); // adds to pAttrList
+
+ // title (comment)
+ // titles for builtin formats are not written
+ sAttrValue = rFormat.GetComment();
+ if ( !sAttrValue.isEmpty() && bUserDef && bDefPart )
+ {
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_TITLE, sAttrValue );
+ }
+
+ // automatic ordering for currency and date formats
+ // only used for some built-in formats
+ bool bAutoOrder = ( eBuiltIn == NF_CURRENCY_1000INT || eBuiltIn == NF_CURRENCY_1000DEC2 ||
+ eBuiltIn == NF_CURRENCY_1000INT_RED || eBuiltIn == NF_CURRENCY_1000DEC2_RED ||
+ eBuiltIn == NF_CURRENCY_1000DEC2_DASHED ||
+ eBuiltIn == NF_DATE_SYSTEM_SHORT || eBuiltIn == NF_DATE_SYSTEM_LONG ||
+ eBuiltIn == NF_DATE_SYS_MMYY || eBuiltIn == NF_DATE_SYS_DDMMM ||
+ eBuiltIn == NF_DATE_SYS_DDMMYYYY || eBuiltIn == NF_DATE_SYS_DDMMYY ||
+ eBuiltIn == NF_DATE_SYS_DMMMYY || eBuiltIn == NF_DATE_SYS_DMMMYYYY ||
+ eBuiltIn == NF_DATE_SYS_DMMMMYYYY || eBuiltIn == NF_DATE_SYS_NNDMMMYY ||
+ eBuiltIn == NF_DATE_SYS_NNDMMMMYYYY || eBuiltIn == NF_DATE_SYS_NNNNDMMMMYYYY ||
+ eBuiltIn == NF_DATETIME_SYSTEM_SHORT_HHMM || eBuiltIn == NF_DATETIME_SYS_DDMMYYYY_HHMM ||
+ eBuiltIn == NF_DATETIME_SYS_DDMMYYYY_HHMMSS );
+
+ // format source (for date and time formats)
+ // only used for some built-in formats
+ bool bSystemDate = ( eBuiltIn == NF_DATE_SYSTEM_SHORT ||
+ eBuiltIn == NF_DATE_SYSTEM_LONG ||
+ eBuiltIn == NF_DATETIME_SYSTEM_SHORT_HHMM );
+ bool bLongSysDate = ( eBuiltIn == NF_DATE_SYSTEM_LONG );
+
+ // check if the format definition matches the key
+ if ( bAutoOrder && ( nFmtType == SvNumFormatType::DATE || nFmtType == SvNumFormatType::DATETIME ) &&
+ !lcl_IsDefaultDateFormat( rFormat, bSystemDate, eBuiltIn ) )
+ {
+ bAutoOrder = bSystemDate = bLongSysDate = false; // don't write automatic-order attribute then
+ }
+
+ if ( bAutoOrder &&
+ ( nFmtType == SvNumFormatType::CURRENCY || nFmtType == SvNumFormatType::DATE || nFmtType == SvNumFormatType::DATETIME ) )
+ {
+ // #85109# format type must be checked to avoid dtd errors if
+ // locale data contains other format types at the built-in positions
+
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_AUTOMATIC_ORDER,
+ XML_TRUE );
+ }
+
+ if ( bSystemDate && bAutoOrder &&
+ ( nFmtType == SvNumFormatType::DATE || nFmtType == SvNumFormatType::DATETIME ) )
+ {
+ // #85109# format type must be checked to avoid dtd errors if
+ // locale data contains other format types at the built-in positions
+
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_FORMAT_SOURCE,
+ XML_LANGUAGE );
+ }
+
+ // overflow for time formats as in [hh]:mm
+ // controlled by bThousand from number format info
+ // default for truncate-on-overflow is true
+ if ( nFmtType == SvNumFormatType::TIME && bThousand )
+ {
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_TRUNCATE_ON_OVERFLOW,
+ XML_FALSE );
+ }
+
+ // Native number transliteration
+ css::i18n::NativeNumberXmlAttributes2 aAttr;
+ rFormat.GetNatNumXml( aAttr, nPart );
+ if ( !aAttr.Format.isEmpty() )
+ {
+ assert(aAttr.Spellout.isEmpty()); // mutually exclusive
+
+ /* FIXME-BCP47: ODF defines no transliteration-script or
+ * transliteration-rfc-language-tag */
+ LanguageTag aLanguageTag( aAttr.Locale);
+ OUString aLanguage, aScript, aCountry;
+ aLanguageTag.getIsoLanguageScriptCountry( aLanguage, aScript, aCountry);
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_FORMAT,
+ aAttr.Format );
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_LANGUAGE,
+ aLanguage );
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_COUNTRY,
+ aCountry );
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_STYLE,
+ aAttr.Style );
+ }
+
+ if ( !aAttr.Spellout.isEmpty() )
+ {
+ const bool bWriteSpellout = aAttr.Format.isEmpty();
+ assert(bWriteSpellout); // mutually exclusive
+
+ // Export only for 1.2 and later with extensions
+ SvtSaveOptions::ODFSaneDefaultVersion eVersion = rExport.getSaneDefaultVersion();
+ // Also ensure that duplicated transliteration-language and
+ // transliteration-country attributes never escape into the wild with
+ // releases.
+ if ( (eVersion & SvtSaveOptions::ODFSVER_EXTENDED) && bWriteSpellout )
+ {
+ /* FIXME-BCP47: ODF defines no transliteration-script or
+ * transliteration-rfc-language-tag */
+ LanguageTag aLanguageTag( aAttr.Locale);
+ OUString aLanguage, aScript, aCountry;
+ aLanguageTag.getIsoLanguageScriptCountry( aLanguage, aScript, aCountry);
+ // For 1.2/1.3+ use loext namespace.
+ rExport.AddAttribute( /*((eVersion < SvtSaveOptions::ODFSVER_)
+ ? */ XML_NAMESPACE_LO_EXT /*: XML_NAMESPACE_NUMBER)*/,
+ XML_TRANSLITERATION_SPELLOUT, aAttr.Spellout );
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_LANGUAGE,
+ aLanguage );
+ rExport.AddAttribute( XML_NAMESPACE_NUMBER, XML_TRANSLITERATION_COUNTRY,
+ aCountry );
+ }
+ }
+
+ // The element
+ SvXMLElementExport aElem( rExport, XML_NAMESPACE_NUMBER, eType,
+ true, true );
+
+ // color (properties element)
+
+ const Color* pCol = rFormat.GetColor( nPart );
+ if (pCol)
+ WriteColorElement_Impl(*pCol);
+
+ // detect if there is "real" content, excluding color and maps
+ //! move to implementation of Write... methods?
+ bool bAnyContent = false;
+
+ // format elements
+
+ SvXMLEmbeddedTextEntryArr aEmbeddedEntries;
+ if ( eBuiltIn == NF_NUMBER_STANDARD )
+ {
+ // default number format contains just one number element
+ WriteNumberElement_Impl( -1, -1, 1, OUString(), false, 0, aEmbeddedEntries );
+ bAnyContent = true;
+ }
+ else if ( eBuiltIn == NF_BOOLEAN )
+ {
+ // boolean format contains just one boolean element
+ WriteBooleanElement_Impl();
+ bAnyContent = true;
+ }
+ else if (eType == XML_BOOLEAN_STYLE)
+ {
+ // <number:boolean-style> may contain only <number:boolean> and
+ // <number:text> elements.
+ sal_uInt16 nPos = 0;
+ bool bEnd = false;
+ while (!bEnd)
+ {
+ const short nElemType = rFormat.GetNumForType( nPart, nPos );
+ switch (nElemType)
+ {
+ case 0:
+ bEnd = true; // end of format reached
+ if (bHasText && sTextContent.isEmpty())
+ bHasText = false; // don't write trailing empty text
+ break;
+ case NF_SYMBOLTYPE_STRING:
+ {
+ const OUString* pElemStr = rFormat.GetNumForString( nPart, nPos );
+ if (pElemStr)
+ AddToTextElement_Impl( *pElemStr );
+ }
+ break;
+ case NF_KEY_BOOLEAN:
+ WriteBooleanElement_Impl();
+ bAnyContent = true;
+ break;
+ }
+ ++nPos;
+ }
+ }
+ else
+ {
+ // first loop to collect attributes
+
+ bool bDecDashes = false;
+ bool bExpFound = false;
+ bool bCurrFound = false;
+ bool bInInteger = true;
+ bool bExpSign = true;
+ bool bDecAlign = false; // decimal alignment with "?"
+ sal_Int32 nExpDigits = 0;
+ sal_Int32 nIntegerSymbols = 0; // for embedded-text, including "#"
+ sal_Int32 nTrailingThousands = 0; // thousands-separators after all digits
+ sal_Int32 nMinDecimals = nPrecision;
+ OUString sCurrExt;
+ OUString aCalendar;
+ bool bImplicitOtherCalendar = false;
+ bool bExplicitCalendar = false;
+ sal_uInt16 nPos = 0;
+ bool bEnd = false;
+ while (!bEnd)
+ {
+ short nElemType = rFormat.GetNumForType( nPart, nPos );
+ const OUString* pElemStr = rFormat.GetNumForString( nPart, nPos );
+
+ switch ( nElemType )
+ {
+ case 0:
+ bEnd = true; // end of format reached
+ break;
+ case NF_SYMBOLTYPE_DIGIT:
+ if ( bExpFound && pElemStr )
+ nExpDigits += pElemStr->getLength();
+ else if ( !bDecDashes && pElemStr && (*pElemStr)[0] == '-' )
+ {
+ bDecDashes = true;
+ nMinDecimals = 0;
+ }
+ else if ( !bInInteger && pElemStr )
+ {
+ for ( sal_Int32 i = pElemStr->getLength()-1; i >= 0 ; i-- )
+ {
+ sal_Unicode aChar = (*pElemStr)[i];
+ if ( aChar == '#' || aChar == '?' )
+ {
+ nMinDecimals --;
+ if ( aChar == '?' )
+ bDecAlign = true;
+ }
+ else
+ break;
+ }
+ }
+ if ( bInInteger && pElemStr )
+ nIntegerSymbols += pElemStr->getLength();
+ nTrailingThousands = 0;
+ break;
+ case NF_SYMBOLTYPE_DECSEP:
+ bInInteger = false;
+ break;
+ case NF_SYMBOLTYPE_THSEP:
+ if (pElemStr)
+ nTrailingThousands += pElemStr->getLength(); // is reset to 0 if digits follow
+ break;
+ case NF_SYMBOLTYPE_EXP:
+ bExpFound = true; // following digits are exponent digits
+ bInInteger = false;
+ if ( pElemStr && ( pElemStr->getLength() == 1
+ || ( pElemStr->getLength() == 2 && (*pElemStr)[1] == '-' ) ) )
+ bExpSign = false; // for 0.00E0 or 0.00E-00
+ break;
+ case NF_SYMBOLTYPE_CURRENCY:
+ bCurrFound = true;
+ break;
+ case NF_SYMBOLTYPE_CURREXT:
+ if (pElemStr)
+ sCurrExt = *pElemStr;
+ break;
+
+ // E, EE, R, RR: select non-gregorian calendar
+ // AAA, AAAA: calendar is switched at the position of the element
+ case NF_KEY_EC:
+ case NF_KEY_EEC:
+ case NF_KEY_R:
+ case NF_KEY_RR:
+ if (aCalendar.isEmpty())
+ {
+ aCalendar = lcl_GetDefaultCalendar( pFormatter, nLang );
+ bImplicitOtherCalendar = true;
+ }
+ break;
+ }
+ ++nPos;
+ }
+
+ // collect strings for embedded-text (must be known before number element is written)
+
+ bool bAllowEmbedded = ( nFmtType == SvNumFormatType::ALL || nFmtType == SvNumFormatType::NUMBER ||
+ nFmtType == SvNumFormatType::CURRENCY ||
+ nFmtType == SvNumFormatType::PERCENT );
+ if ( bAllowEmbedded )
+ {
+ sal_Int32 nDigitsPassed = 0;
+ sal_Int32 nEmbeddedPositionsMax = nIntegerSymbols;
+ // Enable embedded text in decimal part only if there's a decimal part
+ if ( nPrecision )
+ nEmbeddedPositionsMax += nPrecision + 1;
+ nPos = 0;
+ bEnd = false;
+ while (!bEnd)
+ {
+ short nElemType = rFormat.GetNumForType( nPart, nPos );
+ const OUString* pElemStr = rFormat.GetNumForString( nPart, nPos );
+
+ switch ( nElemType )
+ {
+ case 0:
+ bEnd = true; // end of format reached
+ break;
+ case NF_SYMBOLTYPE_DIGIT:
+ if ( pElemStr )
+ nDigitsPassed += pElemStr->getLength();
+ break;
+ case NF_SYMBOLTYPE_DECSEP:
+ nDigitsPassed++;
+ break;
+ case NF_SYMBOLTYPE_STRING:
+ case NF_SYMBOLTYPE_BLANK:
+ case NF_SYMBOLTYPE_PERCENT:
+ if ( 0 < nDigitsPassed && nDigitsPassed < nEmbeddedPositionsMax && pElemStr )
+ {
+ // text (literal or underscore) within the integer (>=0) or decimal (<0) part of a number:number element
+
+ OUString aEmbeddedStr;
+ if ( nElemType == NF_SYMBOLTYPE_STRING || nElemType == NF_SYMBOLTYPE_PERCENT )
+ {
+ aEmbeddedStr = *pElemStr;
+ }
+ else if (pElemStr->getLength() >= 2)
+ {
+ SvNumberformat::InsertBlanks( aEmbeddedStr, 0, (*pElemStr)[1] );
+ }
+ sal_Int32 nEmbedPos = nIntegerSymbols - nDigitsPassed;
+
+ aEmbeddedEntries.push_back(
+ SvXMLEmbeddedTextEntry(nPos, nEmbedPos, aEmbeddedStr));
+ }
+ break;
+ }
+ ++nPos;
+ }
+ }
+
+ // final loop to write elements
+
+ bool bNumWritten = false;
+ bool bCurrencyWritten = false;
+ short nPrevType = 0;
+ nPos = 0;
+ bEnd = false;
+ while (!bEnd)
+ {
+ short nElemType = rFormat.GetNumForType( nPart, nPos );
+ const OUString* pElemStr = rFormat.GetNumForString( nPart, nPos );
+
+ switch ( nElemType )
+ {
+ case 0:
+ bEnd = true; // end of format reached
+ if (bHasText && sTextContent.isEmpty())
+ bHasText = false; // don't write trailing empty text
+ break;
+ case NF_SYMBOLTYPE_STRING:
+ case NF_SYMBOLTYPE_DATESEP:
+ case NF_SYMBOLTYPE_TIMESEP:
+ case NF_SYMBOLTYPE_TIME100SECSEP:
+ case NF_SYMBOLTYPE_PERCENT:
+ if (pElemStr)
+ {
+ if ( ( nPrevType == NF_KEY_S || nPrevType == NF_KEY_SS ) &&
+ ( nElemType == NF_SYMBOLTYPE_TIME100SECSEP ) &&
+ nPrecision > 0 )
+ {
+ // decimal separator after seconds is implied by
+ // "decimal-places" attribute and must not be written
+ // as text element
+ //! difference between '.' and ',' is lost here
+ }
+ else if ( lcl_IsInEmbedded( aEmbeddedEntries, nPos ) )
+ {
+ // text is written as embedded-text child of the number,
+ // don't create a text element
+ }
+ else if ( nFmtType == SvNumFormatType::CURRENCY && !bCurrFound && !bCurrencyWritten )
+ {
+ // automatic currency symbol is implemented as part of
+ // normal text -> search for the symbol
+ bCurrencyWritten = WriteTextWithCurrency_Impl( *pElemStr,
+ LanguageTag::convertToLocale( nLang ) );
+ bAnyContent = true;
+ }
+ else
+ AddToTextElement_Impl( *pElemStr );
+ }
+ break;
+ case NF_SYMBOLTYPE_BLANK:
+ if ( pElemStr && !lcl_IsInEmbedded( aEmbeddedEntries, nPos ) )
+ {
+ // turn "_x" into the number of spaces used for x in InsertBlanks in the NumberFormat
+ // (#i20396# the spaces may also be in embedded-text elements)
+
+ OUString aBlanks;
+ if (pElemStr->getLength() >= 2)
+ SvNumberformat::InsertBlanks( aBlanks, 0, (*pElemStr)[1] );
+ AddToTextElement_Impl( aBlanks );
+ }
+ break;
+ case NF_KEY_GENERAL :
+ WriteNumberElement_Impl( -1, -1, 1, OUString(), false, 0, aEmbeddedEntries );
+ bAnyContent = true;
+ break;
+ case NF_KEY_CCC:
+ if (pElemStr)
+ {
+ if ( bCurrencyWritten )
+ AddToTextElement_Impl( *pElemStr ); // never more than one currency element
+ else
+ {
+ //! must be different from short automatic format
+ //! but should still be empty (meaning automatic)
+ // pElemStr is "CCC"
+
+ WriteCurrencyElement_Impl( *pElemStr, u"" );
+ bAnyContent = true;
+ bCurrencyWritten = true;
+ }
+ }
+ break;
+ case NF_SYMBOLTYPE_CURRENCY:
+ if (pElemStr)
+ {
+ if ( bCurrencyWritten )
+ AddToTextElement_Impl( *pElemStr ); // never more than one currency element
+ else
+ {
+ WriteCurrencyElement_Impl( *pElemStr, sCurrExt );
+ bAnyContent = true;
+ bCurrencyWritten = true;
+ }
+ }
+ break;
+ case NF_SYMBOLTYPE_DIGIT:
+ if (!bNumWritten) // write number part
+ {
+ switch ( nFmtType )
+ {
+ // for type 0 (not recognized as a special type),
+ // write a "normal" number
+ case SvNumFormatType::ALL:
+ case SvNumFormatType::NUMBER:
+ case SvNumFormatType::CURRENCY:
+ case SvNumFormatType::PERCENT:
+ {
+ // decimals
+ // only some built-in formats have automatic decimals
+ sal_Int32 nDecimals = nPrecision; // from GetFormatSpecialInfo
+ if ( eBuiltIn == NF_NUMBER_STANDARD ||
+ eBuiltIn == NF_CURRENCY_1000DEC2 ||
+ eBuiltIn == NF_CURRENCY_1000DEC2_RED ||
+ eBuiltIn == NF_CURRENCY_1000DEC2_CCC ||
+ eBuiltIn == NF_CURRENCY_1000DEC2_DASHED )
+ nDecimals = -1;
+
+ // integer digits
+ // only one built-in format has automatic integer digits
+ sal_Int32 nInteger = nLeading;
+ if ( eBuiltIn == NF_NUMBER_SYSTEM )
+ nInteger = -1;
+
+ // string for decimal replacement
+ // has to be taken from nPrecision
+ // (positive number even for automatic decimals)
+ OUStringBuffer sDashStr;
+ if (bDecDashes && nPrecision > 0)
+ comphelper::string::padToLength(sDashStr, nPrecision, '-');
+ // "?" in decimal part are replaced by space character
+ if (bDecAlign && nPrecision > 0)
+ sDashStr = " ";
+
+ WriteNumberElement_Impl(nDecimals, nMinDecimals, nInteger, sDashStr.makeStringAndClear(),
+ bThousand, nTrailingThousands, aEmbeddedEntries);
+ bAnyContent = true;
+ }
+ break;
+ case SvNumFormatType::SCIENTIFIC:
+ // #i43959# for scientific numbers, count all integer symbols ("0" and "#")
+ // as integer digits: use nIntegerSymbols instead of nLeading
+ // nIntegerSymbols represents exponent interval (for engineering notation)
+ WriteScientificElement_Impl( nPrecision, nMinDecimals, nLeading, bThousand, nExpDigits, nIntegerSymbols, bExpSign );
+ bAnyContent = true;
+ break;
+ case SvNumFormatType::FRACTION:
+ {
+ sal_Int32 nInteger = nLeading;
+ if ( rFormat.GetNumForNumberElementCount( nPart ) == 3 )
+ {
+ // If there is only two numbers + fraction in format string
+ // the fraction doesn't have an integer part, and no
+ // min-integer-digits attribute must be written.
+ nInteger = -1;
+ }
+ WriteFractionElement_Impl( nInteger, bThousand, rFormat, nPart );
+ bAnyContent = true;
+ }
+ break;
+ default: break;
+ }
+
+ bNumWritten = true;
+ }
+ break;
+ case NF_SYMBOLTYPE_DECSEP:
+ if ( pElemStr && nPrecision == 0 )
+ {
+ // A decimal separator after the number, without following decimal digits,
+ // isn't modelled as part of the number element, so it's written as text
+ // (the distinction between a quoted and non-quoted, locale-dependent
+ // character is lost here).
+
+ AddToTextElement_Impl( *pElemStr );
+ }
+ break;
+ case NF_SYMBOLTYPE_DEL:
+ if ( pElemStr && *pElemStr == "@" )
+ {
+ WriteTextContentElement_Impl();
+ bAnyContent = true;
+ }
+ break;
+
+ case NF_SYMBOLTYPE_CALENDAR:
+ if ( pElemStr )
+ {
+ aCalendar = *pElemStr;
+ bExplicitCalendar = true;
+ }
+ break;
+
+ // date elements:
+
+ case NF_KEY_D:
+ case NF_KEY_DD:
+ {
+ bool bLong = ( nElemType == NF_KEY_DD );
+ WriteDayElement_Impl( aCalendar, ( bSystemDate ? bLongSysDate : bLong ) );
+ bAnyContent = true;
+ }
+ break;
+ case NF_KEY_DDD:
+ case NF_KEY_DDDD:
+ case NF_KEY_NN:
+ case NF_KEY_NNN:
+ case NF_KEY_NNNN:
+ case NF_KEY_AAA:
+ case NF_KEY_AAAA:
+ {
+ OUString aCalAttr = aCalendar;
+ if ( nElemType == NF_KEY_AAA || nElemType == NF_KEY_AAAA )
+ {
+ // calendar attribute for AAA and AAAA is switched only for this element
+ if (aCalAttr.isEmpty())
+ aCalAttr = lcl_GetDefaultCalendar( pFormatter, nLang );
+ }
+
+ bool bLong = ( nElemType == NF_KEY_NNN || nElemType == NF_KEY_NNNN ||
+ nElemType == NF_KEY_DDDD || nElemType == NF_KEY_AAAA );
+ WriteDayOfWeekElement_Impl( aCalAttr, ( bSystemDate ? bLongSysDate : bLong ) );
+ bAnyContent = true;
+ if ( nElemType == NF_KEY_NNNN )
+ {
+ // write additional text element for separator
+ pLocaleData.reset( new LocaleDataWrapper( pFormatter->GetComponentContext(),
+ LanguageTag( nLang ) ) );
+ AddToTextElement_Impl( pLocaleData->getLongDateDayOfWeekSep() );
+ }
+ }
+ break;
+ case NF_KEY_M:
+ case NF_KEY_MM:
+ case NF_KEY_MMM:
+ case NF_KEY_MMMM:
+ case NF_KEY_MMMMM: //! first letter of month name, no attribute available
+ {
+ bool bLong = ( nElemType == NF_KEY_MM || nElemType == NF_KEY_MMMM );
+ bool bText = ( nElemType == NF_KEY_MMM || nElemType == NF_KEY_MMMM ||
+ nElemType == NF_KEY_MMMMM );
+ WriteMonthElement_Impl( aCalendar, ( bSystemDate ? bLongSysDate : bLong ), bText );
+ bAnyContent = true;
+ }
+ break;
+ case NF_KEY_YY:
+ case NF_KEY_YYYY:
+ case NF_KEY_EC:
+ case NF_KEY_EEC:
+ case NF_KEY_R: //! R acts as EE, no attribute available
+ {
+ //! distinguish EE and R
+ // Calendar attribute for E and EE and R is set in
+ // first loop. If set and not an explicit calendar and
+ // YY or YYYY is encountered, switch temporarily to
+ // Gregorian.
+ bool bLong = ( nElemType == NF_KEY_YYYY || nElemType == NF_KEY_EEC ||
+ nElemType == NF_KEY_R );
+ WriteYearElement_Impl(
+ ((bImplicitOtherCalendar && !bExplicitCalendar
+ && (nElemType == NF_KEY_YY || nElemType == NF_KEY_YYYY)) ? "gregorian" : aCalendar),
+ (bSystemDate ? bLongSysDate : bLong));
+ bAnyContent = true;
+ }
+ break;
+ case NF_KEY_G:
+ case NF_KEY_GG:
+ case NF_KEY_GGG:
+ case NF_KEY_RR: //! RR acts as GGGEE, no attribute available
+ {
+ //! distinguish GG and GGG and RR
+ bool bLong = ( nElemType == NF_KEY_GGG || nElemType == NF_KEY_RR );
+ WriteEraElement_Impl( aCalendar, ( bSystemDate ? bLongSysDate : bLong ) );
+ bAnyContent = true;
+ if ( nElemType == NF_KEY_RR )
+ {
+ // calendar attribute for RR is set in first loop
+ WriteYearElement_Impl( aCalendar, ( bSystemDate || bLongSysDate ) );
+ }
+ }
+ break;
+ case NF_KEY_Q:
+ case NF_KEY_QQ:
+ {
+ bool bLong = ( nElemType == NF_KEY_QQ );
+ WriteQuarterElement_Impl( aCalendar, ( bSystemDate ? bLongSysDate : bLong ) );
+ bAnyContent = true;
+ }
+ break;
+ case NF_KEY_WW:
+ WriteWeekElement_Impl( aCalendar );
+ bAnyContent = true;
+ break;
+
+ // time elements (bSystemDate is not used):
+
+ case NF_KEY_H:
+ case NF_KEY_HH:
+ WriteHoursElement_Impl( nElemType == NF_KEY_HH );
+ bAnyContent = true;
+ break;
+ case NF_KEY_MI:
+ case NF_KEY_MMI:
+ WriteMinutesElement_Impl( nElemType == NF_KEY_MMI );
+ bAnyContent = true;
+ break;
+ case NF_KEY_S:
+ case NF_KEY_SS:
+ WriteSecondsElement_Impl( ( nElemType == NF_KEY_SS ), nPrecision );
+ bAnyContent = true;
+ break;
+ case NF_KEY_AMPM:
+ case NF_KEY_AP:
+ WriteAMPMElement_Impl(); // short/long?
+ bAnyContent = true;
+ break;
+ case NF_SYMBOLTYPE_STAR :
+ // export only if ODF 1.2 extensions are enabled
+ if (rExport.getSaneDefaultVersion() > SvtSaveOptions::ODFSVER_012)
+ {
+ if ( pElemStr && pElemStr->getLength() > 1 )
+ WriteRepeatedElement_Impl( (*pElemStr)[1] );
+ }
+ break;
+ }
+ nPrevType = nElemType;
+ ++nPos;
+ }
+ }
+
+ if ( !sTextContent.isEmpty() )
+ bAnyContent = true; // element written in FinishTextElement_Impl
+
+ FinishTextElement_Impl(); // final text element - before maps
+
+ if ( !bAnyContent )
+ {
+ // for an empty format, write an empty text element
+ SvXMLElementExport aTElem( rExport, XML_NAMESPACE_NUMBER, XML_TEXT,
+ true, false );
+ }
+
+ // mapping (conditions) must be last elements
+
+ if (!bDefPart)
+ return;
+
+ SvNumberformatLimitOps eOp1, eOp2;
+ double fLimit1, fLimit2;
+ rFormat.GetConditions( eOp1, fLimit1, eOp2, fLimit2 );
+
+ WriteMapElement_Impl( eOp1, fLimit1, nKey, 0 );
+ WriteMapElement_Impl( eOp2, fLimit2, nKey, 1 );
+
+ if ( !rFormat.HasTextFormat() )
+ return;
+
+ // 4th part is for text -> make an "all other numbers" condition for the 3rd part
+ // by reversing the 2nd condition.
+ // For a trailing text format like 0;@ that has no conditions
+ // use a "less or equal than biggest" condition for the number
+ // part, ODF can't store subformats (style maps) without
+ // conditions.
+
+ SvNumberformatLimitOps eOp3 = NUMBERFORMAT_OP_NO;
+ double fLimit3 = fLimit2;
+ sal_uInt16 nLastPart = 2;
+ SvNumberformatLimitOps eOpLast = eOp2;
+ if (eOp2 == NUMBERFORMAT_OP_NO)
+ {
+ eOpLast = eOp1;
+ fLimit3 = fLimit1;
+ nLastPart = (eOp1 == NUMBERFORMAT_OP_NO) ? 0 : 1;
+ }
+ switch ( eOpLast )
+ {
+ case NUMBERFORMAT_OP_EQ: eOp3 = NUMBERFORMAT_OP_NE; break;
+ case NUMBERFORMAT_OP_NE: eOp3 = NUMBERFORMAT_OP_EQ; break;
+ case NUMBERFORMAT_OP_LT: eOp3 = NUMBERFORMAT_OP_GE; break;
+ case NUMBERFORMAT_OP_LE: eOp3 = NUMBERFORMAT_OP_GT; break;
+ case NUMBERFORMAT_OP_GT: eOp3 = NUMBERFORMAT_OP_LE; break;
+ case NUMBERFORMAT_OP_GE: eOp3 = NUMBERFORMAT_OP_LT; break;
+ case NUMBERFORMAT_OP_NO: eOp3 = NUMBERFORMAT_OP_LE; fLimit3 = DBL_MAX; break;
+ }
+
+ if ( fLimit1 == fLimit2 &&
+ ( ( eOp1 == NUMBERFORMAT_OP_LT && eOp2 == NUMBERFORMAT_OP_GT ) ||
+ ( eOp1 == NUMBERFORMAT_OP_GT && eOp2 == NUMBERFORMAT_OP_LT ) ) )
+ {
+ // For <x and >x, add =x as last condition
+ // (just for readability, <=x would be valid, too)
+
+ eOp3 = NUMBERFORMAT_OP_EQ;
+ }
+
+ WriteMapElement_Impl( eOp3, fLimit3, nKey, nLastPart );
+}
+
+// export one format
+
+void SvXMLNumFmtExport::ExportFormat_Impl( const SvNumberformat& rFormat, sal_uInt32 nKey, sal_uInt32 nRealKey )
+{
+ const sal_uInt16 XMLNUM_MAX_PARTS = 4;
+ bool bParts[XMLNUM_MAX_PARTS] = { false, false, false, false };
+ sal_uInt16 nUsedParts = 0;
+ for (sal_uInt16 nPart=0; nPart<XMLNUM_MAX_PARTS; ++nPart)
+ {
+ if (rFormat.GetNumForInfoScannedType( nPart) != SvNumFormatType::UNDEFINED)
+ {
+ bParts[nPart] = true;
+ nUsedParts = nPart + 1;
+ }
+ }
+
+ SvNumberformatLimitOps eOp1, eOp2;
+ double fLimit1, fLimit2;
+ rFormat.GetConditions( eOp1, fLimit1, eOp2, fLimit2 );
+
+ // if conditions are set, even empty formats must be written
+
+ if ( eOp1 != NUMBERFORMAT_OP_NO )
+ {
+ bParts[1] = true;
+ if (nUsedParts < 2)
+ nUsedParts = 2;
+ }
+ if ( eOp2 != NUMBERFORMAT_OP_NO )
+ {
+ bParts[2] = true;
+ if (nUsedParts < 3)
+ nUsedParts = 3;
+ }
+ if ( rFormat.HasTextFormat() )
+ {
+ bParts[3] = true;
+ if (nUsedParts < 4)
+ nUsedParts = 4;
+ }
+
+ for (sal_uInt16 nPart=0; nPart<XMLNUM_MAX_PARTS; ++nPart)
+ {
+ if (bParts[nPart])
+ {
+ bool bDefault = ( nPart+1 == nUsedParts ); // last = default
+ ExportPart_Impl( rFormat, nKey, nRealKey, nPart, bDefault );
+ }
+ }
+}
+
+// export method called by application
+
+void SvXMLNumFmtExport::Export( bool bIsAutoStyle )
+{
+ if ( !pFormatter )
+ return; // no formatter -> no entries
+
+ sal_uInt32 nKey;
+ const SvNumberformat* pFormat = nullptr;
+ bool bNext(pUsedList->GetFirstUsed(nKey));
+ while(bNext)
+ {
+ // ODF has its notation of system formats, so obtain the "real" already
+ // substituted format but use the original key for style name.
+ sal_uInt32 nRealKey = nKey;
+ pFormat = pFormatter->GetSubstitutedEntry( nKey, nRealKey);
+ if(pFormat)
+ ExportFormat_Impl( *pFormat, nKey, nRealKey );
+ bNext = pUsedList->GetNextUsed(nKey);
+ }
+ if (!bIsAutoStyle)
+ {
+ std::vector<LanguageType> aLanguages;
+ pFormatter->GetUsedLanguages( aLanguages );
+ for (const auto& nLang : aLanguages)
+ {
+ sal_uInt32 nDefaultIndex = 0;
+ SvNumberFormatTable& rTable = pFormatter->GetEntryTable(
+ SvNumFormatType::DEFINED, nDefaultIndex, nLang );
+ for (const auto& rTableEntry : rTable)
+ {
+ nKey = rTableEntry.first;
+ pFormat = rTableEntry.second;
+ if (!pUsedList->IsUsed(nKey))
+ {
+ DBG_ASSERT((pFormat->GetType() & SvNumFormatType::DEFINED), "a not user defined numberformat found");
+ sal_uInt32 nRealKey = nKey;
+ if (pFormat->IsSubstituted())
+ {
+ pFormat = pFormatter->GetSubstitutedEntry( nKey, nRealKey); // export the "real" format
+ assert(pFormat);
+ }
+ // user-defined and used formats are exported
+ ExportFormat_Impl( *pFormat, nKey, nRealKey );
+ // if it is a user-defined Format it will be added else nothing will happen
+ pUsedList->SetUsed(nKey);
+ }
+ }
+ }
+ }
+ pUsedList->Export();
+}
+
+OUString SvXMLNumFmtExport::GetStyleName( sal_uInt32 nKey )
+{
+ if(pUsedList->IsUsed(nKey) || pUsedList->IsWasUsed(nKey))
+ return lcl_CreateStyleName( nKey, 0, true, sPrefix );
+ else
+ {
+ OSL_FAIL("There is no written Data-Style");
+ return OUString();
+ }
+}
+
+void SvXMLNumFmtExport::SetUsed( sal_uInt32 nKey )
+{
+ SAL_WARN_IF( pFormatter == nullptr, "xmloff.style", "missing formatter" );
+ if( !pFormatter )
+ return;
+
+ if (pFormatter->GetEntry(nKey))
+ pUsedList->SetUsed( nKey );
+ else {
+ OSL_FAIL("no existing Numberformat found with this key");
+ }
+}
+
+uno::Sequence<sal_Int32> SvXMLNumFmtExport::GetWasUsed() const
+{
+ if (pUsedList)
+ return pUsedList->GetWasUsed();
+ return uno::Sequence<sal_Int32>();
+}
+
+void SvXMLNumFmtExport::SetWasUsed(const uno::Sequence<sal_Int32>& rWasUsed)
+{
+ if (pUsedList)
+ pUsedList->SetWasUsed(rWasUsed);
+}
+
+static const SvNumberformat* lcl_GetFormat( SvNumberFormatter const * pFormatter,
+ sal_uInt32 nKey )
+{
+ return ( pFormatter != nullptr ) ? pFormatter->GetEntry( nKey ) : nullptr;
+}
+
+sal_uInt32 SvXMLNumFmtExport::ForceSystemLanguage( sal_uInt32 nKey )
+{
+ sal_uInt32 nRet = nKey;
+
+ const SvNumberformat* pFormat = lcl_GetFormat( pFormatter, nKey );
+ if( pFormat != nullptr )
+ {
+ SAL_WARN_IF( pFormatter == nullptr, "xmloff.style", "format without formatter?" );
+
+ SvNumFormatType nType = pFormat->GetType();
+
+ sal_uInt32 nNewKey = pFormatter->GetFormatForLanguageIfBuiltIn(
+ nKey, LANGUAGE_SYSTEM );
+
+ if( nNewKey != nKey )
+ {
+ nRet = nNewKey;
+ }
+ else
+ {
+ OUString aFormatString( pFormat->GetFormatstring() );
+ sal_Int32 nErrorPos;
+ pFormatter->PutandConvertEntry(
+ aFormatString,
+ nErrorPos, nType, nNewKey,
+ pFormat->GetLanguage(), LANGUAGE_SYSTEM, true);
+
+ // success? Then use new key.
+ if( nErrorPos == 0 )
+ nRet = nNewKey;
+ }
+ }
+
+ return nRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/xmlnumfi.cxx b/xmloff/source/style/xmlnumfi.cxx
new file mode 100644
index 000000000..b046e5f59
--- /dev/null
+++ b/xmloff/source/style/xmlnumfi.cxx
@@ -0,0 +1,2231 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svl/zforlist.hxx>
+#include <svl/numformat.hxx>
+#include <svl/zformat.hxx>
+#include <svl/numuno.hxx>
+#include <i18nlangtag/languagetag.hxx>
+#include <tools/color.hxx>
+#include <osl/diagnose.h>
+#include <rtl/math.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <sal/log.hxx>
+
+#include <sax/tools/converter.hxx>
+
+#include <xmloff/xmlement.hxx>
+#include <xmloff/xmlnumfi.hxx>
+#include <xmloff/xmltkmap.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmlictxt.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/families.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/languagetagodf.hxx>
+
+#include <memory>
+#include <string_view>
+#include <vector>
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+namespace {
+
+struct SvXMLNumFmtEntry
+{
+ OUString aName;
+ sal_uInt32 nKey;
+ bool bRemoveAfterUse;
+
+ SvXMLNumFmtEntry( const OUString& rN, sal_uInt32 nK, bool bR ) :
+ aName(rN), nKey(nK), bRemoveAfterUse(bR) {}
+};
+
+}
+
+class SvXMLNumImpData
+{
+ SvNumberFormatter* pFormatter;
+ std::unique_ptr<LocaleDataWrapper> pLocaleData;
+ std::vector<SvXMLNumFmtEntry> m_NameEntries;
+
+ uno::Reference< uno::XComponentContext > m_xContext;
+
+public:
+ SvXMLNumImpData(
+ SvNumberFormatter* pFmt,
+ const uno::Reference<uno::XComponentContext>& rxContext );
+
+ SvNumberFormatter* GetNumberFormatter() const { return pFormatter; }
+ const LocaleDataWrapper& GetLocaleData( LanguageType nLang );
+ sal_uInt32 GetKeyForName( std::u16string_view rName );
+ void AddKey( sal_uInt32 nKey, const OUString& rName, bool bRemoveAfterUse );
+ void SetUsed( sal_uInt32 nKey );
+ void RemoveVolatileFormats();
+};
+
+struct SvXMLNumberInfo
+{
+ sal_Int32 nDecimals = -1;
+ sal_Int32 nInteger = -1;
+ sal_Int32 nExpDigits = -1;
+ sal_Int32 nExpInterval = -1;
+ sal_Int32 nMinNumerDigits = -1;
+ sal_Int32 nMinDenomDigits = -1;
+ sal_Int32 nMaxNumerDigits = -1;
+ sal_Int32 nMaxDenomDigits = -1;
+ sal_Int32 nFracDenominator = -1;
+ sal_Int32 nMinDecimalDigits = -1;
+ sal_Int32 nZerosNumerDigits = -1;
+ sal_Int32 nZerosDenomDigits = -1;
+ bool bGrouping = false;
+ bool bDecReplace = false;
+ bool bExpSign = true;
+ bool bDecAlign = false;
+ double fDisplayFactor = 1.0;
+ OUString aIntegerFractionDelimiter;
+ std::map<sal_Int32, OUString> m_EmbeddedElements;
+};
+
+namespace {
+
+enum class SvXMLStyleTokens;
+
+class SvXMLNumFmtElementContext : public SvXMLImportContext
+{
+ SvXMLNumFormatContext& rParent;
+ SvXMLStyleTokens nType;
+ OUStringBuffer aContent;
+ SvXMLNumberInfo aNumInfo;
+ LanguageType nElementLang;
+ bool bLong;
+ bool bTextual;
+ OUString sCalendar;
+
+public:
+ SvXMLNumFmtElementContext( SvXMLImport& rImport, sal_Int32 nElement,
+ SvXMLNumFormatContext& rParentContext, SvXMLStyleTokens nNewType,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList );
+
+ virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+ sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& AttrList ) override;
+ virtual void SAL_CALL characters( const OUString& rChars ) override;
+ virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+
+ void AddEmbeddedElement( sal_Int32 nFormatPos, const OUString& rContent );
+};
+
+class SvXMLNumFmtEmbeddedTextContext : public SvXMLImportContext
+{
+ SvXMLNumFmtElementContext& rParent;
+ OUStringBuffer aContent;
+ sal_Int32 nTextPosition;
+
+public:
+ SvXMLNumFmtEmbeddedTextContext( SvXMLImport& rImport, sal_Int32 nElement,
+ SvXMLNumFmtElementContext& rParentContext,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList );
+
+ virtual void SAL_CALL characters( const OUString& rChars ) override;
+ virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+
+class SvXMLNumFmtMapContext : public SvXMLImportContext
+{
+ SvXMLNumFormatContext& rParent;
+ OUString sCondition;
+ OUString sName;
+
+public:
+ SvXMLNumFmtMapContext( SvXMLImport& rImport, sal_Int32 nElement,
+ SvXMLNumFormatContext& rParentContext,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList );
+
+ virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+
+class SvXMLNumFmtPropContext : public SvXMLImportContext
+{
+ SvXMLNumFormatContext& rParent;
+ Color m_nColor;
+ bool bColSet;
+
+public:
+ SvXMLNumFmtPropContext( SvXMLImport& rImport, sal_Int32 nElement,
+ SvXMLNumFormatContext& rParentContext,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList );
+
+ virtual void SAL_CALL endFastElement(sal_Int32 nElement) override;
+};
+
+enum class SvXMLStyleTokens
+{
+ Text,
+ FillCharacter,
+ Number,
+ ScientificNumber,
+ Fraction,
+ CurrencySymbol,
+ Day,
+ Month,
+ Year,
+ Era,
+ DayOfWeek,
+ WeekOfYear,
+ Quarter,
+ Hours,
+ AmPm,
+ Minutes,
+ Seconds,
+ Boolean,
+ TextContent
+};
+
+}
+
+// standard colors
+
+
+#define XML_NUMF_COLORCOUNT 10
+
+const Color aNumFmtStdColors[XML_NUMF_COLORCOUNT] =
+{
+ COL_BLACK,
+ COL_LIGHTBLUE,
+ COL_LIGHTGREEN,
+ COL_LIGHTCYAN,
+ COL_LIGHTRED,
+ COL_LIGHTMAGENTA,
+ COL_BROWN,
+ COL_GRAY,
+ COL_YELLOW,
+ COL_WHITE
+};
+
+
+// token maps
+
+
+// maps for SvXMLUnitConverter::convertEnum
+
+const SvXMLEnumMapEntry<bool> aStyleValueMap[] =
+{
+ { XML_SHORT, false },
+ { XML_LONG, true },
+ { XML_TOKEN_INVALID, false }
+};
+
+const SvXMLEnumMapEntry<bool> aFormatSourceMap[] =
+{
+ { XML_FIXED, false },
+ { XML_LANGUAGE, true },
+ { XML_TOKEN_INVALID, false }
+};
+
+namespace {
+
+struct SvXMLDefaultDateFormat
+{
+ NfIndexTableOffset eFormat;
+ SvXMLDateElementAttributes eDOW;
+ SvXMLDateElementAttributes eDay;
+ SvXMLDateElementAttributes eMonth;
+ SvXMLDateElementAttributes eYear;
+ SvXMLDateElementAttributes eHours;
+ SvXMLDateElementAttributes eMins;
+ SvXMLDateElementAttributes eSecs;
+ bool bSystem;
+};
+
+}
+
+const SvXMLDefaultDateFormat aDefaultDateFormats[] =
+{
+ // format day-of-week day month year hours minutes seconds format-source
+
+ { NF_DATE_SYSTEM_SHORT, XML_DEA_NONE, XML_DEA_ANY, XML_DEA_ANY, XML_DEA_ANY, XML_DEA_NONE, XML_DEA_NONE, XML_DEA_NONE, true },
+ { NF_DATE_SYSTEM_LONG, XML_DEA_ANY, XML_DEA_ANY, XML_DEA_ANY, XML_DEA_ANY, XML_DEA_NONE, XML_DEA_NONE, XML_DEA_NONE, true },
+ { NF_DATE_SYS_MMYY, XML_DEA_NONE, XML_DEA_NONE, XML_DEA_LONG, XML_DEA_SHORT, XML_DEA_NONE, XML_DEA_NONE, XML_DEA_NONE, false },
+ { NF_DATE_SYS_DDMMM, XML_DEA_NONE, XML_DEA_LONG, XML_DEA_TEXTSHORT, XML_DEA_NONE, XML_DEA_NONE, XML_DEA_NONE, XML_DEA_NONE, false },
+ { NF_DATE_SYS_DDMMYYYY, XML_DEA_NONE, XML_DEA_LONG, XML_DEA_LONG, XML_DEA_LONG, XML_DEA_NONE, XML_DEA_NONE, XML_DEA_NONE, false },
+ { NF_DATE_SYS_DDMMYY, XML_DEA_NONE, XML_DEA_LONG, XML_DEA_LONG, XML_DEA_SHORT, XML_DEA_NONE, XML_DEA_NONE, XML_DEA_NONE, false },
+ { NF_DATE_SYS_DMMMYY, XML_DEA_NONE, XML_DEA_SHORT, XML_DEA_TEXTSHORT, XML_DEA_SHORT, XML_DEA_NONE, XML_DEA_NONE, XML_DEA_NONE, false },
+ { NF_DATE_SYS_DMMMYYYY, XML_DEA_NONE, XML_DEA_SHORT, XML_DEA_TEXTSHORT, XML_DEA_LONG, XML_DEA_NONE, XML_DEA_NONE, XML_DEA_NONE, false },
+ { NF_DATE_SYS_DMMMMYYYY, XML_DEA_NONE, XML_DEA_SHORT, XML_DEA_TEXTLONG, XML_DEA_LONG, XML_DEA_NONE, XML_DEA_NONE, XML_DEA_NONE, false },
+ { NF_DATE_SYS_NNDMMMYY, XML_DEA_SHORT, XML_DEA_SHORT, XML_DEA_TEXTSHORT, XML_DEA_SHORT, XML_DEA_NONE, XML_DEA_NONE, XML_DEA_NONE, false },
+ { NF_DATE_SYS_NNDMMMMYYYY, XML_DEA_SHORT, XML_DEA_SHORT, XML_DEA_TEXTLONG, XML_DEA_LONG, XML_DEA_NONE, XML_DEA_NONE, XML_DEA_NONE, false },
+ { NF_DATE_SYS_NNNNDMMMMYYYY, XML_DEA_LONG, XML_DEA_SHORT, XML_DEA_TEXTLONG, XML_DEA_LONG, XML_DEA_NONE, XML_DEA_NONE, XML_DEA_NONE, false },
+ { NF_DATETIME_SYS_DDMMYYYY_HHMM, XML_DEA_NONE, XML_DEA_ANY, XML_DEA_ANY, XML_DEA_LONG, XML_DEA_ANY, XML_DEA_ANY, XML_DEA_NONE, false },
+ { NF_DATETIME_SYSTEM_SHORT_HHMM, XML_DEA_NONE, XML_DEA_ANY, XML_DEA_ANY, XML_DEA_ANY, XML_DEA_ANY, XML_DEA_ANY, XML_DEA_NONE, true },
+ { NF_DATETIME_SYS_DDMMYYYY_HHMMSS, XML_DEA_NONE, XML_DEA_ANY, XML_DEA_ANY, XML_DEA_ANY, XML_DEA_ANY, XML_DEA_ANY, XML_DEA_ANY, false }
+};
+
+
+// SvXMLNumImpData
+
+
+SvXMLNumImpData::SvXMLNumImpData(
+ SvNumberFormatter* pFmt,
+ const uno::Reference<uno::XComponentContext>& rxContext )
+: pFormatter(pFmt),
+ m_xContext(rxContext)
+{
+ SAL_WARN_IF( !rxContext.is(), "xmloff", "got no service manager" );
+}
+
+sal_uInt32 SvXMLNumImpData::GetKeyForName( std::u16string_view rName )
+{
+ for (const auto& rObj : m_NameEntries)
+ {
+ if (rObj.aName == rName)
+ return rObj.nKey; // found
+ }
+ return NUMBERFORMAT_ENTRY_NOT_FOUND;
+}
+
+void SvXMLNumImpData::AddKey( sal_uInt32 nKey, const OUString& rName, bool bRemoveAfterUse )
+{
+ if ( bRemoveAfterUse )
+ {
+ // if there is already an entry for this key without the bRemoveAfterUse flag,
+ // clear the flag for this entry, too
+
+ for (const auto& rObj : m_NameEntries)
+ {
+ if (rObj.nKey == nKey && !rObj.bRemoveAfterUse)
+ {
+ bRemoveAfterUse = false; // clear flag for new entry
+ break;
+ }
+ }
+ }
+ else
+ {
+ // call SetUsed to clear the bRemoveAfterUse flag for other entries for this key
+ SetUsed( nKey );
+ }
+
+ m_NameEntries.emplace_back(rName, nKey, bRemoveAfterUse);
+}
+
+void SvXMLNumImpData::SetUsed( sal_uInt32 nKey )
+{
+ for (auto& rObj : m_NameEntries)
+ {
+ if (rObj.nKey == nKey)
+ {
+ rObj.bRemoveAfterUse = false; // used -> don't remove
+
+ // continue searching - there may be several entries for the same key
+ // (with different names), the format must not be deleted if any one of
+ // them is used
+ }
+ }
+}
+
+void SvXMLNumImpData::RemoveVolatileFormats()
+{
+ // remove temporary (volatile) formats from NumberFormatter
+ // called at the end of each import (styles and content), so volatile formats
+ // from styles can't be used in content
+
+ if ( !pFormatter )
+ return;
+
+ for (const auto& rObj : m_NameEntries)
+ {
+ if (rObj.bRemoveAfterUse )
+ {
+ const SvNumberformat* pFormat = pFormatter->GetEntry(rObj.nKey);
+ if (pFormat && (pFormat->GetType() & SvNumFormatType::DEFINED))
+ pFormatter->DeleteEntry(rObj.nKey);
+ }
+ }
+}
+
+const LocaleDataWrapper& SvXMLNumImpData::GetLocaleData( LanguageType nLang )
+{
+ if ( !pLocaleData || pLocaleData->getLanguageTag() != LanguageTag(nLang) )
+ pLocaleData = std::make_unique<LocaleDataWrapper>(
+ pFormatter ? pFormatter->GetComponentContext() : m_xContext,
+ LanguageTag( nLang ) );
+ return *pLocaleData;
+}
+
+
+// SvXMLNumFmtMapContext
+
+
+SvXMLNumFmtMapContext::SvXMLNumFmtMapContext( SvXMLImport& rImport,
+ sal_Int32 /*nElement*/,
+ SvXMLNumFormatContext& rParentContext,
+ const uno::Reference<xml::sax::XFastAttributeList>& xAttrList ) :
+ SvXMLImportContext( rImport ),
+ rParent( rParentContext )
+{
+ for( auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ) )
+ {
+ OUString sValue = aIter.toString();
+ switch(aIter.getToken())
+ {
+ case XML_ELEMENT(STYLE, XML_CONDITION):
+ sCondition = sValue;
+ break;
+ case XML_ELEMENT(STYLE, XML_APPLY_STYLE_NAME):
+ sName = sValue;
+ break;
+ default:
+ XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+ }
+ }
+}
+
+void SvXMLNumFmtMapContext::endFastElement(sal_Int32 )
+{
+ rParent.AddCondition( sCondition, sName );
+}
+
+
+// SvXMLNumFmtPropContext
+
+
+SvXMLNumFmtPropContext::SvXMLNumFmtPropContext( SvXMLImport& rImport,
+ sal_Int32 /*nElement*/,
+ SvXMLNumFormatContext& rParentContext,
+ const uno::Reference<xml::sax::XFastAttributeList>& xAttrList ) :
+ SvXMLImportContext( rImport ),
+ rParent( rParentContext ),
+ m_nColor( 0 ),
+ bColSet( false )
+{
+ for( auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ) )
+ {
+ switch ( aIter.getToken())
+ {
+ case XML_ELEMENT(FO, XML_COLOR):
+ case XML_ELEMENT(FO_COMPAT, XML_COLOR):
+ bColSet = ::sax::Converter::convertColor( m_nColor, aIter.toView() );
+ break;
+ default:
+ XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+ }
+ }
+}
+
+void SvXMLNumFmtPropContext::endFastElement(sal_Int32 )
+{
+ if (bColSet)
+ rParent.AddColor( m_nColor );
+}
+
+
+// SvXMLNumFmtEmbeddedTextContext
+
+
+SvXMLNumFmtEmbeddedTextContext::SvXMLNumFmtEmbeddedTextContext( SvXMLImport& rImport,
+ sal_Int32 /*nElement*/,
+ SvXMLNumFmtElementContext& rParentContext,
+ const uno::Reference<xml::sax::XFastAttributeList>& xAttrList ) :
+ SvXMLImportContext( rImport ),
+ rParent( rParentContext ),
+ nTextPosition( 0 )
+{
+ sal_Int32 nAttrVal;
+
+ for( auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ) )
+ {
+ if ( aIter.getToken() == XML_ELEMENT(NUMBER, XML_POSITION) )
+ {
+ if (::sax::Converter::convertNumber( nAttrVal, aIter.toView() ))
+ nTextPosition = nAttrVal;
+ }
+ else
+ XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+ }
+}
+
+void SvXMLNumFmtEmbeddedTextContext::characters( const OUString& rChars )
+{
+ aContent.append( rChars );
+}
+
+void SvXMLNumFmtEmbeddedTextContext::endFastElement(sal_Int32 )
+{
+ rParent.AddEmbeddedElement( nTextPosition, aContent.makeStringAndClear() );
+}
+
+static bool lcl_ValidChar( sal_Unicode cChar, const SvXMLNumFormatContext& rParent )
+{
+ SvXMLStylesTokens nFormatType = rParent.GetType();
+
+ // Treat space equal to non-breaking space separator.
+ const sal_Unicode cNBSP = 0x00A0;
+ sal_Unicode cTS;
+ if ( ( nFormatType == SvXMLStylesTokens::NUMBER_STYLE ||
+ nFormatType == SvXMLStylesTokens::CURRENCY_STYLE ||
+ nFormatType == SvXMLStylesTokens::PERCENTAGE_STYLE ) &&
+ (cChar == (cTS = rParent.GetLocaleData().getNumThousandSep()[0]) ||
+ (cChar == ' ' && cTS == cNBSP)) )
+ {
+ // #i22394# Extra occurrences of thousands separator must be quoted, so they
+ // aren't mis-interpreted as display-factor.
+ // This must be limited to the format types that can contain a number element,
+ // because the same character can be a date separator that should not be quoted
+ // in date formats.
+
+ return false; // force quotes
+ }
+
+ // see ImpSvNumberformatScan::Next_Symbol
+
+ // All format types except BOOLEAN may contain minus sign or delimiter.
+ if ( cChar == '-' )
+ return nFormatType != SvXMLStylesTokens::BOOLEAN_STYLE;
+
+ if ( ( cChar == ' ' ||
+ cChar == '/' ||
+ cChar == '.' ||
+ cChar == ',' ||
+ cChar == ':' ||
+ cChar == '\'' ) &&
+ ( nFormatType == SvXMLStylesTokens::CURRENCY_STYLE ||
+ nFormatType == SvXMLStylesTokens::DATE_STYLE ||
+ nFormatType == SvXMLStylesTokens::TIME_STYLE ) ) // other formats do not require delimiter tdf#97837
+ return true;
+
+ // percent sign must be used without quotes for percentage styles only
+ if ( nFormatType == SvXMLStylesTokens::PERCENTAGE_STYLE && cChar == '%' )
+ return true;
+
+ // don't put quotes around single parentheses (often used for negative numbers)
+ if ( ( nFormatType == SvXMLStylesTokens::NUMBER_STYLE ||
+ nFormatType == SvXMLStylesTokens::CURRENCY_STYLE ||
+ nFormatType == SvXMLStylesTokens::PERCENTAGE_STYLE ) &&
+ ( cChar == '(' || cChar == ')' ) )
+ return true;
+
+ return false;
+}
+
+static void lcl_EnquoteIfNecessary( OUStringBuffer& rContent, const SvXMLNumFormatContext& rParent )
+{
+ bool bQuote = true;
+ sal_Int32 nLength = rContent.getLength();
+ const SvXMLStylesTokens nFormatType = rParent.GetType();
+
+ if (nFormatType != SvXMLStylesTokens::BOOLEAN_STYLE &&
+ ((nLength == 1 && lcl_ValidChar( rContent[0], rParent)) ||
+ (nLength == 2 &&
+ ((rContent[0] == ' ' && rContent[1] == '-') ||
+ (rContent[1] == ' ' && lcl_ValidChar( rContent[0], rParent))))))
+ {
+ // Don't quote single separator characters like space or percent,
+ // or separator characters followed by space (used in date formats).
+ // Or space followed by minus (used in currency formats) that would
+ // lead to almost duplicated formats with built-in formats just with
+ // the difference of quotes.
+ bQuote = false;
+ }
+ else if ( nFormatType == SvXMLStylesTokens::PERCENTAGE_STYLE && nLength > 1 )
+ {
+ // the percent character in percentage styles must be left out of quoting
+ // (one occurrence is enough even if there are several percent characters in the string)
+
+ sal_Int32 nPos = rContent.indexOf( '%' );
+ if ( nPos >= 0 )
+ {
+ if ( nPos + 1 < nLength )
+ {
+ if ( nPos + 2 == nLength && lcl_ValidChar( rContent[nPos + 1], rParent ) )
+ {
+ // single character that doesn't need quoting
+ }
+ else
+ {
+ // quote text behind percent character
+ rContent.insert( nPos + 1, '"' );
+ rContent.append( '"' );
+ }
+ }
+ if ( nPos > 0 )
+ {
+ if ( nPos == 1 && lcl_ValidChar( rContent[0], rParent ) )
+ {
+ // single character that doesn't need quoting
+ }
+ else
+ {
+ // quote text before percent character
+ rContent.insert( nPos, '"' );
+ rContent.insert( 0, '"' );
+ }
+ }
+ bQuote = false;
+ }
+ // else: normal quoting (below)
+ }
+
+ if ( !bQuote )
+ return;
+
+ // #i55469# quotes in the string itself have to be escaped
+ bool bEscape = ( rContent.indexOf( '"' ) >= 0 );
+ if ( bEscape )
+ {
+ // A quote is turned into "\"" - a quote to end quoted text, an escaped quote,
+ // and a quote to resume quoting.
+ OUString aInsert( "\"\\\"" );
+
+ sal_Int32 nPos = 0;
+ while ( nPos < rContent.getLength() )
+ {
+ if ( rContent[nPos] == '"' )
+ {
+ rContent.insert( nPos, aInsert );
+ nPos += aInsert.getLength();
+ }
+ ++nPos;
+ }
+ }
+
+ // quote string literals
+ rContent.insert( 0, '"' );
+ rContent.append( '"' );
+
+ // remove redundant double quotes at start or end
+ if ( !bEscape )
+ return;
+
+ if ( rContent.getLength() > 2 &&
+ rContent[0] == '"' &&
+ rContent[1] == '"' )
+ {
+ rContent.remove(0, 2);
+ }
+
+ sal_Int32 nLen = rContent.getLength();
+ if ( nLen > 2 &&
+ rContent[nLen - 1] == '"' &&
+ rContent[nLen - 2] == '"' )
+ {
+ rContent.truncate(nLen - 2);
+ }
+}
+
+
+// SvXMLNumFmtElementContext
+
+
+SvXMLNumFmtElementContext::SvXMLNumFmtElementContext( SvXMLImport& rImport,
+ sal_Int32 /*nElement*/,
+ SvXMLNumFormatContext& rParentContext, SvXMLStyleTokens nNewType,
+ const uno::Reference<xml::sax::XFastAttributeList>& xAttrList ) :
+ SvXMLImportContext( rImport ),
+ rParent( rParentContext ),
+ nType( nNewType ),
+ nElementLang( LANGUAGE_SYSTEM ),
+ bLong( false ),
+ bTextual( false )
+{
+ LanguageTagODF aLanguageTagODF;
+ sal_Int32 nAttrVal;
+ bool bAttrBool(false);
+ bool bVarDecimals = false;
+ bool bIsMaxDenominator = false;
+ double fAttrDouble;
+
+ for( auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ) )
+ {
+ switch (aIter.getToken())
+ {
+ case XML_ELEMENT(NUMBER, XML_DECIMAL_PLACES):
+ if (::sax::Converter::convertNumber( nAttrVal, aIter.toView(), 0 ))
+ {
+ // fdo#58539 & gnome#627420: limit number of digits during import
+ aNumInfo.nDecimals = std::min<sal_Int32>(nAttrVal, NF_MAX_FORMAT_SYMBOLS);
+ }
+ break;
+ case XML_ELEMENT(LO_EXT, XML_MIN_DECIMAL_PLACES):
+ case XML_ELEMENT(NUMBER, XML_MIN_DECIMAL_PLACES):
+ if (::sax::Converter::convertNumber( nAttrVal, aIter.toView(), 0 ))
+ aNumInfo.nMinDecimalDigits = nAttrVal;
+ break;
+ case XML_ELEMENT(NUMBER, XML_MIN_INTEGER_DIGITS):
+ if (::sax::Converter::convertNumber( nAttrVal, aIter.toView(), 0 ))
+ aNumInfo.nInteger = nAttrVal;
+ break;
+ case XML_ELEMENT(NUMBER, XML_GROUPING):
+ if (::sax::Converter::convertBool( bAttrBool, aIter.toView() ))
+ aNumInfo.bGrouping = bAttrBool;
+ break;
+ case XML_ELEMENT(NUMBER, XML_DISPLAY_FACTOR):
+ if (::sax::Converter::convertDouble( fAttrDouble, aIter.toView() ))
+ aNumInfo.fDisplayFactor = fAttrDouble;
+ break;
+ case XML_ELEMENT(NUMBER, XML_DECIMAL_REPLACEMENT):
+ if ( aIter.toView() == " " )
+ {
+ aNumInfo.bDecAlign = true; // space replacement for "?"
+ bVarDecimals = true;
+ }
+ else
+ if ( aIter.isEmpty() )
+ bVarDecimals = true; // empty replacement string: variable decimals
+ else // all other strings
+ aNumInfo.bDecReplace = true; // decimal replacement with dashes
+ break;
+ case XML_ELEMENT(NUMBER, XML_MIN_EXPONENT_DIGITS):
+ if (::sax::Converter::convertNumber( nAttrVal, aIter.toView(), 0 ))
+ aNumInfo.nExpDigits = std::min<sal_Int32>(nAttrVal, NF_MAX_FORMAT_SYMBOLS);
+ break;
+ case XML_ELEMENT(NUMBER, XML_EXPONENT_INTERVAL):
+ case XML_ELEMENT(LO_EXT, XML_EXPONENT_INTERVAL):
+ if (::sax::Converter::convertNumber( nAttrVal, aIter.toView(), 0 ))
+ aNumInfo.nExpInterval = nAttrVal;
+ break;
+ case XML_ELEMENT(NUMBER, XML_FORCED_EXPONENT_SIGN):
+ case XML_ELEMENT(LO_EXT, XML_FORCED_EXPONENT_SIGN):
+ if (::sax::Converter::convertBool( bAttrBool, aIter.toView() ))
+ aNumInfo.bExpSign = bAttrBool;
+ break;
+ case XML_ELEMENT(NUMBER, XML_MIN_NUMERATOR_DIGITS):
+ if (::sax::Converter::convertNumber( nAttrVal, aIter.toView(), 0 ))
+ aNumInfo.nMinNumerDigits = nAttrVal;
+ break;
+ case XML_ELEMENT(NUMBER, XML_MIN_DENOMINATOR_DIGITS):
+ if (::sax::Converter::convertNumber( nAttrVal, aIter.toView(), 0 ))
+ aNumInfo.nMinDenomDigits = nAttrVal;
+ break;
+ case XML_ELEMENT(LO_EXT, XML_MAX_NUMERATOR_DIGITS):
+ if (::sax::Converter::convertNumber( nAttrVal, aIter.toView(), 1 )) // at least one '#'
+ aNumInfo.nMaxNumerDigits = nAttrVal;
+ break;
+ case XML_ELEMENT(NUMBER, XML_DENOMINATOR_VALUE):
+ if (::sax::Converter::convertNumber( nAttrVal, aIter.toView(), 1 )) // 0 is not valid
+ {
+ aNumInfo.nFracDenominator = nAttrVal;
+ bIsMaxDenominator = false;
+ }
+ break;
+ case XML_ELEMENT(NUMBER, XML_MAX_DENOMINATOR_VALUE): // part of ODF 1.3
+ case XML_ELEMENT(LO_EXT, XML_MAX_DENOMINATOR_VALUE):
+ if (::sax::Converter::convertNumber( nAttrVal, aIter.toView(), 1 ) && aNumInfo.nFracDenominator <= 0)
+ { // if denominator value not yet defined
+ aNumInfo.nFracDenominator = nAttrVal;
+ bIsMaxDenominator = true;
+ }
+ break;
+ case XML_ELEMENT(LO_EXT, XML_ZEROS_NUMERATOR_DIGITS):
+ case XML_ELEMENT(NUMBER, XML_ZEROS_NUMERATOR_DIGITS):
+ if (::sax::Converter::convertNumber( nAttrVal, aIter.toView(), 0 ))
+ aNumInfo.nZerosNumerDigits = nAttrVal;
+ break;
+ case XML_ELEMENT(NUMBER, XML_ZEROS_DENOMINATOR_DIGITS):
+ case XML_ELEMENT(LO_EXT, XML_ZEROS_DENOMINATOR_DIGITS):
+ if (::sax::Converter::convertNumber( nAttrVal, aIter.toView(), 0 ))
+ aNumInfo.nZerosDenomDigits = nAttrVal;
+ break;
+ case XML_ELEMENT(NUMBER, XML_INTEGER_FRACTION_DELIMITER):
+ case XML_ELEMENT(LO_EXT, XML_INTEGER_FRACTION_DELIMITER):
+ aNumInfo.aIntegerFractionDelimiter = aIter.toString();
+ break;
+ case XML_ELEMENT(NUMBER, XML_RFC_LANGUAGE_TAG):
+ aLanguageTagODF.maRfcLanguageTag = aIter.toString();
+ break;
+ case XML_ELEMENT(NUMBER, XML_LANGUAGE):
+ aLanguageTagODF.maLanguage = aIter.toString();
+ break;
+ case XML_ELEMENT(NUMBER, XML_SCRIPT):
+ aLanguageTagODF.maScript = aIter.toString();
+ break;
+ case XML_ELEMENT(NUMBER, XML_COUNTRY):
+ aLanguageTagODF.maCountry = aIter.toString();
+ break;
+ case XML_ELEMENT(NUMBER, XML_STYLE):
+ SvXMLUnitConverter::convertEnum( bLong, aIter.toView(), aStyleValueMap );
+ break;
+ case XML_ELEMENT(NUMBER, XML_TEXTUAL):
+ if (::sax::Converter::convertBool( bAttrBool, aIter.toView() ))
+ bTextual = bAttrBool;
+ break;
+ case XML_ELEMENT(NUMBER, XML_CALENDAR):
+ sCalendar = aIter.toString();
+ break;
+ default:
+ XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+ }
+ }
+ if ( aNumInfo.nMinDecimalDigits == -1)
+ {
+ if ( bVarDecimals || aNumInfo.bDecReplace )
+ aNumInfo.nMinDecimalDigits = 0;
+ else
+ aNumInfo.nMinDecimalDigits = aNumInfo.nDecimals;
+ }
+ if ( aNumInfo.nZerosDenomDigits > 0 )
+ { // nMin = count of '0' and '?'
+ if ( aNumInfo.nMinDenomDigits < aNumInfo.nZerosDenomDigits )
+ aNumInfo.nMinDenomDigits = aNumInfo.nZerosDenomDigits;
+ }
+ else
+ aNumInfo.nZerosDenomDigits = 0;
+ if ( aNumInfo.nMinDenomDigits >= 0 )
+ if ( aNumInfo.nMaxDenomDigits < aNumInfo.nMinDenomDigits )
+ aNumInfo.nMaxDenomDigits = ( aNumInfo.nMinDenomDigits ? aNumInfo.nMinDenomDigits : 1 );
+ if ( aNumInfo.nZerosNumerDigits > 0 )
+ {
+ if ( aNumInfo.nMinNumerDigits < aNumInfo.nZerosNumerDigits )
+ aNumInfo.nMinNumerDigits = aNumInfo.nZerosNumerDigits;
+ }
+ else
+ aNumInfo.nZerosNumerDigits = 0;
+ if ( aNumInfo.nMinNumerDigits >= 0 )
+ if ( aNumInfo.nMaxNumerDigits < aNumInfo.nMinNumerDigits )
+ aNumInfo.nMaxNumerDigits = ( aNumInfo.nMinNumerDigits ? aNumInfo.nMinNumerDigits : 1 );
+ if ( bIsMaxDenominator && aNumInfo.nFracDenominator > 0 )
+ {
+ aNumInfo.nMaxDenomDigits = floor( log10( aNumInfo.nFracDenominator ) ) + 1;
+ aNumInfo.nFracDenominator = -1; // Max denominator value only gives number of digits at denominator
+ }
+ if ( aNumInfo.nMaxDenomDigits > 0 )
+ {
+ if ( aNumInfo.nMinDenomDigits < 0 )
+ aNumInfo.nMinDenomDigits = 0;
+ else if ( aNumInfo.nMinDenomDigits > aNumInfo.nMaxDenomDigits )
+ aNumInfo.nMinDenomDigits = aNumInfo.nMaxDenomDigits;
+ }
+
+ if ( !aLanguageTagODF.isEmpty() )
+ {
+ nElementLang = aLanguageTagODF.getLanguageTag().getLanguageType( false);
+ if ( nElementLang == LANGUAGE_DONTKNOW )
+ nElementLang = LANGUAGE_SYSTEM; //! error handling for unknown locales?
+ }
+
+ if ( aNumInfo.aIntegerFractionDelimiter.isEmpty() )
+ aNumInfo.aIntegerFractionDelimiter = " ";
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SvXMLNumFmtElementContext::createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+ // only number:number supports number:embedded-text child element
+
+ if ( nType == SvXMLStyleTokens::Number &&
+ nElement == XML_ELEMENT(NUMBER, XML_EMBEDDED_TEXT) )
+ {
+ return new SvXMLNumFmtEmbeddedTextContext( GetImport(), nElement, *this, xAttrList );
+ }
+ else
+ XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+ return nullptr;
+}
+
+void SvXMLNumFmtElementContext::characters( const OUString& rChars )
+{
+ aContent.append( rChars );
+}
+
+void SvXMLNumFmtElementContext::AddEmbeddedElement( sal_Int32 nFormatPos, const OUString& rContent )
+{
+ if (rContent.isEmpty())
+ return;
+
+ auto iterPair = aNumInfo.m_EmbeddedElements.emplace(nFormatPos, rContent);
+ if (!iterPair.second)
+ // there's already an element at this position - append text to existing element
+ iterPair.first->second += rContent;
+}
+
+void SvXMLNumFmtElementContext::endFastElement(sal_Int32 )
+{
+ bool bEffLong = bLong;
+ switch (nType)
+ {
+ case SvXMLStyleTokens::Text:
+ if ( rParent.HasLongDoW() &&
+ std::u16string_view(aContent) == rParent.GetLocaleData().getLongDateDayOfWeekSep() )
+ {
+ // skip separator constant after long day of week
+ // (NF_KEY_NNNN contains the separator)
+
+ if ( rParent.ReplaceNfKeyword( NF_KEY_NNN, NF_KEY_NNNN ) )
+ {
+ aContent.truncate();
+ }
+
+ rParent.SetHasLongDoW( false ); // only once
+ }
+ if ( !aContent.isEmpty() )
+ {
+ lcl_EnquoteIfNecessary( aContent, rParent );
+ rParent.AddToCode( aContent );
+ aContent.setLength(0);
+ }
+ else
+ {
+ // Quoted empty text may be significant to separate.
+ aContent.append("\"\"");
+ rParent.AddToCode( aContent );
+ aContent.setLength(0);
+ rParent.SetHasTrailingEmptyText(true); // *after* AddToCode()
+ }
+ break;
+
+ case SvXMLStyleTokens::Number:
+ rParent.AddNumber( aNumInfo );
+ break;
+
+ case SvXMLStyleTokens::CurrencySymbol:
+ rParent.AddCurrency( aContent.makeStringAndClear(), nElementLang );
+ break;
+
+ case SvXMLStyleTokens::TextContent:
+ rParent.AddToCode( '@');
+ break;
+ case SvXMLStyleTokens::FillCharacter:
+ if ( !aContent.isEmpty() )
+ {
+ rParent.AddToCode( '*' );
+ rParent.AddToCode( aContent[0] );
+ }
+ break;
+ case SvXMLStyleTokens::Boolean:
+ rParent.AddNfKeyword( NF_KEY_BOOLEAN );
+ break;
+
+ case SvXMLStyleTokens::Day:
+ rParent.UpdateCalendar( sCalendar );
+//! I18N doesn't provide SYSTEM or extended date information yet
+
+ rParent.AddNfKeyword(
+ sal::static_int_cast< sal_uInt16 >(
+ bEffLong ? NF_KEY_DD : NF_KEY_D ) );
+ break;
+ case SvXMLStyleTokens::Month:
+ rParent.UpdateCalendar( sCalendar );
+//! I18N doesn't provide SYSTEM or extended date information yet
+
+ rParent.AddNfKeyword(
+ sal::static_int_cast< sal_uInt16 >(
+ bTextual
+ ? ( bEffLong ? NF_KEY_MMMM : NF_KEY_MMM )
+ : ( bEffLong ? NF_KEY_MM : NF_KEY_M ) ) );
+ break;
+ case SvXMLStyleTokens::Year:
+//! I18N doesn't provide SYSTEM or extended date information yet
+ {
+ // Y after G (era) is replaced by E for a secondary calendar.
+ // Do not replace for default calendar.
+ // Also replace Y by E if we're switching to the secondary
+ // calendar of a locale if it is known to implicitly use E.
+ rParent.UpdateCalendar( sCalendar);
+ const SvXMLNumFormatContext::ImplicitCalendar eCal = rParent.GetImplicitCalendarState();
+ if (eCal == SvXMLNumFormatContext::ImplicitCalendar::SECONDARY
+ || eCal == SvXMLNumFormatContext::ImplicitCalendar::SECONDARY_FROM_OTHER)
+ {
+ rParent.AddNfKeyword(
+ sal::static_int_cast< sal_uInt16 >(
+ bEffLong ? NF_KEY_EEC : NF_KEY_EC ) );
+ }
+ else
+ {
+ rParent.AddNfKeyword(
+ sal::static_int_cast< sal_uInt16 >(
+ bEffLong ? NF_KEY_YYYY : NF_KEY_YY ) );
+ }
+ }
+ break;
+ case SvXMLStyleTokens::Era:
+ rParent.UpdateCalendar( sCalendar );
+//! I18N doesn't provide SYSTEM or extended date information yet
+ rParent.AddNfKeyword(
+ sal::static_int_cast< sal_uInt16 >(
+ bEffLong ? NF_KEY_GGG : NF_KEY_G ) );
+ // HasEra flag is set
+ break;
+ case SvXMLStyleTokens::DayOfWeek:
+//! I18N doesn't provide SYSTEM or extended date information yet
+ {
+ // Implicit secondary calendar uses A keyword, default and
+ // explicit calendar N keyword.
+ rParent.UpdateCalendar( sCalendar);
+ const SvXMLNumFormatContext::ImplicitCalendar eCal = rParent.GetImplicitCalendarState();
+ if (eCal == SvXMLNumFormatContext::ImplicitCalendar::SECONDARY
+ || eCal == SvXMLNumFormatContext::ImplicitCalendar::SECONDARY_FROM_OTHER)
+ {
+ rParent.AddNfKeyword(
+ sal::static_int_cast< sal_uInt16 >(
+ bEffLong ? NF_KEY_AAAA : NF_KEY_AAA ) );
+ }
+ else
+ {
+ rParent.AddNfKeyword(
+ sal::static_int_cast< sal_uInt16 >(
+ bEffLong ? NF_KEY_NNNN : NF_KEY_NN ) );
+ }
+ }
+ break;
+ case SvXMLStyleTokens::WeekOfYear:
+ rParent.UpdateCalendar( sCalendar );
+ rParent.AddNfKeyword( NF_KEY_WW );
+ break;
+ case SvXMLStyleTokens::Quarter:
+ rParent.UpdateCalendar( sCalendar );
+ rParent.AddNfKeyword(
+ sal::static_int_cast< sal_uInt16 >(
+ bEffLong ? NF_KEY_QQ : NF_KEY_Q ) );
+ break;
+ case SvXMLStyleTokens::Hours:
+ rParent.AddNfKeyword(
+ sal::static_int_cast< sal_uInt16 >(
+ bEffLong ? NF_KEY_HH : NF_KEY_H ) );
+ break;
+ case SvXMLStyleTokens::AmPm:
+ //! short/long?
+ rParent.AddNfKeyword( NF_KEY_AMPM );
+ break;
+ case SvXMLStyleTokens::Minutes:
+ rParent.AddNfKeyword(
+ sal::static_int_cast< sal_uInt16 >(
+ bEffLong ? NF_KEY_MMI : NF_KEY_MI ) );
+ break;
+ case SvXMLStyleTokens::Seconds:
+ rParent.AddNfKeyword(
+ sal::static_int_cast< sal_uInt16 >(
+ bEffLong ? NF_KEY_SS : NF_KEY_S ) );
+ if ( aNumInfo.nDecimals > 0 )
+ {
+ // manually add the decimal places
+ rParent.AddToCode(rParent.GetLocaleData().getNumDecimalSep());
+ for (sal_Int32 i=0; i<aNumInfo.nDecimals; i++)
+ {
+ rParent.AddToCode( '0');
+ }
+ }
+ break;
+
+ case SvXMLStyleTokens::Fraction:
+ {
+ if ( aNumInfo.nInteger >= 0 )
+ {
+ // add integer part only if min-integer-digits attribute is there
+ aNumInfo.nDecimals = 0;
+ rParent.AddNumber( aNumInfo ); // number without decimals
+ OUStringBuffer sIntegerFractionDelimiter(aNumInfo.aIntegerFractionDelimiter);
+ lcl_EnquoteIfNecessary( sIntegerFractionDelimiter, rParent );
+ rParent.AddToCode( sIntegerFractionDelimiter ); // default is ' '
+ }
+
+ //! build string and add at once
+
+ sal_Int32 i;
+ for (i=aNumInfo.nMaxNumerDigits; i > 0; i--)
+ {
+ if ( i > aNumInfo.nMinNumerDigits )
+ rParent.AddToCode( '#' );
+ else if ( i > aNumInfo.nZerosNumerDigits )
+ rParent.AddToCode( '?' );
+ else
+ rParent.AddToCode( '0' );
+ }
+ rParent.AddToCode( '/' );
+ if ( aNumInfo.nFracDenominator > 0 )
+ {
+ rParent.AddToCode( OUString::number( aNumInfo.nFracDenominator ) );
+ }
+ else
+ {
+ for (i=aNumInfo.nMaxDenomDigits; i > 0 ; i--)
+ {
+ if ( i > aNumInfo.nMinDenomDigits )
+ rParent.AddToCode( '#' );
+ else if ( i > aNumInfo.nZerosDenomDigits )
+ rParent.AddToCode( '?' );
+ else
+ rParent.AddToCode( '0' );
+ }
+ }
+ }
+ break;
+
+ case SvXMLStyleTokens::ScientificNumber:
+ {
+ // exponential interval for engineering notation
+ if( !aNumInfo.bGrouping && aNumInfo.nExpInterval > aNumInfo.nInteger )
+ {
+ for (sal_Int32 i=aNumInfo.nInteger; i<aNumInfo.nExpInterval; i++)
+ {
+ rParent.AddToCode( '#' );
+ }
+ }
+ rParent.AddNumber( aNumInfo ); // simple number
+
+ if ( aNumInfo.bExpSign )
+ rParent.AddToCode( u"E+" );
+ else
+ rParent.AddToCode( u"E" );
+ for (sal_Int32 i=0; i<aNumInfo.nExpDigits; i++)
+ {
+ rParent.AddToCode( '0' );
+ }
+ }
+ break;
+
+ default:
+ assert(false && "invalid element ID");
+ }
+}
+
+sal_uInt16 SvXMLNumFmtDefaults::GetDefaultDateFormat( SvXMLDateElementAttributes eDOW,
+ SvXMLDateElementAttributes eDay, SvXMLDateElementAttributes eMonth,
+ SvXMLDateElementAttributes eYear, SvXMLDateElementAttributes eHours,
+ SvXMLDateElementAttributes eMins, SvXMLDateElementAttributes eSecs,
+ bool bSystem )
+{
+ for (const auto & rEntry : aDefaultDateFormats)
+ {
+ if ( bSystem == rEntry.bSystem &&
+ ( eDOW == rEntry.eDOW || ( rEntry.eDOW == XML_DEA_ANY && eDOW != XML_DEA_NONE ) ) &&
+ ( eDay == rEntry.eDay || ( rEntry.eDay == XML_DEA_ANY && eDay != XML_DEA_NONE ) ) &&
+ ( eMonth == rEntry.eMonth || ( rEntry.eMonth == XML_DEA_ANY && eMonth != XML_DEA_NONE ) ) &&
+ ( eYear == rEntry.eYear || ( rEntry.eYear == XML_DEA_ANY && eYear != XML_DEA_NONE ) ) &&
+ ( eHours == rEntry.eHours || ( rEntry.eHours == XML_DEA_ANY && eHours != XML_DEA_NONE ) ) &&
+ ( eMins == rEntry.eMins || ( rEntry.eMins == XML_DEA_ANY && eMins != XML_DEA_NONE ) ) &&
+ ( eSecs == rEntry.eSecs || ( rEntry.eSecs == XML_DEA_ANY && eSecs != XML_DEA_NONE ) ) )
+ {
+ return sal::static_int_cast< sal_uInt16 >(rEntry.eFormat);
+ }
+ }
+
+ return NF_INDEX_TABLE_ENTRIES; // invalid
+}
+
+
+// SvXMLNumFormatContext
+
+SvXMLNumFormatContext::SvXMLNumFormatContext( SvXMLImport& rImport,
+ sal_Int32 /*nElement*/,
+ SvXMLNumImpData* pNewData, SvXMLStylesTokens nNewType,
+ const uno::Reference<xml::sax::XFastAttributeList>& xAttrList,
+ SvXMLStylesContext& rStyles ) :
+ SvXMLStyleContext( rImport ),
+ pData( pNewData ),
+ pStyles( &rStyles ),
+ nType( nNewType ),
+ nKey(-1),
+ eImplicitCalendar(ImplicitCalendar::DEFAULT),
+ nFormatLang( LANGUAGE_SYSTEM ),
+ bAutoOrder( false ),
+ bFromSystem( false ),
+ bTruncate( true ),
+ bAutoDec( false ),
+ bAutoInt( false ),
+ bHasExtraText( false ),
+ bHasTrailingEmptyText( false ),
+ bHasLongDoW( false ),
+ bHasDateTime( false ),
+ bRemoveAfterUse( false ),
+ eDateDOW( XML_DEA_NONE ),
+ eDateDay( XML_DEA_NONE ),
+ eDateMonth( XML_DEA_NONE ),
+ eDateYear( XML_DEA_NONE ),
+ eDateHours( XML_DEA_NONE ),
+ eDateMins( XML_DEA_NONE ),
+ eDateSecs( XML_DEA_NONE ),
+ bDateNoDefault( false )
+{
+ LanguageTagODF aLanguageTagODF;
+ css::i18n::NativeNumberXmlAttributes aNatNumAttr;
+ OUString aSpellout;
+ bool bAttrBool(false);
+
+ for( auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ) )
+ {
+ switch (aIter.getToken())
+ {
+ // attributes for a style
+ case XML_ELEMENT(STYLE, XML_NAME):
+ break;
+ case XML_ELEMENT(NUMBER, XML_RFC_LANGUAGE_TAG):
+ aLanguageTagODF.maRfcLanguageTag = aIter.toString();
+ break;
+ case XML_ELEMENT(NUMBER, XML_LANGUAGE):
+ aLanguageTagODF.maLanguage = aIter.toString();
+ break;
+ case XML_ELEMENT(NUMBER, XML_SCRIPT):
+ aLanguageTagODF.maScript = aIter.toString();
+ break;
+ case XML_ELEMENT(NUMBER, XML_COUNTRY):
+ aLanguageTagODF.maCountry = aIter.toString();
+ break;
+ case XML_ELEMENT(NUMBER, XML_TITLE):
+ sFormatTitle = aIter.toString();
+ break;
+ case XML_ELEMENT(NUMBER, XML_AUTOMATIC_ORDER):
+ if (::sax::Converter::convertBool( bAttrBool, aIter.toView() ))
+ bAutoOrder = bAttrBool;
+ break;
+ case XML_ELEMENT(NUMBER, XML_FORMAT_SOURCE):
+ SvXMLUnitConverter::convertEnum( bFromSystem, aIter.toView(), aFormatSourceMap );
+ break;
+ case XML_ELEMENT(NUMBER, XML_TRUNCATE_ON_OVERFLOW):
+ if (::sax::Converter::convertBool( bAttrBool, aIter.toView() ))
+ bTruncate = bAttrBool;
+ break;
+ case XML_ELEMENT(STYLE, XML_VOLATILE):
+ // volatile formats can be removed after importing
+ // if not used in other styles
+ if (::sax::Converter::convertBool( bAttrBool, aIter.toView() ))
+ bRemoveAfterUse = bAttrBool;
+ break;
+ case XML_ELEMENT(NUMBER, XML_TRANSLITERATION_FORMAT):
+ aNatNumAttr.Format = aIter.toString();
+ break;
+ case XML_ELEMENT(LO_EXT, XML_TRANSLITERATION_SPELLOUT):
+ case XML_ELEMENT(NUMBER, XML_TRANSLITERATION_SPELLOUT):
+ aSpellout = aIter.toString();
+ break;
+ case XML_ELEMENT(NUMBER, XML_TRANSLITERATION_LANGUAGE):
+ aNatNumAttr.Locale.Language = aIter.toString();
+ break;
+ case XML_ELEMENT(NUMBER, XML_TRANSLITERATION_COUNTRY):
+ aNatNumAttr.Locale.Country = aIter.toString();
+ break;
+ case XML_ELEMENT(NUMBER, XML_TRANSLITERATION_STYLE):
+ aNatNumAttr.Style = aIter.toString();
+ break;
+ default:
+ XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+ }
+ }
+
+ if (!aLanguageTagODF.isEmpty())
+ {
+ nFormatLang = aLanguageTagODF.getLanguageTag().getLanguageType( false);
+ if ( nFormatLang == LANGUAGE_DONTKNOW )
+ nFormatLang = LANGUAGE_SYSTEM; //! error handling for unknown locales?
+ }
+
+ if (aNatNumAttr.Format.isEmpty() && aSpellout.isEmpty())
+ return;
+
+ LanguageTag aLanguageTag( OUString(), aNatNumAttr.Locale.Language,
+ std::u16string_view(), aNatNumAttr.Locale.Country);
+ aNatNumAttr.Locale = aLanguageTag.getLocale( false);
+
+ // NatNum12 spell out formula (cardinal, ordinal, ordinal-feminine etc.)
+ if ( !aSpellout.isEmpty() )
+ {
+ aFormatCode.append( "[NatNum12 " );
+ aFormatCode.append( aSpellout );
+ } else {
+ SvNumberFormatter* pFormatter = pData->GetNumberFormatter();
+ if ( !pFormatter ) return;
+
+ sal_Int32 nNatNum = pFormatter->GetNatNum()->convertFromXmlAttributes( aNatNumAttr );
+ aFormatCode.append( "[NatNum" );
+ aFormatCode.append( nNatNum );
+ }
+
+ LanguageType eLang = aLanguageTag.getLanguageType( false );
+ if ( eLang == LANGUAGE_DONTKNOW )
+ eLang = LANGUAGE_SYSTEM; //! error handling for unknown locales?
+ if ( eLang != nFormatLang && eLang != LANGUAGE_SYSTEM )
+ {
+ aFormatCode.append( "][$-" );
+ // language code in upper hex:
+ aFormatCode.append(OUString::number(static_cast<sal_uInt16>(eLang), 16).toAsciiUpperCase());
+ }
+ aFormatCode.append( ']' );
+}
+
+SvXMLNumFormatContext::SvXMLNumFormatContext( SvXMLImport& rImport,
+ const OUString& rName,
+ const uno::Reference<xml::sax::XFastAttributeList>& /*xAttrList*/,
+ const sal_Int32 nTempKey, LanguageType nLang,
+ SvXMLStylesContext& rStyles ) :
+ SvXMLStyleContext( rImport, XmlStyleFamily::DATA_STYLE ),
+ pData( nullptr ),
+ pStyles( &rStyles ),
+ nType( SvXMLStylesTokens::NUMBER_STYLE ),
+ nKey(nTempKey),
+ eImplicitCalendar(ImplicitCalendar::DEFAULT),
+ nFormatLang( nLang ),
+ bAutoOrder( false ),
+ bFromSystem( false ),
+ bTruncate( true ),
+ bAutoDec( false ),
+ bAutoInt( false ),
+ bHasExtraText( false ),
+ bHasTrailingEmptyText( false ),
+ bHasLongDoW( false ),
+ bHasDateTime( false ),
+ bRemoveAfterUse( false ),
+ eDateDOW( XML_DEA_NONE ),
+ eDateDay( XML_DEA_NONE ),
+ eDateMonth( XML_DEA_NONE ),
+ eDateYear( XML_DEA_NONE ),
+ eDateHours( XML_DEA_NONE ),
+ eDateMins( XML_DEA_NONE ),
+ eDateSecs( XML_DEA_NONE ),
+ bDateNoDefault( false )
+{
+ SetAttribute(XML_ELEMENT(STYLE, XML_NAME), rName);
+}
+
+SvXMLNumFormatContext::~SvXMLNumFormatContext()
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SvXMLNumFormatContext::createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+ SvXMLImportContext* pContext = nullptr;
+
+ switch (nElement)
+ {
+ case XML_ELEMENT(LO_EXT, XML_TEXT):
+ case XML_ELEMENT(NUMBER, XML_TEXT):
+ pContext = new SvXMLNumFmtElementContext( GetImport(), nElement,
+ *this, SvXMLStyleTokens::Text, xAttrList );
+ break;
+ case XML_ELEMENT(LO_EXT, XML_FILL_CHARACTER):
+ case XML_ELEMENT(NUMBER, XML_FILL_CHARACTER):
+ pContext = new SvXMLNumFmtElementContext( GetImport(), nElement,
+ *this, SvXMLStyleTokens::FillCharacter, xAttrList );
+ break;
+ case XML_ELEMENT(NUMBER, XML_NUMBER):
+ pContext = new SvXMLNumFmtElementContext( GetImport(), nElement,
+ *this, SvXMLStyleTokens::Number, xAttrList );
+ break;
+ case XML_ELEMENT(NUMBER, XML_SCIENTIFIC_NUMBER):
+ pContext = new SvXMLNumFmtElementContext( GetImport(), nElement,
+ *this, SvXMLStyleTokens::ScientificNumber, xAttrList );
+ break;
+ case XML_ELEMENT(NUMBER, XML_FRACTION):
+ pContext = new SvXMLNumFmtElementContext( GetImport(), nElement,
+ *this, SvXMLStyleTokens::Fraction, xAttrList );
+ break;
+ case XML_ELEMENT(NUMBER, XML_CURRENCY_SYMBOL):
+ pContext = new SvXMLNumFmtElementContext( GetImport(), nElement,
+ *this, SvXMLStyleTokens::CurrencySymbol, xAttrList );
+ break;
+ case XML_ELEMENT(NUMBER, XML_DAY):
+ pContext = new SvXMLNumFmtElementContext( GetImport(), nElement,
+ *this, SvXMLStyleTokens::Day, xAttrList );
+ break;
+ case XML_ELEMENT(NUMBER, XML_MONTH):
+ pContext = new SvXMLNumFmtElementContext( GetImport(), nElement,
+ *this, SvXMLStyleTokens::Month, xAttrList );
+ break;
+ case XML_ELEMENT(NUMBER, XML_YEAR):
+ pContext = new SvXMLNumFmtElementContext( GetImport(), nElement,
+ *this, SvXMLStyleTokens::Year, xAttrList );
+ break;
+ case XML_ELEMENT(NUMBER, XML_ERA):
+ pContext = new SvXMLNumFmtElementContext( GetImport(), nElement,
+ *this, SvXMLStyleTokens::Era, xAttrList );
+ break;
+ case XML_ELEMENT(NUMBER, XML_DAY_OF_WEEK):
+ pContext = new SvXMLNumFmtElementContext( GetImport(), nElement,
+ *this, SvXMLStyleTokens::DayOfWeek, xAttrList );
+ break;
+ case XML_ELEMENT(NUMBER, XML_WEEK_OF_YEAR):
+ pContext = new SvXMLNumFmtElementContext( GetImport(), nElement,
+ *this, SvXMLStyleTokens::WeekOfYear, xAttrList );
+ break;
+ case XML_ELEMENT(NUMBER, XML_QUARTER):
+ pContext = new SvXMLNumFmtElementContext( GetImport(), nElement,
+ *this, SvXMLStyleTokens::Quarter, xAttrList );
+ break;
+ case XML_ELEMENT(NUMBER, XML_HOURS):
+ pContext = new SvXMLNumFmtElementContext( GetImport(), nElement,
+ *this, SvXMLStyleTokens::Hours, xAttrList );
+ break;
+ case XML_ELEMENT(NUMBER, XML_AM_PM):
+ pContext = new SvXMLNumFmtElementContext( GetImport(), nElement,
+ *this, SvXMLStyleTokens::AmPm, xAttrList );
+ break;
+ case XML_ELEMENT(NUMBER, XML_MINUTES):
+ pContext = new SvXMLNumFmtElementContext( GetImport(), nElement,
+ *this, SvXMLStyleTokens::Minutes, xAttrList );
+ break;
+ case XML_ELEMENT(NUMBER, XML_SECONDS):
+ pContext = new SvXMLNumFmtElementContext( GetImport(), nElement,
+ *this, SvXMLStyleTokens::Seconds, xAttrList );
+ break;
+ case XML_ELEMENT(NUMBER, XML_BOOLEAN):
+ pContext = new SvXMLNumFmtElementContext( GetImport(), nElement,
+ *this, SvXMLStyleTokens::Boolean, xAttrList );
+ break;
+ case XML_ELEMENT(NUMBER, XML_TEXT_CONTENT):
+ pContext = new SvXMLNumFmtElementContext( GetImport(), nElement,
+ *this, SvXMLStyleTokens::TextContent, xAttrList );
+ break;
+
+ case XML_ELEMENT(STYLE, XML_TEXT_PROPERTIES):
+ pContext = new SvXMLNumFmtPropContext( GetImport(), nElement,
+ *this, xAttrList );
+ break;
+ case XML_ELEMENT(STYLE, XML_MAP):
+ {
+ // SvXMLNumFmtMapContext::EndElement adds to aMyConditions,
+ // so there's no need for an extra flag
+ pContext = new SvXMLNumFmtMapContext( GetImport(), nElement,
+ *this, xAttrList );
+ }
+ break;
+ }
+
+ if( !pContext )
+ {
+ SAL_WARN("xmloff.core", "No context for unknown-element " << SvXMLImport::getPrefixAndNameFromToken(nElement));
+ pContext = new SvXMLImportContext(GetImport());
+ }
+
+ return pContext;
+}
+
+sal_Int32 SvXMLNumFormatContext::GetKey()
+{
+ if (nKey > -1)
+ {
+ if (bRemoveAfterUse)
+ {
+ // format is used -> don't remove
+ bRemoveAfterUse = false;
+ if (pData)
+ pData->SetUsed(nKey);
+
+ // Add to import's list of keys now - CreateAndInsert didn't add
+ // the style if bRemoveAfterUse was set.
+ GetImport().AddNumberStyle( nKey, GetName() );
+ }
+ return nKey;
+ }
+ else
+ {
+ // reset bRemoveAfterUse before CreateAndInsert, so AddKey is called without bRemoveAfterUse set
+ bRemoveAfterUse = false;
+ CreateAndInsert(true);
+ return nKey;
+ }
+}
+
+sal_Int32 SvXMLNumFormatContext::PrivateGetKey()
+{
+ // used for map elements in CreateAndInsert - don't reset bRemoveAfterUse flag
+
+ if (nKey > -1)
+ return nKey;
+ else
+ {
+ CreateAndInsert(true);
+ return nKey;
+ }
+}
+
+sal_Int32 SvXMLNumFormatContext::CreateAndInsert( css::uno::Reference< css::util::XNumberFormatsSupplier > const & xFormatsSupplier )
+{
+ if (nKey <= -1)
+ {
+ SvNumberFormatter* pFormatter = nullptr;
+ SvNumberFormatsSupplierObj* pObj =
+ comphelper::getFromUnoTunnel<SvNumberFormatsSupplierObj>( xFormatsSupplier );
+ if (pObj)
+ pFormatter = pObj->GetNumberFormatter();
+
+ if ( pFormatter )
+ return CreateAndInsert( pFormatter );
+ else
+ return -1;
+ }
+ else
+ return nKey;
+}
+
+void SvXMLNumFormatContext::CreateAndInsert(bool /*bOverwrite*/)
+{
+ if (nKey <= -1)
+ CreateAndInsert(pData->GetNumberFormatter());
+}
+
+sal_Int32 SvXMLNumFormatContext::CreateAndInsert(SvNumberFormatter* pFormatter)
+{
+ if (!pFormatter)
+ {
+ OSL_FAIL("no number formatter");
+ return -1;
+ }
+
+ sal_uInt32 nIndex = NUMBERFORMAT_ENTRY_NOT_FOUND;
+
+ for (size_t i = 0; i < aMyConditions.size(); i++)
+ {
+ SvXMLNumFormatContext* pStyle = const_cast<SvXMLNumFormatContext*>( static_cast<const SvXMLNumFormatContext *>(pStyles->FindStyleChildContext(
+ XmlStyleFamily::DATA_STYLE, aMyConditions[i].sMapName)));
+ if (this == pStyle)
+ {
+ SAL_INFO("xmloff.style", "invalid style:map references containing style");
+ pStyle = nullptr;
+ }
+ if (pStyle)
+ {
+ if (pStyle->PrivateGetKey() > -1) // don't reset pStyle's bRemoveAfterUse flag
+ AddCondition(i);
+ }
+ }
+
+ sal_Int32 nBufLen;
+ if ( aFormatCode.isEmpty() )
+ {
+ // insert empty format as empty string (with quotes)
+ // #93901# this check has to be done before inserting the conditions
+ aFormatCode.append("\"\""); // ""
+ }
+ else if (bHasTrailingEmptyText && (nBufLen = aFormatCode.getLength()) >= 3)
+ {
+ // Remove a trailing empty text. Earlier this may had been written to
+ // file, like in "General;General" written with elements for
+ // 'General"";General""' (whyever); when reading, empty text was
+ // ignored, which it isn't anymore, so get rid of those.
+ if (aFormatCode[nBufLen-1] == '"' && aFormatCode[nBufLen-2] == '"')
+ aFormatCode.truncate( nBufLen - 2);
+ }
+
+ aFormatCode.insert( 0, aConditions );
+ aConditions.setLength(0);
+ OUString sFormat = aFormatCode.makeStringAndClear();
+
+ // test special cases
+
+ if ( bAutoDec ) // automatic decimal places
+ {
+ // #99391# adjust only if the format contains no text elements, no conditions
+ // and no color definition (detected by the '[' at the start)
+
+ if ( nType == SvXMLStylesTokens::NUMBER_STYLE && !bHasExtraText &&
+ aMyConditions.empty() && sFormat.toChar() != '[' )
+ nIndex = pFormatter->GetStandardIndex( nFormatLang );
+ }
+ if ( bAutoInt ) // automatic integer digits
+ {
+ //! only if two decimal places was set?
+
+ if ( nType == SvXMLStylesTokens::NUMBER_STYLE && !bHasExtraText &&
+ aMyConditions.empty() && sFormat.toChar() != '[' )
+ nIndex = pFormatter->GetFormatIndex( NF_NUMBER_SYSTEM, nFormatLang );
+ }
+
+ if ( nType == SvXMLStylesTokens::BOOLEAN_STYLE && !bHasExtraText &&
+ aMyConditions.empty() && sFormat.toChar() != '[' )
+ nIndex = pFormatter->GetFormatIndex( NF_BOOLEAN, nFormatLang );
+
+ // check for default date formats
+ if ( nType == SvXMLStylesTokens::DATE_STYLE && bAutoOrder && !bDateNoDefault )
+ {
+ NfIndexTableOffset eFormat = static_cast<NfIndexTableOffset>(SvXMLNumFmtDefaults::GetDefaultDateFormat(
+ eDateDOW, eDateDay, eDateMonth, eDateYear,
+ eDateHours, eDateMins, eDateSecs, bFromSystem ));
+ if ( eFormat < NF_INDEX_TABLE_RESERVED_START )
+ {
+ // #109651# if a date format has the automatic-order attribute and
+ // contains exactly the elements of one of the default date formats,
+ // use that default format, with the element order and separators
+ // from the current locale settings
+
+ nIndex = pFormatter->GetFormatIndex( eFormat, nFormatLang );
+ }
+ }
+
+ if ( nIndex == NUMBERFORMAT_ENTRY_NOT_FOUND && !sFormat.isEmpty() )
+ {
+ // insert by format string
+
+ OUString aFormatStr( sFormat );
+ nIndex = pFormatter->GetEntryKey( aFormatStr, nFormatLang );
+ if ( nIndex == NUMBERFORMAT_ENTRY_NOT_FOUND )
+ {
+ sal_Int32 nErrPos = 0;
+ SvNumFormatType l_nType = SvNumFormatType::ALL;
+ bool bOk = pFormatter->PutEntry( aFormatStr, nErrPos, l_nType, nIndex, nFormatLang );
+ if ( !bOk && nErrPos == 0 && aFormatStr != sFormat )
+ {
+ // if the string was modified by PutEntry, look for an existing format
+ // with the modified string
+ nIndex = pFormatter->GetEntryKey( aFormatStr, nFormatLang );
+ if ( nIndex != NUMBERFORMAT_ENTRY_NOT_FOUND )
+ bOk = true;
+ }
+ if (!bOk)
+ nIndex = NUMBERFORMAT_ENTRY_NOT_FOUND;
+ }
+ }
+
+//! I18N doesn't provide SYSTEM or extended date information yet
+ if ( nIndex != NUMBERFORMAT_ENTRY_NOT_FOUND && !bAutoOrder )
+ {
+ // use fixed-order formats instead of SYS... if bAutoOrder is false
+ // (only if the format strings are equal for the locale)
+
+ NfIndexTableOffset eOffset = pFormatter->GetIndexTableOffset( nIndex );
+ if ( eOffset == NF_DATE_SYS_DMMMYYYY )
+ {
+ sal_uInt32 nNewIndex = pFormatter->GetFormatIndex( NF_DATE_DIN_DMMMYYYY, nFormatLang );
+ const SvNumberformat* pOldEntry = pFormatter->GetEntry( nIndex );
+ const SvNumberformat* pNewEntry = pFormatter->GetEntry( nNewIndex );
+ if ( pOldEntry && pNewEntry && pOldEntry->GetFormatstring() == pNewEntry->GetFormatstring() )
+ nIndex = nNewIndex;
+ }
+ else if ( eOffset == NF_DATE_SYS_DMMMMYYYY )
+ {
+ sal_uInt32 nNewIndex = pFormatter->GetFormatIndex( NF_DATE_DIN_DMMMMYYYY, nFormatLang );
+ const SvNumberformat* pOldEntry = pFormatter->GetEntry( nIndex );
+ const SvNumberformat* pNewEntry = pFormatter->GetEntry( nNewIndex );
+ if ( pOldEntry && pNewEntry && pOldEntry->GetFormatstring() == pNewEntry->GetFormatstring() )
+ nIndex = nNewIndex;
+ }
+ }
+
+ if ((nIndex != NUMBERFORMAT_ENTRY_NOT_FOUND) && !sFormatTitle.isEmpty())
+ {
+ SvNumberformat* pFormat = const_cast<SvNumberformat*>(pFormatter->GetEntry( nIndex ));
+ if (pFormat)
+ {
+ pFormat->SetComment(sFormatTitle);
+ }
+ }
+
+ if ( nIndex == NUMBERFORMAT_ENTRY_NOT_FOUND )
+ {
+ OSL_FAIL("invalid number format");
+ nIndex = pFormatter->GetStandardIndex( nFormatLang );
+ }
+
+ pData->AddKey( nIndex, GetName(), bRemoveAfterUse );
+ nKey = nIndex;
+
+ // Add to import's list of keys (shared between styles and content import)
+ // only if not volatile - formats are removed from NumberFormatter at the
+ // end of each import (in SvXMLNumFmtHelper dtor).
+ // If bRemoveAfterUse is reset later in GetKey, AddNumberStyle is called there.
+
+ if (!bRemoveAfterUse)
+ GetImport().AddNumberStyle( nKey, GetName() );
+
+ return nKey;
+}
+
+const LocaleDataWrapper& SvXMLNumFormatContext::GetLocaleData() const
+{
+ return pData->GetLocaleData( nFormatLang );
+}
+
+void SvXMLNumFormatContext::AddToCode( sal_Unicode c )
+{
+ aFormatCode.append( c );
+ bHasExtraText = true;
+}
+
+void SvXMLNumFormatContext::AddToCode( std::u16string_view rString )
+{
+ aFormatCode.append( rString );
+ bHasExtraText = true;
+ bHasTrailingEmptyText = false; // is set by caller again if so
+}
+
+void SvXMLNumFormatContext::AddNumber( const SvXMLNumberInfo& rInfo )
+{
+ SvNumberFormatter* pFormatter = pData->GetNumberFormatter();
+ if (!pFormatter)
+ return;
+
+ // store special conditions
+ bAutoDec = ( rInfo.nDecimals < 0 );
+ bAutoInt = ( rInfo.nInteger < 0 );
+
+ sal_uInt16 nPrec = 0;
+ sal_uInt16 nLeading = 0;
+ if ( rInfo.nDecimals >= 0 ) // < 0 : Default
+ nPrec = static_cast<sal_uInt16>(rInfo.nDecimals);
+ if ( rInfo.nInteger >= 0 ) // < 0 : Default
+ nLeading = static_cast<sal_uInt16>(rInfo.nInteger);
+
+ if ( bAutoDec )
+ {
+ if ( nType == SvXMLStylesTokens::CURRENCY_STYLE )
+ {
+ // for currency formats, "automatic decimals" is used for the automatic
+ // currency format with (fixed) decimals from the locale settings
+
+ const LocaleDataWrapper& rLoc = pData->GetLocaleData( nFormatLang );
+ nPrec = rLoc.getCurrDigits();
+ }
+ else
+ {
+ // for other types, "automatic decimals" means dynamic determination of
+ // decimals, as achieved with the "general" keyword
+
+ aFormatCode.append( pFormatter->GetStandardName( nFormatLang ) );
+ return;
+ }
+ }
+ if ( bAutoInt )
+ {
+ //!...
+ }
+
+ sal_uInt16 nGenPrec = nPrec;
+ if ( rInfo.nMinDecimalDigits >= 0 )
+ nGenPrec = rInfo.nMinDecimalDigits;
+ if ( rInfo.bDecReplace )
+ nGenPrec = 0; // generate format without decimals...
+
+ bool bGrouping = rInfo.bGrouping;
+ size_t const nEmbeddedCount = rInfo.m_EmbeddedElements.size();
+ if ( nEmbeddedCount && rInfo.m_EmbeddedElements.rbegin()->first > 0 )
+ bGrouping = false; // grouping and embedded characters in integer part can't be used together
+
+ sal_uInt32 nStdIndex = pFormatter->GetStandardIndex( nFormatLang );
+ OUStringBuffer aNumStr(pFormatter->GenerateFormat( nStdIndex, nFormatLang,
+ bGrouping, false, nGenPrec, nLeading ));
+
+ if ( rInfo.nExpDigits >= 0 && nLeading == 0 && !bGrouping && nEmbeddedCount == 0 )
+ {
+ // #i43959# For scientific numbers, "#" in the integer part forces a digit,
+ // so it has to be removed if nLeading is 0 (".00E+0", not "#.00E+0").
+
+ aNumStr.stripStart('#');
+ }
+
+ if ( bGrouping && rInfo.nExpInterval > rInfo.nInteger )
+ {
+ sal_Int32 nIndex = 0;
+ sal_Int32 nDigits = rInfo.nInteger;
+ sal_Int32 nIntegerEnd = aNumStr.indexOf( pFormatter->GetNumDecimalSep() );
+ if ( nIntegerEnd < 0 )
+ nIntegerEnd = aNumStr.getLength();
+ while ( nIndex >= 0 && nIndex < nIntegerEnd )
+ {
+ if ( ( nIndex = aNumStr.indexOf( '#', nIndex ) ) >= 0 )
+ {
+ nDigits ++;
+ nIndex ++;
+ }
+ else
+ nIndex = -1;
+ }
+ while ( rInfo.nExpInterval > nDigits )
+ {
+ nDigits++;
+ aNumStr.insert( 0, '#' );
+ }
+ }
+
+ if ( ( rInfo.bDecReplace || rInfo.nMinDecimalDigits < rInfo.nDecimals ) && nPrec ) // add decimal replacement (dashes)
+ {
+ // add dashes for explicit decimal replacement, # or ? for variable decimals
+ sal_Unicode cAdd = rInfo.bDecReplace ? '-' : ( rInfo.bDecAlign ? '?': '#' );
+
+ if ( rInfo.nMinDecimalDigits == 0 )
+ aNumStr.append( pData->GetLocaleData( nFormatLang ).getNumDecimalSep() );
+ for ( sal_uInt16 i=rInfo.nMinDecimalDigits; i<nPrec; i++)
+ aNumStr.append( cAdd );
+ }
+
+ if ( nEmbeddedCount )
+ {
+ // insert embedded strings into number string
+ // support integer (position >=0) and decimal (position <0) part
+ // nZeroPos is the string position where format position 0 is inserted
+
+ sal_Int32 nZeroPos = aNumStr.indexOf( pData->GetLocaleData( nFormatLang ).getNumDecimalSep() );
+ if ( nZeroPos < 0 )
+ {
+ nZeroPos = aNumStr.getLength();
+ }
+
+ // m_EmbeddedElements is sorted - last entry has the largest position (leftmost)
+ sal_Int32 const nLastFormatPos = rInfo.m_EmbeddedElements.rbegin()->first;
+ if ( nLastFormatPos >= nZeroPos )
+ {
+ // add '#' characters so all embedded texts are really embedded in digits
+ // (there always has to be a digit before the leftmost embedded text)
+
+ sal_Int32 nAddCount = nLastFormatPos + 1 - nZeroPos;
+ for(sal_Int32 index = 0; index < nAddCount; ++index)
+ {
+ aNumStr.insert(0, '#');
+ }
+ nZeroPos = nZeroPos + nAddCount;
+ }
+
+ // m_EmbeddedElements is sorted with ascending positions - loop is from right to left
+ for (auto const& it : rInfo.m_EmbeddedElements)
+ {
+ sal_Int32 const nFormatPos = it.first;
+ sal_Int32 nInsertPos = nZeroPos - nFormatPos;
+ if ( nInsertPos >= 0 )
+ {
+ // #107805# always quote embedded strings - even space would otherwise
+ // be recognized as thousands separator in French.
+
+ aNumStr.insert(nInsertPos, '"');
+ aNumStr.insert(nInsertPos, it.second);
+ aNumStr.insert(nInsertPos, '"');
+ }
+ }
+ }
+
+ aFormatCode.append( aNumStr );
+
+ // add extra thousands separators for display factor
+
+ if (rInfo.fDisplayFactor == 1.0 || rInfo.fDisplayFactor <= 0.0)
+ return;
+
+ // test for 1.0 is just for optimization - nSepCount would be 0
+
+ // one separator for each factor of 1000
+ sal_Int32 nSepCount = static_cast<sal_Int32>(::rtl::math::round( log10(rInfo.fDisplayFactor) / 3.0 ));
+ if ( nSepCount > 0 )
+ {
+ OUString aSep = pData->GetLocaleData( nFormatLang ).getNumThousandSep();
+ for ( sal_Int32 i=0; i<nSepCount; i++ )
+ aFormatCode.append( aSep );
+ }
+}
+
+void SvXMLNumFormatContext::AddCurrency( const OUString& rContent, LanguageType nLang )
+{
+ bool bAutomatic = false;
+ OUString aSymbol = rContent;
+ if ( aSymbol.isEmpty())
+ {
+ SvNumberFormatter* pFormatter = pData->GetNumberFormatter();
+ if ( pFormatter )
+ {
+ pFormatter->ChangeIntl( nFormatLang );
+ OUString sCurString, sDummy;
+ pFormatter->GetCompatibilityCurrency( sCurString, sDummy );
+ aSymbol = sCurString;
+
+ bAutomatic = true;
+ }
+ }
+ else if ( nLang == LANGUAGE_SYSTEM && aSymbol == "CCC" )
+ {
+ // "CCC" is used for automatic long symbol
+ bAutomatic = true;
+ }
+
+ if ( bAutomatic )
+ {
+ // remove unnecessary quotes before automatic symbol (formats like "-(0DM)")
+ // otherwise the currency symbol isn't recognized (#94048#)
+
+ sal_Int32 nLength = aFormatCode.getLength();
+ if ( nLength > 1 && aFormatCode[nLength - 1] == '"' )
+ {
+ // find start of quoted string
+ // When SvXMLNumFmtElementContext::EndElement creates escaped quotes,
+ // they must be handled here, too.
+
+ sal_Int32 nFirst = nLength - 2;
+ while ( nFirst >= 0 && aFormatCode[nFirst] != '"' )
+ --nFirst;
+ if ( nFirst >= 0 )
+ {
+ // remove both quotes from aFormatCode
+ OUString aOld = aFormatCode.makeStringAndClear();
+ if ( nFirst > 0 )
+ aFormatCode.append( aOld.subView( 0, nFirst ) );
+ if ( nLength > nFirst + 2 )
+ aFormatCode.append( aOld.subView( nFirst + 1, nLength - nFirst - 2 ) );
+ }
+ }
+ }
+
+ if (!bAutomatic)
+ aFormatCode.append( "[$" ); // intro for "new" currency symbols
+
+ aFormatCode.append( aSymbol );
+
+ if (!bAutomatic)
+ {
+ if ( nLang != LANGUAGE_SYSTEM )
+ {
+ // '-' sign and language code in hex:
+ aFormatCode.append("-" + OUString(OUString::number(sal_uInt16(nLang), 16)).toAsciiUpperCase());
+ }
+
+ aFormatCode.append( ']' ); // end of "new" currency symbol
+ }
+}
+
+void SvXMLNumFormatContext::AddNfKeyword( sal_uInt16 nIndex )
+{
+ SvNumberFormatter* pFormatter = pData->GetNumberFormatter();
+ if (!pFormatter)
+ return;
+
+ if ( nIndex == NF_KEY_NNNN )
+ {
+ nIndex = NF_KEY_NNN;
+ bHasLongDoW = true; // to remove string constant with separator
+ }
+
+ OUString sKeyword = pFormatter->GetKeyword( nFormatLang, nIndex );
+
+ if ( nIndex == NF_KEY_H || nIndex == NF_KEY_HH ||
+ nIndex == NF_KEY_MI || nIndex == NF_KEY_MMI ||
+ nIndex == NF_KEY_S || nIndex == NF_KEY_SS )
+ {
+ if ( !bTruncate && !bHasDateTime )
+ {
+ // with truncate-on-overflow = false, add "[]" to first time part
+ aFormatCode.append("[" + sKeyword + "]");
+ }
+ else
+ {
+ aFormatCode.append( sKeyword );
+ }
+ bHasDateTime = true;
+ }
+ else
+ {
+ aFormatCode.append( sKeyword );
+ }
+ // collect the date elements that the format contains, to recognize default date formats
+ switch ( nIndex )
+ {
+ case NF_KEY_NN: eDateDOW = XML_DEA_SHORT; break;
+ case NF_KEY_NNN:
+ case NF_KEY_NNNN: eDateDOW = XML_DEA_LONG; break;
+ case NF_KEY_D: eDateDay = XML_DEA_SHORT; break;
+ case NF_KEY_DD: eDateDay = XML_DEA_LONG; break;
+ case NF_KEY_M: eDateMonth = XML_DEA_SHORT; break;
+ case NF_KEY_MM: eDateMonth = XML_DEA_LONG; break;
+ case NF_KEY_MMM: eDateMonth = XML_DEA_TEXTSHORT; break;
+ case NF_KEY_MMMM: eDateMonth = XML_DEA_TEXTLONG; break;
+ case NF_KEY_YY: eDateYear = XML_DEA_SHORT; break;
+ case NF_KEY_YYYY: eDateYear = XML_DEA_LONG; break;
+ case NF_KEY_H: eDateHours = XML_DEA_SHORT; break;
+ case NF_KEY_HH: eDateHours = XML_DEA_LONG; break;
+ case NF_KEY_MI: eDateMins = XML_DEA_SHORT; break;
+ case NF_KEY_MMI: eDateMins = XML_DEA_LONG; break;
+ case NF_KEY_S: eDateSecs = XML_DEA_SHORT; break;
+ case NF_KEY_SS: eDateSecs = XML_DEA_LONG; break;
+ case NF_KEY_AP:
+ case NF_KEY_AMPM: break; // AM/PM may or may not be in date/time formats -> ignore by itself
+ default:
+ bDateNoDefault = true; // any other element -> no default format
+ }
+}
+
+static bool lcl_IsAtEnd( OUStringBuffer& rBuffer, const OUString& rToken )
+{
+ sal_Int32 nBufLen = rBuffer.getLength();
+ sal_Int32 nTokLen = rToken.getLength();
+
+ if ( nTokLen > nBufLen )
+ return false;
+
+ sal_Int32 nStartPos = nBufLen - nTokLen;
+ for ( sal_Int32 nTokPos = 0; nTokPos < nTokLen; nTokPos++ )
+ if ( rToken[ nTokPos ] != rBuffer[nStartPos + nTokPos] )
+ return false;
+
+ return true;
+}
+
+bool SvXMLNumFormatContext::ReplaceNfKeyword( sal_uInt16 nOld, sal_uInt16 nNew )
+{
+ // replaces one keyword with another if it is found at the end of the code
+
+ SvNumberFormatter* pFormatter = pData->GetNumberFormatter();
+ if (!pFormatter)
+ return false;
+
+ OUString sOldStr = pFormatter->GetKeyword( nFormatLang, nOld );
+ if ( lcl_IsAtEnd( aFormatCode, sOldStr ) )
+ {
+ // remove old keyword
+ aFormatCode.setLength( aFormatCode.getLength() - sOldStr.getLength() );
+
+ // add new keyword
+ OUString sNewStr = pFormatter->GetKeyword( nFormatLang, nNew );
+ aFormatCode.append( sNewStr );
+
+ return true; // changed
+ }
+ return false; // not found
+}
+
+void SvXMLNumFormatContext::AddCondition( const sal_Int32 nIndex )
+{
+ OUString rApplyName = aMyConditions[nIndex].sMapName;
+ OUString rCondition = aMyConditions[nIndex].sCondition;
+ SvNumberFormatter* pFormatter = pData->GetNumberFormatter();
+ sal_uInt32 l_nKey = pData->GetKeyForName( rApplyName );
+
+ OUString sRealCond;
+ if ( !(pFormatter && l_nKey != NUMBERFORMAT_ENTRY_NOT_FOUND &&
+ rCondition.startsWith("value()", &sRealCond)) )
+ return;
+
+ //! test for valid conditions
+ //! test for default conditions
+
+ bool bDefaultCond = false;
+
+ //! collect all conditions first and adjust default to >=0, >0 or <0 depending on count
+ //! allow blanks in conditions
+ if ( aConditions.isEmpty() && aMyConditions.size() == 1 && sRealCond == ">=0" )
+ bDefaultCond = true;
+
+ if ( nType == SvXMLStylesTokens::TEXT_STYLE && static_cast<size_t>(nIndex) == aMyConditions.size() - 1 )
+ {
+ // The last condition in a number format with a text part can only
+ // be "all other numbers", the condition string must be empty.
+ bDefaultCond = true;
+ }
+
+ if (!bDefaultCond)
+ {
+ // Convert != to <>
+ sal_Int32 nPos = sRealCond.indexOf( "!=" );
+ if ( nPos >= 0 )
+ {
+ sRealCond = sRealCond.replaceAt( nPos, 2, u"<>" );
+ }
+
+ nPos = sRealCond.indexOf( '.' );
+ if ( nPos >= 0 )
+ {
+ // #i8026# #103991# localize decimal separator
+ const OUString& rDecSep = GetLocaleData().getNumDecimalSep();
+ if ( rDecSep.getLength() > 1 || rDecSep[0] != '.' )
+ {
+ sRealCond = sRealCond.replaceAt( nPos, 1, rDecSep );
+ }
+ }
+ aConditions.append("[" + sRealCond + "]");
+ }
+
+ const SvNumberformat* pFormat = pFormatter->GetEntry(l_nKey);
+ if ( pFormat )
+ aConditions.append( pFormat->GetFormatstring() );
+
+ aConditions.append( ';' );
+}
+
+void SvXMLNumFormatContext::AddCondition( const OUString& rCondition, const OUString& rApplyName )
+{
+ MyCondition aCondition;
+ aCondition.sCondition = rCondition;
+ aCondition.sMapName = rApplyName;
+ aMyConditions.push_back(aCondition);
+}
+
+void SvXMLNumFormatContext::AddColor( Color const nColor )
+{
+ SvNumberFormatter* pFormatter = pData->GetNumberFormatter();
+ if (!pFormatter)
+ return;
+
+ OUStringBuffer aColName;
+ for ( sal_uInt16 i=0; i<XML_NUMF_COLORCOUNT; i++ )
+ if (nColor == aNumFmtStdColors[i])
+ {
+ aColName = pFormatter->GetKeyword( nFormatLang, sal::static_int_cast< sal_uInt16 >(NF_KEY_FIRSTCOLOR + i) );
+ break;
+ }
+
+ if ( !aColName.isEmpty() )
+ {
+ aColName.insert( 0, '[' );
+ aColName.append( ']' );
+ aFormatCode.insert( 0, aColName );
+ }
+}
+
+void SvXMLNumFormatContext::UpdateCalendar( const OUString& rNewCalendar )
+{
+ if ( rNewCalendar == sCalendar )
+ return;
+
+ if (rNewCalendar.isEmpty() || rNewCalendar == aImplicitCalendar[0])
+ {
+ eImplicitCalendar = (eImplicitCalendar == ImplicitCalendar::OTHER ?
+ ImplicitCalendar::DEFAULT_FROM_OTHER : ImplicitCalendar::DEFAULT);
+ }
+ else if (aImplicitCalendar[0].isEmpty() && rNewCalendar == GetLocaleData().getDefaultCalendar()->Name)
+ {
+ eImplicitCalendar = (eImplicitCalendar == ImplicitCalendar::OTHER ?
+ ImplicitCalendar::DEFAULT_FROM_OTHER : ImplicitCalendar::DEFAULT);
+ aImplicitCalendar[0] = rNewCalendar;
+ }
+ else if (rNewCalendar == aImplicitCalendar[1])
+ {
+ eImplicitCalendar = (eImplicitCalendar == ImplicitCalendar::OTHER ?
+ ImplicitCalendar::SECONDARY_FROM_OTHER : ImplicitCalendar::SECONDARY);
+ }
+ else if (aImplicitCalendar[1].isEmpty() && GetLocaleData().doesSecondaryCalendarUseEC( rNewCalendar))
+ {
+ eImplicitCalendar = (eImplicitCalendar == ImplicitCalendar::OTHER ?
+ ImplicitCalendar::SECONDARY_FROM_OTHER : ImplicitCalendar::SECONDARY);
+ aImplicitCalendar[1] = rNewCalendar;
+ }
+ else
+ {
+ eImplicitCalendar = ImplicitCalendar::OTHER;
+ }
+
+ if (eImplicitCalendar != ImplicitCalendar::DEFAULT && eImplicitCalendar != ImplicitCalendar::SECONDARY)
+ {
+ // A switch from empty default calendar to named default calendar or
+ // vice versa is not a switch.
+ bool bSameDefault = false;
+ if (sCalendar.isEmpty() || rNewCalendar.isEmpty())
+ {
+ // As both are not equal, only one can be empty here, the other
+ // can not.
+ const OUString& rDefaultCalendar = GetLocaleData().getDefaultCalendar()->Name;
+ // So if one is the named default calendar the other is the
+ // empty default calendar.
+ bSameDefault = (rNewCalendar == rDefaultCalendar || sCalendar == rDefaultCalendar);
+ }
+ if (!bSameDefault)
+ {
+ aFormatCode.append( "[~" ); // intro for calendar code
+ if (rNewCalendar.isEmpty())
+ {
+ // Empty calendar name here means switching to default calendar
+ // from a different calendar. Needs to be explicitly stated in
+ // format code.
+ aFormatCode.append( GetLocaleData().getDefaultCalendar()->Name );
+ }
+ else
+ {
+ aFormatCode.append( rNewCalendar );
+ }
+ aFormatCode.append( ']' ); // end of calendar code
+ }
+ }
+ sCalendar = rNewCalendar;
+}
+
+bool SvXMLNumFormatContext::IsSystemLanguage() const
+{
+ return nFormatLang == LANGUAGE_SYSTEM;
+}
+
+
+// SvXMLNumFmtHelper
+
+
+SvXMLNumFmtHelper::SvXMLNumFmtHelper(
+ const uno::Reference<util::XNumberFormatsSupplier>& rSupp,
+ const uno::Reference<uno::XComponentContext>& rxContext )
+{
+ SAL_WARN_IF( !rxContext.is(), "xmloff", "got no service manager" );
+
+ SvNumberFormatter* pFormatter = nullptr;
+ SvNumberFormatsSupplierObj* pObj =
+ comphelper::getFromUnoTunnel<SvNumberFormatsSupplierObj>( rSupp );
+ if (pObj)
+ pFormatter = pObj->GetNumberFormatter();
+
+ pData = std::make_unique<SvXMLNumImpData>( pFormatter, rxContext );
+}
+
+SvXMLNumFmtHelper::SvXMLNumFmtHelper(
+ SvNumberFormatter* pNumberFormatter,
+ const uno::Reference<uno::XComponentContext>& rxContext )
+{
+ SAL_WARN_IF( !rxContext.is(), "xmloff", "got no service manager" );
+
+ pData = std::make_unique<SvXMLNumImpData>( pNumberFormatter, rxContext );
+}
+
+SvXMLNumFmtHelper::~SvXMLNumFmtHelper()
+{
+ // remove temporary (volatile) formats from NumberFormatter
+ pData->RemoveVolatileFormats();
+}
+
+
+SvXMLStyleContext* SvXMLNumFmtHelper::CreateChildContext( SvXMLImport& rImport,
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList,
+ SvXMLStylesContext& rStyles )
+{
+ SvXMLStylesTokens nStyleToken;
+ switch (nElement)
+ {
+ case XML_ELEMENT(NUMBER, XML_NUMBER_STYLE):
+ nStyleToken = SvXMLStylesTokens::NUMBER_STYLE;
+ break;
+ case XML_ELEMENT(NUMBER, XML_CURRENCY_STYLE):
+ nStyleToken = SvXMLStylesTokens::CURRENCY_STYLE;
+ break;
+ case XML_ELEMENT(NUMBER, XML_PERCENTAGE_STYLE):
+ nStyleToken = SvXMLStylesTokens::PERCENTAGE_STYLE;
+ break;
+ case XML_ELEMENT(NUMBER, XML_DATE_STYLE):
+ nStyleToken = SvXMLStylesTokens::DATE_STYLE;
+ break;
+ case XML_ELEMENT(NUMBER, XML_TIME_STYLE):
+ nStyleToken = SvXMLStylesTokens::TIME_STYLE;
+ break;
+ case XML_ELEMENT(NUMBER, XML_BOOLEAN_STYLE):
+ nStyleToken = SvXMLStylesTokens::BOOLEAN_STYLE;
+ break;
+ case XML_ELEMENT(NUMBER, XML_TEXT_STYLE):
+ nStyleToken = SvXMLStylesTokens::TEXT_STYLE;
+ break;
+ default:
+ // return NULL if not a data style, caller must handle other elements
+ return nullptr;
+ }
+ return new SvXMLNumFormatContext( rImport, nElement,
+ pData.get(), nStyleToken, xAttrList, rStyles );
+}
+
+LanguageType SvXMLNumFmtHelper::GetLanguageForKey(sal_Int32 nKey) const
+{
+ if (pData->GetNumberFormatter())
+ {
+ const SvNumberformat* pEntry = pData->GetNumberFormatter()->GetEntry(nKey);
+ if (pEntry)
+ return pEntry->GetLanguage();
+ }
+
+ return LANGUAGE_SYSTEM;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/xmlnumi.cxx b/xmloff/source/style/xmlnumi.cxx
new file mode 100644
index 000000000..78fba23d0
--- /dev/null
+++ b/xmloff/source/style/xmlnumi.cxx
@@ -0,0 +1,1081 @@
+/* -*- 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/beans/PropertyValue.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/awt/Size.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+#include <com/sun/star/awt/FontDescriptor.hpp>
+#include <com/sun/star/text/HoriOrientation.hpp>
+#include <com/sun/star/text/VertOrientation.hpp>
+#include <com/sun/star/text/PositionAndSpaceMode.hpp>
+#include <com/sun/star/text/LabelFollow.hpp>
+#include <com/sun/star/container/XNameContainer.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/style/XStyle.hpp>
+#include <com/sun/star/io/XOutputStream.hpp>
+#include <com/sun/star/awt/XBitmap.hpp>
+#include <com/sun/star/style/NumberingType.hpp>
+#include <com/sun/star/container/XIndexReplace.hpp>
+
+#include <o3tl/any.hxx>
+#include <o3tl/temporary.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <sal/log.hxx>
+#include <tools/diagnose_ex.h>
+#include <comphelper/sequence.hxx>
+#include <comphelper/propertyvalue.hxx>
+
+#include <tools/fontenum.hxx>
+#include <tools/color.hxx>
+
+#include <sax/tools/converter.hxx>
+
+#include <vcl/vclenum.hxx>
+
+#include <xmloff/xmltkmap.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/XMLBase64ImportContext.hxx>
+#include <xmloff/xmltoken.hxx>
+
+#include <xmloff/xmluconv.hxx>
+#include "fonthdl.hxx"
+#include <xmloff/XMLFontStylesContext.hxx>
+#include <xmloff/families.hxx>
+#include <xmloff/maptype.hxx>
+
+#include <xmloff/xmlnumi.hxx>
+#include <optional>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::style;
+using namespace ::com::sun::star::text;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::frame;
+using namespace ::xmloff::token;
+using namespace ::com::sun::star::io;
+
+class SvxXMLListLevelStyleContext_Impl;
+
+namespace {
+
+class SvxXMLListLevelStyleAttrContext_Impl : public SvXMLImportContext
+{
+ SvxXMLListLevelStyleContext_Impl& rListLevel;
+
+public:
+
+ SvxXMLListLevelStyleAttrContext_Impl(
+ SvXMLImport& rImport, sal_Int32 nElement,
+ const Reference< xml::sax::XFastAttributeList >& xAttrList,
+ SvxXMLListLevelStyleContext_Impl& rLLevel );
+
+ virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+};
+
+class SvxXMLListLevelStyleLabelAlignmentAttrContext_Impl : public SvXMLImportContext
+{
+public:
+
+ SvxXMLListLevelStyleLabelAlignmentAttrContext_Impl(
+ SvXMLImport& rImport, sal_Int32 nElement,
+ const Reference< xml::sax::XFastAttributeList >& xAttrList,
+ SvxXMLListLevelStyleContext_Impl& rLLevel );
+};
+
+}
+
+class SvxXMLListLevelStyleContext_Impl : public SvXMLImportContext
+{
+ friend SvxXMLListLevelStyleAttrContext_Impl;
+
+ OUString sPrefix;
+ OUString sSuffix;
+ std::optional<OUString> sListFormat; // It is optional to distinguish empty format string
+ // from not existing format string in old docs
+ OUString sTextStyleName;
+ OUString sNumFormat;
+ OUString sNumLetterSync;
+ OUString sBulletFontName;
+ OUString sBulletFontStyleName;
+ OUString sImageURL;
+
+ Reference < XOutputStream > xBase64Stream;
+
+ sal_Int32 nLevel;
+ sal_Int32 nSpaceBefore;
+ sal_Int32 nMinLabelWidth;
+ sal_Int32 nMinLabelDist;
+ sal_Int32 nImageWidth;
+ sal_Int32 nImageHeight;
+ sal_Int16 nNumStartValue;
+ sal_Int16 nNumDisplayLevels;
+
+ sal_Int16 eAdjust;
+ sal_Int16 eBulletFontFamily;
+ sal_Int16 eBulletFontPitch;
+ rtl_TextEncoding eBulletFontEncoding;
+ sal_Int16 eImageVertOrient;
+
+ sal_UCS4 cBullet;
+
+ sal_Int16 nRelSize;
+ Color m_nColor;
+
+ sal_Int16 ePosAndSpaceMode;
+ sal_Int16 eLabelFollowedBy;
+ sal_Int32 nListtabStopPosition;
+ sal_Int32 nFirstLineIndent;
+ sal_Int32 nIndentAt;
+
+ bool bBullet : 1;
+ bool bImage : 1;
+ bool bNum : 1;
+ bool bHasColor : 1;
+
+ void SetRelSize( sal_Int16 nRel ) { nRelSize = nRel; }
+ void SetColor( Color nColor )
+ { m_nColor = nColor; bHasColor = true; }
+ void SetSpaceBefore( sal_Int32 nSet ) { nSpaceBefore = nSet; }
+ void SetMinLabelWidth( sal_Int32 nSet ) { nMinLabelWidth = nSet; }
+ void SetMinLabelDist( sal_Int32 nSet ) { nMinLabelDist = nSet; }
+ void SetAdjust( sal_Int16 eSet ) { eAdjust = eSet; }
+
+ void SetBulletFontName( const OUString& rSet ) { sBulletFontName = rSet; }
+ void SetBulletFontStyleName( const OUString& rSet )
+ { sBulletFontStyleName = rSet; }
+ void SetBulletFontFamily( sal_Int16 eSet ) { eBulletFontFamily = eSet; }
+ void SetBulletFontPitch( sal_Int16 eSet ) { eBulletFontPitch = eSet; }
+ void SetBulletFontEncoding( rtl_TextEncoding eSet )
+ { eBulletFontEncoding = eSet; }
+
+ void SetImageWidth( sal_Int32 nSet ) { nImageWidth = nSet; }
+ void SetImageHeight( sal_Int32 nSet ) { nImageHeight = nSet; }
+ void SetImageVertOrient( sal_Int16 eSet )
+ { eImageVertOrient = eSet; }
+
+public:
+
+ SvxXMLListLevelStyleContext_Impl(
+ SvXMLImport& rImport, sal_Int32 nElement,
+ const Reference< xml::sax::XFastAttributeList > & xAttrList );
+
+ virtual css::uno::Reference< css::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList ) override;
+
+ sal_Int32 GetLevel() const { return nLevel; }
+ Sequence<beans::PropertyValue> GetProperties();
+
+ void SetPosAndSpaceMode( sal_Int16 eValue )
+ {
+ ePosAndSpaceMode = eValue;
+ }
+ void SetLabelFollowedBy( sal_Int16 eValue )
+ {
+ eLabelFollowedBy = eValue;
+ }
+ void SetListtabStopPosition( sal_Int32 nValue )
+ {
+ nListtabStopPosition = nValue;
+ }
+ void SetFirstLineIndent( sal_Int32 nValue )
+ {
+ nFirstLineIndent = nValue;
+ }
+ void SetIndentAt( sal_Int32 nValue )
+ {
+ nIndentAt = nValue;
+ }
+};
+
+constexpr OUStringLiteral gsStarBats( u"StarBats" );
+constexpr OUStringLiteral gsStarMath( u"StarMath" );
+
+SvxXMLListLevelStyleContext_Impl::SvxXMLListLevelStyleContext_Impl(
+ SvXMLImport& rImport, sal_Int32 nElement,
+ const Reference< xml::sax::XFastAttributeList > & xAttrList )
+
+: SvXMLImportContext( rImport )
+, sNumFormat( "1" )
+, nLevel( -1 )
+, nSpaceBefore( 0 )
+, nMinLabelWidth( 0 )
+, nMinLabelDist( 0 )
+, nImageWidth( 0 )
+, nImageHeight( 0 )
+, nNumStartValue( 1 )
+, nNumDisplayLevels( 1 )
+, eAdjust( HoriOrientation::LEFT )
+, eBulletFontFamily( FAMILY_DONTKNOW )
+, eBulletFontPitch( PITCH_DONTKNOW )
+, eBulletFontEncoding( RTL_TEXTENCODING_DONTKNOW )
+, eImageVertOrient(0)
+, cBullet( 0 )
+, nRelSize(0)
+, m_nColor(0)
+, ePosAndSpaceMode( PositionAndSpaceMode::LABEL_WIDTH_AND_POSITION )
+, eLabelFollowedBy( LabelFollow::LISTTAB )
+, nListtabStopPosition( 0 )
+, nFirstLineIndent( 0 )
+, nIndentAt( 0 )
+, bBullet( false )
+, bImage( false )
+, bNum( false )
+, bHasColor( false )
+{
+ switch (nElement & TOKEN_MASK)
+ {
+ case XML_LIST_LEVEL_STYLE_NUMBER:
+ case XML_OUTLINE_LEVEL_STYLE:
+ bNum = true;
+ break;
+ case XML_LIST_LEVEL_STYLE_BULLET:
+ bBullet = true;
+ break;
+ case XML_LIST_LEVEL_STYLE_IMAGE:
+ bImage = true;
+ break;
+ }
+
+ for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
+ {
+ switch( aIter.getToken() )
+ {
+ case XML_ELEMENT(TEXT, XML_LEVEL):
+ nLevel = aIter.toInt32();
+ if( nLevel >= 1 )
+ nLevel--;
+ else
+ nLevel = 0;
+ break;
+ case XML_ELEMENT(TEXT, XML_STYLE_NAME):
+ sTextStyleName = aIter.toString();
+ break;
+ case XML_ELEMENT(TEXT, XML_BULLET_CHAR):
+ if (!aIter.isEmpty())
+ {
+ cBullet = aIter.toString().iterateCodePoints(&o3tl::temporary(sal_Int32(0)));
+ }
+ break;
+ case XML_ELEMENT(XLINK, XML_HREF):
+ if( bImage )
+ sImageURL = aIter.toString();
+ break;
+ case XML_ELEMENT(XLINK, XML_TYPE):
+ case XML_ELEMENT(XLINK, XML_SHOW):
+ case XML_ELEMENT(XLINK, XML_ACTUATE):
+ // This properties will be ignored
+ break;
+ case XML_ELEMENT(STYLE, XML_NUM_FORMAT):
+ if( bNum )
+ sNumFormat = aIter.toString();
+ break;
+ case XML_ELEMENT(STYLE, XML_NUM_PREFIX):
+ sPrefix = aIter.toString();
+ break;
+ case XML_ELEMENT(STYLE, XML_NUM_SUFFIX):
+ sSuffix = aIter.toString();
+ break;
+ case XML_ELEMENT(STYLE, XML_NUM_LIST_FORMAT):
+ case XML_ELEMENT(LO_EXT, XML_NUM_LIST_FORMAT):
+ sListFormat = std::make_optional(aIter.toString());
+ break;
+ case XML_ELEMENT(STYLE, XML_NUM_LETTER_SYNC):
+ if( bNum )
+ sNumLetterSync = aIter.toString();
+ break;
+ case XML_ELEMENT(TEXT, XML_START_VALUE):
+ if( bNum )
+ {
+ sal_Int32 nTmp = aIter.toInt32();
+ nNumStartValue =
+ (nTmp < 0) ? 1 : ( (nTmp>SHRT_MAX) ? SHRT_MAX
+ : static_cast<sal_Int16>(nTmp) );
+ }
+ break;
+ case XML_ELEMENT(TEXT, XML_DISPLAY_LEVELS):
+ if( bNum )
+ {
+ sal_Int32 nTmp = aIter.toInt32();
+ nNumDisplayLevels =
+ (nTmp < 1) ? 1 : ( (nTmp>SHRT_MAX) ? SHRT_MAX
+ : static_cast<sal_Int16>(nTmp) );
+ }
+ break;
+ default:
+ XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+ }
+ }
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SvxXMLListLevelStyleContext_Impl::createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+ if( nElement == XML_ELEMENT(STYLE, XML_LIST_LEVEL_PROPERTIES) ||
+ nElement == XML_ELEMENT(STYLE, XML_TEXT_PROPERTIES) )
+ {
+ return new SvxXMLListLevelStyleAttrContext_Impl( GetImport(),
+ nElement,
+ xAttrList,
+ *this );
+ }
+ else if( nElement == XML_ELEMENT(OFFICE, XML_BINARY_DATA) )
+ {
+ if( bImage && sImageURL.isEmpty() && !xBase64Stream.is() )
+ {
+ xBase64Stream = GetImport().GetStreamForGraphicObjectURLFromBase64();
+ if( xBase64Stream.is() )
+ return new XMLBase64ImportContext( GetImport(), xBase64Stream );
+ }
+ }
+ XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+ return nullptr;
+}
+
+Sequence<beans::PropertyValue> SvxXMLListLevelStyleContext_Impl::GetProperties()
+{
+ if (!bBullet && !bImage && !bNum)
+ {
+ return Sequence<beans::PropertyValue>();
+ }
+
+ sal_Int16 eType = NumberingType::NUMBER_NONE;
+ std::vector<beans::PropertyValue> aProperties;
+
+ if( bBullet )
+ {
+ eType = NumberingType::CHAR_SPECIAL;
+ }
+ if( bImage )
+ {
+ eType = NumberingType::BITMAP;
+ }
+ if( bNum )
+ {
+ eType = NumberingType::ARABIC;
+ GetImport().GetMM100UnitConverter().convertNumFormat(
+ eType, sNumFormat, sNumLetterSync, true );
+ }
+
+ if (bBullet && !sSuffix.isEmpty())
+ {
+ sal_uInt16 const nVersion(GetImport().getGeneratorVersion());
+ sal_Int32 nUPD;
+ sal_Int32 nBuildId;
+ if (GetImport().getBuildIds(nUPD, nBuildId)
+ && ( (SvXMLImport::OOo_1x == nVersion)
+ || (SvXMLImport::OOo_2x == nVersion)
+ || (310 == nUPD) || (320 == nUPD) || (330 == nUPD)
+ || ((300 == nUPD) && (nBuildId <= 9573))))
+ {
+ // #i93908# OOo < 3.4 wrote a bogus suffix for bullet chars
+ sSuffix.clear(); // clear it
+ }
+ }
+
+ if (!sListFormat.has_value())
+ {
+ // This is older document: it has no list format, but can probably contain prefix and/or suffix
+ // Generate list format string, based on this
+ sListFormat = std::make_optional(sPrefix);
+
+ for (int i = 1; i <= nNumDisplayLevels; i++)
+ {
+ *sListFormat += "%";
+ *sListFormat += OUString::number(nLevel - nNumDisplayLevels + i + 1);
+ *sListFormat += "%";
+ if (i != nNumDisplayLevels)
+ *sListFormat += "."; // Default separator for older ODT
+ }
+
+ *sListFormat += sSuffix;
+ }
+
+ aProperties.push_back(comphelper::makePropertyValue("NumberingType", eType));
+
+ aProperties.push_back(comphelper::makePropertyValue("Prefix", sPrefix));
+
+ aProperties.push_back(comphelper::makePropertyValue("Suffix", sSuffix));
+
+ aProperties.push_back(comphelper::makePropertyValue("Adjust", eAdjust));
+
+ sal_Int32 nLeftMargin = nSpaceBefore + nMinLabelWidth;
+ aProperties.push_back(comphelper::makePropertyValue("LeftMargin", nLeftMargin));
+
+ sal_Int32 nFirstLineOffset = -nMinLabelWidth;
+ aProperties.push_back(comphelper::makePropertyValue("FirstLineOffset", nFirstLineOffset));
+
+ aProperties.push_back(comphelper::makePropertyValue("SymbolTextDistance", static_cast<sal_Int16>(nMinLabelDist)));
+
+ aProperties.push_back(comphelper::makePropertyValue("PositionAndSpaceMode", ePosAndSpaceMode));
+
+ aProperties.push_back(comphelper::makePropertyValue("LabelFollowedBy", eLabelFollowedBy));
+
+ aProperties.push_back(comphelper::makePropertyValue("ListtabStopPosition", nListtabStopPosition));
+
+ aProperties.push_back(comphelper::makePropertyValue("FirstLineIndent", nFirstLineIndent));
+
+ aProperties.push_back(comphelper::makePropertyValue("IndentAt", nIndentAt));
+
+ OUString sDisplayTextStyleName = GetImport().GetStyleDisplayName(XmlStyleFamily::TEXT_TEXT, sTextStyleName);
+ aProperties.push_back(comphelper::makePropertyValue("CharStyleName", sDisplayTextStyleName));
+
+ if( bBullet )
+ {
+ awt::FontDescriptor aFDesc;
+ aFDesc.Name = sBulletFontName;
+ if( !sBulletFontName.isEmpty() )
+ {
+ aFDesc.StyleName = sBulletFontStyleName;
+ aFDesc.Family = eBulletFontFamily;
+ aFDesc.Pitch = eBulletFontPitch;
+ aFDesc.CharSet = eBulletFontEncoding;
+ aFDesc.Weight = WEIGHT_DONTKNOW;
+ bool bStarSymbol = false;
+ if( aFDesc.Name.equalsIgnoreAsciiCase( gsStarBats ) )
+ {
+ cBullet = GetImport().ConvStarBatsCharToStarSymbol( cBullet );
+ bStarSymbol = true;
+ }
+ else if( aFDesc.Name.equalsIgnoreAsciiCase( gsStarMath ) )
+ {
+ cBullet = GetImport().ConvStarMathCharToStarSymbol( cBullet );
+ bStarSymbol = true;
+ }
+ if( bStarSymbol )
+ aFDesc.Name = "StarSymbol" ;
+ }
+
+ // Must append 'cBullet' even if it is zero
+ // if 'bBullet' is true and 'cBullet' is zero - BulletChar property must be 0.
+ aProperties.push_back(comphelper::makePropertyValue("BulletChar", OUString(&cBullet, 1)));
+ aProperties.push_back(comphelper::makePropertyValue("BulletFont", aFDesc));
+ }
+
+ if( bImage )
+ {
+ uno::Reference<graphic::XGraphic> xGraphic;
+ if (!sImageURL.isEmpty())
+ {
+ xGraphic = GetImport().loadGraphicByURL(sImageURL);
+ }
+ else if( xBase64Stream.is() )
+ {
+ xGraphic = GetImport().loadGraphicFromBase64(xBase64Stream);
+ }
+
+ uno::Reference<awt::XBitmap> xBitmap;
+ if (xGraphic.is())
+ xBitmap.set(xGraphic, uno::UNO_QUERY);
+
+ if (xBitmap.is())
+ {
+ aProperties.push_back(comphelper::makePropertyValue("GraphicBitmap", xBitmap));
+ }
+
+ awt::Size aSize(nImageWidth, nImageHeight);
+ aProperties.push_back(comphelper::makePropertyValue("GraphicSize", aSize));
+ aProperties.push_back(comphelper::makePropertyValue("VertOrient", eImageVertOrient));
+ }
+
+ if( bNum )
+ {
+ aProperties.push_back(comphelper::makePropertyValue("StartWith", nNumStartValue));
+ aProperties.push_back(comphelper::makePropertyValue("ParentNumbering", nNumDisplayLevels));
+ }
+
+ if( ( bNum || bBullet ) && nRelSize )
+ {
+ aProperties.push_back(comphelper::makePropertyValue("BulletRelSize", nRelSize));
+ }
+
+ if( !bImage && bHasColor )
+ {
+ aProperties.push_back(comphelper::makePropertyValue("BulletColor", m_nColor));
+ }
+
+ aProperties.push_back(comphelper::makePropertyValue("ListFormat", *sListFormat));
+
+ return comphelper::containerToSequence(aProperties);
+}
+
+SvxXMLListLevelStyleAttrContext_Impl::SvxXMLListLevelStyleAttrContext_Impl(
+ SvXMLImport& rImport, sal_Int32 /*nElement*/,
+ const Reference< xml::sax::XFastAttributeList > & xAttrList,
+ SvxXMLListLevelStyleContext_Impl& rLLevel ) :
+ SvXMLImportContext( rImport ),
+ rListLevel( rLLevel )
+{
+ SvXMLUnitConverter& rUnitConv = GetImport().GetMM100UnitConverter();
+
+ OUString sFontName, sFontFamily, sFontStyleName, sFontFamilyGeneric,
+ sFontPitch, sFontCharset;
+ OUString sVerticalPos, sVerticalRel;
+
+ for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
+ {
+ sal_Int32 nVal;
+ switch( aIter.getToken() )
+ {
+ case XML_ELEMENT(TEXT, XML_SPACE_BEFORE):
+ if (rUnitConv.convertMeasureToCore(nVal, aIter.toView(), SHRT_MIN, SHRT_MAX))
+ rListLevel.SetSpaceBefore( nVal );
+ break;
+ case XML_ELEMENT(TEXT, XML_MIN_LABEL_WIDTH):
+ if (rUnitConv.convertMeasureToCore( nVal, aIter.toView(), 0, SHRT_MAX ))
+ rListLevel.SetMinLabelWidth( nVal );
+ break;
+ case XML_ELEMENT(TEXT, XML_MIN_LABEL_DISTANCE):
+ if (rUnitConv.convertMeasureToCore( nVal, aIter.toView(), 0, USHRT_MAX ))
+ rListLevel.SetMinLabelDist( nVal );
+ break;
+ case XML_ELEMENT(FO, XML_TEXT_ALIGN):
+ case XML_ELEMENT(FO_COMPAT, XML_TEXT_ALIGN):
+ if( !aIter.isEmpty() )
+ {
+ sal_Int16 eAdjust = HoriOrientation::LEFT;
+ if( IsXMLToken( aIter, XML_CENTER ) )
+ eAdjust = HoriOrientation::CENTER;
+ else if( IsXMLToken( aIter, XML_END ) )
+ eAdjust = HoriOrientation::RIGHT;
+ rListLevel.SetAdjust( eAdjust );
+ }
+ break;
+ case XML_ELEMENT(STYLE, XML_FONT_NAME):
+ sFontName = aIter.toString();
+ break;
+ case XML_ELEMENT(FO, XML_FONT_FAMILY):
+ case XML_ELEMENT(FO_COMPAT, XML_FONT_FAMILY):
+ sFontFamily = aIter.toString();
+ break;
+ case XML_ELEMENT(STYLE, XML_FONT_FAMILY_GENERIC):
+ sFontFamilyGeneric = aIter.toString();
+ break;
+ case XML_ELEMENT(STYLE, XML_FONT_STYLE_NAME):
+ sFontStyleName = aIter.toString();
+ break;
+ case XML_ELEMENT(STYLE, XML_FONT_PITCH):
+ sFontPitch = aIter.toString();
+ break;
+ case XML_ELEMENT(STYLE, XML_FONT_CHARSET):
+ sFontCharset = aIter.toString();
+ break;
+ case XML_ELEMENT(STYLE, XML_VERTICAL_POS):
+ sVerticalPos = aIter.toString();
+ break;
+ case XML_ELEMENT(STYLE, XML_VERTICAL_REL):
+ sVerticalRel = aIter.toString();
+ break;
+ case XML_ELEMENT(FO, XML_WIDTH):
+ case XML_ELEMENT(FO_COMPAT, XML_WIDTH):
+ if (rUnitConv.convertMeasureToCore(nVal, aIter.toView()))
+ rListLevel.SetImageWidth( nVal );
+ break;
+ case XML_ELEMENT(FO, XML_HEIGHT):
+ case XML_ELEMENT(FO_COMPAT, XML_HEIGHT):
+ if (rUnitConv.convertMeasureToCore(nVal, aIter.toView()))
+ rListLevel.SetImageHeight( nVal );
+ break;
+ case XML_ELEMENT(FO, XML_COLOR):
+ case XML_ELEMENT(FO_COMPAT, XML_COLOR):
+ {
+ Color nColor;
+ if (::sax::Converter::convertColor( nColor, aIter.toView() ))
+ rListLevel.SetColor( nColor );
+ }
+ break;
+ case XML_ELEMENT(STYLE, XML_USE_WINDOW_FONT_COLOR):
+ {
+ if( IsXMLToken( aIter, XML_TRUE ) )
+ rListLevel.SetColor(COL_AUTO);
+ }
+ break;
+ case XML_ELEMENT(FO, XML_FONT_SIZE):
+ case XML_ELEMENT(FO_COMPAT, XML_FONT_SIZE):
+ if (::sax::Converter::convertPercent( nVal, aIter.toView() ))
+ rListLevel.SetRelSize( static_cast<sal_Int16>(nVal) );
+ break;
+ case XML_ELEMENT(TEXT, XML_LIST_LEVEL_POSITION_AND_SPACE_MODE):
+ {
+ sal_Int16 ePosAndSpaceMode = PositionAndSpaceMode::LABEL_WIDTH_AND_POSITION;
+ if( IsXMLToken( aIter, XML_LABEL_ALIGNMENT ) )
+ ePosAndSpaceMode = PositionAndSpaceMode::LABEL_ALIGNMENT;
+ rListLevel.SetPosAndSpaceMode( ePosAndSpaceMode );
+ }
+ break;
+ default:
+ XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+ }
+ }
+
+ if( !sFontName.isEmpty() )
+ {
+ const XMLFontStylesContext *pFontDecls =
+ GetImport().GetFontDecls();
+ if( pFontDecls )
+ {
+ ::std::vector < XMLPropertyState > aProps;
+ if( pFontDecls->FillProperties( sFontName, aProps, 0, 1, 2, 3, 4 ) )
+ {
+ OUString sTmp;
+ sal_Int16 nTmp = 0;
+ for( const auto& rProp : aProps )
+ {
+ switch( rProp.mnIndex )
+ {
+ case 0:
+ rProp.maValue >>= sTmp;
+ rListLevel.SetBulletFontName( sTmp);
+ break;
+ case 1:
+ rProp.maValue >>= sTmp;
+ rListLevel.SetBulletFontStyleName( sTmp );
+ break;
+ case 2:
+ rProp.maValue >>= nTmp;
+ rListLevel.SetBulletFontFamily( nTmp );
+ break;
+ case 3:
+ rProp.maValue >>= nTmp;
+ rListLevel.SetBulletFontPitch( nTmp );
+ break;
+ case 4:
+ rProp.maValue >>= nTmp;
+ rListLevel.SetBulletFontEncoding( nTmp );
+ break;
+ }
+ }
+ }
+ }
+ }
+ if( !sFontFamily.isEmpty() )
+ {
+ Any aAny;
+
+ XMLFontFamilyNamePropHdl aFamilyNameHdl;
+ if( aFamilyNameHdl.importXML( sFontFamily, aAny, rUnitConv ) )
+ {
+ OUString sTmp;
+ aAny >>= sTmp;
+ rListLevel.SetBulletFontName( sTmp);
+ }
+
+ XMLFontFamilyPropHdl aFamilyHdl;
+ if( !sFontFamilyGeneric.isEmpty() &&
+ aFamilyHdl.importXML( sFontFamilyGeneric, aAny, rUnitConv ) )
+ {
+ sal_Int16 nTmp = 0;
+ aAny >>= nTmp;
+ rListLevel.SetBulletFontFamily( nTmp );
+ }
+
+ if( !sFontStyleName.isEmpty() )
+ rListLevel.SetBulletFontStyleName( sFontStyleName );
+
+ XMLFontPitchPropHdl aPitchHdl;
+ if( !sFontPitch.isEmpty() &&
+ aPitchHdl.importXML( sFontPitch, aAny, rUnitConv ) )
+ {
+ sal_Int16 nTmp = 0;
+ aAny >>= nTmp;
+ rListLevel.SetBulletFontPitch( nTmp );
+ }
+
+ XMLFontEncodingPropHdl aEncHdl;
+ if( !sFontCharset.isEmpty() &&
+ aEncHdl.importXML( sFontCharset, aAny, rUnitConv ) )
+ {
+ sal_Int16 nTmp = 0;
+ aAny >>= nTmp;
+ rListLevel.SetBulletFontEncoding( nTmp );
+ }
+ }
+
+ sal_Int16 eVertOrient = VertOrientation::LINE_CENTER;
+ if( !sVerticalPos.isEmpty() )
+ {
+ if( IsXMLToken( sVerticalPos, XML_TOP ) )
+ eVertOrient = VertOrientation::LINE_TOP;
+ else if( IsXMLToken( sVerticalPos, XML_BOTTOM ) )
+ eVertOrient = VertOrientation::LINE_BOTTOM;
+ }
+ if( !sVerticalRel.isEmpty() )
+ {
+ if( IsXMLToken( sVerticalRel, XML_BASELINE ) )
+ {
+ // TOP and BOTTOM are exchanged for a baseline relation
+ switch( eVertOrient )
+ {
+ case VertOrientation::LINE_TOP:
+ eVertOrient = VertOrientation::BOTTOM;
+ break;
+ case VertOrientation::LINE_CENTER:
+ eVertOrient = VertOrientation::CENTER;
+ break;
+ case VertOrientation::LINE_BOTTOM:
+ eVertOrient = VertOrientation::TOP;
+ break;
+ }
+ }
+ else if( IsXMLToken( sVerticalRel, XML_CHAR ) )
+ {
+ switch( eVertOrient )
+ {
+ case VertOrientation::LINE_TOP:
+ eVertOrient = VertOrientation::CHAR_TOP;
+ break;
+ case VertOrientation::LINE_CENTER:
+ eVertOrient = VertOrientation::CHAR_CENTER;
+ break;
+ case VertOrientation::LINE_BOTTOM:
+ eVertOrient = VertOrientation::CHAR_BOTTOM;
+ break;
+ }
+ }
+ }
+ rListLevel.SetImageVertOrient( eVertOrient );
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SvxXMLListLevelStyleAttrContext_Impl::createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+ if ( nElement == XML_ELEMENT(STYLE, XML_LIST_LEVEL_LABEL_ALIGNMENT) )
+ {
+ return new SvxXMLListLevelStyleLabelAlignmentAttrContext_Impl( GetImport(),
+ nElement,
+ xAttrList,
+ rListLevel );
+ }
+ XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+ return nullptr;
+}
+
+
+SvxXMLListLevelStyleLabelAlignmentAttrContext_Impl::SvxXMLListLevelStyleLabelAlignmentAttrContext_Impl(
+ SvXMLImport& rImport, sal_Int32 /*nElement*/,
+ const Reference< xml::sax::XFastAttributeList > & xAttrList,
+ SvxXMLListLevelStyleContext_Impl& rLLevel ) :
+ SvXMLImportContext( rImport )
+{
+ SvXMLUnitConverter& rUnitConv = GetImport().GetMM100UnitConverter();
+
+ sal_Int16 eLabelFollowedBy = LabelFollow::LISTTAB;
+ for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
+ {
+ sal_Int32 nVal;
+ switch( aIter.getToken() )
+ {
+ case XML_ELEMENT(TEXT, XML_LABEL_FOLLOWED_BY):
+ case XML_ELEMENT(LO_EXT, XML_LABEL_FOLLOWED_BY):
+ {
+ if( eLabelFollowedBy == LabelFollow::NEWLINE)
+ //NewLine from LO_EXT has precedence over other values of the Non LO_EXT namespace
+ break;
+ if( IsXMLToken( aIter, XML_SPACE ) )
+ eLabelFollowedBy = LabelFollow::SPACE;
+ else if( IsXMLToken( aIter, XML_NOTHING ) )
+ eLabelFollowedBy = LabelFollow::NOTHING;
+ else if( IsXMLToken( aIter, XML_NEWLINE ) )
+ eLabelFollowedBy = LabelFollow::NEWLINE;
+ }
+ break;
+ case XML_ELEMENT(TEXT, XML_LIST_TAB_STOP_POSITION):
+ if (rUnitConv.convertMeasureToCore(nVal, aIter.toView(), 0, SHRT_MAX))
+ rLLevel.SetListtabStopPosition( nVal );
+ break;
+ case XML_ELEMENT(FO, XML_TEXT_INDENT):
+ case XML_ELEMENT(FO_COMPAT, XML_TEXT_INDENT):
+ if (rUnitConv.convertMeasureToCore(nVal, aIter.toView(), SHRT_MIN, SHRT_MAX))
+ rLLevel.SetFirstLineIndent( nVal );
+ break;
+ case XML_ELEMENT(FO, XML_MARGIN_LEFT):
+ case XML_ELEMENT(FO_COMPAT, XML_MARGIN_LEFT):
+ if (rUnitConv.convertMeasureToCore(nVal, aIter.toView(), SHRT_MIN, SHRT_MAX))
+ rLLevel.SetIndentAt( nVal );
+ break;
+ default:
+ XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+ }
+ }
+ rLLevel.SetLabelFollowedBy( eLabelFollowedBy );
+}
+
+void SvxXMLListStyleContext::SetAttribute( sal_Int32 nElement,
+ const OUString& rValue )
+{
+ if( nElement == XML_ELEMENT(TEXT, XML_CONSECUTIVE_NUMBERING) )
+ {
+ bConsecutive = IsXMLToken( rValue, XML_TRUE );
+ }
+ else
+ {
+ SvXMLStyleContext::SetAttribute( nElement, rValue );
+ }
+}
+
+constexpr OUStringLiteral sIsPhysical( u"IsPhysical" );
+constexpr OUStringLiteral sNumberingRules( u"NumberingRules" );
+constexpr OUStringLiteral sIsContinuousNumbering( u"IsContinuousNumbering" );
+
+SvxXMLListStyleContext::SvxXMLListStyleContext( SvXMLImport& rImport,
+ bool bOutl )
+: SvXMLStyleContext( rImport, bOutl ? XmlStyleFamily::TEXT_OUTLINE : XmlStyleFamily::TEXT_LIST )
+, bConsecutive( false )
+, bOutline( bOutl )
+{
+}
+
+SvxXMLListStyleContext::~SvxXMLListStyleContext() {}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SvxXMLListStyleContext::createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+ if( bOutline
+ ? nElement == XML_ELEMENT(TEXT, XML_OUTLINE_LEVEL_STYLE)
+ : ( nElement == XML_ELEMENT(TEXT, XML_LIST_LEVEL_STYLE_NUMBER) ||
+ nElement == XML_ELEMENT(TEXT, XML_LIST_LEVEL_STYLE_BULLET) ||
+ nElement == XML_ELEMENT(TEXT, XML_LIST_LEVEL_STYLE_IMAGE ) ) )
+ {
+ rtl::Reference<SvxXMLListLevelStyleContext_Impl> xLevelStyle{
+ new SvxXMLListLevelStyleContext_Impl( GetImport(), nElement, xAttrList )};
+ if( !pLevelStyles )
+ pLevelStyles = std::make_unique<SvxXMLListStyle_Impl>();
+ pLevelStyles->push_back( xLevelStyle );
+
+ return xLevelStyle;
+ }
+ XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+ return nullptr;
+}
+
+void SvxXMLListStyleContext::FillUnoNumRule(
+ const Reference<container::XIndexReplace> & rNumRule) const
+{
+ try
+ {
+ if( pLevelStyles && rNumRule.is() )
+ {
+ sal_Int32 l_nLevels = rNumRule->getCount();
+ for (const auto& pLevelStyle : *pLevelStyles)
+ {
+ sal_Int32 nLevel = pLevelStyle->GetLevel();
+ if( nLevel >= 0 && nLevel < l_nLevels )
+ {
+ Sequence<beans::PropertyValue> aProps =
+ pLevelStyle->GetProperties();
+ rNumRule->replaceByIndex( nLevel, Any(aProps) );
+ }
+ }
+ }
+
+ Reference < XPropertySet > xPropSet( rNumRule, UNO_QUERY );
+ Reference< XPropertySetInfo > xPropSetInfo;
+ if (xPropSet.is())
+ xPropSetInfo = xPropSet->getPropertySetInfo();
+ if( xPropSetInfo.is() &&
+ xPropSetInfo->hasPropertyByName( sIsContinuousNumbering ) )
+ {
+ xPropSet->setPropertyValue( sIsContinuousNumbering, Any(bConsecutive) );
+ }
+ }
+ catch (const Exception&)
+ {
+ TOOLS_WARN_EXCEPTION("xmloff.style", "" );
+ }
+}
+
+void SvxXMLListStyleContext::CreateAndInsertLate( bool bOverwrite )
+{
+ if( bOutline )
+ {
+ if( bOverwrite )
+ {
+ const Reference< XIndexReplace >& rNumRule =
+ GetImport().GetTextImport()->GetChapterNumbering();
+ // We don't set xNumberingRules here, to avoid using them
+ // as numbering rules.
+ if( rNumRule.is() )
+ FillUnoNumRule(rNumRule);
+ }
+ }
+ else
+ {
+ Reference < XStyle > xStyle;
+ const OUString& rName = GetDisplayName();
+ if( rName.isEmpty() )
+ {
+ SetValid( false );
+ return;
+ }
+
+ const Reference < XNameContainer >& rNumStyles =
+ GetImport().GetTextImport()->GetNumberingStyles();
+ if( !rNumStyles.is() )
+ {
+ SetValid( false );
+ return;
+ }
+
+ bool bNew = false;
+ if( rNumStyles->hasByName( rName ) )
+ {
+ Any aAny = rNumStyles->getByName( rName );
+ aAny >>= xStyle;
+ }
+ else
+ {
+ Reference< XMultiServiceFactory > xFactory( GetImport().GetModel(),
+ UNO_QUERY );
+ SAL_WARN_IF( !xFactory.is(), "xmloff", "no factory" );
+ if( !xFactory.is() )
+ return;
+
+ Reference < XInterface > xIfc = xFactory->createInstance("com.sun.star.style.NumberingStyle");
+ if( !xIfc.is() )
+ return;
+ Reference < XStyle > xTmp( xIfc, UNO_QUERY );
+ xStyle = xTmp;
+ if( !xStyle.is() )
+ return;
+
+ rNumStyles->insertByName( rName, Any(xStyle) );
+ bNew = true;
+ }
+
+ Reference < XPropertySet > xPropSet( xStyle, UNO_QUERY );
+ Reference< XPropertySetInfo > xPropSetInfo =
+ xPropSet->getPropertySetInfo();
+ if( !bNew && xPropSetInfo->hasPropertyByName( sIsPhysical ) )
+ {
+ Any aAny = xPropSet->getPropertyValue( sIsPhysical );
+ bNew = !*o3tl::doAccess<bool>(aAny);
+ }
+
+ if ( xPropSetInfo->hasPropertyByName( "Hidden" ) )
+ xPropSet->setPropertyValue( "Hidden", uno::Any( IsHidden( ) ) );
+
+ if( rName != GetName() )
+ GetImport().AddStyleDisplayName( XmlStyleFamily::TEXT_LIST,
+ GetName(), rName );
+
+ Any aAny = xPropSet->getPropertyValue( sNumberingRules );
+ aAny >>= xNumRules;
+ if( bOverwrite || bNew )
+ {
+ FillUnoNumRule(xNumRules);
+ xPropSet->setPropertyValue( sNumberingRules, Any(xNumRules) );
+ }
+ else
+ {
+ SetValid( false );
+ }
+
+ SetNew( bNew );
+ }
+}
+
+void SvxXMLListStyleContext::CreateAndInsertAuto() const
+{
+ SAL_WARN_IF( bOutline, "xmloff", "Outlines cannot be inserted here" );
+ SAL_WARN_IF( xNumRules.is(), "xmloff", "Numbering Rule is existing already" );
+
+ const OUString& rName = GetName();
+ if( bOutline || xNumRules.is() || rName.isEmpty() )
+ {
+ const_cast<SvxXMLListStyleContext *>(this)->SetValid( false );
+ return;
+ }
+
+ const_cast<SvxXMLListStyleContext *>(this)->xNumRules = CreateNumRule(
+ GetImport().GetModel() );
+
+ FillUnoNumRule(xNumRules);
+}
+
+Reference < XIndexReplace > SvxXMLListStyleContext::CreateNumRule(
+ const Reference < XModel > & rModel )
+{
+ Reference<XIndexReplace> xNumRule;
+
+ Reference< XMultiServiceFactory > xFactory( rModel, UNO_QUERY );
+ SAL_WARN_IF( !xFactory.is(), "xmloff", "no factory" );
+ if( !xFactory.is() )
+ return xNumRule;
+
+ Reference < XInterface > xIfc = xFactory->createInstance("com.sun.star.text.NumberingRules");
+ if( !xIfc.is() )
+ return xNumRule;
+
+ xNumRule.set( xIfc, UNO_QUERY );
+ SAL_WARN_IF( !xNumRule.is(), "xmloff", "go no numbering rule" );
+
+ return xNumRule;
+}
+
+void SvxXMLListStyleContext::SetDefaultStyle(
+ const Reference < XIndexReplace > & rNumRule,
+ sal_Int16 nLevel,
+ bool bOrdered )
+{
+ Sequence<beans::PropertyValue> aPropSeq( bOrdered ? 1 : 4 );
+ beans::PropertyValue *pProps = aPropSeq.getArray();
+
+ pProps->Name = "NumberingType";
+ (pProps++)->Value <<= static_cast<sal_Int16>(bOrdered ? NumberingType::ARABIC
+ : NumberingType::CHAR_SPECIAL );
+ if( !bOrdered )
+ {
+ // TODO: Bullet-Font
+ awt::FontDescriptor aFDesc;
+ aFDesc.Name =
+#ifdef _WIN32
+ "StarBats"
+#else
+ "starbats"
+#endif
+ ;
+ aFDesc.Family = FAMILY_DONTKNOW ;
+ aFDesc.Pitch = PITCH_DONTKNOW ;
+ aFDesc.CharSet = RTL_TEXTENCODING_SYMBOL ;
+ aFDesc.Weight = WEIGHT_DONTKNOW;
+ pProps->Name = "BulletFont";
+ (pProps++)->Value <<= aFDesc;
+
+ pProps->Name = "BulletChar";
+ (pProps++)->Value <<= OUString(sal_Unicode(0xF000 + 149));
+ pProps->Name = "CharStyleName";
+ (pProps++)->Value <<= OUString( "Numbering Symbols" );
+ }
+
+ rNumRule->replaceByIndex( nLevel, Any(aPropSeq) );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/xmlprcon.cxx b/xmloff/source/style/xmlprcon.cxx
new file mode 100644
index 000000000..cb0a6eca9
--- /dev/null
+++ b/xmloff/source/style/xmlprcon.cxx
@@ -0,0 +1,89 @@
+/* -*- 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/log.hxx>
+#include <xmloff/xmlprcon.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmltypes.hxx>
+#include <xmloff/maptype.hxx>
+#include <xmloff/xmlimppr.hxx>
+#include <xmloff/xmlprmap.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::std;
+
+SvXMLPropertySetContext::SvXMLPropertySetContext(
+ SvXMLImport& rImp, sal_Int32 /*nElement*/,
+ const uno::Reference< xml::sax::XFastAttributeList >& xAttrList,
+ sal_uInt32 nFam,
+ vector< XMLPropertyState > &rProps,
+ const rtl::Reference < SvXMLImportPropertyMapper > &rMap,
+ sal_Int32 nSIdx, sal_Int32 nEIdx )
+: SvXMLImportContext( rImp )
+, mnStartIdx( nSIdx )
+, mnEndIdx( nEIdx )
+, mnFamily( nFam )
+, mrProperties( rProps )
+, mxMapper( rMap )
+{
+ mxMapper->importXML( mrProperties, xAttrList,
+ GetImport().GetMM100UnitConverter(),
+ GetImport().GetNamespaceMap(), mnFamily,
+ mnStartIdx, mnEndIdx );
+}
+
+SvXMLPropertySetContext::~SvXMLPropertySetContext()
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SvXMLPropertySetContext::createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+ rtl::Reference< XMLPropertySetMapper > aSetMapper(
+ mxMapper->getPropertySetMapper() );
+ sal_Int32 nEntryIndex = aSetMapper->GetEntryIndex( nElement, mnFamily, mnStartIdx );
+
+ if( ( nEntryIndex != -1 ) && (-1 == mnEndIdx || nEntryIndex < mnEndIdx ) &&
+ ( 0 != ( aSetMapper->GetEntryFlags( nEntryIndex )
+ & MID_FLAG_ELEMENT_ITEM_IMPORT ) ) )
+ {
+ XMLPropertyState aProp( nEntryIndex );
+ return createFastChildContext( nElement, xAttrList, mrProperties, aProp );
+ }
+ XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+ return nullptr;
+}
+
+/** This method is called from this instance implementation of
+ CreateChildContext if the element matches an entry in the
+ SvXMLImportItemMapper with the mid flag MID_FLAG_ELEMENT
+*/
+css::uno::Reference< css::xml::sax::XFastContextHandler > SvXMLPropertySetContext::createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& /*xAttrList*/,
+ ::std::vector< XMLPropertyState > &/*rProperties*/,
+ const XMLPropertyState& /*rProp*/ )
+{
+ XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+ return nullptr;
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/xmlprhdl.cxx b/xmloff/source/style/xmlprhdl.cxx
new file mode 100644
index 000000000..530bcd479
--- /dev/null
+++ b/xmloff/source/style/xmlprhdl.cxx
@@ -0,0 +1,33 @@
+/* -*- 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 <xmloff/xmlprhdl.hxx>
+#include <com/sun/star/uno/Any.hxx>
+
+XMLPropertyHandler::~XMLPropertyHandler()
+{
+ // does nothing
+}
+
+bool XMLPropertyHandler::equals(const css::uno::Any& r1, const css::uno::Any& r2) const
+{
+ return (r1 == r2);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/xmlprmap.cxx b/xmloff/source/style/xmlprmap.cxx
new file mode 100644
index 000000000..a2e35b774
--- /dev/null
+++ b/xmloff/source/style/xmlprmap.cxx
@@ -0,0 +1,361 @@
+/* -*- 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 <o3tl/safeint.hxx>
+#include <rtl/ref.hxx>
+
+#include <xmloff/xmlprmap.hxx>
+#include <xmloff/xmlprhdl.hxx>
+#include <xmloff/xmltypes.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/maptype.hxx>
+#include <xmloff/prhdlfac.hxx>
+#include <xmloff/xmlimp.hxx>
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+
+#include <vector>
+
+using namespace ::std;
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using ::xmloff::token::GetXMLToken;
+
+namespace {
+
+/** Helper-class for XML-im/export:
+ - Holds a pointer to a given array of XMLPropertyMapEntry
+ - Provides several methods to access data from this array
+ - Holds a Sequence of XML-names (for properties)
+ - The filter takes all properties of the XPropertySet which are also
+ in the XMLPropertyMapEntry and which are have not a default value
+ and put them into a vector of XMLPropertyStae
+ - this class knows how to compare, im/export properties
+
+ Attention: At all methods, which get an index as parameter, there is no
+ range validation to save runtime !!
+*/
+struct XMLPropertySetMapperEntry_Impl
+{
+ OUString sXMLAttributeName;
+ OUString sAPIPropertyName;
+ sal_Int32 nType;
+ sal_uInt16 nXMLNameSpace;
+ sal_Int16 nContextId;
+ SvtSaveOptions::ODFSaneDefaultVersion nEarliestODFVersionForExport;
+ bool bImportOnly;
+ const XMLPropertyHandler *pHdl;
+
+ XMLPropertySetMapperEntry_Impl(
+ const XMLPropertyMapEntry& rMapEntry,
+ const rtl::Reference< XMLPropertyHandlerFactory >& rFactory );
+
+ sal_uInt32 GetPropType() const { return nType & XML_TYPE_PROP_MASK; }
+};
+
+}
+
+XMLPropertySetMapperEntry_Impl::XMLPropertySetMapperEntry_Impl(
+ const XMLPropertyMapEntry& rMapEntry,
+ const rtl::Reference< XMLPropertyHandlerFactory >& rFactory ) :
+ sXMLAttributeName( GetXMLToken(rMapEntry.meXMLName) ),
+ sAPIPropertyName( OUString(rMapEntry.msApiName, rMapEntry.nApiNameLength,
+ RTL_TEXTENCODING_ASCII_US ) ),
+ nType( rMapEntry.mnType ),
+ nXMLNameSpace( rMapEntry.mnNameSpace ),
+ nContextId( rMapEntry.mnContextId ),
+ nEarliestODFVersionForExport( rMapEntry.mnEarliestODFVersionForExport ),
+ bImportOnly( rMapEntry.mbImportOnly),
+ pHdl( rFactory->GetPropertyHandler( rMapEntry.mnType & MID_FLAG_MASK ) )
+{
+ assert(pHdl);
+}
+
+struct XMLPropertySetMapper::Impl
+{
+ std::vector<XMLPropertySetMapperEntry_Impl> maMapEntries;
+ std::vector<rtl::Reference <XMLPropertyHandlerFactory> > maHdlFactories;
+
+ bool mbOnlyExportMappings;
+
+ explicit Impl( bool bForExport ) : mbOnlyExportMappings(bForExport) {}
+};
+
+// Ctor
+XMLPropertySetMapper::XMLPropertySetMapper(
+ const XMLPropertyMapEntry* pEntries, const rtl::Reference<XMLPropertyHandlerFactory>& rFactory,
+ bool bForExport ) :
+ mpImpl(new Impl(bForExport))
+{
+ mpImpl->maHdlFactories.push_back(rFactory);
+ if( !pEntries )
+ return;
+
+ const XMLPropertyMapEntry* pIter = pEntries;
+
+ if (mpImpl->mbOnlyExportMappings)
+ {
+ while( pIter->msApiName )
+ {
+ if (!pIter->mbImportOnly)
+ {
+ XMLPropertySetMapperEntry_Impl aEntry( *pIter, rFactory );
+ mpImpl->maMapEntries.push_back( aEntry );
+ }
+ ++pIter;
+ }
+ }
+ else
+ {
+ while( pIter->msApiName )
+ {
+ XMLPropertySetMapperEntry_Impl aEntry( *pIter, rFactory );
+ mpImpl->maMapEntries.push_back( aEntry );
+ ++pIter;
+ }
+ }
+}
+
+XMLPropertySetMapper::~XMLPropertySetMapper()
+{
+}
+
+void XMLPropertySetMapper::AddMapperEntry(
+ const rtl::Reference < XMLPropertySetMapper >& rMapper )
+{
+ for( const auto& rHdlFactory : rMapper->mpImpl->maHdlFactories )
+ {
+ mpImpl->maHdlFactories.push_back(rHdlFactory);
+ }
+
+ for( const auto& rMapEntry : rMapper->mpImpl->maMapEntries )
+ {
+ if (!mpImpl->mbOnlyExportMappings || !rMapEntry.bImportOnly)
+ mpImpl->maMapEntries.push_back( rMapEntry );
+ }
+}
+
+sal_Int32 XMLPropertySetMapper::GetEntryCount() const
+{
+ return mpImpl->maMapEntries.size();
+}
+
+sal_uInt32 XMLPropertySetMapper::GetEntryFlags( sal_Int32 nIndex ) const
+{
+ assert((0 <= nIndex) && (o3tl::make_unsigned(nIndex) < mpImpl->maMapEntries.size()));
+ return mpImpl->maMapEntries[nIndex].nType & ~MID_FLAG_MASK;
+}
+
+sal_uInt32 XMLPropertySetMapper::GetEntryType( sal_Int32 nIndex ) const
+{
+ assert((0 <= nIndex) && (o3tl::make_unsigned(nIndex) < mpImpl->maMapEntries.size()));
+ sal_uInt32 nType = mpImpl->maMapEntries[nIndex].nType;
+ return nType;
+}
+
+sal_uInt16 XMLPropertySetMapper::GetEntryNameSpace( sal_Int32 nIndex ) const
+{
+ assert((0 <= nIndex) && (o3tl::make_unsigned(nIndex) < mpImpl->maMapEntries.size()));
+ return mpImpl->maMapEntries[nIndex].nXMLNameSpace;
+}
+
+const OUString& XMLPropertySetMapper::GetEntryXMLName( sal_Int32 nIndex ) const
+{
+ assert((0 <= nIndex) && (o3tl::make_unsigned(nIndex) < mpImpl->maMapEntries.size()));
+ return mpImpl->maMapEntries[nIndex].sXMLAttributeName;
+}
+
+const OUString& XMLPropertySetMapper::GetEntryAPIName( sal_Int32 nIndex ) const
+{
+ assert((0 <= nIndex) && (o3tl::make_unsigned(nIndex) < mpImpl->maMapEntries.size()));
+ return mpImpl->maMapEntries[nIndex].sAPIPropertyName;
+}
+
+sal_Int16 XMLPropertySetMapper::GetEntryContextId( sal_Int32 nIndex ) const
+{
+ assert((-1 <= nIndex) && (nIndex < static_cast<sal_Int32>(mpImpl->maMapEntries.size())));
+ return nIndex == -1 ? 0 : mpImpl->maMapEntries[nIndex].nContextId;
+}
+
+SvtSaveOptions::ODFSaneDefaultVersion
+XMLPropertySetMapper::GetEarliestODFVersionForExport(sal_Int32 const nIndex) const
+{
+ assert((0 <= nIndex) && (o3tl::make_unsigned(nIndex) < mpImpl->maMapEntries.size()));
+ return mpImpl->maMapEntries[nIndex].nEarliestODFVersionForExport;
+}
+
+const XMLPropertyHandler* XMLPropertySetMapper::GetPropertyHandler( sal_Int32 nIndex ) const
+{
+ assert((0 <= nIndex) && (o3tl::make_unsigned(nIndex) < mpImpl->maMapEntries.size()));
+ return mpImpl->maMapEntries[nIndex].pHdl;
+}
+
+// Export a Property
+bool XMLPropertySetMapper::exportXML(
+ OUString& rStrExpValue,
+ const XMLPropertyState& rProperty,
+ const SvXMLUnitConverter& rUnitConverter ) const
+{
+ bool bRet = false;
+
+ const XMLPropertyHandler* pHdl = GetPropertyHandler( rProperty.mnIndex );
+
+ assert(pHdl);
+ if( pHdl )
+ bRet = pHdl->exportXML( rStrExpValue, rProperty.maValue,
+ rUnitConverter );
+
+ return bRet;
+}
+
+// Import a Property
+bool XMLPropertySetMapper::importXML(
+ const OUString& rStrImpValue,
+ XMLPropertyState& rProperty,
+ const SvXMLUnitConverter& rUnitConverter ) const
+{
+ bool bRet = false;
+
+ const XMLPropertyHandler* pHdl = GetPropertyHandler( rProperty.mnIndex );
+
+ if( pHdl )
+ bRet = pHdl->importXML( rStrImpValue, rProperty.maValue,
+ rUnitConverter );
+
+ return bRet;
+}
+
+// Search for the given name and the namespace in the list and return
+// the index of the entry
+// If there is no matching entry the method returns -1
+sal_Int32 XMLPropertySetMapper::GetEntryIndex(
+ sal_uInt16 nNamespace,
+ std::u16string_view rStrName,
+ sal_uInt32 nPropType,
+ sal_Int32 nStartAt /* = -1 */ ) const
+{
+ sal_Int32 nEntries = GetEntryCount();
+ sal_Int32 nIndex= nStartAt == - 1? 0 : nStartAt+1;
+
+ if ( nEntries && nIndex < nEntries )
+ {
+ do
+ {
+ const XMLPropertySetMapperEntry_Impl& rEntry = mpImpl->maMapEntries[nIndex];
+ if( (!nPropType || nPropType == rEntry.GetPropType()) &&
+ rEntry.nXMLNameSpace == nNamespace &&
+ rStrName == rEntry.sXMLAttributeName )
+ return nIndex;
+ else
+ nIndex++;
+
+ } while( nIndex<nEntries );
+ }
+
+ return -1;
+}
+
+// Search for the given name and the namespace in the list and return
+// the index of the entry
+// If there is no matching entry the method returns -1
+sal_Int32 XMLPropertySetMapper::GetEntryIndex(
+ sal_Int32 nElement,
+ sal_uInt32 nPropType,
+ sal_Int32 nStartAt /* = -1 */ ) const
+{
+ sal_Int32 nEntries = GetEntryCount();
+ sal_Int32 nIndex= nStartAt == - 1? 0 : nStartAt+1;
+
+ if ( nEntries && nIndex < nEntries )
+ {
+ sal_uInt16 nNamespace = (nElement >> NMSP_SHIFT) - 1;
+ const OUString& rStrName = SvXMLImport::getNameFromToken(nElement);
+ do
+ {
+ const XMLPropertySetMapperEntry_Impl& rEntry = mpImpl->maMapEntries[nIndex];
+ if( (!nPropType || nPropType == rEntry.GetPropType()) &&
+ rEntry.nXMLNameSpace == nNamespace &&
+ rStrName == rEntry.sXMLAttributeName )
+ return nIndex;
+ else
+ nIndex++;
+
+ } while( nIndex<nEntries );
+ }
+
+ return -1;
+}
+
+/** searches for an entry that matches the given api name, namespace and local name or -1 if nothing found */
+sal_Int32 XMLPropertySetMapper::FindEntryIndex(
+ const char* sApiName,
+ sal_uInt16 nNameSpace,
+ std::u16string_view sXMLName ) const
+{
+ sal_Int32 nIndex = 0;
+ sal_Int32 nEntries = GetEntryCount();
+
+ do
+ {
+ const XMLPropertySetMapperEntry_Impl& rEntry = mpImpl->maMapEntries[nIndex];
+ if( rEntry.nXMLNameSpace == nNameSpace &&
+ rEntry.sXMLAttributeName == sXMLName &&
+ rEntry.sAPIPropertyName.equalsAscii( sApiName ) )
+ return nIndex;
+ else
+ nIndex++;
+
+ } while( nIndex < nEntries );
+
+ return -1;
+}
+
+sal_Int32 XMLPropertySetMapper::FindEntryIndex( const sal_Int16 nContextId ) const
+{
+ const sal_Int32 nEntries = GetEntryCount();
+
+ if ( nEntries )
+ {
+ sal_Int32 nIndex = 0;
+ do
+ {
+ const XMLPropertySetMapperEntry_Impl& rEntry = mpImpl->maMapEntries[nIndex];
+ if( rEntry.nContextId == nContextId )
+ return nIndex;
+ else
+ nIndex++;
+
+ } while( nIndex < nEntries );
+ }
+
+ return -1;
+}
+
+void XMLPropertySetMapper::RemoveEntry( sal_Int32 nIndex )
+{
+ const sal_Int32 nEntries = GetEntryCount();
+ if( nIndex>=nEntries || nIndex<0 )
+ return;
+ vector < XMLPropertySetMapperEntry_Impl >::iterator aEIter = mpImpl->maMapEntries.begin();
+ std::advance(aEIter, nIndex);
+ mpImpl->maMapEntries.erase( aEIter );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/xmlstyle.cxx b/xmloff/source/style/xmlstyle.cxx
new file mode 100644
index 000000000..d46365008
--- /dev/null
+++ b/xmloff/source/style/xmlstyle.cxx
@@ -0,0 +1,806 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <config_wasm_strip.h>
+
+#include <sal/config.h>
+
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/xml/sax/XAttributeList.hpp>
+#include <com/sun/star/container/XNameContainer.hpp>
+#include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
+#include <com/sun/star/style/XAutoStylesSupplier.hpp>
+#include <com/sun/star/style/XAutoStyleFamily.hpp>
+#include <PageMasterPropMapper.hxx>
+#include <sal/log.hxx>
+#include <svl/style.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+
+#include <xmloff/families.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <xmloff/xmlnumi.hxx>
+#include <xmloff/xmlimppr.hxx>
+#include <xmloff/xmlstyle.hxx>
+#include <xmloff/txtstyli.hxx>
+#include <xmloff/xmlnumfi.hxx>
+#include <XMLChartStyleContext.hxx>
+#include <XMLChartPropertySetMapper.hxx>
+#include <xmloff/XMLShapeStyleContext.hxx>
+#include "FillStyleContext.hxx"
+#include <XMLFootnoteConfigurationImportContext.hxx>
+#include <XMLIndexBibliographyConfigurationContext.hxx>
+#include <XMLLineNumberingImportContext.hxx>
+#include <PageMasterImportContext.hxx>
+#include "PageMasterImportPropMapper.hxx"
+
+#include <memory>
+#include <set>
+#include <string_view>
+#include <vector>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::style;
+using namespace ::xmloff::token;
+
+constexpr OUStringLiteral gsParaStyleServiceName( u"com.sun.star.style.ParagraphStyle" );
+constexpr OUStringLiteral gsTextStyleServiceName( u"com.sun.star.style.CharacterStyle" );
+
+void SvXMLStyleContext::SetAttribute( sal_Int32 nElement,
+ const OUString& rValue )
+{
+ switch (nElement)
+ {
+ case XML_ELEMENT(STYLE, XML_FAMILY):
+ {
+ if( IsXMLToken( rValue, XML_PARAGRAPH ) )
+ mnFamily = XmlStyleFamily(SfxStyleFamily::Para);
+ else if( IsXMLToken( rValue, XML_TEXT ) )
+ mnFamily = XmlStyleFamily(SfxStyleFamily::Char);
+ break;
+ }
+ case XML_ELEMENT(STYLE, XML_NAME):
+ maName = rValue;
+ break;
+ case XML_ELEMENT(STYLE, XML_DISPLAY_NAME):
+ maDisplayName = rValue;
+ break;
+ case XML_ELEMENT(STYLE, XML_PARENT_STYLE_NAME):
+ maParentName = rValue;
+ break;
+ case XML_ELEMENT(STYLE, XML_NEXT_STYLE_NAME):
+ maFollow = rValue;
+ break;
+ case XML_ELEMENT(LO_EXT, XML_LINKED_STYLE_NAME):
+ maLinked = rValue;
+ break;
+ case XML_ELEMENT(STYLE, XML_HIDDEN):
+ mbHidden = rValue.toBoolean();
+ break;
+ case XML_ELEMENT(LO_EXT, XML_HIDDEN):
+ mbHidden = rValue.toBoolean();
+ break;
+ }
+}
+
+
+SvXMLStyleContext::SvXMLStyleContext(
+ SvXMLImport& rImp,
+ XmlStyleFamily nFam, bool bDefault ) :
+ SvXMLImportContext( rImp ),
+ mbHidden( false ),
+ mnFamily( nFam ),
+ mbValid( true ),
+ mbNew( true ),
+ mbDefaultStyle( bDefault )
+{
+}
+
+SvXMLStyleContext::~SvXMLStyleContext()
+{
+}
+
+void SvXMLStyleContext::startFastElement(
+ sal_Int32 /*nElement*/,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+ for( auto &it : sax_fastparser::castToFastAttributeList( xAttrList ) )
+ SetAttribute( it.getToken(), it.toString() );
+}
+
+void SvXMLStyleContext::SetDefaults()
+{
+}
+
+void SvXMLStyleContext::CreateAndInsert( bool /*bOverwrite*/ )
+{
+}
+
+void SvXMLStyleContext::CreateAndInsertLate( bool /*bOverwrite*/ )
+{
+}
+
+void SvXMLStyleContext::Finish( bool /*bOverwrite*/ )
+{
+}
+
+bool SvXMLStyleContext::IsTransient() const
+{
+ return false;
+}
+
+namespace {
+
+class SvXMLStyleIndex_Impl
+{
+ OUString sName;
+ XmlStyleFamily nFamily;
+ // we deliberately don't use a reference here, to avoid creating a ref-count-cycle
+ SvXMLStyleContext* mpStyle;
+
+public:
+
+ SvXMLStyleIndex_Impl( XmlStyleFamily nFam, const OUString& rName ) :
+ sName( rName ),
+ nFamily( nFam ),
+ mpStyle(nullptr)
+ {
+ }
+
+ SvXMLStyleIndex_Impl( const rtl::Reference<SvXMLStyleContext> &rStl ) :
+ sName( rStl->GetName() ),
+ nFamily( rStl->GetFamily() ),
+ mpStyle ( rStl.get() )
+ {
+ }
+
+ const OUString& GetName() const { return sName; }
+ XmlStyleFamily GetFamily() const { return nFamily; }
+ const SvXMLStyleContext *GetStyle() const { return mpStyle; }
+};
+
+struct SvXMLStyleIndexCmp_Impl
+{
+ bool operator()(const SvXMLStyleIndex_Impl& r1, const SvXMLStyleIndex_Impl& r2) const
+ {
+ sal_Int32 nRet;
+
+ if( r1.GetFamily() < r2.GetFamily() )
+ nRet = -1;
+ else if( r1.GetFamily() > r2.GetFamily() )
+ nRet = 1;
+ else
+ nRet = r1.GetName().compareTo( r2.GetName() );
+
+ return nRet < 0;
+ }
+};
+
+}
+
+class SvXMLStylesContext_Impl
+{
+ typedef std::set<SvXMLStyleIndex_Impl, SvXMLStyleIndexCmp_Impl> IndicesType;
+
+ std::vector<rtl::Reference<SvXMLStyleContext>> aStyles;
+ mutable std::unique_ptr<IndicesType> pIndices;
+ bool bAutomaticStyle;
+
+#if OSL_DEBUG_LEVEL > 0
+ mutable sal_uInt32 m_nIndexCreated;
+#endif
+
+ void FlushIndex() { pIndices.reset(); }
+
+public:
+ explicit SvXMLStylesContext_Impl( bool bAuto );
+
+ size_t GetStyleCount() const { return aStyles.size(); }
+
+ SvXMLStyleContext *GetStyle( size_t i )
+ {
+ return i < aStyles.size() ? aStyles[ i ].get() : nullptr;
+ }
+
+ inline void AddStyle( SvXMLStyleContext *pStyle );
+ void dispose();
+
+ const SvXMLStyleContext *FindStyleChildContext( XmlStyleFamily nFamily,
+ const OUString& rName,
+ bool bCreateIndex ) const;
+ bool IsAutomaticStyle() const { return bAutomaticStyle; }
+};
+
+SvXMLStylesContext_Impl::SvXMLStylesContext_Impl( bool bAuto ) :
+ bAutomaticStyle( bAuto )
+#if OSL_DEBUG_LEVEL > 0
+ , m_nIndexCreated( 0 )
+#endif
+{}
+
+inline void SvXMLStylesContext_Impl::AddStyle( SvXMLStyleContext *pStyle )
+{
+#if OSL_DEBUG_LEVEL > 0
+// for (auto const & xStyle : aStyles)
+// if (xStyle->GetFamily() == pStyle->GetFamily() && xStyle->GetName() == pStyle->GetName())
+// assert(false && "duplicate style");
+#endif
+ aStyles.emplace_back(pStyle );
+
+ FlushIndex();
+}
+
+void SvXMLStylesContext_Impl::dispose()
+{
+ FlushIndex();
+ aStyles.clear();
+}
+
+const SvXMLStyleContext *SvXMLStylesContext_Impl::FindStyleChildContext( XmlStyleFamily nFamily,
+ const OUString& rName,
+ bool bCreateIndex ) const
+{
+ const SvXMLStyleContext *pStyle = nullptr;
+
+ if( !pIndices && bCreateIndex && !aStyles.empty() )
+ {
+ pIndices = std::make_unique<IndicesType>(aStyles.begin(), aStyles.end());
+ SAL_WARN_IF(pIndices->size() != aStyles.size(), "xmloff.style", "Here is a duplicate Style");
+#if OSL_DEBUG_LEVEL > 0
+ SAL_WARN_IF(0 != m_nIndexCreated, "xmloff.style",
+ "Performance warning: sdbcx::Index created multiple times");
+ ++m_nIndexCreated;
+#endif
+ }
+
+ if( pIndices )
+ {
+ SvXMLStyleIndex_Impl aIndex( nFamily, rName );
+ IndicesType::iterator aFind = pIndices->find(aIndex);
+ if( aFind != pIndices->end() )
+ pStyle = aFind->GetStyle();
+ }
+ else
+ {
+ for( size_t i = 0; !pStyle && i < aStyles.size(); i++ )
+ {
+ const SvXMLStyleContext *pS = aStyles[ i ].get();
+ if( pS->GetFamily() == nFamily &&
+ pS->GetName() == rName )
+ pStyle = pS;
+ }
+ }
+ return pStyle;
+}
+
+
+sal_uInt32 SvXMLStylesContext::GetStyleCount() const
+{
+ return mpImpl->GetStyleCount();
+}
+
+SvXMLStyleContext *SvXMLStylesContext::GetStyle( sal_uInt32 i )
+{
+ return mpImpl->GetStyle( i );
+}
+
+const SvXMLStyleContext *SvXMLStylesContext::GetStyle( sal_uInt32 i ) const
+{
+ return mpImpl->GetStyle( i );
+}
+
+bool SvXMLStylesContext::IsAutomaticStyle() const
+{
+ return mpImpl->IsAutomaticStyle();
+}
+
+SvXMLStyleContext *SvXMLStylesContext::CreateStyleChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+ SvXMLStyleContext *pStyle = nullptr;
+
+ if(GetImport().GetDataStylesImport())
+ {
+ pStyle = GetImport().GetDataStylesImport()->CreateChildContext(GetImport(), nElement,
+ xAttrList, *this);
+ if (pStyle)
+ return pStyle;
+ }
+
+ switch (nElement)
+ {
+ case XML_ELEMENT(STYLE, XML_STYLE):
+ case XML_ELEMENT(STYLE, XML_DEFAULT_STYLE):
+ {
+ XmlStyleFamily nFamily = XmlStyleFamily::DATA_STYLE;
+ for( auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ) )
+ {
+ if( aIter.getToken() == XML_ELEMENT(STYLE, XML_FAMILY) )
+ {
+ nFamily = GetFamily( aIter.toString() );
+ break;
+ }
+ }
+ pStyle = XML_ELEMENT(STYLE, XML_STYLE)==nElement
+ ? CreateStyleStyleChildContext( nFamily, nElement, xAttrList )
+ : CreateDefaultStyleStyleChildContext( nFamily, nElement, xAttrList );
+ break;
+ }
+ case XML_ELEMENT(TEXT, XML_BIBLIOGRAPHY_CONFIGURATION):
+ pStyle = new XMLIndexBibliographyConfigurationContext(GetImport());
+ break;
+ case XML_ELEMENT(TEXT, XML_NOTES_CONFIGURATION):
+ pStyle = new XMLFootnoteConfigurationImportContext(
+ GetImport(), nElement, xAttrList);
+ break;
+ case XML_ELEMENT(TEXT, XML_LINENUMBERING_CONFIGURATION):
+ pStyle = new XMLLineNumberingImportContext(GetImport());
+ break;
+ case XML_ELEMENT(STYLE, XML_PAGE_LAYOUT):
+ case XML_ELEMENT(STYLE, XML_DEFAULT_PAGE_LAYOUT):
+ {
+ //there is not page family in ODF now, so I specify one for it
+ bool bDefaultStyle = XML_ELEMENT(STYLE, XML_DEFAULT_PAGE_LAYOUT) == nElement;
+ pStyle = new PageStyleContext( GetImport(), *this, bDefaultStyle );
+ }
+ break;
+ case XML_ELEMENT(TEXT, XML_LIST_STYLE):
+ pStyle = new SvxXMLListStyleContext( GetImport() );
+ break;
+ case XML_ELEMENT(TEXT, XML_OUTLINE_STYLE):
+ pStyle = new SvxXMLListStyleContext( GetImport(), true );
+ break;
+
+ // FillStyles
+
+ case XML_ELEMENT(DRAW, XML_GRADIENT):
+ {
+ pStyle = new XMLGradientStyleContext( GetImport(), nElement, xAttrList );
+ break;
+ }
+ case XML_ELEMENT(DRAW, XML_HATCH):
+ {
+ pStyle = new XMLHatchStyleContext( GetImport(), nElement, xAttrList );
+ break;
+ }
+ case XML_ELEMENT(DRAW, XML_FILL_IMAGE):
+ {
+ pStyle = new XMLBitmapStyleContext( GetImport(), nElement, xAttrList );
+ break;
+ }
+ case XML_ELEMENT(DRAW, XML_OPACITY):
+ {
+ pStyle = new XMLTransGradientStyleContext( GetImport(), nElement, xAttrList );
+ break;
+ }
+ case XML_ELEMENT(DRAW, XML_MARKER):
+ {
+ pStyle = new XMLMarkerStyleContext( GetImport(), nElement, xAttrList );
+ break;
+ }
+ case XML_ELEMENT(DRAW, XML_STROKE_DASH):
+ {
+ pStyle = new XMLDashStyleContext( GetImport(), nElement, xAttrList );
+ break;
+ }
+ }
+
+ if (!pStyle)
+ SAL_WARN("xmloff", "Unknown element " << SvXMLImport::getPrefixAndNameFromToken(nElement));
+
+ return pStyle;
+}
+
+SvXMLStyleContext *SvXMLStylesContext::CreateStyleStyleChildContext(
+ XmlStyleFamily nFamily, sal_Int32 /*nElement*/,
+ const uno::Reference< xml::sax::XFastAttributeList > & /*xAttrList*/ )
+{
+ SvXMLStyleContext *pStyle = nullptr;
+
+ switch( nFamily )
+ {
+ case XmlStyleFamily::TEXT_PARAGRAPH:
+ case XmlStyleFamily::TEXT_TEXT:
+ case XmlStyleFamily::TEXT_SECTION:
+ pStyle = new XMLTextStyleContext( GetImport(), *this, nFamily );
+ break;
+
+ case XmlStyleFamily::TEXT_RUBY:
+ pStyle = new XMLPropStyleContext( GetImport(), *this, nFamily );
+ break;
+#if !ENABLE_WASM_STRIP_CHART
+ // WASM_CHART change
+ case XmlStyleFamily::SCH_CHART_ID:
+ pStyle = new XMLChartStyleContext( GetImport(), *this, nFamily );
+ break;
+#endif
+ case XmlStyleFamily::SD_GRAPHICS_ID:
+ case XmlStyleFamily::SD_PRESENTATION_ID:
+ case XmlStyleFamily::SD_POOL_ID:
+ pStyle = new XMLShapeStyleContext( GetImport(), *this, nFamily );
+ break;
+ default: break;
+ }
+
+ return pStyle;
+}
+
+SvXMLStyleContext *SvXMLStylesContext::CreateDefaultStyleStyleChildContext(
+ XmlStyleFamily /*nFamily*/, sal_Int32 /*nElement*/,
+ const uno::Reference< xml::sax::XFastAttributeList > & )
+{
+ return nullptr;
+}
+
+bool SvXMLStylesContext::InsertStyleFamily( XmlStyleFamily ) const
+{
+ return true;
+}
+
+XmlStyleFamily SvXMLStylesContext::GetFamily( std::u16string_view rValue )
+{
+ XmlStyleFamily nFamily = XmlStyleFamily::DATA_STYLE;
+ if( IsXMLToken( rValue, XML_PARAGRAPH ) )
+ {
+ nFamily = XmlStyleFamily::TEXT_PARAGRAPH;
+ }
+ else if( IsXMLToken( rValue, XML_TEXT ) )
+ {
+ nFamily = XmlStyleFamily::TEXT_TEXT;
+ }
+ else if( IsXMLToken( rValue, XML_DATA_STYLE ) )
+ {
+ nFamily = XmlStyleFamily::DATA_STYLE;
+ }
+ else if ( IsXMLToken( rValue, XML_SECTION ) )
+ {
+ nFamily = XmlStyleFamily::TEXT_SECTION;
+ }
+ else if( IsXMLToken( rValue, XML_TABLE ) )
+ {
+ nFamily = XmlStyleFamily::TABLE_TABLE;
+ }
+ else if( IsXMLToken( rValue, XML_TABLE_COLUMN ) )
+ nFamily = XmlStyleFamily::TABLE_COLUMN;
+ else if( IsXMLToken( rValue, XML_TABLE_ROW ) )
+ nFamily = XmlStyleFamily::TABLE_ROW;
+ else if( IsXMLToken( rValue, XML_TABLE_CELL ) )
+ nFamily = XmlStyleFamily::TABLE_CELL;
+ else if ( rValue == XML_STYLE_FAMILY_SD_GRAPHICS_NAME )
+ {
+ nFamily = XmlStyleFamily::SD_GRAPHICS_ID;
+ }
+ else if ( rValue == XML_STYLE_FAMILY_SD_PRESENTATION_NAME )
+ {
+ nFamily = XmlStyleFamily::SD_PRESENTATION_ID;
+ }
+ else if ( rValue == XML_STYLE_FAMILY_SD_POOL_NAME )
+ {
+ nFamily = XmlStyleFamily::SD_POOL_ID;
+ }
+ else if ( rValue == XML_STYLE_FAMILY_SD_DRAWINGPAGE_NAME )
+ {
+ nFamily = XmlStyleFamily::SD_DRAWINGPAGE_ID;
+ }
+ else if ( rValue == XML_STYLE_FAMILY_SCH_CHART_NAME )
+ {
+ nFamily = XmlStyleFamily::SCH_CHART_ID;
+ }
+ else if ( IsXMLToken( rValue, XML_RUBY ) )
+ {
+ nFamily = XmlStyleFamily::TEXT_RUBY;
+ }
+
+ return nFamily;
+}
+
+rtl::Reference < SvXMLImportPropertyMapper > SvXMLStylesContext::GetImportPropertyMapper(
+ XmlStyleFamily nFamily ) const
+{
+ rtl::Reference < SvXMLImportPropertyMapper > xMapper;
+
+ switch( nFamily )
+ {
+ case XmlStyleFamily::TEXT_PARAGRAPH:
+ if( !mxParaImpPropMapper.is() )
+ {
+ SvXMLStylesContext * pThis = const_cast<SvXMLStylesContext *>(this);
+ pThis->mxParaImpPropMapper =
+ pThis->GetImport().GetTextImport()
+ ->GetParaImportPropertySetMapper();
+ }
+ xMapper = mxParaImpPropMapper;
+ break;
+ case XmlStyleFamily::TEXT_TEXT:
+ if( !mxTextImpPropMapper.is() )
+ {
+ SvXMLStylesContext * pThis = const_cast<SvXMLStylesContext *>(this);
+ pThis->mxTextImpPropMapper =
+ pThis->GetImport().GetTextImport()
+ ->GetTextImportPropertySetMapper();
+ }
+ xMapper = mxTextImpPropMapper;
+ break;
+
+ case XmlStyleFamily::TEXT_SECTION:
+ // don't cache section mapper, as it's rarely used
+ // *sigh*, cast to non-const, because this is a const method,
+ // but SvXMLImport::GetTextImport() isn't.
+ xMapper = const_cast<SvXMLStylesContext*>(this)->GetImport().GetTextImport()->
+ GetSectionImportPropertySetMapper();
+ break;
+
+ case XmlStyleFamily::TEXT_RUBY:
+ // don't cache section mapper, as it's rarely used
+ // *sigh*, cast to non-const, because this is a const method,
+ // but SvXMLImport::GetTextImport() isn't.
+ xMapper = const_cast<SvXMLStylesContext*>(this)->GetImport().GetTextImport()->
+ GetRubyImportPropertySetMapper();
+ break;
+
+ case XmlStyleFamily::SD_GRAPHICS_ID:
+ case XmlStyleFamily::SD_PRESENTATION_ID:
+ case XmlStyleFamily::SD_POOL_ID:
+ if(!mxShapeImpPropMapper.is())
+ {
+ rtl::Reference< XMLShapeImportHelper > aImpHelper = const_cast<SvXMLImport&>(GetImport()).GetShapeImport();
+ const_cast<SvXMLStylesContext*>(this)->mxShapeImpPropMapper =
+ aImpHelper->GetPropertySetMapper();
+ }
+ xMapper = mxShapeImpPropMapper;
+ break;
+#if !ENABLE_WASM_STRIP_CHART
+ // WASM_CHART change
+ case XmlStyleFamily::SCH_CHART_ID:
+ if( ! mxChartImpPropMapper.is() )
+ {
+ XMLPropertySetMapper *const pPropMapper = new XMLChartPropertySetMapper(nullptr);
+ mxChartImpPropMapper = new XMLChartImportPropertyMapper( pPropMapper, GetImport() );
+ }
+ xMapper = mxChartImpPropMapper;
+ break;
+#endif
+ case XmlStyleFamily::PAGE_MASTER:
+ if( ! mxPageImpPropMapper.is() )
+ {
+ XMLPropertySetMapper *pPropMapper =
+ new XMLPageMasterPropSetMapper();
+ mxPageImpPropMapper =
+ new PageMasterImportPropertyMapper( pPropMapper,
+ const_cast<SvXMLStylesContext*>(this)->GetImport() );
+ }
+ xMapper = mxPageImpPropMapper;
+ break;
+ default: break;
+ }
+
+ return xMapper;
+}
+
+Reference < XAutoStyleFamily > SvXMLStylesContext::GetAutoStyles( XmlStyleFamily nFamily ) const
+{
+ Reference < XAutoStyleFamily > xAutoStyles;
+ if( XmlStyleFamily::TEXT_TEXT == nFamily || XmlStyleFamily::TEXT_PARAGRAPH == nFamily)
+ {
+ bool bPara = XmlStyleFamily::TEXT_PARAGRAPH == nFamily;
+ if( !bPara && mxTextAutoStyles.is() )
+ xAutoStyles = mxTextAutoStyles;
+ else if( bPara && mxParaAutoStyles.is() )
+ xAutoStyles = mxParaAutoStyles;
+ else
+ {
+ OUString sName(bPara ? std::u16string_view( u"ParagraphStyles" ): std::u16string_view( u"CharacterStyles" ));
+ Reference< XAutoStylesSupplier > xAutoStylesSupp( GetImport().GetModel(), UNO_QUERY );
+ Reference< XAutoStyles > xAutoStyleFamilies = xAutoStylesSupp->getAutoStyles();
+ if (xAutoStyleFamilies->hasByName(sName))
+ {
+ Any aAny = xAutoStyleFamilies->getByName( sName );
+ aAny >>= xAutoStyles;
+ if( bPara )
+ const_cast<SvXMLStylesContext *>(this)->mxParaAutoStyles = xAutoStyles;
+ else
+ const_cast<SvXMLStylesContext *>(this)->mxTextAutoStyles = xAutoStyles;
+ }
+ }
+ }
+ return xAutoStyles;
+}
+
+Reference < XNameContainer > SvXMLStylesContext::GetStylesContainer(
+ XmlStyleFamily nFamily ) const
+{
+ Reference < XNameContainer > xStyles;
+ OUString sName;
+ switch( nFamily )
+ {
+ case XmlStyleFamily::TEXT_PARAGRAPH:
+ if( mxParaStyles.is() )
+ xStyles = mxParaStyles;
+ else
+ sName = "ParagraphStyles";
+ break;
+
+ case XmlStyleFamily::TEXT_TEXT:
+ if( mxTextStyles.is() )
+ xStyles = mxTextStyles;
+ else
+ sName = "CharacterStyles";
+ break;
+ default: break;
+ }
+ if( !xStyles.is() && !sName.isEmpty() )
+ {
+ Reference< XStyleFamiliesSupplier > xFamiliesSupp(
+ GetImport().GetModel(), UNO_QUERY );
+ if ( xFamiliesSupp.is() )
+ {
+ Reference< XNameAccess > xFamilies = xFamiliesSupp->getStyleFamilies();
+ if (xFamilies->hasByName(sName))
+ {
+ xStyles.set(xFamilies->getByName( sName ),uno::UNO_QUERY);
+
+ switch( nFamily )
+ {
+ case XmlStyleFamily::TEXT_PARAGRAPH:
+ const_cast<SvXMLStylesContext *>(this)->mxParaStyles = xStyles;
+ break;
+
+ case XmlStyleFamily::TEXT_TEXT:
+ const_cast<SvXMLStylesContext *>(this)->mxTextStyles = xStyles;
+ break;
+ default: break;
+ }
+ }
+ }
+ }
+
+ return xStyles;
+}
+
+OUString SvXMLStylesContext::GetServiceName( XmlStyleFamily nFamily ) const
+{
+ OUString sServiceName;
+ switch( nFamily )
+ {
+ case XmlStyleFamily::TEXT_PARAGRAPH:
+ sServiceName = gsParaStyleServiceName;
+ break;
+ case XmlStyleFamily::TEXT_TEXT:
+ sServiceName = gsTextStyleServiceName;
+ break;
+ default: break;
+ }
+
+ return sServiceName;
+}
+
+SvXMLStylesContext::SvXMLStylesContext( SvXMLImport& rImport, bool bAuto ) :
+ SvXMLImportContext( rImport ),
+ mpImpl( new SvXMLStylesContext_Impl( bAuto ) )
+{
+}
+
+SvXMLStylesContext::~SvXMLStylesContext()
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SvXMLStylesContext::createFastChildContext(
+ sal_Int32 nElement, const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
+{
+ SvXMLStyleContext *pStyle =
+ CreateStyleChildContext( nElement, xAttrList );
+ if( pStyle )
+ {
+ if( !pStyle->IsTransient() )
+ mpImpl->AddStyle( pStyle );
+ return pStyle;
+ }
+
+ return nullptr;
+}
+
+void SvXMLStylesContext::AddStyle(SvXMLStyleContext& rNew)
+{
+ mpImpl->AddStyle( &rNew );
+}
+
+void SvXMLStylesContext::dispose()
+{
+ mpImpl->dispose();
+}
+
+void SvXMLStylesContext::CopyAutoStylesToDoc()
+{
+ sal_uInt32 nCount = GetStyleCount();
+ sal_uInt32 i;
+ for( i = 0; i < nCount; i++ )
+ {
+ SvXMLStyleContext *pStyle = GetStyle( i );
+ if( !pStyle || ( pStyle->GetFamily() != XmlStyleFamily::TEXT_TEXT &&
+ pStyle->GetFamily() != XmlStyleFamily::TEXT_PARAGRAPH &&
+ pStyle->GetFamily() != XmlStyleFamily::TABLE_CELL ) )
+ continue;
+ pStyle->CreateAndInsert( false );
+ }
+}
+
+void SvXMLStylesContext::CopyStylesToDoc( bool bOverwrite,
+ bool bFinish )
+{
+ // pass 1: create text, paragraph and frame styles
+ sal_uInt32 nCount = GetStyleCount();
+ sal_uInt32 i;
+
+ for( i = 0; i < nCount; i++ )
+ {
+ SvXMLStyleContext *pStyle = GetStyle( i );
+ if( !pStyle )
+ continue;
+
+ if (pStyle->IsDefaultStyle())
+ {
+ if (bOverwrite) pStyle->SetDefaults();
+ }
+ else if( InsertStyleFamily( pStyle->GetFamily() ) )
+ pStyle->CreateAndInsert( bOverwrite );
+ }
+
+ // pass 2: create list styles (they require char styles)
+ for( i=0; i<nCount; i++ )
+ {
+ SvXMLStyleContext *pStyle = GetStyle( i );
+ if( !pStyle || pStyle->IsDefaultStyle())
+ continue;
+
+ if( InsertStyleFamily( pStyle->GetFamily() ) )
+ pStyle->CreateAndInsertLate( bOverwrite );
+ }
+
+ // pass3: finish creation of styles
+ if( bFinish )
+ FinishStyles( bOverwrite );
+}
+
+void SvXMLStylesContext::FinishStyles( bool bOverwrite )
+{
+ sal_uInt32 nCount = GetStyleCount();
+ for( sal_uInt32 i=0; i<nCount; i++ )
+ {
+ SvXMLStyleContext *pStyle = GetStyle( i );
+ if( !pStyle || !pStyle->IsValid() || pStyle->IsDefaultStyle() )
+ continue;
+
+ if( InsertStyleFamily( pStyle->GetFamily() ) )
+ pStyle->Finish( bOverwrite );
+ }
+}
+
+const SvXMLStyleContext *SvXMLStylesContext::FindStyleChildContext(
+ XmlStyleFamily nFamily,
+ const OUString& rName,
+ bool bCreateIndex ) const
+{
+ return mpImpl->FindStyleChildContext( nFamily, rName, bCreateIndex );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/xmltabe.cxx b/xmloff/source/style/xmltabe.cxx
new file mode 100644
index 000000000..661caedf6
--- /dev/null
+++ b/xmloff/source/style/xmltabe.cxx
@@ -0,0 +1,120 @@
+/* -*- 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/TabAlign.hpp>
+#include <rtl/ustrbuf.hxx>
+#include <osl/diagnose.h>
+#include <xmloff/xmlement.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <xmltabe.hxx>
+
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+SvXMLEnumMapEntry<style::TabAlign> const pXML_tabstop_style[] =
+{
+ { XML_LEFT, style::TabAlign_LEFT },
+ { XML_CENTER, style::TabAlign_CENTER },
+ { XML_RIGHT, style::TabAlign_RIGHT },
+ { XML_CHAR, style::TabAlign_DECIMAL },
+ { XML_DEFAULT, style::TabAlign_DEFAULT }, // ?????????????????????????????????????
+ { XML_TOKEN_INVALID, style::TabAlign(0) }
+};
+
+void SvxXMLTabStopExport::exportTabStop( const css::style::TabStop* pTabStop )
+{
+ SvXMLUnitConverter& rUnitConv = rExport.GetMM100UnitConverter();
+
+ // text:level
+ OUStringBuffer sBuffer;
+
+ // position attribute
+ rUnitConv.convertMeasureToXML( sBuffer, pTabStop->Position );
+ rExport.AddAttribute( XML_NAMESPACE_STYLE, XML_POSITION,
+ sBuffer.makeStringAndClear() );
+
+ // type attribute
+ if( style::TabAlign_LEFT != pTabStop->Alignment )
+ {
+ SvXMLUnitConverter::convertEnum( sBuffer, pTabStop->Alignment,
+ pXML_tabstop_style );
+ rExport.AddAttribute( XML_NAMESPACE_STYLE, XML_TYPE,
+ sBuffer.makeStringAndClear() );
+ }
+
+ // char
+ if( style::TabAlign_DECIMAL == pTabStop->Alignment &&
+ pTabStop->DecimalChar != 0 )
+ {
+ sBuffer.append( pTabStop->DecimalChar );
+ rExport.AddAttribute( XML_NAMESPACE_STYLE, XML_CHAR,
+ sBuffer.makeStringAndClear() );
+ }
+
+ // leader-char
+ if( ' ' != pTabStop->FillChar && 0 != pTabStop->FillChar )
+ {
+ rExport.AddAttribute( XML_NAMESPACE_STYLE, XML_LEADER_STYLE,
+ GetXMLToken('.' == pTabStop->FillChar ? XML_DOTTED
+ : XML_SOLID) );
+
+ sBuffer.append( pTabStop->FillChar );
+ rExport.AddAttribute( XML_NAMESPACE_STYLE, XML_LEADER_TEXT,
+ sBuffer.makeStringAndClear() );
+ }
+
+ SvXMLElementExport rElem( rExport, XML_NAMESPACE_STYLE, XML_TAB_STOP,
+ true, true );
+}
+
+
+SvxXMLTabStopExport::SvxXMLTabStopExport(
+ SvXMLExport& rExp)
+ : rExport( rExp )
+{
+}
+
+void SvxXMLTabStopExport::Export( const uno::Any& rAny )
+{
+ uno::Sequence< css::style::TabStop> aSeq;
+ if(!(rAny >>= aSeq))
+ {
+ OSL_FAIL( "SvxXMLTabStopExport needs a Sequence css::style::TabStop>" );
+ }
+ else
+ {
+ SvXMLElementExport rElem( rExport, XML_NAMESPACE_STYLE, XML_TAB_STOPS,
+ true, true );
+
+ for( const auto& rTab : std::as_const(aSeq) )
+ {
+ if( style::TabAlign_DEFAULT != rTab.Alignment )
+ exportTabStop( &rTab );
+ }
+ }
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/xmloff/source/style/xmltabi.cxx b/xmloff/source/style/xmltabi.cxx
new file mode 100644
index 000000000..601c3f5fd
--- /dev/null
+++ b/xmloff/source/style/xmltabi.cxx
@@ -0,0 +1,186 @@
+/* -*- 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/TabAlign.hpp>
+#include <sal/log.hxx>
+#include <xmloff/xmltkmap.hxx>
+#include <xmloff/namespacemap.hxx>
+#include <xmloff/xmlnamespace.hxx>
+#include <xmloff/xmlimp.hxx>
+#include <com/sun/star/style/TabStop.hpp>
+#include <xmloff/xmltoken.hxx>
+#include <xmloff/xmluconv.hxx>
+#include <xmltabi.hxx>
+
+
+using namespace ::com::sun::star;
+using namespace ::xmloff::token;
+
+class SvxXMLTabStopContext_Impl : public SvXMLImportContext
+{
+private:
+ style::TabStop aTabStop;
+
+public:
+
+ SvxXMLTabStopContext_Impl( SvXMLImport& rImport, sal_Int32 nElement,
+ const uno::Reference< xml::sax::XFastAttributeList > & xAttrList );
+
+ const style::TabStop& getTabStop() const { return aTabStop; }
+};
+
+
+SvxXMLTabStopContext_Impl::SvxXMLTabStopContext_Impl(
+ SvXMLImport& rImport, sal_Int32 /*nElement*/,
+ const uno::Reference< xml::sax::XFastAttributeList > & xAttrList )
+: SvXMLImportContext( rImport )
+{
+ aTabStop.Position = 0;
+ aTabStop.Alignment = style::TabAlign_LEFT;
+ aTabStop.DecimalChar = ',';
+ aTabStop.FillChar = ' ';
+ sal_Unicode cTextFillChar = 0;
+
+ for (auto &aIter : sax_fastparser::castToFastAttributeList(xAttrList))
+ {
+ sal_Int32 nVal;
+ switch( aIter.getToken() )
+ {
+ case XML_ELEMENT(STYLE, XML_POSITION):
+ if (GetImport().GetMM100UnitConverter().convertMeasureToCore(
+ nVal, aIter.toView()))
+ {
+ aTabStop.Position = nVal;
+ }
+ break;
+ case XML_ELEMENT(STYLE, XML_TYPE):
+ if( IsXMLToken( aIter, XML_LEFT ) )
+ {
+ aTabStop.Alignment = style::TabAlign_LEFT;
+ }
+ else if( IsXMLToken( aIter, XML_RIGHT ) )
+ {
+ aTabStop.Alignment = style::TabAlign_RIGHT;
+ }
+ else if( IsXMLToken( aIter, XML_CENTER ) )
+ {
+ aTabStop.Alignment = style::TabAlign_CENTER;
+ }
+ else if( IsXMLToken( aIter, XML_CHAR ) )
+ {
+ aTabStop.Alignment = style::TabAlign_DECIMAL;
+ }
+ else if( IsXMLToken( aIter, XML_DEFAULT ) )
+ {
+ aTabStop.Alignment = style::TabAlign_DEFAULT;
+ }
+ break;
+ case XML_ELEMENT(STYLE, XML_CHAR):
+ if( !aIter.isEmpty() )
+ aTabStop.DecimalChar = aIter.toString()[0];
+ break;
+ case XML_ELEMENT(STYLE, XML_LEADER_STYLE):
+ if( IsXMLToken( aIter, XML_NONE ) )
+ aTabStop.FillChar = ' ';
+ else if( IsXMLToken( aIter, XML_DOTTED ) )
+ aTabStop.FillChar = '.';
+ else
+ aTabStop.FillChar = '_';
+ break;
+ case XML_ELEMENT(STYLE, XML_LEADER_TEXT):
+ if( !aIter.isEmpty() )
+ cTextFillChar = aIter.toString()[0];
+ break;
+ default:
+ XMLOFF_WARN_UNKNOWN("xmloff", aIter);
+ }
+ }
+
+ if( cTextFillChar != 0 && aTabStop.FillChar != ' ' )
+ aTabStop.FillChar = cTextFillChar;
+}
+
+
+SvxXMLTabStopImportContext::SvxXMLTabStopImportContext(
+ SvXMLImport& rImport, sal_Int32 nElement,
+ const XMLPropertyState& rProp,
+ ::std::vector< XMLPropertyState > &rProps )
+: XMLElementPropertyContext( rImport, nElement, rProp, rProps )
+{
+}
+
+css::uno::Reference< css::xml::sax::XFastContextHandler > SvxXMLTabStopImportContext::createFastChildContext(
+ sal_Int32 nElement,
+ const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
+{
+ if( nElement == XML_ELEMENT(STYLE, XML_TAB_STOP) )
+ {
+ // create new tabstop import context
+ const rtl::Reference<SvxXMLTabStopContext_Impl> xTabStopContext{
+ new SvxXMLTabStopContext_Impl( GetImport(), nElement, xAttrList )};
+
+ // add new tabstop to array of tabstops
+ if( !mpTabStops )
+ mpTabStops = std::make_unique<SvxXMLTabStopArray_Impl>();
+
+ mpTabStops->push_back( xTabStopContext );
+
+ return xTabStopContext;
+ }
+ else
+ XMLOFF_WARN_UNKNOWN_ELEMENT("xmloff", nElement);
+
+ return nullptr;
+}
+
+void SvxXMLTabStopImportContext::endFastElement(sal_Int32 nElement)
+{
+ sal_uInt16 nCount = mpTabStops ? mpTabStops->size() : 0;
+ uno::Sequence< style::TabStop> aSeq( nCount );
+
+ if( mpTabStops )
+ {
+ sal_uInt16 nNewCount = 0;
+
+ style::TabStop* pTabStops = aSeq.getArray();
+ for( sal_uInt16 i=0; i < nCount; i++ )
+ {
+ SvxXMLTabStopContext_Impl *pTabStopContext = (*mpTabStops)[i].get();
+ const style::TabStop& rTabStop = pTabStopContext->getTabStop();
+ bool bDflt = style::TabAlign_DEFAULT == rTabStop.Alignment;
+ if( !bDflt || 0==i )
+ {
+ *pTabStops++ = pTabStopContext->getTabStop();
+ nNewCount++;
+ }
+ if( bDflt && 0==i )
+ break;
+ }
+
+ if( nCount != nNewCount )
+ aSeq.realloc( nNewCount );
+ }
+ aProp.maValue <<= aSeq;
+
+ SetInsert( true );
+ XMLElementPropertyContext::endFastElement(nElement);
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */