sc/source/filter/xml/xmlstyle.cxx

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