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