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