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