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