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