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