LibreOffice Module sc (master) 1
xmlstyle.cxx
Go to the documentation of this file.
1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20#include "xmlstyle.hxx"
21#include "xmlexprt.hxx"
22
23#include <rangeutl.hxx>
24#include <unonames.hxx>
25
26#include <o3tl/safeint.hxx>
27#include <xmloff/xmlnamespace.hxx>
28#include <xmloff/xmltypes.hxx>
29#include <xmloff/families.hxx>
30#include <xmloff/contextid.hxx>
31#include <xmloff/txtprmap.hxx>
32#include <xmloff/XMLComplexColorHandler.hxx>
33#include <xmloff/XMLComplexColorExport.hxx>
34#include <docmodel/color/ComplexColor.hxx>
35#include <docmodel/uno/UnoComplexColor.hxx>
36#include <sax/tools/converter.hxx>
37#include <com/sun/star/util/CellProtection.hpp>
38#include <com/sun/star/table/CellOrientation.hpp>
39#include <com/sun/star/table/CellVertJustify2.hpp>
40#include <com/sun/star/table/CellHoriJustify.hpp>
41#include <com/sun/star/table/CellJustifyMethod.hpp>
42#include <com/sun/star/table/BorderLine2.hpp>
43#include <com/sun/star/util/XComplexColor.hpp>
44#include <com/sun/star/sheet/XSheetConditionalEntry.hpp>
45#include <com/sun/star/sheet/XSheetCondition.hpp>
46#include <com/sun/star/beans/XPropertySet.hpp>
47#include <com/sun/star/container/XIndexAccess.hpp>
48#include <comphelper/extract.hxx>
49
50#include <rtl/ustrbuf.hxx>
51#include <osl/diagnose.h>
52
53using namespace com::sun::star;
54using namespace ::xmloff::token;
55using namespace ::formula;
56
57#define MAP(name,prefix,token,type,context) { name, prefix, token, type, context, SvtSaveOptions::ODFSVER_010, false }
58#define MAP_ODF13(name,prefix,token,type,context) { name, prefix, token, type, context, SvtSaveOptions::ODFSVER_013, false }
59// extensions import/export
60#define MAP_EXT(name,prefix,token,type,context) { name, prefix, token, type, context, SvtSaveOptions::ODFSVER_FUTURE_EXTENDED, false }
61// extensions import only
62#define MAP_EXT_I(name,prefix,token,type,context) { name, prefix, token, type, context, SvtSaveOptions::ODFSVER_FUTURE_EXTENDED, true }
63#define MAP_END() { nullptr }
64
65const XMLPropertyMapEntry aXMLScCellStylesProperties[] =
66{
67 MAP( SC_UNONAME_ASIANVERT, XML_NAMESPACE_STYLE, XML_GLYPH_ORIENTATION_VERTICAL, XML_TYPE_PROP_TABLE_CELL|XML_SC_TYPE_VERTICAL, 0),
68 MAP( SC_UNONAME_BOTTBORDER, XML_NAMESPACE_FO, XML_BORDER_BOTTOM, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER, CTF_SC_BOTTOMBORDER ),
69 MAP( SC_UNONAME_BOTTBORDER, XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH_BOTTOM, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER_WIDTH, CTF_SC_BOTTOMBORDERWIDTH ),
70 MAP( SC_UNONAME_CELLBACK, XML_NAMESPACE_FO, XML_BACKGROUND_COLOR, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_COLORTRANSPARENT|MID_FLAG_MULTI_PROPERTY|MID_FLAG_MERGE_ATTRIBUTE, 0 ),
71 MAP_EXT( SC_UNONAME_CELL_BACKGROUND_COMPLEX_COLOR, XML_NAMESPACE_LO_EXT, XML_BACKGROUND_COMPLEX_COLOR, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_COMPLEX_COLOR|MID_FLAG_ELEMENT_ITEM, CTF_COMPLEX_COLOR),
72 MAP( SC_UNONAME_CELLPRO, XML_NAMESPACE_STYLE, XML_CELL_PROTECT, XML_TYPE_PROP_TABLE_CELL|XML_SC_TYPE_CELLPROTECTION|MID_FLAG_MERGE_PROPERTY, 0 ),
73 MAP( SC_UNONAME_CELLPRO, XML_NAMESPACE_STYLE, XML_PRINT_CONTENT, XML_TYPE_PROP_TABLE_CELL|XML_SC_TYPE_PRINTCONTENT|MID_FLAG_MERGE_PROPERTY, 0 ),
74 MAP( SC_UNONAME_CELLSTYL, XML_NAMESPACE_STYLE, XML_STYLE, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_STRING, CTF_SC_CELLSTYLE ),
75 MAP( SC_UNONAME_CONDXML, XML_NAMESPACE_STYLE, XML_MAP, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_STRING|MID_FLAG_SPECIAL_ITEM, CTF_SC_IMPORT_MAP ),
76 MAP( SC_UNONAME_CONDXML, XML_NAMESPACE_STYLE, XML_MAP, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_STRING|MID_FLAG_SPECIAL_ITEM, CTF_SC_MAP ),
77 MAP( SC_UNONAME_DIAGONAL_BLTR, XML_NAMESPACE_STYLE, XML_DIAGONAL_BL_TR, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER, CTF_SC_DIAGONALBLTR ),
78 MAP( SC_UNONAME_DIAGONAL_BLTR, XML_NAMESPACE_STYLE, XML_DIAGONAL_BL_TR_WIDTH, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER_WIDTH, CTF_SC_DIAGONALBLTRWIDTH ), // #i102690# for old files
79 MAP( SC_UNONAME_DIAGONAL_BLTR, XML_NAMESPACE_STYLE, XML_DIAGONAL_BL_TR_WIDTHS, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER_WIDTH, CTF_SC_DIAGONALBLTRWIDTHS ),
80 MAP( SC_UNONAME_DIAGONAL_TLBR, XML_NAMESPACE_STYLE, XML_DIAGONAL_TL_BR, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER, CTF_SC_DIAGONALTLBR ),
81 MAP( SC_UNONAME_DIAGONAL_TLBR, XML_NAMESPACE_STYLE, XML_DIAGONAL_TL_BR_WIDTH, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER_WIDTH, CTF_SC_DIAGONALTLBRWIDTH ), // #i102690# for old files
82 MAP( SC_UNONAME_DIAGONAL_TLBR, XML_NAMESPACE_STYLE, XML_DIAGONAL_TL_BR_WIDTHS, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER_WIDTH, CTF_SC_DIAGONALTLBRWIDTHS ),
83 MAP( SC_UNONAME_CELLHJUS, XML_NAMESPACE_FO, XML_TEXT_ALIGN, XML_TYPE_PROP_PARAGRAPH|XML_SC_TYPE_HORIJUSTIFY|MID_FLAG_MERGE_PROPERTY, 0 ),
84 MAP( SC_UNONAME_CELLHJUS, XML_NAMESPACE_STYLE, XML_TEXT_ALIGN_SOURCE, XML_TYPE_PROP_TABLE_CELL|XML_SC_TYPE_HORIJUSTIFYSOURCE|MID_FLAG_MERGE_PROPERTY, 0 ),
85 MAP( SC_UNONAME_CELLHJUS, XML_NAMESPACE_STYLE, XML_REPEAT_CONTENT, XML_TYPE_PROP_TABLE_CELL|XML_SC_TYPE_HORIJUSTIFYREPEAT|MID_FLAG_MERGE_PROPERTY, 0 ),
86 // FIXME this was wrongly exported to STYLE namespace since 2013
87 MAP_EXT( SC_UNONAME_HYPERLINK, XML_NAMESPACE_STYLE, XML_HYPERLINK, XML_TYPE_PROP_TABLE_CELL | XML_TYPE_STRING | MID_FLAG_ELEMENT_ITEM, CTF_SC_HYPERLINK ),
88 MAP_EXT( SC_UNONAME_HYPERLINK, XML_NAMESPACE_LO_EXT, XML_HYPERLINK, XML_TYPE_PROP_TABLE_CELL | XML_TYPE_STRING | MID_FLAG_ELEMENT_ITEM, CTF_SC_HYPERLINK ),
89 MAP_EXT( SC_UNONAME_CELLHJUS_METHOD, XML_NAMESPACE_CSS3TEXT, XML_TEXT_JUSTIFY, XML_TYPE_PROP_PARAGRAPH|XML_SC_TYPE_HORIJUSTIFY_METHOD, 0 ),
90 MAP( SC_UNONAME_CELLTRAN, XML_NAMESPACE_FO, XML_BACKGROUND_COLOR, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_ISTRANSPARENT|MID_FLAG_MULTI_PROPERTY|MID_FLAG_MERGE_ATTRIBUTE, 0 ),
91 MAP( SC_UNONAME_WRAP, XML_NAMESPACE_FO, XML_WRAP_OPTION, XML_TYPE_PROP_TABLE_CELL|XML_SC_ISTEXTWRAPPED, 0 ),
92 MAP( SC_UNONAME_LEFTBORDER, XML_NAMESPACE_FO, XML_BORDER, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER, CTF_SC_ALLBORDER ),
93 MAP( SC_UNONAME_LEFTBORDER, XML_NAMESPACE_FO, XML_BORDER_LEFT, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER, CTF_SC_LEFTBORDER ),
94 MAP( SC_UNONAME_LEFTBORDER, XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER_WIDTH, CTF_SC_ALLBORDERWIDTH ),
95 MAP( SC_UNONAME_LEFTBORDER, XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH_LEFT, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER_WIDTH, CTF_SC_LEFTBORDERWIDTH ),
96 MAP( SC_UNONAME_NUMFMT, XML_NAMESPACE_STYLE, XML_DATA_STYLE_NAME, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_NUMBER|MID_FLAG_SPECIAL_ITEM, CTF_SC_NUMBERFORMAT),
97 MAP( SC_UNONAME_ORIENT, XML_NAMESPACE_STYLE, XML_DIRECTION, XML_TYPE_PROP_TABLE_CELL|XML_SC_TYPE_ORIENTATION, 0 ),
98 MAP( SC_UNONAME_PBMARGIN, XML_NAMESPACE_FO, XML_PADDING, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_MEASURE, CTF_SC_ALLPADDING ),
99 MAP( SC_UNONAME_PBMARGIN, XML_NAMESPACE_FO, XML_PADDING_BOTTOM, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_MEASURE, CTF_SC_BOTTOMPADDING ),
100 MAP( SC_UNONAME_PINDENT, XML_NAMESPACE_FO, XML_MARGIN_LEFT, XML_TYPE_PROP_PARAGRAPH|XML_TYPE_MEASURE16, 0 ),
101 MAP( SC_UNONAME_PLMARGIN, XML_NAMESPACE_FO, XML_PADDING_LEFT, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_MEASURE, CTF_SC_LEFTPADDING ),
102 MAP( SC_UNONAME_PRMARGIN, XML_NAMESPACE_FO, XML_PADDING_RIGHT, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_MEASURE, CTF_SC_RIGHTPADDING ),
103 MAP( SC_UNONAME_PTMARGIN, XML_NAMESPACE_FO, XML_PADDING_TOP, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_MEASURE, CTF_SC_TOPPADDING ),
104 MAP( SC_UNONAME_RIGHTBORDER, XML_NAMESPACE_FO, XML_BORDER_RIGHT, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER, CTF_SC_RIGHTBORDER ),
105 MAP( SC_UNONAME_RIGHTBORDER, XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH_RIGHT, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER_WIDTH, CTF_SC_RIGHTBORDERWIDTH ),
106 MAP( SC_UNONAME_ROTANG, XML_NAMESPACE_STYLE, XML_ROTATION_ANGLE, XML_TYPE_PROP_TABLE_CELL|XML_SC_TYPE_ROTATEANGLE, 0 ),
107 MAP( SC_UNONAME_ROTREF, XML_NAMESPACE_STYLE, XML_ROTATION_ALIGN, XML_TYPE_PROP_TABLE_CELL|XML_SC_TYPE_ROTATEREFERENCE, 0),
108 MAP( SC_UNONAME_SHADOW, XML_NAMESPACE_STYLE, XML_SHADOW, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_TEXT_SHADOW, 0 ),
109 MAP( SC_UNONAME_SHRINK_TO_FIT, XML_NAMESPACE_STYLE, XML_SHRINK_TO_FIT, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BOOL, 0 ),
110 MAP( SC_UNO_STANDARDDEC, XML_NAMESPACE_STYLE, XML_DECIMAL_PLACES, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_NUMBER16, 0 ),
111 MAP( SC_UNONAME_TOPBORDER, XML_NAMESPACE_FO, XML_BORDER_TOP, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER, CTF_SC_TOPBORDER ),
112 MAP( SC_UNONAME_TOPBORDER, XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH_TOP, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER_WIDTH, CTF_SC_TOPBORDERWIDTH ),
113 MAP( SC_UNONAME_USERDEF, XML_NAMESPACE_TEXT, XML_XMLNS, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_ATTRIBUTE_CONTAINER | MID_FLAG_SPECIAL_ITEM, 0 ),
114 MAP( SC_UNONAME_VALIXML, XML_NAMESPACE_TABLE, XML_CONTENT_VALIDATION, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BUILDIN_CMP_ONLY, CTF_SC_VALIDATION ),
115 MAP( SC_UNONAME_CELLVJUS, XML_NAMESPACE_STYLE, XML_VERTICAL_ALIGN, XML_TYPE_PROP_TABLE_CELL|XML_SC_TYPE_VERTJUSTIFY, 0),
116 MAP_EXT_I( SC_UNONAME_CELLVJUS_METHOD, XML_NAMESPACE_STYLE, XML_VERTICAL_JUSTIFY, XML_TYPE_PROP_TABLE_CELL|XML_SC_TYPE_VERTJUSTIFY_METHOD, 0 ), // proposed ODF 1.2+
117 MAP_EXT( SC_UNONAME_CELLVJUS_METHOD, XML_NAMESPACE_LO_EXT, XML_VERTICAL_JUSTIFY, XML_TYPE_PROP_TABLE_CELL|XML_SC_TYPE_VERTJUSTIFY_METHOD, 0 ), // extension namespace
118 MAP_END()
119};
120
121const XMLPropertyMapEntry aXMLScColumnStylesProperties[] =
122{
123 MAP( SC_UNONAME_MANPAGE, XML_NAMESPACE_FO, XML_BREAK_BEFORE, XML_TYPE_PROP_TABLE_COLUMN|XML_SC_TYPE_BREAKBEFORE, 0),
124 MAP( SC_UNONAME_CELLVIS, XML_NAMESPACE_TABLE, XML_DISPLAY, XML_TYPE_PROP_TABLE_COLUMN|XML_SC_TYPE_EQUAL|MID_FLAG_SPECIAL_ITEM, CTF_SC_ISVISIBLE ),
125 MAP( SC_UNONAME_CELLWID, XML_NAMESPACE_STYLE, XML_COLUMN_WIDTH, XML_TYPE_PROP_TABLE_COLUMN|XML_TYPE_MEASURE, 0 ),
126 MAP_END()
127};
128
129const XMLPropertyMapEntry aXMLScRowStylesImportProperties[] =
130{
131 // #i57867# Include background color (CellBackColor/IsCellBackgroundTransparent) for import only.
132 // Import and export should use the same map, with MID_FLAG_NO_PROPERTY_EXPORT for the background entries,
133 // but this doesn't work at the moment because SvXMLImportPropertyMapper compares MID_FLAG_NO_PROPERTY to 0.
134 // If this is changed (not for 2.0.x), a single map can be used again.
135
136 MAP( SC_UNONAME_CELLBACK, XML_NAMESPACE_FO, XML_BACKGROUND_COLOR, XML_TYPE_PROP_TABLE_ROW|XML_TYPE_COLORTRANSPARENT|MID_FLAG_MULTI_PROPERTY|MID_FLAG_MERGE_ATTRIBUTE, 0 ),
137 MAP( SC_UNONAME_CELLHGT, XML_NAMESPACE_STYLE, XML_ROW_HEIGHT, XML_TYPE_PROP_TABLE_ROW|XML_TYPE_MEASURE, CTF_SC_ROWHEIGHT),
138 MAP( SC_UNONAME_CELLTRAN, XML_NAMESPACE_FO, XML_BACKGROUND_COLOR, XML_TYPE_PROP_TABLE_ROW|XML_TYPE_ISTRANSPARENT|MID_FLAG_MULTI_PROPERTY|MID_FLAG_MERGE_ATTRIBUTE, 0 ),
139 MAP_EXT( SC_UNONAME_CELL_BACKGROUND_COMPLEX_COLOR, XML_NAMESPACE_LO_EXT, XML_BACKGROUND_COMPLEX_COLOR, XML_TYPE_PROP_TABLE_ROW|XML_TYPE_COMPLEX_COLOR, CTF_COMPLEX_COLOR ),
140 MAP( SC_UNONAME_MANPAGE, XML_NAMESPACE_FO, XML_BREAK_BEFORE, XML_TYPE_PROP_TABLE_ROW|XML_SC_TYPE_BREAKBEFORE, CTF_SC_ROWBREAKBEFORE),
141 MAP( SC_UNONAME_OHEIGHT, XML_NAMESPACE_STYLE, XML_USE_OPTIMAL_ROW_HEIGHT, XML_TYPE_PROP_TABLE_ROW|XML_TYPE_BOOL, CTF_SC_ROWOPTIMALHEIGHT),
142 MAP_END()
143};
144
145const XMLPropertyMapEntry aXMLScRowStylesProperties[] =
146{
147 MAP( SC_UNONAME_CELLHGT, XML_NAMESPACE_STYLE, XML_ROW_HEIGHT, XML_TYPE_PROP_TABLE_ROW|XML_TYPE_MEASURE, CTF_SC_ROWHEIGHT),
148 MAP( SC_UNONAME_MANPAGE, XML_NAMESPACE_FO, XML_BREAK_BEFORE, XML_TYPE_PROP_TABLE_ROW|XML_SC_TYPE_BREAKBEFORE, CTF_SC_ROWBREAKBEFORE),
149 MAP( SC_UNONAME_OHEIGHT, XML_NAMESPACE_STYLE, XML_USE_OPTIMAL_ROW_HEIGHT, XML_TYPE_PROP_TABLE_ROW|XML_TYPE_BOOL, CTF_SC_ROWOPTIMALHEIGHT),
150 MAP_END()
151};
152
153const XMLPropertyMapEntry aXMLScFromXLSRowStylesProperties[] =
154{
155 MAP( SC_UNONAME_CELLHGT, XML_NAMESPACE_STYLE, XML_ROW_HEIGHT, XML_TYPE_PROP_TABLE_ROW|XML_TYPE_MEASURE, CTF_SC_ROWHEIGHT),
156 MAP( SC_UNONAME_MANPAGE, XML_NAMESPACE_FO, XML_BREAK_BEFORE, XML_TYPE_PROP_TABLE_ROW|XML_SC_TYPE_BREAKBEFORE, CTF_SC_ROWBREAKBEFORE),
157 MAP( SC_UNONAME_OHEIGHT, XML_NAMESPACE_STYLE, XML_USE_OPTIMAL_ROW_HEIGHT, XML_TYPE_PROP_TABLE_ROW|XML_TYPE_BOOL_FALSE, CTF_SC_ROWOPTIMALHEIGHT),
158 MAP_END()
159};
160
161const XMLPropertyMapEntry aXMLScTableStylesImportProperties[] =
162{
163 // #i57869# Include background color (CellBackColor/IsCellBackgroundTransparent) for import only.
164 // Import and export should use the same map, with MID_FLAG_NO_PROPERTY_EXPORT for the background entries,
165 // but this doesn't work at the moment because SvXMLImportPropertyMapper compares MID_FLAG_NO_PROPERTY to 0.
166 // If this is changed (not for 2.0.x), a single map can be used again.
167
168 MAP( SC_UNONAME_CELLBACK, XML_NAMESPACE_FO, XML_BACKGROUND_COLOR, XML_TYPE_PROP_TABLE|XML_TYPE_COLORTRANSPARENT|MID_FLAG_MULTI_PROPERTY|MID_FLAG_MERGE_ATTRIBUTE, 0 ),
169 MAP( SC_UNONAME_CELLTRAN, XML_NAMESPACE_FO, XML_BACKGROUND_COLOR, XML_TYPE_PROP_TABLE|XML_TYPE_ISTRANSPARENT|MID_FLAG_MULTI_PROPERTY|MID_FLAG_MERGE_ATTRIBUTE, 0 ),
170 MAP_EXT( SC_UNONAME_CELL_BACKGROUND_COMPLEX_COLOR, XML_NAMESPACE_LO_EXT, XML_BACKGROUND_COMPLEX_COLOR, XML_TYPE_PROP_TABLE|XML_TYPE_COMPLEX_COLOR, CTF_COMPLEX_COLOR ),
171 MAP( SC_UNONAME_CELLVIS, XML_NAMESPACE_TABLE, XML_DISPLAY, XML_TYPE_PROP_TABLE|XML_TYPE_BOOL, 0 ),
172 MAP( SC_UNONAME_PAGESTL, XML_NAMESPACE_STYLE, XML_MASTER_PAGE_NAME, XML_TYPE_PROP_TABLE|XML_TYPE_STRING|MID_FLAG_SPECIAL_ITEM, CTF_SC_MASTERPAGENAME ),
173 MAP( SC_UNONAME_TABLAYOUT, XML_NAMESPACE_STYLE, XML_WRITING_MODE, XML_TYPE_PROP_TABLE|XML_TYPE_TEXT_WRITING_MODE, 0 ),
174 MAP_ODF13( SC_UNONAME_TABCOLOR, XML_NAMESPACE_TABLE, XML_TAB_COLOR, XML_TYPE_PROP_TABLE|XML_TYPE_COLORAUTO, 0 ),
175 MAP_ODF13( SC_UNONAME_TABCOLOR, XML_NAMESPACE_TABLE_EXT, XML_TAB_COLOR, XML_TYPE_PROP_TABLE|XML_TYPE_COLORAUTO, 0 ),
176 MAP_END()
177};
178
179const XMLPropertyMapEntry aXMLScTableStylesProperties[] =
180{
181 MAP( SC_UNONAME_CELLVIS, XML_NAMESPACE_TABLE, XML_DISPLAY, XML_TYPE_PROP_TABLE|XML_TYPE_BOOL, 0 ),
182 MAP( SC_UNONAME_PAGESTL, XML_NAMESPACE_STYLE, XML_MASTER_PAGE_NAME, XML_TYPE_PROP_TABLE|XML_TYPE_STRING|MID_FLAG_SPECIAL_ITEM, CTF_SC_MASTERPAGENAME ),
183 MAP( SC_UNONAME_TABLAYOUT, XML_NAMESPACE_STYLE, XML_WRITING_MODE, XML_TYPE_PROP_TABLE|XML_TYPE_TEXT_WRITING_MODE, 0 ),
184 // ODF 1.3 OFFICE-2173
185 MAP_ODF13( SC_UNONAME_TABCOLOR, XML_NAMESPACE_TABLE, XML_TAB_COLOR, XML_TYPE_PROP_TABLE|XML_TYPE_COLORAUTO, 0 ),
186 MAP_ODF13( SC_UNONAME_TABCOLOR, XML_NAMESPACE_TABLE_EXT, XML_TAB_COLOR, XML_TYPE_PROP_TABLE|XML_TYPE_COLORAUTO, 0 ),
187 MAP_END()
188};
189
190ScXMLCellExportPropertyMapper::ScXMLCellExportPropertyMapper(
191 const rtl::Reference< XMLPropertySetMapper >& rMapper )
192 : SvXMLExportPropertyMapper(rMapper)
193{
194}
195
196ScXMLCellExportPropertyMapper::~ScXMLCellExportPropertyMapper()
197{
198}
199
200void ScXMLCellExportPropertyMapper::ContextFilter(
201 bool bEnableFoFontFamily,
202 ::std::vector< XMLPropertyState >& rProperties,
203 const uno::Reference< beans::XPropertySet >& rPropSet ) const
204{
205 XMLPropertyState* pPadding = nullptr;
206 XMLPropertyState* pPadding_Bottom = nullptr;
207 XMLPropertyState* pPadding_Left = nullptr;
208 XMLPropertyState* pPadding_Right = nullptr;
209 XMLPropertyState* pPadding_Top = nullptr;
210
211 XMLPropertyState* pBorder = nullptr;
212 XMLPropertyState* pBorder_Bottom = nullptr;
213 XMLPropertyState* pBorder_Left = nullptr;
214 XMLPropertyState* pBorder_Right = nullptr;
215 XMLPropertyState* pBorder_Top = nullptr;
216 XMLPropertyState* pSWBorder = nullptr;
217 XMLPropertyState* pSWBorder_Bottom = nullptr;
218 XMLPropertyState* pSWBorder_Left = nullptr;
219 XMLPropertyState* pSWBorder_Right = nullptr;
220 XMLPropertyState* pSWBorder_Top = nullptr;
221
222 XMLPropertyState* pAllBorderWidthState = nullptr;
223 XMLPropertyState* pLeftBorderWidthState = nullptr;
224 XMLPropertyState* pRightBorderWidthState = nullptr;
225 XMLPropertyState* pTopBorderWidthState = nullptr;
226 XMLPropertyState* pBottomBorderWidthState = nullptr;
227 XMLPropertyState* pSWAllBorderWidthState = nullptr;
228 XMLPropertyState* pSWLeftBorderWidthState = nullptr;
229 XMLPropertyState* pSWRightBorderWidthState = nullptr;
230 XMLPropertyState* pSWTopBorderWidthState = nullptr;
231 XMLPropertyState* pSWBottomBorderWidthState = nullptr;
232 XMLPropertyState* pDiagonalTLBRWidthState = nullptr;
233 XMLPropertyState* pDiagonalBLTRWidthState = nullptr;
234
235 XMLPropertyState* pParaMarginLeft = nullptr;
236 XMLPropertyState* pParaMarginLeftRel = nullptr;
237 XMLPropertyState* pParaMarginRight = nullptr;
238 XMLPropertyState* pParaMarginRightRel = nullptr;
239 XMLPropertyState* pParaMarginTop = nullptr;
240 XMLPropertyState* pParaMarginTopRel = nullptr;
241 XMLPropertyState* pParaMarginBottom = nullptr;
242 XMLPropertyState* pParaMarginBottomRel = nullptr;
243
244 XMLPropertyState* pParaAdjust = nullptr;
245 XMLPropertyState* pParaAdjustLast = nullptr;
246
247 for( auto& rProperty : rProperties )
248 {
249 XMLPropertyState* propertyState = &rProperty;
250 if (propertyState->mnIndex != -1)
251 {
252 switch( getPropertySetMapper()->GetEntryContextId( propertyState->mnIndex ) )
253 {
254 case CTF_SC_ALLPADDING: pPadding = propertyState; break;
255 case CTF_SC_BOTTOMPADDING: pPadding_Bottom = propertyState; break;
256 case CTF_SC_LEFTPADDING: pPadding_Left = propertyState; break;
257 case CTF_SC_RIGHTPADDING: pPadding_Right = propertyState; break;
258 case CTF_SC_TOPPADDING: pPadding_Top = propertyState; break;
259 case CTF_SC_ALLBORDER: pBorder = propertyState; break;
260 case CTF_SC_LEFTBORDER: pBorder_Left = propertyState; break;
261 case CTF_SC_RIGHTBORDER: pBorder_Right = propertyState; break;
262 case CTF_SC_BOTTOMBORDER: pBorder_Bottom = propertyState; break;
263 case CTF_SC_TOPBORDER: pBorder_Top = propertyState; break;
264 case CTF_SC_ALLBORDERWIDTH: pAllBorderWidthState = propertyState; break;
265 case CTF_SC_LEFTBORDERWIDTH: pLeftBorderWidthState = propertyState; break;
266 case CTF_SC_RIGHTBORDERWIDTH: pRightBorderWidthState = propertyState; break;
267 case CTF_SC_TOPBORDERWIDTH: pTopBorderWidthState = propertyState; break;
268 case CTF_SC_BOTTOMBORDERWIDTH: pBottomBorderWidthState = propertyState; break;
269 case CTF_ALLBORDER: pSWBorder = propertyState; break;
270 case CTF_LEFTBORDER: pSWBorder_Left = propertyState; break;
271 case CTF_RIGHTBORDER: pSWBorder_Right = propertyState; break;
272 case CTF_BOTTOMBORDER: pSWBorder_Bottom = propertyState; break;
273 case CTF_TOPBORDER: pSWBorder_Top = propertyState; break;
274 case CTF_ALLBORDERWIDTH: pSWAllBorderWidthState = propertyState; break;
275 case CTF_LEFTBORDERWIDTH: pSWLeftBorderWidthState = propertyState; break;
276 case CTF_RIGHTBORDERWIDTH: pSWRightBorderWidthState = propertyState; break;
277 case CTF_TOPBORDERWIDTH: pSWTopBorderWidthState = propertyState; break;
278 case CTF_BOTTOMBORDERWIDTH: pSWBottomBorderWidthState = propertyState; break;
279 case CTF_SC_DIAGONALTLBR: break; //old diagonal line attribute names without "s" are only read, not written
280 case CTF_SC_DIAGONALTLBRWIDTH: pDiagonalTLBRWidthState = propertyState; break;
281 case CTF_SC_DIAGONALBLTR: break; //old diagonal line attribute names without "s" are only read, not written
282 case CTF_SC_DIAGONALBLTRWIDTH: pDiagonalBLTRWidthState = propertyState; break;
283 case CTF_SD_SHAPE_PARA_ADJUST: pParaAdjust = propertyState; break;
284 case CTF_PARA_ADJUSTLAST: pParaAdjustLast = propertyState; break;
285 case CTF_PARALEFTMARGIN: pParaMarginLeft = propertyState; break;
286 case CTF_PARALEFTMARGIN_REL: pParaMarginLeftRel = propertyState; break;
287 case CTF_PARARIGHTMARGIN: pParaMarginRight = propertyState; break;
288 case CTF_PARARIGHTMARGIN_REL: pParaMarginRightRel = propertyState; break;
289 case CTF_PARATOPMARGIN: pParaMarginTop = propertyState; break;
290 case CTF_PARATOPMARGIN_REL: pParaMarginTopRel = propertyState; break;
291 case CTF_PARABOTTOMMARGIN: pParaMarginBottom = propertyState; break;
292 case CTF_PARABOTTOMMARGIN_REL: pParaMarginBottomRel = propertyState; break;
293 }
294 }
295 }
296
297 if (pPadding && pPadding_Bottom && pPadding_Left && pPadding_Right && pPadding_Top)
298 {
299 sal_Int32 nBottom = 0, nTop = 0, nLeft = 0, nRight = 0;
300 if ((pPadding_Bottom->maValue >>= nBottom) &&
301 (pPadding_Left->maValue >>= nLeft) &&
302 (pPadding_Right->maValue >>= nRight) &&
303 (pPadding_Top->maValue >>= nTop))
304 {
305 if ((nBottom == nTop) && (nLeft == nRight) && (nTop == nLeft))
306 {
307 pPadding_Bottom->mnIndex = -1;
308 pPadding_Bottom->maValue.clear();
309 pPadding_Left->mnIndex = -1;
310 pPadding_Left->maValue.clear();
311 pPadding_Right->mnIndex = -1;
312 pPadding_Right->maValue.clear();
313 pPadding_Top->mnIndex = -1;
314 pPadding_Top->maValue.clear();
315 }
316 else
317 {
318 pPadding->mnIndex = -1;
319 pPadding->maValue.clear();
320 }
321 }
322 }
323 if( pBorder )
324 {
325 if( pBorder_Left && pBorder_Right && pBorder_Top && pBorder_Bottom )
326 {
327 table::BorderLine2 aLeft, aRight, aTop, aBottom;
328
329 pBorder_Left->maValue >>= aLeft;
330 pBorder_Right->maValue >>= aRight;
331 pBorder_Top->maValue >>= aTop;
332 pBorder_Bottom->maValue >>= aBottom;
333 if( aLeft.Color == aRight.Color && aLeft.InnerLineWidth == aRight.InnerLineWidth &&
334 aLeft.OuterLineWidth == aRight.OuterLineWidth && aLeft.LineDistance == aRight.LineDistance &&
335 aLeft.Color == aTop.Color && aLeft.InnerLineWidth == aTop.InnerLineWidth &&
336 aLeft.OuterLineWidth == aTop.OuterLineWidth && aLeft.LineDistance == aTop.LineDistance &&
337 aLeft.Color == aBottom.Color && aLeft.InnerLineWidth == aBottom.InnerLineWidth &&
338 aLeft.OuterLineWidth == aBottom.OuterLineWidth && aLeft.LineDistance == aBottom.LineDistance &&
339 aLeft.LineStyle == aRight.LineStyle && aLeft.LineStyle == aTop.LineStyle &&
340 aLeft.LineStyle == aBottom.LineStyle && aLeft.LineWidth == aRight.LineWidth &&
341 aLeft.LineWidth == aTop.LineWidth && aLeft.LineWidth == aBottom.LineWidth )
342 {
343 pBorder_Left->mnIndex = -1;
344 pBorder_Left->maValue.clear();
345 pBorder_Right->mnIndex = -1;
346 pBorder_Right->maValue.clear();
347 pBorder_Top->mnIndex = -1;
348 pBorder_Top->maValue.clear();
349 pBorder_Bottom->mnIndex = -1;
350 pBorder_Bottom->maValue.clear();
351 }
352 else
353 {
354 pBorder->mnIndex = -1;
355 pBorder->maValue.clear();
356 }
357 }
358 else
359 {
360 pBorder->mnIndex = -1;
361 pBorder->maValue.clear();
362 }
363 }
364 if( pAllBorderWidthState )
365 {
366 if( pLeftBorderWidthState && pRightBorderWidthState && pTopBorderWidthState && pBottomBorderWidthState )
367 {
368 table::BorderLine2 aLeft, aRight, aTop, aBottom;
369
370 pLeftBorderWidthState->maValue >>= aLeft;
371 pRightBorderWidthState->maValue >>= aRight;
372 pTopBorderWidthState->maValue >>= aTop;
373 pBottomBorderWidthState->maValue >>= aBottom;
374 if( aLeft.InnerLineWidth == aRight.InnerLineWidth && aLeft.OuterLineWidth == aRight.OuterLineWidth &&
375 aLeft.LineDistance == aRight.LineDistance && aLeft.InnerLineWidth == aTop.InnerLineWidth &&
376 aLeft.OuterLineWidth == aTop.OuterLineWidth && aLeft.LineDistance == aTop.LineDistance &&
377 aLeft.InnerLineWidth == aBottom.InnerLineWidth && aLeft.OuterLineWidth == aBottom.OuterLineWidth &&
378 aLeft.LineDistance == aBottom.LineDistance && aLeft.LineWidth == aRight.LineWidth &&
379 aLeft.LineWidth == aTop.LineWidth && aLeft.LineWidth == aBottom.LineWidth )
380 {
381 pLeftBorderWidthState->mnIndex = -1;
382 pLeftBorderWidthState->maValue.clear();
383 pRightBorderWidthState->mnIndex = -1;
384 pRightBorderWidthState->maValue.clear();
385 pTopBorderWidthState->mnIndex = -1;
386 pTopBorderWidthState->maValue.clear();
387 pBottomBorderWidthState->mnIndex = -1;
388 pBottomBorderWidthState->maValue.clear();
389 }
390 else
391 {
392 pAllBorderWidthState->mnIndex = -1;
393 pAllBorderWidthState->maValue.clear();
394 }
395 }
396 else
397 {
398 pAllBorderWidthState->mnIndex = -1;
399 pAllBorderWidthState->maValue.clear();
400 }
401 }
402
403 if (pParaAdjust)
404 {
405 pParaAdjust->mnIndex = -1;
406 pParaAdjust->maValue.clear();
407 }
408 if (pParaAdjustLast)
409 {
410 pParaAdjustLast->mnIndex = -1;
411 pParaAdjustLast->maValue.clear();
412 }
413 if (pSWBorder)
414 {
415 pSWBorder->mnIndex = -1;
416 pSWBorder->maValue.clear();
417 }
418 if (pSWBorder_Left)
419 {
420 pSWBorder_Left->mnIndex = -1;
421 pSWBorder_Left->maValue.clear();
422 }
423 if (pSWBorder_Right)
424 {
425 pSWBorder_Right->mnIndex = -1;
426 pSWBorder_Right->maValue.clear();
427 }
428 if (pSWBorder_Bottom)
429 {
430 pSWBorder_Bottom->mnIndex = -1;
431 pSWBorder_Bottom->maValue.clear();
432 }
433 if (pSWBorder_Top)
434 {
435 pSWBorder_Top->mnIndex = -1;
436 pSWBorder_Top->maValue.clear();
437 }
438 if (pSWAllBorderWidthState)
439 {
440 pSWAllBorderWidthState->mnIndex = -1;
441 pSWAllBorderWidthState->maValue.clear();
442 }
443 if (pSWLeftBorderWidthState)
444 {
445 pSWLeftBorderWidthState->mnIndex = -1;
446 pSWLeftBorderWidthState->maValue.clear();
447 }
448 if (pSWRightBorderWidthState)
449 {
450 pSWRightBorderWidthState->mnIndex = -1;
451 pSWRightBorderWidthState->maValue.clear();
452 }
453 if (pSWTopBorderWidthState)
454 {
455 pSWTopBorderWidthState->mnIndex = -1;
456 pSWTopBorderWidthState->maValue.clear();
457 }
458 if (pSWBottomBorderWidthState)
459 {
460 pSWBottomBorderWidthState->mnIndex = -1;
461 pSWBottomBorderWidthState->maValue.clear();
462 }
463
464 if (pParaMarginLeft)
465 {
466 pParaMarginLeft->mnIndex = -1;
467 pParaMarginLeft->maValue.clear();
468 }
469 if (pParaMarginLeftRel)
470 {
471 pParaMarginLeftRel->mnIndex = -1;
472 pParaMarginLeftRel->maValue.clear();
473 }
474 if (pParaMarginRight)
475 {
476 pParaMarginRight->mnIndex = -1;
477 pParaMarginRight->maValue.clear();
478 }
479 if (pParaMarginRightRel)
480 {
481 pParaMarginRightRel->mnIndex = -1;
482 pParaMarginRightRel->maValue.clear();
483 }
484 if (pParaMarginTop)
485 {
486 pParaMarginTop->mnIndex = -1;
487 pParaMarginTop->maValue.clear();
488 }
489 if (pParaMarginTopRel)
490 {
491 pParaMarginTopRel->mnIndex = -1;
492 pParaMarginTopRel->maValue.clear();
493 }
494 if (pParaMarginBottom)
495 {
496 pParaMarginBottom->mnIndex = -1;
497 pParaMarginBottom->maValue.clear();
498 }
499 if (pParaMarginBottomRel)
500 {
501 pParaMarginBottomRel->mnIndex = -1;
502 pParaMarginBottomRel->maValue.clear();
503 }
504
505 // #i102690# old diagonal line attribute names without "s" are only read, not written
506 if (pDiagonalTLBRWidthState)
507 {
508 pDiagonalTLBRWidthState->mnIndex = -1;
509 pDiagonalTLBRWidthState->maValue.clear();
510 }
511 if (pDiagonalBLTRWidthState)
512 {
513 pDiagonalBLTRWidthState->mnIndex = -1;
514 pDiagonalBLTRWidthState->maValue.clear();
515 }
516
517 SvXMLExportPropertyMapper::ContextFilter(bEnableFoFontFamily, rProperties, rPropSet);
518}
519
521void ScXMLCellExportPropertyMapper::handleSpecialItem(
522 comphelper::AttributeList& /* rAttrList */,
523 const XMLPropertyState& /* rProperty */,
524 const SvXMLUnitConverter& /* rUnitConverter */,
525 const SvXMLNamespaceMap& /* rNamespaceMap */,
526 const ::std::vector< XMLPropertyState > * /* pProperties */,
527 sal_uInt32 /* nIdx */ ) const
528{
529 // the SpecialItem NumberFormat must not be handled by this method
530 // the SpecialItem ConditionlaFormat must not be handled by this method
531 // the SpecialItem CharBackColor must not be handled by this method
532}
533
534void ScXMLCellExportPropertyMapper::handleElementItem(
535 SvXMLExport& rExport,
536 const XMLPropertyState& rProperty,
537 SvXmlExportFlags /* nFlags */,
538 const ::std::vector< XMLPropertyState > * /* pProperties */,
539 sal_uInt32 /* nIdx */) const
540{
541 sal_uInt32 nContextId = getPropertySetMapper()->GetEntryContextId( rProperty.mnIndex );
542 switch (nContextId)
543 {
544 case CTF_SC_HYPERLINK:
545 {
546 OUString sURL;
547 if ((rProperty.maValue >>= sURL) && !sURL.isEmpty())
548 {
549 rExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, sURL );
550 rExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE,
551 XML_SIMPLE );
552 sal_uInt32 nPropIndex = rProperty.mnIndex;
553 sal_uInt16 nPrefix = getPropertySetMapper()->GetEntryNameSpace( nPropIndex );
554 OUString sLocalName = getPropertySetMapper()->GetEntryXMLName( nPropIndex );
555 SvXMLElementExport aElem( rExport, nPrefix, sLocalName, true, true );
556 }
557 }
558 break;
559 case CTF_COMPLEX_COLOR:
560 {
561 XMLComplexColorExport aExport(rExport);
562 aExport.exportXML(rProperty.maValue,
563 getPropertySetMapper()->GetEntryNameSpace(rProperty.mnIndex),
564 getPropertySetMapper()->GetEntryXMLName(rProperty.mnIndex));
565 }
566 break;
567 default:
568 break;
569 }
570}
571
572ScXMLRowExportPropertyMapper::ScXMLRowExportPropertyMapper(
573 const rtl::Reference< XMLPropertySetMapper >& rMapper )
574 : SvXMLExportPropertyMapper(rMapper)
575{
576}
577
578ScXMLRowExportPropertyMapper::~ScXMLRowExportPropertyMapper()
579{
580}
581
582void ScXMLRowExportPropertyMapper::ContextFilter(
583 bool /* bEnableFoFontFamily */,
584 ::std::vector< XMLPropertyState >& /* rProperties */,
585 const uno::Reference< beans::XPropertySet >& /* rPropSet */ ) const
586{
587 //#108550#; don't filter the height, so other applications know the calculated height
588}
589
590ScXMLColumnExportPropertyMapper::ScXMLColumnExportPropertyMapper(
591 const rtl::Reference< XMLPropertySetMapper >& rMapper )
592 : SvXMLExportPropertyMapper(rMapper)
593{
594}
595
596ScXMLColumnExportPropertyMapper::~ScXMLColumnExportPropertyMapper()
597{
598}
599
601void ScXMLColumnExportPropertyMapper::handleSpecialItem(
602 comphelper::AttributeList& /* rAttrList */,
603 const XMLPropertyState& /* rProperty */,
604 const SvXMLUnitConverter& /* rUnitConverter */,
605 const SvXMLNamespaceMap& /* rNamespaceMap */,
606 const ::std::vector< XMLPropertyState > * /* pProperties */,
607 sal_uInt32 /* nIdx */ ) const
608{
609 // the SpecialItem IsVisible must not be handled by this method
610}
611
612ScXMLTableExportPropertyMapper::ScXMLTableExportPropertyMapper(
613 const rtl::Reference< XMLPropertySetMapper >& rMapper )
614 : SvXMLExportPropertyMapper(rMapper)
615{
616}
617
618ScXMLTableExportPropertyMapper::~ScXMLTableExportPropertyMapper()
619{
620}
621
623void ScXMLTableExportPropertyMapper::handleSpecialItem(
624 comphelper::AttributeList& /* rAttrList */,
625 const XMLPropertyState& /* rProperty */,
626 const SvXMLUnitConverter& /* rUnitConverter */,
627 const SvXMLNamespaceMap& /* rNamespaceMap */,
628 const ::std::vector< XMLPropertyState > * /* pProperties */,
629 sal_uInt32 /* nIdx */ ) const
630{
631 // the SpecialItem PageStyle must not be handled by this method
632}
633
634void ScXMLAutoStylePoolP::exportStyleAttributes(
635 comphelper::AttributeList& rAttrList,
636 XmlStyleFamily nFamily,
637 const ::std::vector< XMLPropertyState >& rProperties,
638 const SvXMLExportPropertyMapper& rPropExp
639 , const SvXMLUnitConverter& rUnitConverter,
640 const SvXMLNamespaceMap& rNamespaceMap
641 ) const
642{
643 SvXMLAutoStylePoolP::exportStyleAttributes( rAttrList, nFamily, rProperties, rPropExp, rUnitConverter, rNamespaceMap );
644 if (nFamily == XmlStyleFamily::TABLE_CELL)
645 {
646 for(const auto& rProperty : rProperties)
647 {
648 rtl::Reference< XMLPropertySetMapper > aPropMapper(rScXMLExport.GetCellStylesPropertySetMapper());
649 sal_Int16 nContextID(aPropMapper->GetEntryContextId(rProperty.mnIndex));
650 switch (nContextID)
651 {
652 case CTF_SC_NUMBERFORMAT :
653 {
654 sal_Int32 nNumberFormat = 0;
655 if (rProperty.maValue >>= nNumberFormat)
656 {
657 OUString sAttrValue(rScXMLExport.getDataStyleName(nNumberFormat));
658 if (!sAttrValue.isEmpty())
659 {
660 GetExport().AddAttribute(
661 aPropMapper->GetEntryNameSpace(rProperty.mnIndex),
662 aPropMapper->GetEntryXMLName(rProperty.mnIndex),
663 sAttrValue );
664 }
665 }
666 }
667 break;
668 }
669 }
670 }
671 else if (nFamily == XmlStyleFamily::TABLE_TABLE)
672 {
673 for(const auto& rProperty : rProperties)
674 {
675 rtl::Reference< XMLPropertySetMapper > aPropMapper(rScXMLExport.GetTableStylesPropertySetMapper());
676 sal_Int16 nContextID(aPropMapper->GetEntryContextId(rProperty.mnIndex));
677 switch (nContextID)
678 {
679 case CTF_SC_MASTERPAGENAME :
680 {
681 OUString sName;
682 if (rProperty.maValue >>= sName)
683 {
684 GetExport().AddAttribute(
685 aPropMapper->GetEntryNameSpace(rProperty.mnIndex),
686 aPropMapper->GetEntryXMLName(rProperty.mnIndex),
687 GetExport().EncodeStyleName( sName ));
688 }
689 }
690 break;
691 }
692 }
693 }
694}
695
696void ScXMLAutoStylePoolP::exportStyleContent(
697 const css::uno::Reference< css::xml::sax::XDocumentHandler > & rHandler,
698 XmlStyleFamily nFamily,
699 const std::vector< XMLPropertyState >& rProperties,
700 const SvXMLExportPropertyMapper& rPropExp
701 , const SvXMLUnitConverter& rUnitConverter,
702 const SvXMLNamespaceMap& rNamespaceMap
703 ) const
704{
705 SvXMLAutoStylePoolP::exportStyleContent( rHandler, nFamily, rProperties, rPropExp, rUnitConverter, rNamespaceMap );
706 if (nFamily != XmlStyleFamily::TABLE_CELL)
707 return;
708
709 for(const auto& rProperty : rProperties)
710 {
711 if (rProperty.mnIndex != -1)
712 {
713 sal_Int16 nContextID = rScXMLExport.GetCellStylesPropertySetMapper()->GetEntryContextId(rProperty.mnIndex);
714 switch (nContextID)
715 {
716 case CTF_SC_MAP :
717 {
718 uno::Reference<container::XIndexAccess> xIndex( rProperty.maValue, uno::UNO_QUERY );
719 if ( xIndex.is() )
720 {
721 sal_Int32 nConditionCount(xIndex->getCount());
722 for (sal_Int32 nCondition = 0; nCondition < nConditionCount; ++nCondition)
723 {
724 uno::Reference <sheet::XSheetConditionalEntry> xSheetConditionalEntry(xIndex->getByIndex(nCondition), uno::UNO_QUERY);
725 if (xSheetConditionalEntry.is())
726 {
727 OUString sStyleName(xSheetConditionalEntry->getStyleName());
728 uno::Reference <sheet::XSheetCondition> xSheetCondition(xSheetConditionalEntry, uno::UNO_QUERY);
729 if (xSheetCondition.is())
730 {
731 sheet::ConditionOperator aOperator = xSheetCondition->getOperator();
732 if (aOperator != sheet::ConditionOperator_NONE)
733 {
734 if (aOperator == sheet::ConditionOperator_FORMULA)
735 {
736 OUString sCondition = "is-true-formula("
737 + xSheetCondition->getFormula1()
738 + ")";
739 rScXMLExport.AddAttribute(XML_NAMESPACE_STYLE, XML_CONDITION, sCondition);
740 rScXMLExport.AddAttribute(XML_NAMESPACE_STYLE, XML_APPLY_STYLE_NAME, rScXMLExport.EncodeStyleName( sStyleName ));
741 OUString sOUBaseAddress;
742 ScDocument* pDoc = rScXMLExport.GetDocument();
743 ScRangeStringConverter::GetStringFromAddress( sOUBaseAddress,
744 xSheetCondition->getSourcePosition(), pDoc, FormulaGrammar::CONV_OOO );
745 rScXMLExport.AddAttribute(XML_NAMESPACE_STYLE, XML_BASE_CELL_ADDRESS, sOUBaseAddress);
746 SvXMLElementExport aMElem(rScXMLExport, XML_NAMESPACE_STYLE, XML_MAP, true, true);
747 }
748 else
749 {
750 OUString sCondition;
751 if (aOperator == sheet::ConditionOperator_BETWEEN ||
752 aOperator == sheet::ConditionOperator_NOT_BETWEEN)
753 {
754 if (aOperator == sheet::ConditionOperator_BETWEEN)
755 sCondition = "cell-content-is-between(";
756 else
757 sCondition = "cell-content-is-not-between(";
758 sCondition += xSheetCondition->getFormula1()
759 + ","
760 + xSheetCondition->getFormula2()
761 + ")";
762 }
763 else
764 {
765 sCondition = "cell-content()";
766 switch (aOperator)
767 {
768 case sheet::ConditionOperator_LESS:
769 sCondition += "<";
770 break;
771 case sheet::ConditionOperator_GREATER:
772 sCondition += ">";
773 break;
774 case sheet::ConditionOperator_LESS_EQUAL:
775 sCondition += "<=";
776 break;
777 case sheet::ConditionOperator_GREATER_EQUAL:
778 sCondition += ">=";
779 break;
780 case sheet::ConditionOperator_EQUAL:
781 sCondition += "=";
782 break;
783 case sheet::ConditionOperator_NOT_EQUAL:
784 sCondition += "!=";
785 break;
786 default:
787 {
788 // added to avoid warnings
789 }
790 }
791 sCondition += xSheetCondition->getFormula1();
792 }
793 rScXMLExport.AddAttribute(XML_NAMESPACE_STYLE, XML_CONDITION, sCondition);
794 rScXMLExport.AddAttribute(XML_NAMESPACE_STYLE, XML_APPLY_STYLE_NAME, rScXMLExport.EncodeStyleName( sStyleName ));
795 OUString sOUBaseAddress;
796 ScRangeStringConverter::GetStringFromAddress( sOUBaseAddress,
797 xSheetCondition->getSourcePosition(), rScXMLExport.GetDocument(), FormulaGrammar::CONV_OOO );
798 rScXMLExport.AddAttribute(XML_NAMESPACE_STYLE, XML_BASE_CELL_ADDRESS, sOUBaseAddress);
799 SvXMLElementExport aMElem(rScXMLExport, XML_NAMESPACE_STYLE, XML_MAP, true, true);
800 }
801 }
802 }
803 }
804 }
805 }
806 }
807 break;
808 }
809 }
810 }
811}
812
813ScXMLAutoStylePoolP::ScXMLAutoStylePoolP(ScXMLExport& rTempScXMLExport):
814 SvXMLAutoStylePoolP(rTempScXMLExport),
815 rScXMLExport(rTempScXMLExport)
816{
817}
818
819ScXMLAutoStylePoolP::~ScXMLAutoStylePoolP()
820{
821}
822
823XMLScPropHdlFactory::XMLScPropHdlFactory()
824{
825}
826
827XMLScPropHdlFactory::~XMLScPropHdlFactory()
828{
829}
830
831const XMLPropertyHandler* XMLScPropHdlFactory::GetPropertyHandler( sal_Int32 nType ) const
832{
833 nType &= MID_FLAG_MASK;
834
835 XMLPropertyHandler* pHdl(const_cast<XMLPropertyHandler*>(XMLPropertyHandlerFactory::GetPropertyHandler( nType )));
836 if(!pHdl)
837 {
838 switch(nType)
839 {
840 case XML_SC_TYPE_CELLPROTECTION :
841 {
842 pHdl = new XmlScPropHdl_CellProtection;
843 }
844 break;
845 case XML_SC_TYPE_PRINTCONTENT :
846 {
847 pHdl = new XmlScPropHdl_PrintContent;
848 }
849 break;
850 case XML_SC_TYPE_HORIJUSTIFY_METHOD:
851 case XML_SC_TYPE_VERTJUSTIFY_METHOD:
852 {
853 pHdl = new XmlScPropHdl_JustifyMethod;
854 }
855 break;
856 case XML_SC_TYPE_HORIJUSTIFY :
857 {
858 pHdl = new XmlScPropHdl_HoriJustify;
859 }
860 break;
861 case XML_SC_TYPE_HORIJUSTIFYSOURCE :
862 {
863 pHdl = new XmlScPropHdl_HoriJustifySource;
864 }
865 break;
866 case XML_SC_TYPE_HORIJUSTIFYREPEAT :
867 {
868 pHdl = new XmlScPropHdl_HoriJustifyRepeat;
869 }
870 break;
871 case XML_SC_TYPE_ORIENTATION :
872 {
873 pHdl = new XmlScPropHdl_Orientation;
874 }
875 break;
876 case XML_SC_TYPE_ROTATEANGLE :
877 {
878 pHdl = new XmlScPropHdl_RotateAngle;
879 }
880 break;
881 case XML_SC_TYPE_ROTATEREFERENCE :
882 {
883 pHdl = new XmlScPropHdl_RotateReference;
884 }
885 break;
886 case XML_SC_TYPE_VERTJUSTIFY :
887 {
888 pHdl = new XmlScPropHdl_VertJustify;
889 }
890 break;
891 case XML_SC_TYPE_BREAKBEFORE :
892 {
893 pHdl = new XmlScPropHdl_BreakBefore;
894 }
895 break;
896 case XML_SC_ISTEXTWRAPPED :
897 {
898 pHdl = new XmlScPropHdl_IsTextWrapped;
899 }
900 break;
901 case XML_SC_TYPE_EQUAL :
902 {
903 pHdl = new XmlScPropHdl_IsEqual;
904 }
905 break;
906 case XML_SC_TYPE_VERTICAL :
907 {
908 pHdl = new XmlScPropHdl_Vertical;
909 }
910 break;
911 case XML_TYPE_COMPLEX_COLOR:
912 {
913 pHdl = new XMLComplexColorHandler;
914 }
915 break;
916 }
917
918 if(pHdl)
919 PutHdlCache(nType, pHdl);
920 }
921
922 return pHdl;
923}
924
925XmlScPropHdl_CellProtection::~XmlScPropHdl_CellProtection()
926{
927}
928
929bool XmlScPropHdl_CellProtection::equals(
930 const css::uno::Any& r1,
931 const css::uno::Any& r2 ) const
932{
933 util::CellProtection aCellProtection1, aCellProtection2;
934
935 if((r1 >>= aCellProtection1) && (r2 >>= aCellProtection2))
936 {
937 return ((aCellProtection1.IsHidden == aCellProtection2.IsHidden) &&
938 (aCellProtection1.IsLocked == aCellProtection2.IsLocked) &&
939 (aCellProtection1.IsFormulaHidden == aCellProtection2.IsFormulaHidden));
940 }
941 return false;
942}
943
944bool XmlScPropHdl_CellProtection::importXML(
945 const OUString& rStrImpValue,
946 css::uno::Any& rValue,
947 const SvXMLUnitConverter& /* rUnitConverter */ ) const
948{
949 bool bRetval(false);
950
951 util::CellProtection aCellProtection;
952 bool bDefault(false);
953 if (!rValue.hasValue())
954 {
955 aCellProtection.IsHidden = false;
956 aCellProtection.IsLocked = true;
957 aCellProtection.IsFormulaHidden = false;
958 aCellProtection.IsPrintHidden = false;
959 bDefault = true;
960 }
961 if ((rValue >>= aCellProtection) || bDefault)
962 {
963 if (IsXMLToken(rStrImpValue, XML_NONE))
964 {
965 aCellProtection.IsFormulaHidden = false;
966 aCellProtection.IsHidden = false;
967 aCellProtection.IsLocked = false;
968 rValue <<= aCellProtection;
969 bRetval = true;
970 }
971 else if (IsXMLToken(rStrImpValue, XML_HIDDEN_AND_PROTECTED))
972 {
973 aCellProtection.IsFormulaHidden = true;
974 aCellProtection.IsHidden = true;
975 aCellProtection.IsLocked = true;
976 rValue <<= aCellProtection;
977 bRetval = true;
978 }
979 else if (IsXMLToken(rStrImpValue, XML_PROTECTED))
980 {
981 aCellProtection.IsFormulaHidden = false;
982 aCellProtection.IsHidden = false;
983 aCellProtection.IsLocked = true;
984 rValue <<= aCellProtection;
985 bRetval = true;
986 }
987 else if (IsXMLToken(rStrImpValue, XML_FORMULA_HIDDEN))
988 {
989 aCellProtection.IsFormulaHidden = true;
990 aCellProtection.IsHidden = false;
991 aCellProtection.IsLocked = false;
992 rValue <<= aCellProtection;
993 bRetval = true;
994 }
995 else
996 {
997 sal_Int32 i(0);
998 while (i < rStrImpValue.getLength() && rStrImpValue[i] != ' ')
999 ++i;
1000 OUString sFirst(rStrImpValue.copy(0, i));
1001 OUString sSecond(rStrImpValue.copy(i + 1));
1002 aCellProtection.IsFormulaHidden = false;
1003 aCellProtection.IsHidden = false;
1004 aCellProtection.IsLocked = false;
1005 if ((IsXMLToken(sFirst, XML_PROTECTED)) || (IsXMLToken(sSecond, XML_PROTECTED)))
1006 aCellProtection.IsLocked = true;
1007 if ((IsXMLToken(sFirst, XML_FORMULA_HIDDEN)) || (IsXMLToken(sSecond, XML_FORMULA_HIDDEN)))
1008 aCellProtection.IsFormulaHidden = true;
1009 rValue <<= aCellProtection;
1010 bRetval = true;
1011 }
1012 }
1013
1014 return bRetval;
1015}
1016
1017bool XmlScPropHdl_CellProtection::exportXML(
1018 OUString& rStrExpValue,
1019 const css::uno::Any& rValue,
1020 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1021{
1022 bool bRetval(false);
1023 util::CellProtection aCellProtection;
1024
1025 if(rValue >>= aCellProtection)
1026 {
1027 if (!(aCellProtection.IsFormulaHidden || aCellProtection.IsHidden || aCellProtection.IsLocked))
1028 {
1029 rStrExpValue = GetXMLToken(XML_NONE);
1030 bRetval = true;
1031 }
1032 else if (aCellProtection.IsHidden)
1033 {
1034 // #i105964# "Hide all" implies "Protected" in the UI, so it must be saved as "hidden-and-protected"
1035 // even if "IsLocked" is not set in the CellProtection struct.
1036 rStrExpValue = GetXMLToken(XML_HIDDEN_AND_PROTECTED);
1037 bRetval = true;
1038 }
1039 else if (aCellProtection.IsLocked && !aCellProtection.IsFormulaHidden)
1040 {
1041 rStrExpValue = GetXMLToken(XML_PROTECTED);
1042 bRetval = true;
1043 }
1044 else if (aCellProtection.IsFormulaHidden && !aCellProtection.IsLocked)
1045 {
1046 rStrExpValue = GetXMLToken(XML_FORMULA_HIDDEN);
1047 bRetval = true;
1048 }
1049 else if (aCellProtection.IsFormulaHidden && aCellProtection.IsLocked)
1050 {
1051 rStrExpValue = GetXMLToken(XML_PROTECTED);
1052 rStrExpValue += " ";
1053 rStrExpValue += GetXMLToken(XML_FORMULA_HIDDEN);
1054 bRetval = true;
1055 }
1056 }
1057
1058 return bRetval;
1059}
1060
1061XmlScPropHdl_PrintContent::~XmlScPropHdl_PrintContent()
1062{
1063}
1064
1065bool XmlScPropHdl_PrintContent::equals(
1066 const css::uno::Any& r1,
1067 const css::uno::Any& r2 ) const
1068{
1069 util::CellProtection aCellProtection1, aCellProtection2;
1070
1071 if((r1 >>= aCellProtection1) && (r2 >>= aCellProtection2))
1072 {
1073 return (aCellProtection1.IsPrintHidden == aCellProtection2.IsPrintHidden);
1074 }
1075 return false;
1076}
1077
1078bool XmlScPropHdl_PrintContent::importXML(
1079 const OUString& rStrImpValue,
1080 css::uno::Any& rValue,
1081 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1082{
1083 bool bRetval(false);
1084 util::CellProtection aCellProtection;
1085 bool bDefault(false);
1086 if (!rValue.hasValue())
1087 {
1088 aCellProtection.IsHidden = false;
1089 aCellProtection.IsLocked = true;
1090 aCellProtection.IsFormulaHidden = false;
1091 aCellProtection.IsPrintHidden = false;
1092 bDefault = true;
1093 }
1094 if ((rValue >>= aCellProtection) || bDefault)
1095 {
1096 bool bValue(false);
1097 if (::sax::Converter::convertBool(bValue, rStrImpValue))
1098 {
1099 aCellProtection.IsPrintHidden = !bValue;
1100 rValue <<= aCellProtection;
1101 bRetval = true;
1102 }
1103 }
1104
1105 return bRetval;
1106}
1107
1108bool XmlScPropHdl_PrintContent::exportXML(
1109 OUString& rStrExpValue,
1110 const css::uno::Any& rValue,
1111 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1112{
1113 bool bRetval(false);
1114
1115 util::CellProtection aCellProtection;
1116 if(rValue >>= aCellProtection)
1117 {
1118 OUStringBuffer sValue;
1119 ::sax::Converter::convertBool(sValue, !aCellProtection.IsPrintHidden);
1120 rStrExpValue = sValue.makeStringAndClear();
1121 bRetval = true;
1122 }
1123
1124 return bRetval;
1125}
1126
1127XmlScPropHdl_JustifyMethod::~XmlScPropHdl_JustifyMethod()
1128{
1129}
1130
1131bool XmlScPropHdl_JustifyMethod::equals(
1132 const css::uno::Any& r1,
1133 const css::uno::Any& r2 ) const
1134{
1135 sal_Int32 nVal1(0), nVal2(0);
1136
1137 if((r1 >>= nVal1) && (r2 >>= nVal2))
1138 return (nVal1 == nVal2);
1139 return false;
1140}
1141
1142bool XmlScPropHdl_JustifyMethod::importXML(
1143 const OUString& rStrImpValue,
1144 css::uno::Any& rValue,
1145 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1146{
1147 bool bRetval = false;
1148
1149 sal_Int32 nValue = table::CellJustifyMethod::AUTO;
1150 if (IsXMLToken(rStrImpValue, XML_AUTO))
1151 {
1152 nValue = table::CellJustifyMethod::AUTO;
1153 rValue <<= nValue;
1154 bRetval = true;
1155 }
1156 else if (IsXMLToken(rStrImpValue, XML_DISTRIBUTE))
1157 {
1158 nValue = table::CellJustifyMethod::DISTRIBUTE;
1159 rValue <<= nValue;
1160 bRetval = true;
1161 }
1162 else
1163 bRetval = true;
1164
1165 return bRetval;
1166}
1167
1168bool XmlScPropHdl_JustifyMethod::exportXML(
1169 OUString& rStrExpValue,
1170 const css::uno::Any& rValue,
1171 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1172{
1173 sal_Int32 nVal(0);
1174 bool bRetval = false;
1175
1176 if (rValue >>= nVal)
1177 {
1178 switch (nVal)
1179 {
1180 case table::CellJustifyMethod::AUTO:
1181 {
1182 rStrExpValue = GetXMLToken(XML_AUTO);
1183 bRetval = true;
1184 }
1185 break;
1186 case table::CellJustifyMethod::DISTRIBUTE:
1187 {
1188 rStrExpValue = GetXMLToken(XML_DISTRIBUTE);
1189 bRetval = true;
1190 }
1191 break;
1192 default:
1193 {
1194 // added to avoid warnings
1195 }
1196 }
1197 }
1198 return bRetval;
1199}
1200
1201XmlScPropHdl_HoriJustify::~XmlScPropHdl_HoriJustify()
1202{
1203}
1204
1205bool XmlScPropHdl_HoriJustify::equals(
1206 const css::uno::Any& r1,
1207 const css::uno::Any& r2 ) const
1208{
1209 table::CellHoriJustify aHoriJustify1, aHoriJustify2;
1210
1211 if((r1 >>= aHoriJustify1) && (r2 >>= aHoriJustify2))
1212 return (aHoriJustify1 == aHoriJustify2);
1213 return false;
1214}
1215
1216bool XmlScPropHdl_HoriJustify::importXML(
1217 const OUString& rStrImpValue,
1218 css::uno::Any& rValue,
1219 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1220{
1221 bool bRetval(false);
1222
1223 table::CellHoriJustify nValue = table::CellHoriJustify_LEFT;
1224 rValue >>= nValue;
1225 if (nValue != table::CellHoriJustify_REPEAT)
1226 {
1227 if (IsXMLToken(rStrImpValue, XML_START))
1228 {
1229 nValue = table::CellHoriJustify_LEFT;
1230 rValue <<= nValue;
1231 bRetval = true;
1232 }
1233 else if (IsXMLToken(rStrImpValue, XML_END))
1234 {
1235 nValue = table::CellHoriJustify_RIGHT;
1236 rValue <<= nValue;
1237 bRetval = true;
1238 }
1239 else if (IsXMLToken(rStrImpValue, XML_CENTER))
1240 {
1241 nValue = table::CellHoriJustify_CENTER;
1242 rValue <<= nValue;
1243 bRetval = true;
1244 }
1245 else if (IsXMLToken(rStrImpValue, XML_JUSTIFY))
1246 {
1247 nValue = table::CellHoriJustify_BLOCK;
1248 rValue <<= nValue;
1249 bRetval = true;
1250 }
1251 }
1252 else
1253 bRetval = true;
1254
1255 return bRetval;
1256}
1257
1258bool XmlScPropHdl_HoriJustify::exportXML(
1259 OUString& rStrExpValue,
1260 const css::uno::Any& rValue,
1261 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1262{
1263 table::CellHoriJustify nVal;
1264 bool bRetval(false);
1265
1266 if(rValue >>= nVal)
1267 {
1268 switch (nVal)
1269 {
1270 case table::CellHoriJustify_REPEAT:
1271 case table::CellHoriJustify_LEFT:
1272 {
1273 rStrExpValue = GetXMLToken(XML_START);
1274 bRetval = true;
1275 }
1276 break;
1277 case table::CellHoriJustify_RIGHT:
1278 {
1279 rStrExpValue = GetXMLToken(XML_END);
1280 bRetval = true;
1281 }
1282 break;
1283 case table::CellHoriJustify_CENTER:
1284 {
1285 rStrExpValue = GetXMLToken(XML_CENTER);
1286 bRetval = true;
1287 }
1288 break;
1289 case table::CellHoriJustify_BLOCK:
1290 {
1291 rStrExpValue = GetXMLToken(XML_JUSTIFY);
1292 bRetval = true;
1293 }
1294 break;
1295 default:
1296 {
1297 // added to avoid warnings
1298 }
1299 }
1300 }
1301
1302 return bRetval;
1303}
1304
1305XmlScPropHdl_HoriJustifySource::~XmlScPropHdl_HoriJustifySource()
1306{
1307}
1308
1309bool XmlScPropHdl_HoriJustifySource::equals(
1310 const css::uno::Any& r1,
1311 const css::uno::Any& r2 ) const
1312{
1313 table::CellHoriJustify aHoriJustify1, aHoriJustify2;
1314
1315 if((r1 >>= aHoriJustify1) && (r2 >>= aHoriJustify2))
1316 return (aHoriJustify1 == aHoriJustify2);
1317 return false;
1318}
1319
1320bool XmlScPropHdl_HoriJustifySource::importXML(
1321 const OUString& rStrImpValue,
1322 css::uno::Any& rValue,
1323 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1324{
1325 bool bRetval(false);
1326
1327 if (IsXMLToken(rStrImpValue, XML_FIX))
1328 {
1329 bRetval = true;
1330 }
1331 else if (IsXMLToken(rStrImpValue, XML_VALUE_TYPE))
1332 {
1333 rValue <<= table::CellHoriJustify_STANDARD;
1334 bRetval = true;
1335 }
1336
1337 return bRetval;
1338}
1339
1340bool XmlScPropHdl_HoriJustifySource::exportXML(
1341 OUString& rStrExpValue,
1342 const css::uno::Any& rValue,
1343 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1344{
1345 table::CellHoriJustify nVal;
1346 bool bRetval(false);
1347
1348 if(rValue >>= nVal)
1349 {
1350 if (nVal == table::CellHoriJustify_STANDARD)
1351 {
1352 rStrExpValue = GetXMLToken(XML_VALUE_TYPE);
1353 bRetval = true;
1354 }
1355 else
1356 {
1357 rStrExpValue = GetXMLToken(XML_FIX);
1358 bRetval = true;
1359 }
1360 }
1361
1362 return bRetval;
1363}
1364
1365XmlScPropHdl_HoriJustifyRepeat::~XmlScPropHdl_HoriJustifyRepeat()
1366{
1367}
1368
1369bool XmlScPropHdl_HoriJustifyRepeat::equals(
1370 const css::uno::Any& r1,
1371 const css::uno::Any& r2 ) const
1372{
1373 table::CellHoriJustify aHoriJustify1, aHoriJustify2;
1374
1375 if((r1 >>= aHoriJustify1) && (r2 >>= aHoriJustify2))
1376 return (aHoriJustify1 == aHoriJustify2);
1377 return false;
1378}
1379
1380bool XmlScPropHdl_HoriJustifyRepeat::importXML(
1381 const OUString& rStrImpValue,
1382 css::uno::Any& rValue,
1383 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1384{
1385 bool bRetval(false);
1386
1387 if (IsXMLToken(rStrImpValue, XML_FALSE))
1388 {
1389 bRetval = true;
1390 }
1391 else if (IsXMLToken(rStrImpValue, XML_TRUE))
1392 {
1393 rValue <<= table::CellHoriJustify_REPEAT;
1394 bRetval = true;
1395 }
1396
1397 return bRetval;
1398}
1399
1400bool XmlScPropHdl_HoriJustifyRepeat::exportXML(
1401 OUString& rStrExpValue,
1402 const css::uno::Any& rValue,
1403 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1404{
1405 table::CellHoriJustify nVal;
1406 bool bRetval(false);
1407
1408 if(rValue >>= nVal)
1409 {
1410 if (nVal == table::CellHoriJustify_REPEAT)
1411 {
1412 rStrExpValue = GetXMLToken(XML_TRUE);
1413 bRetval = true;
1414 }
1415 else
1416 {
1417 rStrExpValue = GetXMLToken(XML_FALSE);
1418 bRetval = true;
1419 }
1420 }
1421
1422 return bRetval;
1423}
1424
1425XmlScPropHdl_Orientation::~XmlScPropHdl_Orientation()
1426{
1427}
1428
1429bool XmlScPropHdl_Orientation::equals(
1430 const css::uno::Any& r1,
1431 const css::uno::Any& r2 ) const
1432{
1433 table::CellOrientation aOrientation1, aOrientation2;
1434
1435 if((r1 >>= aOrientation1) && (r2 >>= aOrientation2))
1436 return (aOrientation1 == aOrientation2);
1437 return false;
1438}
1439
1440bool XmlScPropHdl_Orientation::importXML(
1441 const OUString& rStrImpValue,
1442 css::uno::Any& rValue,
1443 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1444{
1445 bool bRetval(false);
1446
1447 table::CellOrientation nValue;
1448 if (IsXMLToken(rStrImpValue, XML_LTR))
1449 {
1450 nValue = table::CellOrientation_STANDARD;
1451 rValue <<= nValue;
1452 bRetval = true;
1453 }
1454 else if (IsXMLToken(rStrImpValue, XML_TTB))
1455 {
1456 nValue = table::CellOrientation_STACKED;
1457 rValue <<= nValue;
1458 bRetval = true;
1459 }
1460
1461 return bRetval;
1462}
1463
1464bool XmlScPropHdl_Orientation::exportXML(
1465 OUString& rStrExpValue,
1466 const css::uno::Any& rValue,
1467 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1468{
1469 table::CellOrientation nVal;
1470 bool bRetval(false);
1471
1472 if(rValue >>= nVal)
1473 {
1474 switch (nVal)
1475 {
1476 case table::CellOrientation_STACKED :
1477 {
1478 rStrExpValue = GetXMLToken(XML_TTB);
1479 bRetval = true;
1480 }
1481 break;
1482 default:
1483 {
1484 rStrExpValue = GetXMLToken(XML_LTR);
1485 bRetval = true;
1486 }
1487 break;
1488 }
1489 }
1490
1491 return bRetval;
1492}
1493
1494XmlScPropHdl_RotateAngle::~XmlScPropHdl_RotateAngle()
1495{
1496}
1497
1498bool XmlScPropHdl_RotateAngle::equals(
1499 const css::uno::Any& r1,
1500 const css::uno::Any& r2 ) const
1501{
1502 sal_Int32 aAngle1 = 0, aAngle2 = 0;
1503
1504 if((r1 >>= aAngle1) && (r2 >>= aAngle2))
1505 return (aAngle1 == aAngle2);
1506 return false;
1507}
1508
1509bool XmlScPropHdl_RotateAngle::importXML(
1510 const OUString& rStrImpValue,
1511 css::uno::Any& rValue,
1512 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1513{
1514 bool bRetval(false);
1515
1516 sal_Int32 nValue;
1517 if (::sax::Converter::convertNumber(nValue, rStrImpValue) && !o3tl::checked_multiply<sal_Int32>(nValue, 100, nValue))
1518 {
1519 rValue <<= nValue;
1520 bRetval = true;
1521 }
1522
1523 return bRetval;
1524}
1525
1526bool XmlScPropHdl_RotateAngle::exportXML(
1527 OUString& rStrExpValue,
1528 const css::uno::Any& rValue,
1529 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1530{
1531 sal_Int32 nVal = 0;
1532 bool bRetval(false);
1533
1534 if(rValue >>= nVal)
1535 {
1536 rStrExpValue = OUString::number(nVal / 100);
1537 bRetval = true;
1538 }
1539
1540 return bRetval;
1541}
1542
1543XmlScPropHdl_RotateReference::~XmlScPropHdl_RotateReference()
1544{
1545}
1546
1547bool XmlScPropHdl_RotateReference::equals(
1548 const css::uno::Any& r1,
1549 const css::uno::Any& r2 ) const
1550{
1551 sal_Int32 aReference1(0), aReference2(0);
1552
1553 if((r1 >>= aReference1) && (r2 >>= aReference2))
1554 return (aReference1 == aReference2);
1555 return false;
1556}
1557
1558bool XmlScPropHdl_RotateReference::importXML(
1559 const OUString& rStrImpValue,
1560 css::uno::Any& rValue,
1561 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1562{
1563 bool bRetval(false);
1564
1565 sal_Int32 nValue;
1566 if (IsXMLToken(rStrImpValue, XML_NONE))
1567 {
1568 nValue = table::CellVertJustify2::STANDARD;
1569 rValue <<= nValue;
1570 bRetval = true;
1571 }
1572 else if (IsXMLToken(rStrImpValue, XML_BOTTOM))
1573 {
1574 nValue = table::CellVertJustify2::BOTTOM;
1575 rValue <<= nValue;
1576 bRetval = true;
1577 }
1578 else if (IsXMLToken(rStrImpValue, XML_TOP))
1579 {
1580 nValue = table::CellVertJustify2::TOP;
1581 rValue <<= nValue;
1582 bRetval = true;
1583 }
1584 else if (IsXMLToken(rStrImpValue, XML_CENTER))
1585 {
1586 nValue = table::CellVertJustify2::CENTER;
1587 rValue <<= nValue;
1588 bRetval = true;
1589 }
1590
1591 return bRetval;
1592}
1593
1594bool XmlScPropHdl_RotateReference::exportXML(
1595 OUString& rStrExpValue,
1596 const css::uno::Any& rValue,
1597 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1598{
1599 sal_Int32 nVal(0);
1600 bool bRetval(false);
1601
1602 if(rValue >>= nVal)
1603 {
1604 switch (nVal)
1605 {
1606 case table::CellVertJustify2::BOTTOM :
1607 {
1608 rStrExpValue = GetXMLToken(XML_BOTTOM);
1609 bRetval = true;
1610 }
1611 break;
1612 case table::CellVertJustify2::CENTER :
1613 {
1614 rStrExpValue = GetXMLToken(XML_CENTER);
1615 bRetval = true;
1616 }
1617 break;
1618 case table::CellVertJustify2::STANDARD :
1619 {
1620 rStrExpValue = GetXMLToken(XML_NONE);
1621 bRetval = true;
1622 }
1623 break;
1624 case table::CellVertJustify2::TOP :
1625 {
1626 rStrExpValue = GetXMLToken(XML_TOP);
1627 bRetval = true;
1628 }
1629 break;
1630 default:
1631 {
1632 // added to avoid warnings
1633 }
1634 }
1635 }
1636
1637 return bRetval;
1638}
1639
1640XmlScPropHdl_VertJustify::~XmlScPropHdl_VertJustify()
1641{
1642}
1643
1644bool XmlScPropHdl_VertJustify::equals(
1645 const css::uno::Any& r1,
1646 const css::uno::Any& r2 ) const
1647{
1648 sal_Int32 aReference1(0), aReference2(0);
1649
1650 if((r1 >>= aReference1) && (r2 >>= aReference2))
1651 return (aReference1 == aReference2);
1652 return false;
1653}
1654
1655bool XmlScPropHdl_VertJustify::importXML(
1656 const OUString& rStrImpValue,
1657 css::uno::Any& rValue,
1658 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1659{
1660 bool bRetval(false);
1661
1662 sal_Int32 nValue;
1663 if (IsXMLToken(rStrImpValue, XML_AUTOMATIC))
1664 {
1665 nValue = table::CellVertJustify2::STANDARD;
1666 rValue <<= nValue;
1667 bRetval = true;
1668 }
1669 else if (IsXMLToken(rStrImpValue, XML_BOTTOM))
1670 {
1671 nValue = table::CellVertJustify2::BOTTOM;
1672 rValue <<= nValue;
1673 bRetval = true;
1674 }
1675 else if (IsXMLToken(rStrImpValue, XML_TOP))
1676 {
1677 nValue = table::CellVertJustify2::TOP;
1678 rValue <<= nValue;
1679 bRetval = true;
1680 }
1681 else if (IsXMLToken(rStrImpValue, XML_MIDDLE))
1682 {
1683 nValue = table::CellVertJustify2::CENTER;
1684 rValue <<= nValue;
1685 bRetval = true;
1686 }
1687 else if (IsXMLToken(rStrImpValue, XML_JUSTIFY))
1688 {
1689 nValue = table::CellVertJustify2::BLOCK;
1690 rValue <<= nValue;
1691 bRetval = true;
1692 }
1693
1694 return bRetval;
1695}
1696
1697bool XmlScPropHdl_VertJustify::exportXML(
1698 OUString& rStrExpValue,
1699 const css::uno::Any& rValue,
1700 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1701{
1702 sal_Int32 nVal(0);
1703 bool bRetval(false);
1704
1705 if(rValue >>= nVal)
1706 {
1707 switch (nVal)
1708 {
1709 case table::CellVertJustify2::BOTTOM :
1710 {
1711 rStrExpValue = GetXMLToken(XML_BOTTOM);
1712 bRetval = true;
1713 }
1714 break;
1715 case table::CellVertJustify2::CENTER :
1716 {
1717 rStrExpValue = GetXMLToken(XML_MIDDLE);
1718 bRetval = true;
1719 }
1720 break;
1721 case table::CellVertJustify2::STANDARD :
1722 {
1723 rStrExpValue = GetXMLToken(XML_AUTOMATIC);
1724 bRetval = true;
1725 }
1726 break;
1727 case table::CellVertJustify2::TOP :
1728 {
1729 rStrExpValue = GetXMLToken(XML_TOP);
1730 bRetval = true;
1731 }
1732 break;
1733 case table::CellVertJustify2::BLOCK :
1734 {
1735 rStrExpValue = GetXMLToken(XML_JUSTIFY);
1736 bRetval = true;
1737 }
1738 break;
1739 default:
1740 {
1741 // added to avoid warnings
1742 }
1743 }
1744 }
1745
1746 return bRetval;
1747}
1748
1749XmlScPropHdl_BreakBefore::~XmlScPropHdl_BreakBefore()
1750{
1751}
1752
1753bool XmlScPropHdl_BreakBefore::equals(
1754 const css::uno::Any& r1,
1755 const css::uno::Any& r2 ) const
1756{
1757 bool aBreak1 = false, aBreak2 = false;
1758
1759 if((r1 >>= aBreak1) && (r2 >>= aBreak2))
1760 return (aBreak1 == aBreak2);
1761 return false;
1762}
1763
1764bool XmlScPropHdl_BreakBefore::importXML(
1765 const OUString& rStrImpValue,
1766 css::uno::Any& rValue,
1767 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1768{
1769 bool bRetval(false);
1770
1771 bool bValue;
1772 if (IsXMLToken(rStrImpValue, XML_AUTO))
1773 {
1774 bValue = false;
1775 rValue <<= bValue;
1776 bRetval = true;
1777 }
1778 else if (IsXMLToken(rStrImpValue, XML_PAGE))
1779 {
1780 bValue = true;
1781 rValue <<= bValue;
1782 bRetval = true;
1783 }
1784
1785 return bRetval;
1786}
1787
1788bool XmlScPropHdl_BreakBefore::exportXML(
1789 OUString& rStrExpValue,
1790 const css::uno::Any& rValue,
1791 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1792{
1793 bool bRetval(false);
1794
1795 if(::cppu::any2bool(rValue))
1796 {
1797 rStrExpValue = GetXMLToken(XML_PAGE);
1798 bRetval = true;
1799 }
1800 else
1801 {
1802 rStrExpValue = GetXMLToken(XML_AUTO);
1803 bRetval = true;
1804 }
1805
1806 return bRetval;
1807}
1808
1809XmlScPropHdl_IsTextWrapped::~XmlScPropHdl_IsTextWrapped()
1810{
1811}
1812
1813bool XmlScPropHdl_IsTextWrapped::equals(
1814 const css::uno::Any& r1,
1815 const css::uno::Any& r2 ) const
1816{
1817 return (::cppu::any2bool(r1) == ::cppu::any2bool(r2));
1818}
1819
1820bool XmlScPropHdl_IsTextWrapped::importXML(
1821 const OUString& rStrImpValue,
1822 css::uno::Any& rValue,
1823 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1824{
1825 bool bRetval(false);
1826
1827 if (IsXMLToken(rStrImpValue, XML_WRAP))
1828 {
1829 rValue <<= true;
1830 bRetval = true;
1831 }
1832 else if (IsXMLToken(rStrImpValue, XML_NO_WRAP))
1833 {
1834 rValue <<= false;
1835 bRetval = true;
1836 }
1837
1838 return bRetval;
1839}
1840
1841bool XmlScPropHdl_IsTextWrapped::exportXML(
1842 OUString& rStrExpValue,
1843 const css::uno::Any& rValue,
1844 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1845{
1846 bool bRetval(false);
1847
1848 if (::cppu::any2bool(rValue))
1849 {
1850 rStrExpValue = GetXMLToken(XML_WRAP);
1851 bRetval = true;
1852 }
1853 else
1854 {
1855 rStrExpValue = GetXMLToken(XML_NO_WRAP);
1856 bRetval = true;
1857 }
1858
1859 return bRetval;
1860}
1861
1862bool XmlScPropHdl_IsEqual::importXML( const OUString& /* rStrImpValue */,
1863 css::uno::Any& /* rValue */,
1864 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1865{
1866 OSL_FAIL("should never be called");
1867 return false;
1868}
1869
1870bool XmlScPropHdl_IsEqual::exportXML( OUString& /* rStrExpValue */,
1871 const css::uno::Any& /* rValue */,
1872 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1873{
1874 OSL_FAIL("should never be called");
1875 return false;
1876}
1877
1878XmlScPropHdl_Vertical::~XmlScPropHdl_Vertical()
1879{
1880}
1881
1882bool XmlScPropHdl_Vertical::equals(
1883 const css::uno::Any& r1,
1884 const css::uno::Any& r2 ) const
1885{
1886 return (::cppu::any2bool(r1) == ::cppu::any2bool(r2));
1887}
1888
1889bool XmlScPropHdl_Vertical::importXML(
1890 const OUString& rStrImpValue,
1891 css::uno::Any& rValue,
1892 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1893{
1894 bool bRetval(false);
1895
1896 if (IsXMLToken(rStrImpValue, XML_AUTO))
1897 {
1898 rValue <<= true;
1899 bRetval = true;
1900 }
1901 else if (IsXMLToken(rStrImpValue, XML_0))
1902 {
1903 rValue <<= false;
1904 bRetval = true;
1905 }
1906
1907 return bRetval;
1908}
1909
1910bool XmlScPropHdl_Vertical::exportXML(
1911 OUString& rStrExpValue,
1912 const css::uno::Any& rValue,
1913 const SvXMLUnitConverter& /* rUnitConverter */ ) const
1914{
1915 bool bRetval(false);
1916
1917 if (::cppu::any2bool(rValue))
1918 {
1919 rStrExpValue = GetXMLToken(XML_AUTO);
1920 bRetval = true;
1921 }
1922 else
1923 {
1924 rStrExpValue = GetXMLToken(XML_0);
1925 bRetval = true;
1926 }
1927
1928 return bRetval;
1929}
1930
1931/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
ScRangeStringConverter::GetStringFromAddress
static void GetStringFromAddress(OUString &rString, const ScAddress &rAddress, const ScDocument *pDocument, formula::FormulaGrammar::AddressConvention eConv, sal_Unicode cSeparator=' ', bool bAppendStr=false, ScRefFlags nFormatFlags=ScRefFlags::VALID|ScRefFlags::TAB_3D)
Range to String core.
ScXMLAutoStylePoolP::exportStyleContent
virtual void exportStyleContent(const css::uno::Reference< css::xml::sax::XDocumentHandler > &rHandler, XmlStyleFamily nFamily, const ::std::vector< XMLPropertyState > &rProperties, const SvXMLExportPropertyMapper &rPropExp, const SvXMLUnitConverter &rUnitConverter, const SvXMLNamespaceMap &rNamespaceMap) const override
Definition: xmlstyle.cxx:696
ScXMLAutoStylePoolP::ScXMLAutoStylePoolP
ScXMLAutoStylePoolP(ScXMLExport &rScXMLExport)
Definition: xmlstyle.cxx:813
ScXMLAutoStylePoolP::rScXMLExport
ScXMLExport & rScXMLExport
Definition: xmlstyle.hxx:182
ScXMLAutoStylePoolP::exportStyleAttributes
virtual void exportStyleAttributes(comphelper::AttributeList &rAttrList, XmlStyleFamily nFamily, const ::std::vector< XMLPropertyState > &rProperties, const SvXMLExportPropertyMapper &rPropExp, const SvXMLUnitConverter &rUnitConverter, const SvXMLNamespaceMap &rNamespaceMap) const override
Definition: xmlstyle.cxx:634
ScXMLAutoStylePoolP::~ScXMLAutoStylePoolP
virtual ~ScXMLAutoStylePoolP() override
Definition: xmlstyle.cxx:819
ScXMLCellExportPropertyMapper::handleSpecialItem
virtual void handleSpecialItem(comphelper::AttributeList &rAttrList, const XMLPropertyState &rProperty, const SvXMLUnitConverter &rUnitConverter, const SvXMLNamespaceMap &rNamespaceMap, const ::std::vector< XMLPropertyState > *pProperties, sal_uInt32 nIdx) const override
this method is called for every item that has the MID_FLAG_SPECIAL_ITEM_EXPORT flag set
Definition: xmlstyle.cxx:521
ScXMLCellExportPropertyMapper::ScXMLCellExportPropertyMapper
ScXMLCellExportPropertyMapper(const rtl::Reference< XMLPropertySetMapper > &rMapper)
Definition: xmlstyle.cxx:190
ScXMLCellExportPropertyMapper::~ScXMLCellExportPropertyMapper
virtual ~ScXMLCellExportPropertyMapper() override
Definition: xmlstyle.cxx:196
ScXMLCellExportPropertyMapper::handleElementItem
virtual void handleElementItem(SvXMLExport &rExport, const XMLPropertyState &rProperty, SvXmlExportFlags nFlags, const ::std::vector< XMLPropertyState > *pProperties, sal_uInt32 nIdx) const override
Definition: xmlstyle.cxx:534
ScXMLCellExportPropertyMapper::ContextFilter
virtual void ContextFilter(bool bEnableFoFontFamily, ::std::vector< XMLPropertyState > &rProperties, const css::uno::Reference< css::beans::XPropertySet > &rPropSet) const override
Application-specific filter.
Definition: xmlstyle.cxx:200
ScXMLColumnExportPropertyMapper::ScXMLColumnExportPropertyMapper
ScXMLColumnExportPropertyMapper(const rtl::Reference< XMLPropertySetMapper > &rMapper)
Definition: xmlstyle.cxx:590
ScXMLColumnExportPropertyMapper::~ScXMLColumnExportPropertyMapper
virtual ~ScXMLColumnExportPropertyMapper() override
Definition: xmlstyle.cxx:596
ScXMLColumnExportPropertyMapper::handleSpecialItem
virtual void handleSpecialItem(comphelper::AttributeList &rAttrList, const XMLPropertyState &rProperty, const SvXMLUnitConverter &rUnitConverter, const SvXMLNamespaceMap &rNamespaceMap, const ::std::vector< XMLPropertyState > *pProperties, sal_uInt32 nIdx) const override
this method is called for every item that has the MID_FLAG_SPECIAL_ITEM_EXPORT flag set
Definition: xmlstyle.cxx:601
ScXMLExport::GetDocument
ScDocument * GetDocument()
Definition: xmlexprt.hxx:240
ScXMLExport::GetTableStylesPropertySetMapper
const rtl::Reference< XMLPropertySetMapper > & GetTableStylesPropertySetMapper() const
Definition: xmlexprt.hxx:246
ScXMLExport::GetCellStylesPropertySetMapper
const rtl::Reference< XMLPropertySetMapper > & GetCellStylesPropertySetMapper() const
Definition: xmlexprt.hxx:245
ScXMLRowExportPropertyMapper::ContextFilter
virtual void ContextFilter(bool bEnableFoFontFamily, ::std::vector< XMLPropertyState > &rProperties, const css::uno::Reference< css::beans::XPropertySet > &rPropSet) const override
Application-specific filter.
Definition: xmlstyle.cxx:582
ScXMLRowExportPropertyMapper::ScXMLRowExportPropertyMapper
ScXMLRowExportPropertyMapper(const rtl::Reference< XMLPropertySetMapper > &rMapper)
Definition: xmlstyle.cxx:572
ScXMLRowExportPropertyMapper::~ScXMLRowExportPropertyMapper
virtual ~ScXMLRowExportPropertyMapper() override
Definition: xmlstyle.cxx:578
ScXMLTableExportPropertyMapper::handleSpecialItem
virtual void handleSpecialItem(comphelper::AttributeList &rAttrList, const XMLPropertyState &rProperty, const SvXMLUnitConverter &rUnitConverter, const SvXMLNamespaceMap &rNamespaceMap, const ::std::vector< XMLPropertyState > *pProperties, sal_uInt32 nIdx) const override
this method is called for every item that has the MID_FLAG_SPECIAL_ITEM_EXPORT flag set
Definition: xmlstyle.cxx:623
ScXMLTableExportPropertyMapper::~ScXMLTableExportPropertyMapper
virtual ~ScXMLTableExportPropertyMapper() override
Definition: xmlstyle.cxx:618
ScXMLTableExportPropertyMapper::ScXMLTableExportPropertyMapper
ScXMLTableExportPropertyMapper(const rtl::Reference< XMLPropertySetMapper > &rMapper)
Definition: xmlstyle.cxx:612
SvXMLAutoStylePoolP::GetExport
SvXMLExport & GetExport() const
SvXMLAutoStylePoolP::exportStyleContent
virtual void exportStyleContent(const css::uno::Reference< css::xml::sax::XDocumentHandler > &rHandler, XmlStyleFamily nFamily, const ::std::vector< XMLPropertyState > &rProperties, const SvXMLExportPropertyMapper &rPropExp, const SvXMLUnitConverter &rUnitConverter, const SvXMLNamespaceMap &rNamespaceMap) const
SvXMLAutoStylePoolP::exportStyleAttributes
virtual void exportStyleAttributes(comphelper::AttributeList &rAttrList, XmlStyleFamily nFamily, const ::std::vector< XMLPropertyState > &rProperties, const SvXMLExportPropertyMapper &rPropExp, const SvXMLUnitConverter &rUnitConverter, const SvXMLNamespaceMap &rNamespaceMap) const
SvXMLExportPropertyMapper::ContextFilter
virtual void ContextFilter(bool bEnableFoFontFamily, ::std::vector< XMLPropertyState > &rProperties, const css::uno::Reference< css::beans::XPropertySet > &rPropSet) const
SvXMLExportPropertyMapper::getPropertySetMapper
const rtl::Reference< XMLPropertySetMapper > & getPropertySetMapper() const
SvXMLExport::AddAttribute
void AddAttribute(sal_uInt16 nPrefix, const OUString &rName, const OUString &rValue)
SvXMLExport::getDataStyleName
virtual OUString getDataStyleName(const sal_Int32 nNumberFormat, bool bTimeFormat=false) const
SvXMLExport::EncodeStyleName
OUString EncodeStyleName(const OUString &rName, bool *pEncoded=nullptr) const
XMLComplexColorExport::exportXML
void exportXML(const css::uno::Any &rAny, sal_uInt16 nPrefix, const OUString &rLocalName)
XMLPropertyHandlerFactory::PutHdlCache
void PutHdlCache(sal_Int32 nType, const XMLPropertyHandler *pHdl) const
XMLPropertyHandlerFactory::GetPropertyHandler
virtual const XMLPropertyHandler * GetPropertyHandler(sal_Int32 nType) const
XMLScPropHdlFactory::GetPropertyHandler
virtual const XMLPropertyHandler * GetPropertyHandler(sal_Int32 nType) const override
Definition: xmlstyle.cxx:831
XMLScPropHdlFactory::~XMLScPropHdlFactory
virtual ~XMLScPropHdlFactory() override
Definition: xmlstyle.cxx:827
XmlScPropHdl_BreakBefore
Definition: xmlstyle.hxx:306
XmlScPropHdl_BreakBefore::importXML
virtual bool importXML(const OUString &rStrImpValue, css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1764
XmlScPropHdl_BreakBefore::exportXML
virtual bool exportXML(OUString &rStrExpValue, const css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1788
XmlScPropHdl_BreakBefore::~XmlScPropHdl_BreakBefore
virtual ~XmlScPropHdl_BreakBefore() override
Definition: xmlstyle.cxx:1749
XmlScPropHdl_BreakBefore::equals
virtual bool equals(const css::uno::Any &r1, const css::uno::Any &r2) const override
Definition: xmlstyle.cxx:1753
XmlScPropHdl_CellProtection
Definition: xmlstyle.hxx:216
XmlScPropHdl_CellProtection::exportXML
virtual bool exportXML(OUString &rStrExpValue, const css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1017
XmlScPropHdl_CellProtection::equals
virtual bool equals(const css::uno::Any &r1, const css::uno::Any &r2) const override
Definition: xmlstyle.cxx:929
XmlScPropHdl_CellProtection::importXML
virtual bool importXML(const OUString &rStrImpValue, css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:944
XmlScPropHdl_CellProtection::~XmlScPropHdl_CellProtection
virtual ~XmlScPropHdl_CellProtection() override
Definition: xmlstyle.cxx:925
XmlScPropHdl_HoriJustifyRepeat
Definition: xmlstyle.hxx:261
XmlScPropHdl_HoriJustifyRepeat::importXML
virtual bool importXML(const OUString &rStrImpValue, css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1380
XmlScPropHdl_HoriJustifyRepeat::~XmlScPropHdl_HoriJustifyRepeat
virtual ~XmlScPropHdl_HoriJustifyRepeat() override
Definition: xmlstyle.cxx:1365
XmlScPropHdl_HoriJustifyRepeat::equals
virtual bool equals(const css::uno::Any &r1, const css::uno::Any &r2) const override
Definition: xmlstyle.cxx:1369
XmlScPropHdl_HoriJustifyRepeat::exportXML
virtual bool exportXML(OUString &rStrExpValue, const css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1400
XmlScPropHdl_HoriJustifySource
Definition: xmlstyle.hxx:252
XmlScPropHdl_HoriJustifySource::importXML
virtual bool importXML(const OUString &rStrImpValue, css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1320
XmlScPropHdl_HoriJustifySource::~XmlScPropHdl_HoriJustifySource
virtual ~XmlScPropHdl_HoriJustifySource() override
Definition: xmlstyle.cxx:1305
XmlScPropHdl_HoriJustifySource::equals
virtual bool equals(const css::uno::Any &r1, const css::uno::Any &r2) const override
Definition: xmlstyle.cxx:1309
XmlScPropHdl_HoriJustifySource::exportXML
virtual bool exportXML(OUString &rStrExpValue, const css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1340
XmlScPropHdl_HoriJustify
Definition: xmlstyle.hxx:243
XmlScPropHdl_HoriJustify::equals
virtual bool equals(const css::uno::Any &r1, const css::uno::Any &r2) const override
Definition: xmlstyle.cxx:1205
XmlScPropHdl_HoriJustify::~XmlScPropHdl_HoriJustify
virtual ~XmlScPropHdl_HoriJustify() override
Definition: xmlstyle.cxx:1201
XmlScPropHdl_HoriJustify::importXML
virtual bool importXML(const OUString &rStrImpValue, css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1216
XmlScPropHdl_HoriJustify::exportXML
virtual bool exportXML(OUString &rStrExpValue, const css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1258
XmlScPropHdl_IsEqual
Definition: xmlstyle.hxx:324
XmlScPropHdl_IsEqual::importXML
virtual bool importXML(const OUString &rStrImpValue, css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1862
XmlScPropHdl_IsEqual::exportXML
virtual bool exportXML(OUString &rStrExpValue, const css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1870
XmlScPropHdl_IsTextWrapped
Definition: xmlstyle.hxx:315
XmlScPropHdl_IsTextWrapped::importXML
virtual bool importXML(const OUString &rStrImpValue, css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1820
XmlScPropHdl_IsTextWrapped::exportXML
virtual bool exportXML(OUString &rStrExpValue, const css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1841
XmlScPropHdl_IsTextWrapped::equals
virtual bool equals(const css::uno::Any &r1, const css::uno::Any &r2) const override
Definition: xmlstyle.cxx:1813
XmlScPropHdl_IsTextWrapped::~XmlScPropHdl_IsTextWrapped
virtual ~XmlScPropHdl_IsTextWrapped() override
Definition: xmlstyle.cxx:1809
XmlScPropHdl_JustifyMethod
Definition: xmlstyle.hxx:234
XmlScPropHdl_JustifyMethod::~XmlScPropHdl_JustifyMethod
virtual ~XmlScPropHdl_JustifyMethod() override
Definition: xmlstyle.cxx:1127
XmlScPropHdl_JustifyMethod::equals
virtual bool equals(const css::uno::Any &r1, const css::uno::Any &r2) const override
Definition: xmlstyle.cxx:1131
XmlScPropHdl_JustifyMethod::importXML
virtual bool importXML(const OUString &rStrImpValue, css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1142
XmlScPropHdl_JustifyMethod::exportXML
virtual bool exportXML(OUString &rStrExpValue, const css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1168
XmlScPropHdl_Orientation
Definition: xmlstyle.hxx:270
XmlScPropHdl_Orientation::~XmlScPropHdl_Orientation
virtual ~XmlScPropHdl_Orientation() override
Definition: xmlstyle.cxx:1425
XmlScPropHdl_Orientation::equals
virtual bool equals(const css::uno::Any &r1, const css::uno::Any &r2) const override
Definition: xmlstyle.cxx:1429
XmlScPropHdl_Orientation::importXML
virtual bool importXML(const OUString &rStrImpValue, css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1440
XmlScPropHdl_Orientation::exportXML
virtual bool exportXML(OUString &rStrExpValue, const css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1464
XmlScPropHdl_PrintContent
Definition: xmlstyle.hxx:225
XmlScPropHdl_PrintContent::exportXML
virtual bool exportXML(OUString &rStrExpValue, const css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1108
XmlScPropHdl_PrintContent::importXML
virtual bool importXML(const OUString &rStrImpValue, css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1078
XmlScPropHdl_PrintContent::equals
virtual bool equals(const css::uno::Any &r1, const css::uno::Any &r2) const override
Definition: xmlstyle.cxx:1065
XmlScPropHdl_PrintContent::~XmlScPropHdl_PrintContent
virtual ~XmlScPropHdl_PrintContent() override
Definition: xmlstyle.cxx:1061
XmlScPropHdl_RotateAngle
Definition: xmlstyle.hxx:279
XmlScPropHdl_RotateAngle::importXML
virtual bool importXML(const OUString &rStrImpValue, css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1509
XmlScPropHdl_RotateAngle::~XmlScPropHdl_RotateAngle
virtual ~XmlScPropHdl_RotateAngle() override
Definition: xmlstyle.cxx:1494
XmlScPropHdl_RotateAngle::equals
virtual bool equals(const css::uno::Any &r1, const css::uno::Any &r2) const override
Definition: xmlstyle.cxx:1498
XmlScPropHdl_RotateAngle::exportXML
virtual bool exportXML(OUString &rStrExpValue, const css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1526
XmlScPropHdl_RotateReference
Definition: xmlstyle.hxx:288
XmlScPropHdl_RotateReference::exportXML
virtual bool exportXML(OUString &rStrExpValue, const css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1594
XmlScPropHdl_RotateReference::~XmlScPropHdl_RotateReference
virtual ~XmlScPropHdl_RotateReference() override
Definition: xmlstyle.cxx:1543
XmlScPropHdl_RotateReference::importXML
virtual bool importXML(const OUString &rStrImpValue, css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1558
XmlScPropHdl_RotateReference::equals
virtual bool equals(const css::uno::Any &r1, const css::uno::Any &r2) const override
Definition: xmlstyle.cxx:1547
XmlScPropHdl_VertJustify
Definition: xmlstyle.hxx:297
XmlScPropHdl_VertJustify::exportXML
virtual bool exportXML(OUString &rStrExpValue, const css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1697
XmlScPropHdl_VertJustify::equals
virtual bool equals(const css::uno::Any &r1, const css::uno::Any &r2) const override
Definition: xmlstyle.cxx:1644
XmlScPropHdl_VertJustify::importXML
virtual bool importXML(const OUString &rStrImpValue, css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1655
XmlScPropHdl_VertJustify::~XmlScPropHdl_VertJustify
virtual ~XmlScPropHdl_VertJustify() override
Definition: xmlstyle.cxx:1640
XmlScPropHdl_Vertical
Definition: xmlstyle.hxx:332
XmlScPropHdl_Vertical::equals
virtual bool equals(const css::uno::Any &r1, const css::uno::Any &r2) const override
Definition: xmlstyle.cxx:1882
XmlScPropHdl_Vertical::exportXML
virtual bool exportXML(OUString &rStrExpValue, const css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1910
XmlScPropHdl_Vertical::importXML
virtual bool importXML(const OUString &rStrImpValue, css::uno::Any &rValue, const SvXMLUnitConverter &rUnitConverter) const override
Definition: xmlstyle.cxx:1889
XmlScPropHdl_Vertical::~XmlScPropHdl_Vertical
virtual ~XmlScPropHdl_Vertical() override
Definition: xmlstyle.cxx:1878
sax::Converter::convertNumber
static bool convertNumber(sal_Int32 &rValue, std::u16string_view aString, sal_Int32 nMin=SAL_MIN_INT32, sal_Int32 nMax=SAL_MAX_INT32)
sax::Converter::convertBool
static bool convertBool(bool &rBool, std::u16string_view rString)
CTF_SD_SHAPE_PARA_ADJUST
#define CTF_SD_SHAPE_PARA_ADJUST
XmlStyleFamily
XmlStyleFamily
nValue
sal_Int16 nValue
sName
OUString sName
i
int i
XML_PADDING_BOTTOM
XML_PADDING_BOTTOM
XML_FORMULA_HIDDEN
XML_FORMULA_HIDDEN
XML_DIAGONAL_BL_TR_WIDTHS
XML_DIAGONAL_BL_TR_WIDTHS
XML_DIAGONAL_TL_BR
XML_DIAGONAL_TL_BR
XML_START
XML_START
XML_HIDDEN_AND_PROTECTED
XML_HIDDEN_AND_PROTECTED
XML_TEXT_JUSTIFY
XML_TEXT_JUSTIFY
XML_BREAK_BEFORE
XML_BREAK_BEFORE
XML_VERTICAL_JUSTIFY
XML_VERTICAL_JUSTIFY
XML_AUTO
XML_AUTO
XML_PAGE
XML_PAGE
XML_BORDER_RIGHT
XML_BORDER_RIGHT
XML_PADDING_LEFT
XML_PADDING_LEFT
XML_PRINT_CONTENT
XML_PRINT_CONTENT
XML_MASTER_PAGE_NAME
XML_MASTER_PAGE_NAME
XML_BORDER_LINE_WIDTH_BOTTOM
XML_BORDER_LINE_WIDTH_BOTTOM
XML_PADDING_TOP
XML_PADDING_TOP
XML_BORDER_LINE_WIDTH
XML_BORDER_LINE_WIDTH
XML_BORDER_LINE_WIDTH_RIGHT
XML_BORDER_LINE_WIDTH_RIGHT
XML_HREF
XML_HREF
XML_TTB
XML_TTB
XML_WRITING_MODE
XML_WRITING_MODE
XML_BACKGROUND_COMPLEX_COLOR
XML_BACKGROUND_COMPLEX_COLOR
XML_END
XML_END
XML_DISPLAY
XML_DISPLAY
XML_TRUE
XML_TRUE
XML_DIAGONAL_BL_TR
XML_DIAGONAL_BL_TR
XML_NONE
XML_NONE
XML_TEXT_ALIGN_SOURCE
XML_TEXT_ALIGN_SOURCE
XML_LTR
XML_LTR
XML_NO_WRAP
XML_NO_WRAP
XML_WRAP_OPTION
XML_WRAP_OPTION
XML_DIAGONAL_TL_BR_WIDTHS
XML_DIAGONAL_TL_BR_WIDTHS
XML_CONDITION
XML_CONDITION
XML_CELL_PROTECT
XML_CELL_PROTECT
XML_SHRINK_TO_FIT
XML_SHRINK_TO_FIT
XML_DISTRIBUTE
XML_DISTRIBUTE
XML_SHADOW
XML_SHADOW
XML_MARGIN_LEFT
XML_MARGIN_LEFT
XML_BORDER
XML_BORDER
XML_PADDING_RIGHT
XML_PADDING_RIGHT
XML_APPLY_STYLE_NAME
XML_APPLY_STYLE_NAME
XML_JUSTIFY
XML_JUSTIFY
XML_DIAGONAL_TL_BR_WIDTH
XML_DIAGONAL_TL_BR_WIDTH
XML_TOP
XML_TOP
XML_SIMPLE
XML_SIMPLE
XML_ROTATION_ALIGN
XML_ROTATION_ALIGN
XML_XMLNS
XML_XMLNS
XML_STYLE
XML_STYLE
XML_MIDDLE
XML_MIDDLE
XML_TEXT_ALIGN
XML_TEXT_ALIGN
XML_FALSE
XML_FALSE
XML_CONTENT_VALIDATION
XML_CONTENT_VALIDATION
XML_HYPERLINK
XML_HYPERLINK
XML_USE_OPTIMAL_ROW_HEIGHT
XML_USE_OPTIMAL_ROW_HEIGHT
XML_BORDER_LINE_WIDTH_LEFT
XML_BORDER_LINE_WIDTH_LEFT
XML_ROW_HEIGHT
XML_ROW_HEIGHT
XML_VERTICAL_ALIGN
XML_VERTICAL_ALIGN
XML_ROTATION_ANGLE
XML_ROTATION_ANGLE
XML_VALUE_TYPE
XML_VALUE_TYPE
XML_CENTER
XML_CENTER
XML_FIX
XML_FIX
XML_BORDER_LEFT
XML_BORDER_LEFT
XML_BORDER_BOTTOM
XML_BORDER_BOTTOM
XML_BACKGROUND_COLOR
XML_BACKGROUND_COLOR
XML_TAB_COLOR
XML_TAB_COLOR
XML_DATA_STYLE_NAME
XML_DATA_STYLE_NAME
XML_AUTOMATIC
XML_AUTOMATIC
XML_DECIMAL_PLACES
XML_DECIMAL_PLACES
XML_PROTECTED
XML_PROTECTED
XML_DIRECTION
XML_DIRECTION
XML_BORDER_TOP
XML_BORDER_TOP
XML_COLUMN_WIDTH
XML_COLUMN_WIDTH
XML_0
XML_0
XML_BASE_CELL_ADDRESS
XML_BASE_CELL_ADDRESS
XML_WRAP
XML_WRAP
XML_BORDER_LINE_WIDTH_TOP
XML_BORDER_LINE_WIDTH_TOP
XML_DIAGONAL_BL_TR_WIDTH
XML_DIAGONAL_BL_TR_WIDTH
XML_MAP
XML_MAP
XML_REPEAT_CONTENT
XML_REPEAT_CONTENT
XML_PADDING
XML_PADDING
XML_BOTTOM
XML_BOTTOM
XML_GLYPH_ORIENTATION_VERTICAL
XML_GLYPH_ORIENTATION_VERTICAL
XML_TYPE
XML_TYPE
IsXMLToken
bool IsXMLToken(std::u16string_view rString, enum XMLTokenEnum eToken)
GetXMLToken
const OUString & GetXMLToken(enum XMLTokenEnum eToken)
nType
QPRO_FUNC_TYPE nType
Definition: qproform.cxx:398
XMLPropertyState::maValue
css::uno::Any maValue
XMLPropertyState::mnIndex
sal_Int32 mnIndex
CTF_RIGHTBORDER
#define CTF_RIGHTBORDER
CTF_LEFTBORDERWIDTH
#define CTF_LEFTBORDERWIDTH
CTF_PARABOTTOMMARGIN_REL
#define CTF_PARABOTTOMMARGIN_REL
CTF_PARALEFTMARGIN
#define CTF_PARALEFTMARGIN
CTF_PARATOPMARGIN_REL
#define CTF_PARATOPMARGIN_REL
CTF_BOTTOMBORDER
#define CTF_BOTTOMBORDER
CTF_ALLBORDERWIDTH
#define CTF_ALLBORDERWIDTH
CTF_PARATOPMARGIN
#define CTF_PARATOPMARGIN
CTF_PARARIGHTMARGIN
#define CTF_PARARIGHTMARGIN
CTF_COMPLEX_COLOR
#define CTF_COMPLEX_COLOR
CTF_LEFTBORDER
#define CTF_LEFTBORDER
CTF_TOPBORDER
#define CTF_TOPBORDER
CTF_RIGHTBORDERWIDTH
#define CTF_RIGHTBORDERWIDTH
CTF_ALLBORDER
#define CTF_ALLBORDER
CTF_PARABOTTOMMARGIN
#define CTF_PARABOTTOMMARGIN
CTF_PARARIGHTMARGIN_REL
#define CTF_PARARIGHTMARGIN_REL
CTF_TOPBORDERWIDTH
#define CTF_TOPBORDERWIDTH
CTF_PARA_ADJUSTLAST
#define CTF_PARA_ADJUSTLAST
CTF_PARALEFTMARGIN_REL
#define CTF_PARALEFTMARGIN_REL
CTF_BOTTOMBORDERWIDTH
#define CTF_BOTTOMBORDERWIDTH
SC_UNONAME_TOPBORDER
constexpr OUStringLiteral SC_UNONAME_TOPBORDER
Definition: unonames.hxx:129
SC_UNONAME_PRMARGIN
constexpr OUStringLiteral SC_UNONAME_PRMARGIN
Definition: unonames.hxx:119
SC_UNO_STANDARDDEC
constexpr OUStringLiteral SC_UNO_STANDARDDEC
Definition: unonames.hxx:523
SC_UNONAME_HYPERLINK
constexpr OUStringLiteral SC_UNONAME_HYPERLINK
Definition: unonames.hxx:206
SC_UNONAME_CELL_BACKGROUND_COMPLEX_COLOR
constexpr OUStringLiteral SC_UNONAME_CELL_BACKGROUND_COMPLEX_COLOR
Definition: unonames.hxx:101
SC_UNONAME_ORIENT
constexpr OUStringLiteral SC_UNONAME_ORIENT
Definition: unonames.hxx:312
SC_UNONAME_CELLWID
constexpr OUStringLiteral SC_UNONAME_CELLWID
Definition: unonames.hxx:173
SC_UNONAME_BOTTBORDER
constexpr OUStringLiteral SC_UNONAME_BOTTBORDER
Definition: unonames.hxx:126
SC_UNONAME_CELLVJUS_METHOD
constexpr OUStringLiteral SC_UNONAME_CELLVJUS_METHOD
Definition: unonames.hxx:107
SC_UNONAME_NUMFMT
constexpr OUStringLiteral SC_UNONAME_NUMFMT
Definition: unonames.hxx:109
SC_UNONAME_WRAP
constexpr OUStringLiteral SC_UNONAME_WRAP
Definition: unonames.hxx:114
SC_UNONAME_CELLHGT
constexpr OUStringLiteral SC_UNONAME_CELLHGT
Definition: unonames.hxx:172
SC_UNONAME_PINDENT
constexpr OUStringLiteral SC_UNONAME_PINDENT
Definition: unonames.hxx:115
SC_UNONAME_PLMARGIN
constexpr OUStringLiteral SC_UNONAME_PLMARGIN
Definition: unonames.hxx:118
SC_UNONAME_CELLTRAN
constexpr OUStringLiteral SC_UNONAME_CELLTRAN
Definition: unonames.hxx:102
SC_UNONAME_OHEIGHT
constexpr OUStringLiteral SC_UNONAME_OHEIGHT
Definition: unonames.hxx:178
SC_UNONAME_VALIXML
constexpr OUStringLiteral SC_UNONAME_VALIXML
Definition: unonames.hxx:218
SC_UNONAME_RIGHTBORDER
constexpr OUStringLiteral SC_UNONAME_RIGHTBORDER
Definition: unonames.hxx:128
SC_UNONAME_CELLPRO
constexpr OUStringLiteral SC_UNONAME_CELLPRO
Definition: unonames.hxx:103
SC_UNONAME_PTMARGIN
constexpr OUStringLiteral SC_UNONAME_PTMARGIN
Definition: unonames.hxx:116
SC_UNONAME_PBMARGIN
constexpr OUStringLiteral SC_UNONAME_PBMARGIN
Definition: unonames.hxx:117
SC_UNONAME_LEFTBORDER
constexpr OUStringLiteral SC_UNONAME_LEFTBORDER
Definition: unonames.hxx:127
SC_UNONAME_TABCOLOR
constexpr OUStringLiteral SC_UNONAME_TABCOLOR
Definition: unonames.hxx:191
SC_UNONAME_MANPAGE
constexpr OUStringLiteral SC_UNONAME_MANPAGE
Definition: unonames.hxx:176
SC_UNONAME_SHRINK_TO_FIT
constexpr OUStringLiteral SC_UNONAME_SHRINK_TO_FIT
Definition: unonames.hxx:147
SC_UNONAME_ASIANVERT
constexpr OUStringLiteral SC_UNONAME_ASIANVERT
Definition: unonames.hxx:122
SC_UNONAME_ROTANG
constexpr OUStringLiteral SC_UNONAME_ROTANG
Definition: unonames.hxx:120
SC_UNONAME_DIAGONAL_BLTR
constexpr OUStringLiteral SC_UNONAME_DIAGONAL_BLTR
Definition: unonames.hxx:142
SC_UNONAME_DIAGONAL_TLBR
constexpr OUStringLiteral SC_UNONAME_DIAGONAL_TLBR
Definition: unonames.hxx:141
SC_UNONAME_USERDEF
constexpr OUStringLiteral SC_UNONAME_USERDEF
Definition: unonames.hxx:224
SC_UNONAME_CELLVJUS
constexpr OUStringLiteral SC_UNONAME_CELLVJUS
Definition: unonames.hxx:105
SC_UNONAME_CONDXML
constexpr OUStringLiteral SC_UNONAME_CONDXML
Definition: unonames.hxx:215
SC_UNONAME_ROTREF
constexpr OUStringLiteral SC_UNONAME_ROTREF
Definition: unonames.hxx:121
SC_UNONAME_CELLBACK
constexpr OUStringLiteral SC_UNONAME_CELLBACK
Definition: unonames.hxx:100
SC_UNONAME_CELLVIS
constexpr OUStringLiteral SC_UNONAME_CELLVIS
Definition: unonames.hxx:174
SC_UNONAME_SHADOW
constexpr OUStringLiteral SC_UNONAME_SHADOW
Definition: unonames.hxx:111
SC_UNONAME_TABLAYOUT
constexpr OUStringLiteral SC_UNONAME_TABLAYOUT
Definition: unonames.hxx:189
SC_UNONAME_CELLSTYL
constexpr OUStringLiteral SC_UNONAME_CELLSTYL
Definition: unonames.hxx:99
SC_UNONAME_CELLHJUS
constexpr OUStringLiteral SC_UNONAME_CELLHJUS
Definition: unonames.hxx:104
SC_UNONAME_PAGESTL
constexpr OUStringLiteral SC_UNONAME_PAGESTL
Definition: unonames.hxx:180
SC_UNONAME_CELLHJUS_METHOD
constexpr OUStringLiteral SC_UNONAME_CELLHJUS_METHOD
Definition: unonames.hxx:106
SvXmlExportFlags
SvXmlExportFlags
XML_NAMESPACE_TABLE_EXT
constexpr sal_uInt16 XML_NAMESPACE_TABLE_EXT
XML_NAMESPACE_XLINK
constexpr sal_uInt16 XML_NAMESPACE_XLINK
XML_NAMESPACE_TEXT
constexpr sal_uInt16 XML_NAMESPACE_TEXT
XML_NAMESPACE_TABLE
constexpr sal_uInt16 XML_NAMESPACE_TABLE
XML_NAMESPACE_CSS3TEXT
constexpr sal_uInt16 XML_NAMESPACE_CSS3TEXT
XML_NAMESPACE_LO_EXT
constexpr sal_uInt16 XML_NAMESPACE_LO_EXT
XML_NAMESPACE_STYLE
constexpr sal_uInt16 XML_NAMESPACE_STYLE
XML_NAMESPACE_FO
constexpr sal_uInt16 XML_NAMESPACE_FO
MAP_END
#define MAP_END()
Definition: xmlstyle.cxx:63
aXMLScTableStylesProperties
const XMLPropertyMapEntry aXMLScTableStylesProperties[]
Definition: xmlstyle.cxx:179
aXMLScRowStylesProperties
const XMLPropertyMapEntry aXMLScRowStylesProperties[]
Definition: xmlstyle.cxx:145
aXMLScRowStylesImportProperties
const XMLPropertyMapEntry aXMLScRowStylesImportProperties[]
Definition: xmlstyle.cxx:129
aXMLScTableStylesImportProperties
const XMLPropertyMapEntry aXMLScTableStylesImportProperties[]
Definition: xmlstyle.cxx:161
MAP_ODF13
#define MAP_ODF13(name, prefix, token, type, context)
Definition: xmlstyle.cxx:58
aXMLScFromXLSRowStylesProperties
const XMLPropertyMapEntry aXMLScFromXLSRowStylesProperties[]
Definition: xmlstyle.cxx:153
aXMLScColumnStylesProperties
const XMLPropertyMapEntry aXMLScColumnStylesProperties[]
Definition: xmlstyle.cxx:121
aXMLScCellStylesProperties
const XMLPropertyMapEntry aXMLScCellStylesProperties[]
Definition: xmlstyle.cxx:65
MAP
#define MAP(name, prefix, token, type, context)
Definition: xmlstyle.cxx:57
MAP_EXT
#define MAP_EXT(name, prefix, token, type, context)
Definition: xmlstyle.cxx:60
MAP_EXT_I
#define MAP_EXT_I(name, prefix, token, type, context)
Definition: xmlstyle.cxx:62
CTF_SC_ALLPADDING
#define CTF_SC_ALLPADDING
Definition: xmlstyle.hxx:60
CTF_SC_MAP
#define CTF_SC_MAP
Definition: xmlstyle.hxx:76
CTF_SC_ROWHEIGHT
#define CTF_SC_ROWHEIGHT
Definition: xmlstyle.hxx:89
XML_SC_TYPE_ROTATEANGLE
#define XML_SC_TYPE_ROTATEANGLE
Definition: xmlstyle.hxx:46
CTF_SC_DIAGONALTLBRWIDTHS
#define CTF_SC_DIAGONALTLBRWIDTHS
Definition: xmlstyle.hxx:86
CTF_SC_LEFTBORDERWIDTH
#define CTF_SC_LEFTBORDERWIDTH
Definition: xmlstyle.hxx:71
XML_SC_TYPE_PRINTCONTENT
#define XML_SC_TYPE_PRINTCONTENT
Definition: xmlstyle.hxx:40
CTF_SC_TOPPADDING
#define CTF_SC_TOPPADDING
Definition: xmlstyle.hxx:64
CTF_SC_NUMBERFORMAT
#define CTF_SC_NUMBERFORMAT
Definition: xmlstyle.hxx:75
CTF_SC_ROWOPTIMALHEIGHT
#define CTF_SC_ROWOPTIMALHEIGHT
Definition: xmlstyle.hxx:90
CTF_SC_TOPBORDERWIDTH
#define CTF_SC_TOPBORDERWIDTH
Definition: xmlstyle.hxx:73
XML_SC_TYPE_HORIJUSTIFY_METHOD
#define XML_SC_TYPE_HORIJUSTIFY_METHOD
Definition: xmlstyle.hxx:42
CTF_SC_DIAGONALBLTRWIDTH
#define CTF_SC_DIAGONALBLTRWIDTH
Definition: xmlstyle.hxx:85
XML_SC_TYPE_ORIENTATION
#define XML_SC_TYPE_ORIENTATION
Definition: xmlstyle.hxx:45
CTF_SC_ALLBORDERWIDTH
#define CTF_SC_ALLBORDERWIDTH
Definition: xmlstyle.hxx:70
XML_SC_ISTEXTWRAPPED
#define XML_SC_ISTEXTWRAPPED
Definition: xmlstyle.hxx:54
CTF_SC_DIAGONALTLBRWIDTH
#define CTF_SC_DIAGONALTLBRWIDTH
Definition: xmlstyle.hxx:83
CTF_SC_BOTTOMPADDING
#define CTF_SC_BOTTOMPADDING
Definition: xmlstyle.hxx:61
CTF_SC_MASTERPAGENAME
#define CTF_SC_MASTERPAGENAME
Definition: xmlstyle.hxx:94
CTF_SC_DIAGONALBLTRWIDTHS
#define CTF_SC_DIAGONALBLTRWIDTHS
Definition: xmlstyle.hxx:87
XML_SC_TYPE_ROTATEREFERENCE
#define XML_SC_TYPE_ROTATEREFERENCE
Definition: xmlstyle.hxx:47
CTF_SC_RIGHTBORDER
#define CTF_SC_RIGHTBORDER
Definition: xmlstyle.hxx:67
CTF_SC_IMPORT_MAP
#define CTF_SC_IMPORT_MAP
Definition: xmlstyle.hxx:79
XML_SC_TYPE_BREAKBEFORE
#define XML_SC_TYPE_BREAKBEFORE
Definition: xmlstyle.hxx:98
CTF_SC_BOTTOMBORDERWIDTH
#define CTF_SC_BOTTOMBORDERWIDTH
Definition: xmlstyle.hxx:74
XML_SC_TYPE_CELLPROTECTION
#define XML_SC_TYPE_CELLPROTECTION
Definition: xmlstyle.hxx:39
XML_SC_TYPE_EQUAL
#define XML_SC_TYPE_EQUAL
Definition: xmlstyle.hxx:55
CTF_SC_CELLSTYLE
#define CTF_SC_CELLSTYLE
Definition: xmlstyle.hxx:80
XML_SC_TYPE_HORIJUSTIFYSOURCE
#define XML_SC_TYPE_HORIJUSTIFYSOURCE
Definition: xmlstyle.hxx:43
CTF_SC_VALIDATION
#define CTF_SC_VALIDATION
Definition: xmlstyle.hxx:81
CTF_SC_ALLBORDER
#define CTF_SC_ALLBORDER
Definition: xmlstyle.hxx:65
CTF_SC_RIGHTBORDERWIDTH
#define CTF_SC_RIGHTBORDERWIDTH
Definition: xmlstyle.hxx:72
CTF_SC_ISVISIBLE
#define CTF_SC_ISVISIBLE
Definition: xmlstyle.hxx:92
CTF_SC_DIAGONALTLBR
#define CTF_SC_DIAGONALTLBR
Definition: xmlstyle.hxx:82
XML_SC_TYPE_HORIJUSTIFY
#define XML_SC_TYPE_HORIJUSTIFY
Definition: xmlstyle.hxx:41
CTF_SC_DIAGONALBLTR
#define CTF_SC_DIAGONALBLTR
Definition: xmlstyle.hxx:84
CTF_SC_RIGHTPADDING
#define CTF_SC_RIGHTPADDING
Definition: xmlstyle.hxx:63
XML_SC_TYPE_VERTICAL
#define XML_SC_TYPE_VERTICAL
Definition: xmlstyle.hxx:56
CTF_SC_HYPERLINK
#define CTF_SC_HYPERLINK
Definition: xmlstyle.hxx:95
CTF_SC_TOPBORDER
#define CTF_SC_TOPBORDER
Definition: xmlstyle.hxx:68
XML_SC_TYPE_VERTJUSTIFY_METHOD
#define XML_SC_TYPE_VERTJUSTIFY_METHOD
Definition: xmlstyle.hxx:53
XML_SC_TYPE_HORIJUSTIFYREPEAT
#define XML_SC_TYPE_HORIJUSTIFYREPEAT
Definition: xmlstyle.hxx:44
CTF_SC_BOTTOMBORDER
#define CTF_SC_BOTTOMBORDER
Definition: xmlstyle.hxx:69
XML_SC_TYPE_VERTJUSTIFY
#define XML_SC_TYPE_VERTJUSTIFY
Definition: xmlstyle.hxx:52
CTF_SC_ROWBREAKBEFORE
#define CTF_SC_ROWBREAKBEFORE
Definition: xmlstyle.hxx:91
CTF_SC_LEFTPADDING
#define CTF_SC_LEFTPADDING
Definition: xmlstyle.hxx:62
CTF_SC_LEFTBORDER
#define CTF_SC_LEFTBORDER
Definition: xmlstyle.hxx:66
XML_TYPE_NUMBER16
#define XML_TYPE_NUMBER16
MID_FLAG_MERGE_PROPERTY
#define MID_FLAG_MERGE_PROPERTY
XML_TYPE_COLORTRANSPARENT
#define XML_TYPE_COLORTRANSPARENT
XML_TYPE_PROP_TABLE_CELL
#define XML_TYPE_PROP_TABLE_CELL
XML_TYPE_PROP_PARAGRAPH
#define XML_TYPE_PROP_PARAGRAPH
XML_TYPE_MEASURE16
#define XML_TYPE_MEASURE16
XML_TYPE_TEXT_SHADOW
#define XML_TYPE_TEXT_SHADOW
XML_TYPE_BUILDIN_CMP_ONLY
#define XML_TYPE_BUILDIN_CMP_ONLY
MID_FLAG_SPECIAL_ITEM
#define MID_FLAG_SPECIAL_ITEM
MID_FLAG_MULTI_PROPERTY
#define MID_FLAG_MULTI_PROPERTY
MID_FLAG_ELEMENT_ITEM
#define MID_FLAG_ELEMENT_ITEM
XML_TYPE_TEXT_WRITING_MODE
#define XML_TYPE_TEXT_WRITING_MODE
XML_TYPE_ATTRIBUTE_CONTAINER
#define XML_TYPE_ATTRIBUTE_CONTAINER
XML_TYPE_BOOL_FALSE
#define XML_TYPE_BOOL_FALSE
XML_TYPE_BORDER
#define XML_TYPE_BORDER
XML_TYPE_PROP_TABLE_COLUMN
#define XML_TYPE_PROP_TABLE_COLUMN
XML_TYPE_PROP_TABLE
#define XML_TYPE_PROP_TABLE
XML_TYPE_STRING
#define XML_TYPE_STRING
XML_TYPE_BORDER_WIDTH
#define XML_TYPE_BORDER_WIDTH
XML_TYPE_MEASURE
#define XML_TYPE_MEASURE
XML_TYPE_COMPLEX_COLOR
#define XML_TYPE_COMPLEX_COLOR
XML_TYPE_COLORAUTO
#define XML_TYPE_COLORAUTO
MID_FLAG_MERGE_ATTRIBUTE
#define MID_FLAG_MERGE_ATTRIBUTE
XML_TYPE_NUMBER
#define XML_TYPE_NUMBER
XML_TYPE_ISTRANSPARENT
#define XML_TYPE_ISTRANSPARENT
XML_TYPE_PROP_TABLE_ROW
#define XML_TYPE_PROP_TABLE_ROW
MID_FLAG_MASK
#define MID_FLAG_MASK
XML_TYPE_BOOL
#define XML_TYPE_BOOL
Generated on Sun Jul 30 2023 04:29:04 for LibreOffice Module sc (master) by doxygen 1.9.3