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