/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include "xmlstyle.hxx"
#include "xmlexprt.hxx"
#include "xmlimprt.hxx"
#include "XMLConverter.hxx"
#include <rangeutl.hxx>
#include <unonames.hxx>
#include <o3tl/safeint.hxx>
#include <xmloff/xmlnmspe.hxx>
#include <xmloff/xmltypes.hxx>
#include <xmloff/families.hxx>
#include <xmloff/xmlnumfe.hxx>
#include <xmloff/xmlnumfi.hxx>
#include <xmloff/nmspmap.hxx>
#include <xmloff/attrlist.hxx>
#include <xmloff/contextid.hxx>
#include <xmloff/txtprmap.hxx>
#include <sax/tools/converter.hxx>
#include <com/sun/star/util/CellProtection.hpp>
#include <com/sun/star/table/CellOrientation.hpp>
#include <com/sun/star/table/CellVertJustify2.hpp>
#include <com/sun/star/table/CellHoriJustify.hpp>
#include <com/sun/star/table/CellJustifyMethod.hpp>
#include <com/sun/star/table/BorderLine2.hpp>
#include <com/sun/star/sheet/XSheetConditionalEntry.hpp>
#include <com/sun/star/sheet/XSheetCondition.hpp>
#include <com/sun/star/beans/XPropertyState.hpp>
#include <comphelper/extract.hxx>
#include <rtl/ustrbuf.hxx>
using namespace com::sun::star;
using namespace ::xmloff::token;
using namespace ::formula;
#define MAP(name,prefix,token,type,context) { name, sizeof(name)-1, prefix, token, type, context, SvtSaveOptions::ODFVER_010, false }
// extensions import/export
#define MAP_EXT(name,prefix,token,type,context) { name, sizeof(name)-1, prefix, token, type, context, SvtSaveOptions::ODFVER_012_EXT_COMPAT, false }
// extensions import only
#define MAP_EXT_I(name,prefix,token,type,context) { name, sizeof(name)-1, prefix, token, type, context, SvtSaveOptions::ODFVER_012_EXT_COMPAT, true }
#define MAP_END() { nullptr, 0, 0, XML_TOKEN_INVALID, 0, 0, SvtSaveOptions::ODFVER_010, false }
const XMLPropertyMapEntry aXMLScCellStylesProperties[] =
{
MAP( "AsianVerticalMode", XML_NAMESPACE_STYLE, XML_GLYPH_ORIENTATION_VERTICAL, XML_TYPE_PROP_TABLE_CELL|XML_SC_TYPE_VERTICAL, 0),
MAP( "BottomBorder", XML_NAMESPACE_FO, XML_BORDER_BOTTOM, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER, CTF_SC_BOTTOMBORDER ),
MAP( "BottomBorder", XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH_BOTTOM, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER_WIDTH, CTF_SC_BOTTOMBORDERWIDTH ),
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 ),
MAP( "CellProtection", XML_NAMESPACE_STYLE, XML_CELL_PROTECT, XML_TYPE_PROP_TABLE_CELL|XML_SC_TYPE_CELLPROTECTION|MID_FLAG_MERGE_PROPERTY, 0 ),
MAP( "CellProtection", XML_NAMESPACE_STYLE, XML_PRINT_CONTENT, XML_TYPE_PROP_TABLE_CELL|XML_SC_TYPE_PRINTCONTENT|MID_FLAG_MERGE_PROPERTY, 0 ),
MAP( "CellStyle", XML_NAMESPACE_STYLE, XML_STYLE, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_STRING, CTF_SC_CELLSTYLE ),
MAP( "ConditionalFormatXML", XML_NAMESPACE_STYLE, XML_MAP, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_STRING|MID_FLAG_SPECIAL_ITEM, CTF_SC_IMPORT_MAP ),
MAP( "ConditionalFormatXML", XML_NAMESPACE_STYLE, XML_MAP, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_STRING|MID_FLAG_SPECIAL_ITEM, CTF_SC_MAP ),
MAP( "DiagonalBLTR", XML_NAMESPACE_STYLE, XML_DIAGONAL_BL_TR, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER, CTF_SC_DIAGONALBLTR ),
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
MAP( "DiagonalBLTR", XML_NAMESPACE_STYLE, XML_DIAGONAL_BL_TR_WIDTHS, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER_WIDTH, CTF_SC_DIAGONALBLTRWIDTHS ),
MAP( "DiagonalTLBR", XML_NAMESPACE_STYLE, XML_DIAGONAL_TL_BR, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER, CTF_SC_DIAGONALTLBR ),
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
MAP( "DiagonalTLBR", XML_NAMESPACE_STYLE, XML_DIAGONAL_TL_BR_WIDTHS, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER_WIDTH, CTF_SC_DIAGONALTLBRWIDTHS ),
MAP( "HoriJustify", XML_NAMESPACE_FO, XML_TEXT_ALIGN, XML_TYPE_PROP_PARAGRAPH|XML_SC_TYPE_HORIJUSTIFY|MID_FLAG_MERGE_PROPERTY, 0 ),
MAP( "HoriJustify", XML_NAMESPACE_STYLE, XML_TEXT_ALIGN_SOURCE, XML_TYPE_PROP_TABLE_CELL|XML_SC_TYPE_HORIJUSTIFYSOURCE|MID_FLAG_MERGE_PROPERTY, 0 ),
MAP( "HoriJustify", XML_NAMESPACE_STYLE, XML_REPEAT_CONTENT, XML_TYPE_PROP_TABLE_CELL|XML_SC_TYPE_HORIJUSTIFYREPEAT|MID_FLAG_MERGE_PROPERTY, 0 ),
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 ),
MAP_EXT( SC_UNONAME_CELLHJUS_METHOD, XML_NAMESPACE_CSS3TEXT, XML_TEXT_JUSTIFY, XML_TYPE_PROP_PARAGRAPH|XML_SC_TYPE_HORIJUSTIFY_METHOD, 0 ),
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 ),
MAP( "IsTextWrapped", XML_NAMESPACE_FO, XML_WRAP_OPTION, XML_TYPE_PROP_TABLE_CELL|XML_SC_ISTEXTWRAPPED, 0 ),
MAP( "LeftBorder", XML_NAMESPACE_FO, XML_BORDER, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER, CTF_SC_ALLBORDER ),
MAP( "LeftBorder", XML_NAMESPACE_FO, XML_BORDER_LEFT, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER, CTF_SC_LEFTBORDER ),
MAP( "LeftBorder", XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER_WIDTH, CTF_SC_ALLBORDERWIDTH ),
MAP( "LeftBorder", XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH_LEFT, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER_WIDTH, CTF_SC_LEFTBORDERWIDTH ),
MAP( "NumberFormat", XML_NAMESPACE_STYLE, XML_DATA_STYLE_NAME, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_NUMBER|MID_FLAG_SPECIAL_ITEM, CTF_SC_NUMBERFORMAT),
MAP( "Orientation", XML_NAMESPACE_STYLE, XML_DIRECTION, XML_TYPE_PROP_TABLE_CELL|XML_SC_TYPE_ORIENTATION, 0 ),
MAP( "ParaBottomMargin", XML_NAMESPACE_FO, XML_PADDING, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_MEASURE, CTF_SC_ALLPADDING ),
MAP( "ParaBottomMargin", XML_NAMESPACE_FO, XML_PADDING_BOTTOM, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_MEASURE, CTF_SC_BOTTOMPADDING ),
MAP( "ParaIndent", XML_NAMESPACE_FO, XML_MARGIN_LEFT, XML_TYPE_PROP_PARAGRAPH|XML_TYPE_MEASURE16, 0 ),
MAP( "ParaLeftMargin", XML_NAMESPACE_FO, XML_PADDING_LEFT, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_MEASURE, CTF_SC_LEFTPADDING ),
MAP( "ParaRightMargin", XML_NAMESPACE_FO, XML_PADDING_RIGHT, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_MEASURE, CTF_SC_RIGHTPADDING ),
MAP( "ParaTopMargin", XML_NAMESPACE_FO, XML_PADDING_TOP, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_MEASURE, CTF_SC_TOPPADDING ),
MAP( "RightBorder", XML_NAMESPACE_FO, XML_BORDER_RIGHT, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER, CTF_SC_RIGHTBORDER ),
MAP( "RightBorder", XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH_RIGHT, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER_WIDTH, CTF_SC_RIGHTBORDERWIDTH ),
MAP( "RotateAngle", XML_NAMESPACE_STYLE, XML_ROTATION_ANGLE, XML_TYPE_PROP_TABLE_CELL|XML_SC_TYPE_ROTATEANGLE, 0 ),
MAP( "RotateReference", XML_NAMESPACE_STYLE, XML_ROTATION_ALIGN, XML_TYPE_PROP_TABLE_CELL|XML_SC_TYPE_ROTATEREFERENCE, 0),
MAP( "ShadowFormat", XML_NAMESPACE_STYLE, XML_SHADOW, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_TEXT_SHADOW, 0 ),
MAP( "ShrinkToFit", XML_NAMESPACE_STYLE, XML_SHRINK_TO_FIT, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BOOL, 0 ),
MAP( "StandardDecimals", XML_NAMESPACE_STYLE, XML_DECIMAL_PLACES, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_NUMBER16, 0 ),
MAP( "TopBorder", XML_NAMESPACE_FO, XML_BORDER_TOP, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER, CTF_SC_TOPBORDER ),
MAP( "TopBorder", XML_NAMESPACE_STYLE, XML_BORDER_LINE_WIDTH_TOP, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BORDER_WIDTH, CTF_SC_TOPBORDERWIDTH ),
MAP( "UserDefinedAttributes", XML_NAMESPACE_TEXT, XML_XMLNS, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_ATTRIBUTE_CONTAINER | MID_FLAG_SPECIAL_ITEM, 0 ),
MAP( "ValidationXML", XML_NAMESPACE_TABLE, XML_CONTENT_VALIDATION, XML_TYPE_PROP_TABLE_CELL|XML_TYPE_BUILDIN_CMP_ONLY, CTF_SC_VALIDATION ),
MAP( "VertJustify", XML_NAMESPACE_STYLE, XML_VERTICAL_ALIGN, XML_TYPE_PROP_TABLE_CELL|XML_SC_TYPE_VERTJUSTIFY, 0),
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+
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
MAP_END()
};
const XMLPropertyMapEntry aXMLScColumnStylesProperties[] =
{
MAP( "IsManualPageBreak", XML_NAMESPACE_FO, XML_BREAK_BEFORE, XML_TYPE_PROP_TABLE_COLUMN|XML_SC_TYPE_BREAKBEFORE, 0),
MAP( "IsVisible", XML_NAMESPACE_TABLE, XML_DISPLAY, XML_TYPE_PROP_TABLE_COLUMN|XML_SC_TYPE_EQUAL|MID_FLAG_SPECIAL_ITEM, CTF_SC_ISVISIBLE ),
MAP( "Width", XML_NAMESPACE_STYLE, XML_COLUMN_WIDTH, XML_TYPE_PROP_TABLE_COLUMN|XML_TYPE_MEASURE, 0 ),
MAP_END()
};
const XMLPropertyMapEntry aXMLScRowStylesImportProperties[] =
{
// #i57867# Include background color (CellBackColor/IsCellBackgroundTransparent) for import only.
// Import and export should use the same map, with MID_FLAG_NO_PROPERTY_EXPORT for the background entries,
// but this doesn't work at the moment because SvXMLImportPropertyMapper compares MID_FLAG_NO_PROPERTY to 0.
// If this is changed (not for 2.0.x), a single map can be used again.
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 ),
MAP( "Height", XML_NAMESPACE_STYLE, XML_ROW_HEIGHT, XML_TYPE_PROP_TABLE_ROW|XML_TYPE_MEASURE, CTF_SC_ROWHEIGHT),
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 ),
MAP( "IsManualPageBreak", XML_NAMESPACE_FO, XML_BREAK_BEFORE, XML_TYPE_PROP_TABLE_ROW|XML_SC_TYPE_BREAKBEFORE, CTF_SC_ROWBREAKBEFORE),
MAP( "OptimalHeight", XML_NAMESPACE_STYLE, XML_USE_OPTIMAL_ROW_HEIGHT, XML_TYPE_PROP_TABLE_ROW|XML_TYPE_BOOL, CTF_SC_ROWOPTIMALHEIGHT),
MAP_END()
};
const XMLPropertyMapEntry aXMLScRowStylesProperties[] =
{
MAP( "Height", XML_NAMESPACE_STYLE, XML_ROW_HEIGHT, XML_TYPE_PROP_TABLE_ROW|XML_TYPE_MEASURE, CTF_SC_ROWHEIGHT),
MAP( "IsManualPageBreak", XML_NAMESPACE_FO, XML_BREAK_BEFORE, XML_TYPE_PROP_TABLE_ROW|XML_SC_TYPE_BREAKBEFORE, CTF_SC_ROWBREAKBEFORE),
MAP( "OptimalHeight", XML_NAMESPACE_STYLE, XML_USE_OPTIMAL_ROW_HEIGHT, XML_TYPE_PROP_TABLE_ROW|XML_TYPE_BOOL, CTF_SC_ROWOPTIMALHEIGHT),
MAP_END()
};
const XMLPropertyMapEntry aXMLScFromXLSRowStylesProperties[] =
{
MAP( "Height", XML_NAMESPACE_STYLE, XML_ROW_HEIGHT, XML_TYPE_PROP_TABLE_ROW|XML_TYPE_MEASURE, CTF_SC_ROWHEIGHT),
MAP( "IsManualPageBreak", XML_NAMESPACE_FO, XML_BREAK_BEFORE, XML_TYPE_PROP_TABLE_ROW|XML_SC_TYPE_BREAKBEFORE, CTF_SC_ROWBREAKBEFORE),
MAP( "OptimalHeight", XML_NAMESPACE_STYLE, XML_USE_OPTIMAL_ROW_HEIGHT, XML_TYPE_PROP_TABLE_ROW|XML_TYPE_BOOL_FALSE, CTF_SC_ROWOPTIMALHEIGHT),
MAP_END()
};
const XMLPropertyMapEntry aXMLScTableStylesImportProperties[] =
{
// #i57869# Include background color (CellBackColor/IsCellBackgroundTransparent) for import only.
// Import and export should use the same map, with MID_FLAG_NO_PROPERTY_EXPORT for the background entries,
// but this doesn't work at the moment because SvXMLImportPropertyMapper compares MID_FLAG_NO_PROPERTY to 0.
// If this is changed (not for 2.0.x), a single map can be used again.
MAP( "CellBackColor", XML_NAMESPACE_FO, XML_BACKGROUND_COLOR, XML_TYPE_PROP_TABLE|XML_TYPE_COLORTRANSPARENT|MID_FLAG_MULTI_PROPERTY|MID_FLAG_MERGE_ATTRIBUTE, 0 ),
MAP( "IsCellBackgroundTransparent", XML_NAMESPACE_FO, XML_BACKGROUND_COLOR, XML_TYPE_PROP_TABLE|XML_TYPE_ISTRANSPARENT|MID_FLAG_MULTI_PROPERTY|MID_FLAG_MERGE_ATTRIBUTE, 0 ),
MAP( "IsVisible", XML_NAMESPACE_TABLE, XML_DISPLAY, XML_TYPE_PROP_TABLE|XML_TYPE_BOOL, 0 ),
MAP( "PageStyle", XML_NAMESPACE_STYLE, XML_MASTER_PAGE_NAME, XML_TYPE_PROP_TABLE|XML_TYPE_STRING|MID_FLAG_SPECIAL_ITEM, CTF_SC_MASTERPAGENAME ),
MAP( "TableLayout", XML_NAMESPACE_STYLE, XML_WRITING_MODE, XML_TYPE_PROP_TABLE|XML_TYPE_TEXT_WRITING_MODE, 0 ),
MAP( "TabColor", XML_NAMESPACE_TABLE, XML_TAB_COLOR, XML_TYPE_PROP_TABLE|XML_TYPE_COLORAUTO, 0 ),
MAP_EXT( "TabColor", XML_NAMESPACE_TABLE_EXT, XML_TAB_COLOR, XML_TYPE_PROP_TABLE|XML_TYPE_COLORAUTO, 0 ),
MAP_END()
};
const XMLPropertyMapEntry aXMLScTableStylesProperties[] =
{
MAP( "IsVisible", XML_NAMESPACE_TABLE, XML_DISPLAY, XML_TYPE_PROP_TABLE|XML_TYPE_BOOL, 0 ),
MAP( "PageStyle", XML_NAMESPACE_STYLE, XML_MASTER_PAGE_NAME, XML_TYPE_PROP_TABLE|XML_TYPE_STRING|MID_FLAG_SPECIAL_ITEM, CTF_SC_MASTERPAGENAME ),
MAP( "TableLayout", XML_NAMESPACE_STYLE, XML_WRITING_MODE, XML_TYPE_PROP_TABLE|XML_TYPE_TEXT_WRITING_MODE, 0 ),
MAP_EXT( "TabColor", XML_NAMESPACE_TABLE_EXT, XML_TAB_COLOR, XML_TYPE_PROP_TABLE|XML_TYPE_COLORAUTO, 0 ),
MAP_END()
};
ScXMLCellExportPropertyMapper::ScXMLCellExportPropertyMapper(
const rtl::Reference< XMLPropertySetMapper >& rMapper )
: SvXMLExportPropertyMapper(rMapper)
{
}
ScXMLCellExportPropertyMapper::~ScXMLCellExportPropertyMapper()
{
}
void ScXMLCellExportPropertyMapper::ContextFilter(
bool bEnableFoFontFamily,
::std::vector< XMLPropertyState >& rProperties,
const uno::Reference< beans::XPropertySet >& rPropSet ) const
{
XMLPropertyState* pPadding = nullptr;
XMLPropertyState* pPadding_Bottom = nullptr;
XMLPropertyState* pPadding_Left = nullptr;
XMLPropertyState* pPadding_Right = nullptr;
XMLPropertyState* pPadding_Top = nullptr;
XMLPropertyState* pBorder = nullptr;
XMLPropertyState* pBorder_Bottom = nullptr;
XMLPropertyState* pBorder_Left = nullptr;
XMLPropertyState* pBorder_Right = nullptr;
XMLPropertyState* pBorder_Top = nullptr;
XMLPropertyState* pSWBorder = nullptr;
XMLPropertyState* pSWBorder_Bottom = nullptr;
XMLPropertyState* pSWBorder_Left = nullptr;
XMLPropertyState* pSWBorder_Right = nullptr;
XMLPropertyState* pSWBorder_Top = nullptr;
XMLPropertyState* pAllBorderWidthState = nullptr;
XMLPropertyState* pLeftBorderWidthState = nullptr;
XMLPropertyState* pRightBorderWidthState = nullptr;
XMLPropertyState* pTopBorderWidthState = nullptr;
XMLPropertyState* pBottomBorderWidthState = nullptr;
XMLPropertyState* pSWAllBorderWidthState = nullptr;
XMLPropertyState* pSWLeftBorderWidthState = nullptr;
XMLPropertyState* pSWRightBorderWidthState = nullptr;
XMLPropertyState* pSWTopBorderWidthState = nullptr;
XMLPropertyState* pSWBottomBorderWidthState = nullptr;
XMLPropertyState* pDiagonalTLBRWidthState = nullptr;
XMLPropertyState* pDiagonalBLTRWidthState = nullptr;
XMLPropertyState* pParaMarginLeft = nullptr;
XMLPropertyState* pParaMarginLeftRel = nullptr;
XMLPropertyState* pParaMarginRight = nullptr;
XMLPropertyState* pParaMarginRightRel = nullptr;
XMLPropertyState* pParaMarginTop = nullptr;
XMLPropertyState* pParaMarginTopRel = nullptr;
XMLPropertyState* pParaMarginBottom = nullptr;
XMLPropertyState* pParaMarginBottomRel = nullptr;
XMLPropertyState* pParaAdjust = nullptr;
XMLPropertyState* pParaAdjustLast = nullptr;
::std::vector< XMLPropertyState >::iterator aEndIter(rProperties.end());
for( ::std::vector< XMLPropertyState >::iterator aIter = rProperties.begin();
aIter != aEndIter; ++aIter )
{
XMLPropertyState* propertyState = &(*aIter);
if (propertyState->mnIndex != -1)
{
switch( getPropertySetMapper()->GetEntryContextId( propertyState->mnIndex ) )
{
case CTF_SC_ALLPADDING: pPadding = propertyState; break;
case CTF_SC_BOTTOMPADDING: pPadding_Bottom = propertyState; break;
case CTF_SC_LEFTPADDING: pPadding_Left = propertyState; break;
case CTF_SC_RIGHTPADDING: pPadding_Right = propertyState; break;
case CTF_SC_TOPPADDING: pPadding_Top = propertyState; break;
case CTF_SC_ALLBORDER: pBorder = propertyState; break;
case CTF_SC_LEFTBORDER: pBorder_Left = propertyState; break;
case CTF_SC_RIGHTBORDER: pBorder_Right = propertyState; break;
case CTF_SC_BOTTOMBORDER: pBorder_Bottom = propertyState; break;
case CTF_SC_TOPBORDER: pBorder_Top = propertyState; break;
case CTF_SC_ALLBORDERWIDTH: pAllBorderWidthState = propertyState; break;
case CTF_SC_LEFTBORDERWIDTH: pLeftBorderWidthState = propertyState; break;
case CTF_SC_RIGHTBORDERWIDTH: pRightBorderWidthState = propertyState; break;
case CTF_SC_TOPBORDERWIDTH: pTopBorderWidthState = propertyState; break;
case CTF_SC_BOTTOMBORDERWIDTH: pBottomBorderWidthState = propertyState; break;
case CTF_ALLBORDER: pSWBorder = propertyState; break;
case CTF_LEFTBORDER: pSWBorder_Left = propertyState; break;
case CTF_RIGHTBORDER: pSWBorder_Right = propertyState; break;
case CTF_BOTTOMBORDER: pSWBorder_Bottom = propertyState; break;
case CTF_TOPBORDER: pSWBorder_Top = propertyState; break;
case CTF_ALLBORDERWIDTH: pSWAllBorderWidthState = propertyState; break;
case CTF_LEFTBORDERWIDTH: pSWLeftBorderWidthState = propertyState; break;
case CTF_RIGHTBORDERWIDTH: pSWRightBorderWidthState = propertyState; break;
case CTF_TOPBORDERWIDTH: pSWTopBorderWidthState = propertyState; break;
case CTF_BOTTOMBORDERWIDTH: pSWBottomBorderWidthState = propertyState; break;
case CTF_SC_DIAGONALTLBR: break; //old diagonal line attribute names without "s" are only read, not written
case CTF_SC_DIAGONALTLBRWIDTH: pDiagonalTLBRWidthState = propertyState; break;
case CTF_SC_DIAGONALBLTR: break; //old diagonal line attribute names without "s" are only read, not written
case CTF_SC_DIAGONALBLTRWIDTH: pDiagonalBLTRWidthState = propertyState; break;
case CTF_SD_SHAPE_PARA_ADJUST: pParaAdjust = propertyState; break;
case CTF_PARA_ADJUSTLAST: pParaAdjustLast = propertyState; break;
case CTF_PARALEFTMARGIN: pParaMarginLeft = propertyState; break;
case CTF_PARALEFTMARGIN_REL: pParaMarginLeftRel = propertyState; break;
case CTF_PARARIGHTMARGIN: pParaMarginRight = propertyState; break;
case CTF_PARARIGHTMARGIN_REL: pParaMarginRightRel = propertyState; break;
case CTF_PARATOPMARGIN: pParaMarginTop = propertyState; break;
case CTF_PARATOPMARGIN_REL: pParaMarginTopRel = propertyState; break;
case CTF_PARABOTTOMMARGIN: pParaMarginBottom = propertyState; break;
case CTF_PARABOTTOMMARGIN_REL: pParaMarginBottomRel = propertyState; break;
}
}
}
if (pPadding && pPadding_Bottom && pPadding_Left && pPadding_Right && pPadding_Top)
{
sal_Int32 nBottom = 0, nTop = 0, nLeft = 0, nRight = 0;
if ((pPadding_Bottom->maValue >>= nBottom) &&
(pPadding_Left->maValue >>= nLeft) &&
(pPadding_Right->maValue >>= nRight) &&
(pPadding_Top->maValue >>= nTop))
{
if ((nBottom == nTop) && (nLeft == nRight) && (nTop == nLeft))
{
pPadding_Bottom->mnIndex = -1;
pPadding_Bottom->maValue.clear();
pPadding_Left->mnIndex = -1;
pPadding_Left->maValue.clear();
pPadding_Right->mnIndex = -1;
pPadding_Right->maValue.clear();
pPadding_Top->mnIndex = -1;
pPadding_Top->maValue.clear();
}
else
{
pPadding->mnIndex = -1;
pPadding->maValue.clear();
}
}
}
if( pBorder )
{
if( pBorder_Left && pBorder_Right && pBorder_Top && pBorder_Bottom )
{
table::BorderLine2 aLeft, aRight, aTop, aBottom;
pBorder_Left->maValue >>= aLeft;
pBorder_Right->maValue >>= aRight;
pBorder_Top->maValue >>= aTop;
pBorder_Bottom->maValue >>= aBottom;
if( aLeft.Color == aRight.Color && aLeft.InnerLineWidth == aRight.InnerLineWidth &&
aLeft.OuterLineWidth == aRight.OuterLineWidth && aLeft.LineDistance == aRight.LineDistance &&
aLeft.Color == aTop.Color && aLeft.InnerLineWidth == aTop.InnerLineWidth &&
aLeft.OuterLineWidth == aTop.OuterLineWidth && aLeft.LineDistance == aTop.LineDistance &&
aLeft.Color == aBottom.Color && aLeft.InnerLineWidth == aBottom.InnerLineWidth &&
aLeft.OuterLineWidth == aBottom.OuterLineWidth && aLeft.LineDistance == aBottom.LineDistance &&
aLeft.LineStyle == aRight.LineStyle && aLeft.LineStyle == aTop.LineStyle &&
aLeft.LineStyle == aBottom.LineStyle && aLeft.LineWidth == aRight.LineWidth &&
aLeft.LineWidth == aTop.LineWidth && aLeft.LineWidth == aBottom.LineWidth )
{
pBorder_Left->mnIndex = -1;
pBorder_Left->maValue.clear();
pBorder_Right->mnIndex = -1;
pBorder_Right->maValue.clear();
pBorder_Top->mnIndex = -1;
pBorder_Top->maValue.clear();
pBorder_Bottom->mnIndex = -1;
pBorder_Bottom->maValue.clear();
}
else
{
pBorder->mnIndex = -1;
pBorder->maValue.clear();
}
}
else
{
pBorder->mnIndex = -1;
pBorder->maValue.clear();
}
}
if( pAllBorderWidthState )
{
if( pLeftBorderWidthState && pRightBorderWidthState && pTopBorderWidthState && pBottomBorderWidthState )
{
table::BorderLine2 aLeft, aRight, aTop, aBottom;
pLeftBorderWidthState->maValue >>= aLeft;
pRightBorderWidthState->maValue >>= aRight;
pTopBorderWidthState->maValue >>= aTop;
pBottomBorderWidthState->maValue >>= aBottom;
if( aLeft.InnerLineWidth == aRight.InnerLineWidth && aLeft.OuterLineWidth == aRight.OuterLineWidth &&
aLeft.LineDistance == aRight.LineDistance && aLeft.InnerLineWidth == aTop.InnerLineWidth &&
aLeft.OuterLineWidth == aTop.OuterLineWidth && aLeft.LineDistance == aTop.LineDistance &&
aLeft.InnerLineWidth == aBottom.InnerLineWidth && aLeft.OuterLineWidth == aBottom.OuterLineWidth &&
aLeft.LineDistance == aBottom.LineDistance && aLeft.LineWidth == aRight.LineWidth &&
aLeft.LineWidth == aTop.LineWidth && aLeft.LineWidth == aBottom.LineWidth )
{
pLeftBorderWidthState->mnIndex = -1;
pLeftBorderWidthState->maValue.clear();
pRightBorderWidthState->mnIndex = -1;
pRightBorderWidthState->maValue.clear();
pTopBorderWidthState->mnIndex = -1;
pTopBorderWidthState->maValue.clear();
pBottomBorderWidthState->mnIndex = -1;
pBottomBorderWidthState->maValue.clear();
}
else
{
pAllBorderWidthState->mnIndex = -1;
pAllBorderWidthState->maValue.clear();
}
}
else
{
pAllBorderWidthState->mnIndex = -1;
pAllBorderWidthState->maValue.clear();
}
}
if (pParaAdjust)
{
pParaAdjust->mnIndex = -1;
pParaAdjust->maValue.clear();
}
if (pParaAdjustLast)
{
pParaAdjustLast->mnIndex = -1;
pParaAdjustLast->maValue.clear();
}
if (pSWBorder)
{
pSWBorder->mnIndex = -1;
pSWBorder->maValue.clear();
}
if (pSWBorder_Left)
{
pSWBorder_Left->mnIndex = -1;
pSWBorder_Left->maValue.clear();
}
if (pSWBorder_Right)
{
pSWBorder_Right->mnIndex = -1;
pSWBorder_Right->maValue.clear();
}
if (pSWBorder_Bottom)
{
pSWBorder_Bottom->mnIndex = -1;
pSWBorder_Bottom->maValue.clear();
}
if (pSWBorder_Top)
{
pSWBorder_Top->mnIndex = -1;
pSWBorder_Top->maValue.clear();
}
if (pSWAllBorderWidthState)
{
pSWAllBorderWidthState->mnIndex = -1;
pSWAllBorderWidthState->maValue.clear();
}
if (pSWLeftBorderWidthState)
{
pSWLeftBorderWidthState->mnIndex = -1;
pSWLeftBorderWidthState->maValue.clear();
}
if (pSWRightBorderWidthState)
{
pSWRightBorderWidthState->mnIndex = -1;
pSWRightBorderWidthState->maValue.clear();
}
if (pSWTopBorderWidthState)
{
pSWTopBorderWidthState->mnIndex = -1;
pSWTopBorderWidthState->maValue.clear();
}
if (pSWBottomBorderWidthState)
{
pSWBottomBorderWidthState->mnIndex = -1;
pSWBottomBorderWidthState->maValue.clear();
}
if (pParaMarginLeft)
{
pParaMarginLeft->mnIndex = -1;
pParaMarginLeft->maValue.clear();
}
if (pParaMarginLeftRel)
{
pParaMarginLeftRel->mnIndex = -1;
pParaMarginLeftRel->maValue.clear();
}
if (pParaMarginRight)
{
pParaMarginRight->mnIndex = -1;
pParaMarginRight->maValue.clear();
}
if (pParaMarginRightRel)
{
pParaMarginRightRel->mnIndex = -1;
pParaMarginRightRel->maValue.clear();
}
if (pParaMarginTop)
{
pParaMarginTop->mnIndex = -1;
pParaMarginTop->maValue.clear();
}
if (pParaMarginTopRel)
{
pParaMarginTopRel->mnIndex = -1;
pParaMarginTopRel->maValue.clear();
}
if (pParaMarginBottom)
{
pParaMarginBottom->mnIndex = -1;
pParaMarginBottom->maValue.clear();
}
if (pParaMarginBottomRel)
{
pParaMarginBottomRel->mnIndex = -1;
pParaMarginBottomRel->maValue.clear();
}
// #i102690# old diagonal line attribute names without "s" are only read, not written
if (pDiagonalTLBRWidthState)
{
pDiagonalTLBRWidthState->mnIndex = -1;
pDiagonalTLBRWidthState->maValue.clear();
}
if (pDiagonalBLTRWidthState)
{
pDiagonalBLTRWidthState->mnIndex = -1;
pDiagonalBLTRWidthState->maValue.clear();
}
SvXMLExportPropertyMapper::ContextFilter(bEnableFoFontFamily, rProperties, rPropSet);
}
/** this method is called for every item that has the MID_FLAG_SPECIAL_ITEM_EXPORT flag set */
void ScXMLCellExportPropertyMapper::handleSpecialItem(
SvXMLAttributeList& /* rAttrList */,
const XMLPropertyState& /* rProperty */,
const SvXMLUnitConverter& /* rUnitConverter */,
const SvXMLNamespaceMap& /* rNamespaceMap */,
const ::std::vector< XMLPropertyState > * /* pProperties */,
sal_uInt32 /* nIdx */ ) const
{
// the SpecialItem NumberFormat must not be handled by this method
// the SpecialItem ConditionlaFormat must not be handled by this method
// the SpecialItem CharBackColor must not be handled by this method
}
void ScXMLCellExportPropertyMapper::handleElementItem(
SvXMLExport& rExport,
const XMLPropertyState& rProperty,
SvXmlExportFlags /* nFlags */,
const ::std::vector< XMLPropertyState > * /* pProperties */,
sal_uInt32 /* nIdx */) const
{
sal_uInt32 nContextId = getPropertySetMapper()->GetEntryContextId( rProperty.mnIndex );
OUString sURL;
if ( ( nContextId == CTF_SC_HYPERLINK ) &&
( rProperty.maValue >>= sURL ) &&
!sURL.isEmpty() )
{
rExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, sURL );
rExport.AddAttribute( XML_NAMESPACE_XLINK, XML_TYPE,
XML_SIMPLE );
sal_uInt32 nPropIndex = rProperty.mnIndex;
sal_uInt16 nPrefix = getPropertySetMapper()->GetEntryNameSpace( nPropIndex );
OUString sLocalName = getPropertySetMapper()->GetEntryXMLName( nPropIndex );
SvXMLElementExport aElem( rExport, nPrefix, sLocalName, true, true );
}
}
ScXMLRowExportPropertyMapper::ScXMLRowExportPropertyMapper(
const rtl::Reference< XMLPropertySetMapper >& rMapper )
: SvXMLExportPropertyMapper(rMapper)
{
}
ScXMLRowExportPropertyMapper::~ScXMLRowExportPropertyMapper()
{
}
void ScXMLRowExportPropertyMapper::ContextFilter(
bool /* bEnableFoFontFamily */,
::std::vector< XMLPropertyState >& /* rProperties */,
const uno::Reference< beans::XPropertySet >& /* rPropSet */ ) const
{
//#108550#; don't filter the height, so other applications know the calculated height
}
ScXMLColumnExportPropertyMapper::ScXMLColumnExportPropertyMapper(
const rtl::Reference< XMLPropertySetMapper >& rMapper )
: SvXMLExportPropertyMapper(rMapper)
{
}
ScXMLColumnExportPropertyMapper::~ScXMLColumnExportPropertyMapper()
{
}
/** this method is called for every item that has the MID_FLAG_SPECIAL_ITEM_EXPORT flag set */
void ScXMLColumnExportPropertyMapper::handleSpecialItem(
SvXMLAttributeList& /* rAttrList */,
const XMLPropertyState& /* rProperty */,
const SvXMLUnitConverter& /* rUnitConverter */,
const SvXMLNamespaceMap& /* rNamespaceMap */,
const ::std::vector< XMLPropertyState > * /* pProperties */,
sal_uInt32 /* nIdx */ ) const
{
// the SpecialItem IsVisible must not be handled by this method
}
ScXMLTableExportPropertyMapper::ScXMLTableExportPropertyMapper(
const rtl::Reference< XMLPropertySetMapper >& rMapper )
: SvXMLExportPropertyMapper(rMapper)
{
}
ScXMLTableExportPropertyMapper::~ScXMLTableExportPropertyMapper()
{
}
/** this method is called for every item that has the MID_FLAG_SPECIAL_ITEM_EXPORT flag set */
void ScXMLTableExportPropertyMapper::handleSpecialItem(
SvXMLAttributeList& /* rAttrList */,
const XMLPropertyState& /* rProperty */,
const SvXMLUnitConverter& /* rUnitConverter */,
const SvXMLNamespaceMap& /* rNamespaceMap */,
const ::std::vector< XMLPropertyState > * /* pProperties */,
sal_uInt32 /* nIdx */ ) const
{
// the SpecialItem PageStyle must not be handled by this method
}
void ScXMLAutoStylePoolP::exportStyleAttributes(
SvXMLAttributeList& rAttrList,
sal_Int32 nFamily,
const ::std::vector< XMLPropertyState >& rProperties,
const SvXMLExportPropertyMapper& rPropExp
, const SvXMLUnitConverter& rUnitConverter,
const SvXMLNamespaceMap& rNamespaceMap
) const
{
SvXMLAutoStylePoolP::exportStyleAttributes( rAttrList, nFamily, rProperties, rPropExp, rUnitConverter, rNamespaceMap );
if (nFamily == XML_STYLE_FAMILY_TABLE_CELL)
{
::std::vector< XMLPropertyState >::const_iterator i(rProperties.begin());
::std::vector< XMLPropertyState >::const_iterator endi(rProperties.end());
for(; i != endi; ++i)
{
rtl::Reference< XMLPropertySetMapper > aPropMapper(rScXMLExport.GetCellStylesPropertySetMapper());
sal_Int16 nContextID(aPropMapper->GetEntryContextId(i->mnIndex));
switch (nContextID)
{
case CTF_SC_NUMBERFORMAT :
{
sal_Int32 nNumberFormat = 0;
if (i->maValue >>= nNumberFormat)
{
OUString sAttrValue(rScXMLExport.getDataStyleName(nNumberFormat));
if (!sAttrValue.isEmpty())
{
GetExport().AddAttribute(
aPropMapper->GetEntryNameSpace(i->mnIndex),
aPropMapper->GetEntryXMLName(i->mnIndex),
sAttrValue );
}
}
}
break;
}
}
}
else if (nFamily == XML_STYLE_FAMILY_TABLE_TABLE)
{
::std::vector< XMLPropertyState >::const_iterator i(rProperties.begin());
::std::vector< XMLPropertyState >::const_iterator endi(rProperties.end());
for(; i != endi; ++i)
{
rtl::Reference< XMLPropertySetMapper > aPropMapper(rScXMLExport.GetTableStylesPropertySetMapper());
sal_Int16 nContextID(aPropMapper->GetEntryContextId(i->mnIndex));
switch (nContextID)
{
case CTF_SC_MASTERPAGENAME :
{
OUString sName;
if (i->maValue >>= sName)
{
GetExport().AddAttribute(
aPropMapper->GetEntryNameSpace(i->mnIndex),
aPropMapper->GetEntryXMLName(i->mnIndex),
GetExport().EncodeStyleName( sName ));
}
}
break;
}
}
}
}
void ScXMLAutoStylePoolP::exportStyleContent(
const css::uno::Reference< css::xml::sax::XDocumentHandler > & rHandler,
sal_Int32 nFamily,
const std::vector< XMLPropertyState >& rProperties,
const SvXMLExportPropertyMapper& rPropExp
, const SvXMLUnitConverter& rUnitConverter,
const SvXMLNamespaceMap& rNamespaceMap
) const
{
SvXMLAutoStylePoolP::exportStyleContent( rHandler, nFamily, rProperties, rPropExp, rUnitConverter, rNamespaceMap );
if (nFamily == XML_STYLE_FAMILY_TABLE_CELL)
{
::std::vector< XMLPropertyState >::const_iterator i(rProperties.begin());
::std::vector< XMLPropertyState >::const_iterator endi(rProperties.end());
for(; i != endi; ++i)
{
if (i->mnIndex != -1)
{
sal_Int16 nContextID = rScXMLExport.GetCellStylesPropertySetMapper()->GetEntryContextId(i->mnIndex);
switch (nContextID)
{
case CTF_SC_MAP :
{
uno::Reference<container::XIndexAccess> xIndex( i->maValue, uno::UNO_QUERY );
if ( xIndex.is() )
{
sal_Int32 nConditionCount(xIndex->getCount());
for (sal_Int32 nCondition = 0; nCondition < nConditionCount; ++nCondition)
{
uno::Reference <sheet::XSheetConditionalEntry> xSheetConditionalEntry(xIndex->getByIndex(nCondition), uno::UNO_QUERY);
if (xSheetConditionalEntry.is())
{
OUString sStyleName(xSheetConditionalEntry->getStyleName());
uno::Reference <sheet::XSheetCondition> xSheetCondition(xSheetConditionalEntry, uno::UNO_QUERY);
if (xSheetCondition.is())
{
sheet::ConditionOperator aOperator = xSheetCondition->getOperator();
if (aOperator != sheet::ConditionOperator_NONE)
{
if (aOperator == sheet::ConditionOperator_FORMULA)
{
OUString sCondition = "is-true-formula("
+ xSheetCondition->getFormula1()
+ ")";
rScXMLExport.AddAttribute(XML_NAMESPACE_STYLE, XML_CONDITION, sCondition);
rScXMLExport.AddAttribute(XML_NAMESPACE_STYLE, XML_APPLY_STYLE_NAME, rScXMLExport.EncodeStyleName( sStyleName ));
OUString sOUBaseAddress;
ScDocument* pDoc = rScXMLExport.GetDocument();
ScRangeStringConverter::GetStringFromAddress( sOUBaseAddress,
xSheetCondition->getSourcePosition(), pDoc, FormulaGrammar::CONV_OOO );
rScXMLExport.AddAttribute(XML_NAMESPACE_STYLE, XML_BASE_CELL_ADDRESS, sOUBaseAddress);
SvXMLElementExport aMElem(rScXMLExport, XML_NAMESPACE_STYLE, XML_MAP, true, true);
}
else
{
OUString sCondition;
if (aOperator == sheet::ConditionOperator_BETWEEN ||
aOperator == sheet::ConditionOperator_NOT_BETWEEN)
{
if (aOperator == sheet::ConditionOperator_BETWEEN)
sCondition = "cell-content-is-between(";
else
sCondition = "cell-content-is-not-between(";
sCondition += xSheetCondition->getFormula1()
+ ","
+ xSheetCondition->getFormula2()
+ ")";
}
else
{
sCondition = "cell-content()";
switch (aOperator)
{
case sheet::ConditionOperator_LESS:
sCondition += "<";
break;
case sheet::ConditionOperator_GREATER:
sCondition += ">";
break;
case sheet::ConditionOperator_LESS_EQUAL:
sCondition += "<=";
break;
case sheet::ConditionOperator_GREATER_EQUAL:
sCondition += ">=";
break;
case sheet::ConditionOperator_EQUAL:
sCondition += "=";
break;
case sheet::ConditionOperator_NOT_EQUAL:
sCondition += "!=";
break;
default:
{
// added to avoid warnings
}
}
sCondition += xSheetCondition->getFormula1();
}
rScXMLExport.AddAttribute(XML_NAMESPACE_STYLE, XML_CONDITION, sCondition);
rScXMLExport.AddAttribute(XML_NAMESPACE_STYLE, XML_APPLY_STYLE_NAME, rScXMLExport.EncodeStyleName( sStyleName ));
OUString sOUBaseAddress;
ScRangeStringConverter::GetStringFromAddress( sOUBaseAddress,
xSheetCondition->getSourcePosition(), rScXMLExport.GetDocument(), FormulaGrammar::CONV_OOO );
rScXMLExport.AddAttribute(XML_NAMESPACE_STYLE, XML_BASE_CELL_ADDRESS, sOUBaseAddress);
SvXMLElementExport aMElem(rScXMLExport, XML_NAMESPACE_STYLE, XML_MAP, true, true);
}
}
}
}
}
}
}
break;
}
}
}
}
}
ScXMLAutoStylePoolP::ScXMLAutoStylePoolP(ScXMLExport& rTempScXMLExport):
SvXMLAutoStylePoolP(rTempScXMLExport),
rScXMLExport(rTempScXMLExport)
{
}
ScXMLAutoStylePoolP::~ScXMLAutoStylePoolP()
{
}
void ScXMLStyleExport::exportStyleAttributes(
const css::uno::Reference< css::style::XStyle > & rStyle )
{
uno::Reference< beans::XPropertySet > xPropSet( rStyle, uno::UNO_QUERY );
if (xPropSet.is())
{
uno::Reference< beans::XPropertySetInfo > xPropSetInfo(xPropSet->getPropertySetInfo());
OUString sNumberFormat("NumberFormat");
if( xPropSetInfo->hasPropertyByName( sNumberFormat ) )
{
uno::Reference< beans::XPropertyState > xPropState( xPropSet, uno::UNO_QUERY );
if( xPropState.is() && (beans::PropertyState_DIRECT_VALUE ==
xPropState->getPropertyState( sNumberFormat )) )
{
sal_Int32 nNumberFormat = 0;
if (xPropSet->getPropertyValue( sNumberFormat ) >>= nNumberFormat)
GetExport().AddAttribute( XML_NAMESPACE_STYLE, XML_DATA_STYLE_NAME,
GetExport().getDataStyleName(nNumberFormat) );
}
}
}
}
void ScXMLStyleExport::exportStyleContent( const css::uno::Reference<css::style::XStyle > & /* rStyle */ )
{
}
ScXMLStyleExport::ScXMLStyleExport(
SvXMLExport& rExp,
SvXMLAutoStylePoolP *pAutoStyleP )
: XMLStyleExport(rExp, pAutoStyleP)
{
}
ScXMLStyleExport::~ScXMLStyleExport()
{
}
XMLScPropHdlFactory::XMLScPropHdlFactory()
: XMLPropertyHandlerFactory()
{
}
XMLScPropHdlFactory::~XMLScPropHdlFactory()
{
}
const XMLPropertyHandler* XMLScPropHdlFactory::GetPropertyHandler( sal_Int32 nType ) const
{
nType &= MID_FLAG_MASK;
XMLPropertyHandler* pHdl(const_cast<XMLPropertyHandler*>(XMLPropertyHandlerFactory::GetPropertyHandler( nType )));
if(!pHdl)
{
switch(nType)
{
case XML_SC_TYPE_CELLPROTECTION :
{
pHdl = new XmlScPropHdl_CellProtection;
}
break;
case XML_SC_TYPE_PRINTCONTENT :
{
pHdl = new XmlScPropHdl_PrintContent;
}
break;
case XML_SC_TYPE_HORIJUSTIFY_METHOD:
case XML_SC_TYPE_VERTJUSTIFY_METHOD:
{
pHdl = new XmlScPropHdl_JustifyMethod;
}
break;
case XML_SC_TYPE_HORIJUSTIFY :
{
pHdl = new XmlScPropHdl_HoriJustify;
}
break;
case XML_SC_TYPE_HORIJUSTIFYSOURCE :
{
pHdl = new XmlScPropHdl_HoriJustifySource;
}
break;
case XML_SC_TYPE_HORIJUSTIFYREPEAT :
{
pHdl = new XmlScPropHdl_HoriJustifyRepeat;
}
break;
case XML_SC_TYPE_ORIENTATION :
{
pHdl = new XmlScPropHdl_Orientation;
}
break;
case XML_SC_TYPE_ROTATEANGLE :
{
pHdl = new XmlScPropHdl_RotateAngle;
}
break;
case XML_SC_TYPE_ROTATEREFERENCE :
{
pHdl = new XmlScPropHdl_RotateReference;
}
break;
case XML_SC_TYPE_VERTJUSTIFY :
{
pHdl = new XmlScPropHdl_VertJustify;
}
break;
case XML_SC_TYPE_BREAKBEFORE :
{
pHdl = new XmlScPropHdl_BreakBefore;
}
break;
case XML_SC_ISTEXTWRAPPED :
{
pHdl = new XmlScPropHdl_IsTextWrapped;
}
break;
case XML_SC_TYPE_EQUAL :
{
pHdl = new XmlScPropHdl_IsEqual;
}
break;
case XML_SC_TYPE_VERTICAL :
{
pHdl = new XmlScPropHdl_Vertical;
}
break;
}
if(pHdl)
PutHdlCache(nType, pHdl);
}
return pHdl;
}
XmlScPropHdl_CellProtection::~XmlScPropHdl_CellProtection()
{
}
bool XmlScPropHdl_CellProtection::equals(
const css::uno::Any& r1,
const css::uno::Any& r2 ) const
{
util::CellProtection aCellProtection1, aCellProtection2;
if((r1 >>= aCellProtection1) && (r2 >>= aCellProtection2))
{
return ((aCellProtection1.IsHidden == aCellProtection2.IsHidden) &&
(aCellProtection1.IsLocked == aCellProtection2.IsLocked) &&
(aCellProtection1.IsFormulaHidden == aCellProtection2.IsFormulaHidden));
}
return false;
}
bool XmlScPropHdl_CellProtection::importXML(
const OUString& rStrImpValue,
css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
bool bRetval(false);
util::CellProtection aCellProtection;
bool bDefault(false);
if (!rValue.hasValue())
{
aCellProtection.IsHidden = false;
aCellProtection.IsLocked = true;
aCellProtection.IsFormulaHidden = false;
aCellProtection.IsPrintHidden = false;
bDefault = true;
}
if ((rValue >>= aCellProtection) || bDefault)
{
if (IsXMLToken(rStrImpValue, XML_NONE))
{
aCellProtection.IsFormulaHidden = false;
aCellProtection.IsHidden = false;
aCellProtection.IsLocked = false;
rValue <<= aCellProtection;
bRetval = true;
}
else if (IsXMLToken(rStrImpValue, XML_HIDDEN_AND_PROTECTED))
{
aCellProtection.IsFormulaHidden = true;
aCellProtection.IsHidden = true;
aCellProtection.IsLocked = true;
rValue <<= aCellProtection;
bRetval = true;
}
else if (IsXMLToken(rStrImpValue, XML_PROTECTED))
{
aCellProtection.IsFormulaHidden = false;
aCellProtection.IsHidden = false;
aCellProtection.IsLocked = true;
rValue <<= aCellProtection;
bRetval = true;
}
else if (IsXMLToken(rStrImpValue, XML_FORMULA_HIDDEN))
{
aCellProtection.IsFormulaHidden = true;
aCellProtection.IsHidden = false;
aCellProtection.IsLocked = false;
rValue <<= aCellProtection;
bRetval = true;
}
else
{
sal_Int32 i(0);
while (i < rStrImpValue.getLength() && rStrImpValue[i] != ' ')
++i;
OUString sFirst(rStrImpValue.copy(0, i));
OUString sSecond(rStrImpValue.copy(i + 1));
aCellProtection.IsFormulaHidden = false;
aCellProtection.IsHidden = false;
aCellProtection.IsLocked = false;
if ((IsXMLToken(sFirst, XML_PROTECTED)) || (IsXMLToken(sSecond, XML_PROTECTED)))
aCellProtection.IsLocked = true;
if ((IsXMLToken(sFirst, XML_FORMULA_HIDDEN)) || (IsXMLToken(sSecond, XML_FORMULA_HIDDEN)))
aCellProtection.IsFormulaHidden = true;
rValue <<= aCellProtection;
bRetval = true;
}
}
return bRetval;
}
bool XmlScPropHdl_CellProtection::exportXML(
OUString& rStrExpValue,
const css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
bool bRetval(false);
util::CellProtection aCellProtection;
if(rValue >>= aCellProtection)
{
if (!(aCellProtection.IsFormulaHidden || aCellProtection.IsHidden || aCellProtection.IsLocked))
{
rStrExpValue = GetXMLToken(XML_NONE);
bRetval = true;
}
else if (aCellProtection.IsHidden)
{
// #i105964# "Hide all" implies "Protected" in the UI, so it must be saved as "hidden-and-protected"
// even if "IsLocked" is not set in the CellProtection struct.
rStrExpValue = GetXMLToken(XML_HIDDEN_AND_PROTECTED);
bRetval = true;
}
else if (aCellProtection.IsLocked && !(aCellProtection.IsFormulaHidden || aCellProtection.IsHidden))
{
rStrExpValue = GetXMLToken(XML_PROTECTED);
bRetval = true;
}
else if (aCellProtection.IsFormulaHidden && !(aCellProtection.IsLocked || aCellProtection.IsHidden))
{
rStrExpValue = GetXMLToken(XML_FORMULA_HIDDEN);
bRetval = true;
}
else if (aCellProtection.IsFormulaHidden && aCellProtection.IsLocked)
{
rStrExpValue = GetXMLToken(XML_PROTECTED);
rStrExpValue += " ";
rStrExpValue += GetXMLToken(XML_FORMULA_HIDDEN);
bRetval = true;
}
}
return bRetval;
}
XmlScPropHdl_PrintContent::~XmlScPropHdl_PrintContent()
{
}
bool XmlScPropHdl_PrintContent::equals(
const css::uno::Any& r1,
const css::uno::Any& r2 ) const
{
util::CellProtection aCellProtection1, aCellProtection2;
if((r1 >>= aCellProtection1) && (r2 >>= aCellProtection2))
{
return (aCellProtection1.IsPrintHidden == aCellProtection2.IsPrintHidden);
}
return false;
}
bool XmlScPropHdl_PrintContent::importXML(
const OUString& rStrImpValue,
css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
bool bRetval(false);
util::CellProtection aCellProtection;
bool bDefault(false);
if (!rValue.hasValue())
{
aCellProtection.IsHidden = false;
aCellProtection.IsLocked = true;
aCellProtection.IsFormulaHidden = false;
aCellProtection.IsPrintHidden = false;
bDefault = true;
}
if ((rValue >>= aCellProtection) || bDefault)
{
bool bValue(false);
if (::sax::Converter::convertBool(bValue, rStrImpValue))
{
aCellProtection.IsPrintHidden = !bValue;
rValue <<= aCellProtection;
bRetval = true;
}
}
return bRetval;
}
bool XmlScPropHdl_PrintContent::exportXML(
OUString& rStrExpValue,
const css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
bool bRetval(false);
util::CellProtection aCellProtection;
if(rValue >>= aCellProtection)
{
OUStringBuffer sValue;
::sax::Converter::convertBool(sValue, !aCellProtection.IsPrintHidden);
rStrExpValue = sValue.makeStringAndClear();
bRetval = true;
}
return bRetval;
}
XmlScPropHdl_JustifyMethod::~XmlScPropHdl_JustifyMethod()
{
}
bool XmlScPropHdl_JustifyMethod::equals(
const css::uno::Any& r1,
const css::uno::Any& r2 ) const
{
sal_Int32 nVal1(0), nVal2(0);
if((r1 >>= nVal1) && (r2 >>= nVal2))
return (nVal1 == nVal2);
return false;
}
bool XmlScPropHdl_JustifyMethod::importXML(
const OUString& rStrImpValue,
css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
bool bRetval = false;
sal_Int32 nValue = table::CellJustifyMethod::AUTO;
if (IsXMLToken(rStrImpValue, XML_AUTO))
{
nValue = table::CellJustifyMethod::AUTO;
rValue <<= nValue;
bRetval = true;
}
else if (IsXMLToken(rStrImpValue, XML_DISTRIBUTE))
{
nValue = table::CellJustifyMethod::DISTRIBUTE;
rValue <<= nValue;
bRetval = true;
}
else
bRetval = true;
return bRetval;
}
bool XmlScPropHdl_JustifyMethod::exportXML(
OUString& rStrExpValue,
const css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
sal_Int32 nVal(0);
bool bRetval = false;
if (rValue >>= nVal)
{
switch (nVal)
{
case table::CellJustifyMethod::AUTO:
{
rStrExpValue = GetXMLToken(XML_AUTO);
bRetval = true;
}
break;
case table::CellJustifyMethod::DISTRIBUTE:
{
rStrExpValue = GetXMLToken(XML_DISTRIBUTE);
bRetval = true;
}
break;
default:
{
// added to avoid warnings
}
}
}
return bRetval;
}
XmlScPropHdl_HoriJustify::~XmlScPropHdl_HoriJustify()
{
}
bool XmlScPropHdl_HoriJustify::equals(
const css::uno::Any& r1,
const css::uno::Any& r2 ) const
{
table::CellHoriJustify aHoriJustify1, aHoriJustify2;
if((r1 >>= aHoriJustify1) && (r2 >>= aHoriJustify2))
return (aHoriJustify1 == aHoriJustify2);
return false;
}
bool XmlScPropHdl_HoriJustify::importXML(
const OUString& rStrImpValue,
css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
bool bRetval(false);
table::CellHoriJustify nValue = table::CellHoriJustify_LEFT;
rValue >>= nValue;
if (nValue != table::CellHoriJustify_REPEAT)
{
if (IsXMLToken(rStrImpValue, XML_START))
{
nValue = table::CellHoriJustify_LEFT;
rValue <<= nValue;
bRetval = true;
}
else if (IsXMLToken(rStrImpValue, XML_END))
{
nValue = table::CellHoriJustify_RIGHT;
rValue <<= nValue;
bRetval = true;
}
else if (IsXMLToken(rStrImpValue, XML_CENTER))
{
nValue = table::CellHoriJustify_CENTER;
rValue <<= nValue;
bRetval = true;
}
else if (IsXMLToken(rStrImpValue, XML_JUSTIFY))
{
nValue = table::CellHoriJustify_BLOCK;
rValue <<= nValue;
bRetval = true;
}
}
else
bRetval = true;
return bRetval;
}
bool XmlScPropHdl_HoriJustify::exportXML(
OUString& rStrExpValue,
const css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
table::CellHoriJustify nVal;
bool bRetval(false);
if(rValue >>= nVal)
{
switch (nVal)
{
case table::CellHoriJustify_REPEAT:
case table::CellHoriJustify_LEFT:
{
rStrExpValue = GetXMLToken(XML_START);
bRetval = true;
}
break;
case table::CellHoriJustify_RIGHT:
{
rStrExpValue = GetXMLToken(XML_END);
bRetval = true;
}
break;
case table::CellHoriJustify_CENTER:
{
rStrExpValue = GetXMLToken(XML_CENTER);
bRetval = true;
}
break;
case table::CellHoriJustify_BLOCK:
{
rStrExpValue = GetXMLToken(XML_JUSTIFY);
bRetval = true;
}
break;
default:
{
// added to avoid warnings
}
}
}
return bRetval;
}
XmlScPropHdl_HoriJustifySource::~XmlScPropHdl_HoriJustifySource()
{
}
bool XmlScPropHdl_HoriJustifySource::equals(
const css::uno::Any& r1,
const css::uno::Any& r2 ) const
{
table::CellHoriJustify aHoriJustify1, aHoriJustify2;
if((r1 >>= aHoriJustify1) && (r2 >>= aHoriJustify2))
return (aHoriJustify1 == aHoriJustify2);
return false;
}
bool XmlScPropHdl_HoriJustifySource::importXML(
const OUString& rStrImpValue,
css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
bool bRetval(false);
if (IsXMLToken(rStrImpValue, XML_FIX))
{
bRetval = true;
}
else if (IsXMLToken(rStrImpValue, XML_VALUE_TYPE))
{
rValue <<= table::CellHoriJustify_STANDARD;
bRetval = true;
}
return bRetval;
}
bool XmlScPropHdl_HoriJustifySource::exportXML(
OUString& rStrExpValue,
const css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
table::CellHoriJustify nVal;
bool bRetval(false);
if(rValue >>= nVal)
{
if (nVal == table::CellHoriJustify_STANDARD)
{
rStrExpValue = GetXMLToken(XML_VALUE_TYPE);
bRetval = true;
}
else
{
rStrExpValue = GetXMLToken(XML_FIX);
bRetval = true;
}
}
return bRetval;
}
XmlScPropHdl_HoriJustifyRepeat::~XmlScPropHdl_HoriJustifyRepeat()
{
}
bool XmlScPropHdl_HoriJustifyRepeat::equals(
const css::uno::Any& r1,
const css::uno::Any& r2 ) const
{
table::CellHoriJustify aHoriJustify1, aHoriJustify2;
if((r1 >>= aHoriJustify1) && (r2 >>= aHoriJustify2))
return (aHoriJustify1 == aHoriJustify2);
return false;
}
bool XmlScPropHdl_HoriJustifyRepeat::importXML(
const OUString& rStrImpValue,
css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
bool bRetval(false);
if (IsXMLToken(rStrImpValue, XML_FALSE))
{
bRetval = true;
}
else if (IsXMLToken(rStrImpValue, XML_TRUE))
{
rValue <<= table::CellHoriJustify_REPEAT;
bRetval = true;
}
return bRetval;
}
bool XmlScPropHdl_HoriJustifyRepeat::exportXML(
OUString& rStrExpValue,
const css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
table::CellHoriJustify nVal;
bool bRetval(false);
if(rValue >>= nVal)
{
if (nVal == table::CellHoriJustify_REPEAT)
{
rStrExpValue = GetXMLToken(XML_TRUE);
bRetval = true;
}
else
{
rStrExpValue = GetXMLToken(XML_FALSE);
bRetval = true;
}
}
return bRetval;
}
XmlScPropHdl_Orientation::~XmlScPropHdl_Orientation()
{
}
bool XmlScPropHdl_Orientation::equals(
const css::uno::Any& r1,
const css::uno::Any& r2 ) const
{
table::CellOrientation aOrientation1, aOrientation2;
if((r1 >>= aOrientation1) && (r2 >>= aOrientation2))
return (aOrientation1 == aOrientation2);
return false;
}
bool XmlScPropHdl_Orientation::importXML(
const OUString& rStrImpValue,
css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
bool bRetval(false);
table::CellOrientation nValue;
if (IsXMLToken(rStrImpValue, XML_LTR))
{
nValue = table::CellOrientation_STANDARD;
rValue <<= nValue;
bRetval = true;
}
else if (IsXMLToken(rStrImpValue, XML_TTB))
{
nValue = table::CellOrientation_STACKED;
rValue <<= nValue;
bRetval = true;
}
return bRetval;
}
bool XmlScPropHdl_Orientation::exportXML(
OUString& rStrExpValue,
const css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
table::CellOrientation nVal;
bool bRetval(false);
if(rValue >>= nVal)
{
switch (nVal)
{
case table::CellOrientation_STACKED :
{
rStrExpValue = GetXMLToken(XML_TTB);
bRetval = true;
}
break;
default:
{
rStrExpValue = GetXMLToken(XML_LTR);
bRetval = true;
}
break;
}
}
return bRetval;
}
XmlScPropHdl_RotateAngle::~XmlScPropHdl_RotateAngle()
{
}
bool XmlScPropHdl_RotateAngle::equals(
const css::uno::Any& r1,
const css::uno::Any& r2 ) const
{
sal_Int32 aAngle1 = 0, aAngle2 = 0;
if((r1 >>= aAngle1) && (r2 >>= aAngle2))
return (aAngle1 == aAngle2);
return false;
}
bool XmlScPropHdl_RotateAngle::importXML(
const OUString& rStrImpValue,
css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
bool bRetval(false);
sal_Int32 nValue;
if (::sax::Converter::convertNumber(nValue, rStrImpValue) && !o3tl::checked_multiply<sal_Int32>(nValue, 100, nValue))
{
rValue <<= nValue;
bRetval = true;
}
return bRetval;
}
bool XmlScPropHdl_RotateAngle::exportXML(
OUString& rStrExpValue,
const css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
sal_Int32 nVal = 0;
bool bRetval(false);
if(rValue >>= nVal)
{
rStrExpValue = OUString::number(nVal / 100);
bRetval = true;
}
return bRetval;
}
XmlScPropHdl_RotateReference::~XmlScPropHdl_RotateReference()
{
}
bool XmlScPropHdl_RotateReference::equals(
const css::uno::Any& r1,
const css::uno::Any& r2 ) const
{
sal_Int32 aReference1(0), aReference2(0);
if((r1 >>= aReference1) && (r2 >>= aReference2))
return (aReference1 == aReference2);
return false;
}
bool XmlScPropHdl_RotateReference::importXML(
const OUString& rStrImpValue,
css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
bool bRetval(false);
sal_Int32 nValue;
if (IsXMLToken(rStrImpValue, XML_NONE))
{
nValue = table::CellVertJustify2::STANDARD;
rValue <<= nValue;
bRetval = true;
}
else if (IsXMLToken(rStrImpValue, XML_BOTTOM))
{
nValue = table::CellVertJustify2::BOTTOM;
rValue <<= nValue;
bRetval = true;
}
else if (IsXMLToken(rStrImpValue, XML_TOP))
{
nValue = table::CellVertJustify2::TOP;
rValue <<= nValue;
bRetval = true;
}
else if (IsXMLToken(rStrImpValue, XML_CENTER))
{
nValue = table::CellVertJustify2::CENTER;
rValue <<= nValue;
bRetval = true;
}
return bRetval;
}
bool XmlScPropHdl_RotateReference::exportXML(
OUString& rStrExpValue,
const css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
sal_Int32 nVal(0);
bool bRetval(false);
if(rValue >>= nVal)
{
switch (nVal)
{
case table::CellVertJustify2::BOTTOM :
{
rStrExpValue = GetXMLToken(XML_BOTTOM);
bRetval = true;
}
break;
case table::CellVertJustify2::CENTER :
{
rStrExpValue = GetXMLToken(XML_CENTER);
bRetval = true;
}
break;
case table::CellVertJustify2::STANDARD :
{
rStrExpValue = GetXMLToken(XML_NONE);
bRetval = true;
}
break;
case table::CellVertJustify2::TOP :
{
rStrExpValue = GetXMLToken(XML_TOP);
bRetval = true;
}
break;
default:
{
// added to avoid warnings
}
}
}
return bRetval;
}
XmlScPropHdl_VertJustify::~XmlScPropHdl_VertJustify()
{
}
bool XmlScPropHdl_VertJustify::equals(
const css::uno::Any& r1,
const css::uno::Any& r2 ) const
{
sal_Int32 aReference1(0), aReference2(0);
if((r1 >>= aReference1) && (r2 >>= aReference2))
return (aReference1 == aReference2);
return false;
}
bool XmlScPropHdl_VertJustify::importXML(
const OUString& rStrImpValue,
css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
bool bRetval(false);
sal_Int32 nValue;
if (IsXMLToken(rStrImpValue, XML_AUTOMATIC))
{
nValue = table::CellVertJustify2::STANDARD;
rValue <<= nValue;
bRetval = true;
}
else if (IsXMLToken(rStrImpValue, XML_BOTTOM))
{
nValue = table::CellVertJustify2::BOTTOM;
rValue <<= nValue;
bRetval = true;
}
else if (IsXMLToken(rStrImpValue, XML_TOP))
{
nValue = table::CellVertJustify2::TOP;
rValue <<= nValue;
bRetval = true;
}
else if (IsXMLToken(rStrImpValue, XML_MIDDLE))
{
nValue = table::CellVertJustify2::CENTER;
rValue <<= nValue;
bRetval = true;
}
else if (IsXMLToken(rStrImpValue, XML_JUSTIFY))
{
nValue = table::CellVertJustify2::BLOCK;
rValue <<= nValue;
bRetval = true;
}
return bRetval;
}
bool XmlScPropHdl_VertJustify::exportXML(
OUString& rStrExpValue,
const css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
sal_Int32 nVal(0);
bool bRetval(false);
if(rValue >>= nVal)
{
switch (nVal)
{
case table::CellVertJustify2::BOTTOM :
{
rStrExpValue = GetXMLToken(XML_BOTTOM);
bRetval = true;
}
break;
case table::CellVertJustify2::CENTER :
{
rStrExpValue = GetXMLToken(XML_MIDDLE);
bRetval = true;
}
break;
case table::CellVertJustify2::STANDARD :
{
rStrExpValue = GetXMLToken(XML_AUTOMATIC);
bRetval = true;
}
break;
case table::CellVertJustify2::TOP :
{
rStrExpValue = GetXMLToken(XML_TOP);
bRetval = true;
}
break;
case table::CellVertJustify2::BLOCK :
{
rStrExpValue = GetXMLToken(XML_JUSTIFY);
bRetval = true;
}
break;
default:
{
// added to avoid warnings
}
}
}
return bRetval;
}
XmlScPropHdl_BreakBefore::~XmlScPropHdl_BreakBefore()
{
}
bool XmlScPropHdl_BreakBefore::equals(
const css::uno::Any& r1,
const css::uno::Any& r2 ) const
{
bool aBreak1 = false, aBreak2 = false;
if((r1 >>= aBreak1) && (r2 >>= aBreak2))
return (aBreak1 == aBreak2);
return false;
}
bool XmlScPropHdl_BreakBefore::importXML(
const OUString& rStrImpValue,
css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
bool bRetval(false);
bool bValue;
if (IsXMLToken(rStrImpValue, XML_AUTO))
{
bValue = false;
rValue <<= bValue;
bRetval = true;
}
else if (IsXMLToken(rStrImpValue, XML_PAGE))
{
bValue = true;
rValue <<= bValue;
bRetval = true;
}
return bRetval;
}
bool XmlScPropHdl_BreakBefore::exportXML(
OUString& rStrExpValue,
const css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
bool bRetval(false);
if(::cppu::any2bool(rValue))
{
rStrExpValue = GetXMLToken(XML_PAGE);
bRetval = true;
}
else
{
rStrExpValue = GetXMLToken(XML_AUTO);
bRetval = true;
}
return bRetval;
}
XmlScPropHdl_IsTextWrapped::~XmlScPropHdl_IsTextWrapped()
{
}
bool XmlScPropHdl_IsTextWrapped::equals(
const css::uno::Any& r1,
const css::uno::Any& r2 ) const
{
return (::cppu::any2bool(r1) == ::cppu::any2bool(r2));
}
bool XmlScPropHdl_IsTextWrapped::importXML(
const OUString& rStrImpValue,
css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
bool bRetval(false);
if (IsXMLToken(rStrImpValue, XML_WRAP))
{
rValue <<= true;
bRetval = true;
}
else if (IsXMLToken(rStrImpValue, XML_NO_WRAP))
{
rValue <<= false;
bRetval = true;
}
return bRetval;
}
bool XmlScPropHdl_IsTextWrapped::exportXML(
OUString& rStrExpValue,
const css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
bool bRetval(false);
if (::cppu::any2bool(rValue))
{
rStrExpValue = GetXMLToken(XML_WRAP);
bRetval = true;
}
else
{
rStrExpValue = GetXMLToken(XML_NO_WRAP);
bRetval = true;
}
return bRetval;
}
bool XmlScPropHdl_IsEqual::importXML( const OUString& /* rStrImpValue */,
css::uno::Any& /* rValue */,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
OSL_FAIL("should never be called");
return false;
}
bool XmlScPropHdl_IsEqual::exportXML( OUString& /* rStrExpValue */,
const css::uno::Any& /* rValue */,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
OSL_FAIL("should never be called");
return false;
}
XmlScPropHdl_Vertical::~XmlScPropHdl_Vertical()
{
}
bool XmlScPropHdl_Vertical::equals(
const css::uno::Any& r1,
const css::uno::Any& r2 ) const
{
return (::cppu::any2bool(r1) == ::cppu::any2bool(r2));
}
bool XmlScPropHdl_Vertical::importXML(
const OUString& rStrImpValue,
css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
bool bRetval(false);
if (IsXMLToken(rStrImpValue, XML_AUTO))
{
rValue <<= true;
bRetval = true;
}
else if (IsXMLToken(rStrImpValue, XML_0))
{
rValue <<= false;
bRetval = true;
}
return bRetval;
}
bool XmlScPropHdl_Vertical::exportXML(
OUString& rStrExpValue,
const css::uno::Any& rValue,
const SvXMLUnitConverter& /* rUnitConverter */ ) const
{
bool bRetval(false);
if (::cppu::any2bool(rValue))
{
rStrExpValue = GetXMLToken(XML_AUTO);
bRetval = true;
}
else
{
rStrExpValue = GetXMLToken(XML_0);
bRetval = true;
}
return bRetval;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V560 A part of conditional expression is always false: aCellProtection.IsHidden.
↑ V1019 Compound assignment expression 'pPadding_Left->maValue >>= nLeft' is used inside condition.
↑ V1019 Compound assignment expression 'pPadding_Right->maValue >>= nRight' is used inside condition.
↑ V1019 Compound assignment expression 'pPadding_Top->maValue >>= nTop' is used inside condition.
↑ V1019 Compound assignment expression 'rProperty.maValue >>= sURL' is used inside condition.
↑ V560 A part of conditional expression is always false: aCellProtection.IsHidden.
↑ V1019 Compound assignment expression 'r2 >>= aAngle2' is used inside condition.
↑ V1019 Compound assignment expression 'r2 >>= aReference2' is used inside condition.
↑ V1019 Compound assignment expression 'r2 >>= aReference2' is used inside condition.
↑ V1019 Compound assignment expression 'r2 >>= aCellProtection2' is used inside condition.
↑ V1019 Compound assignment expression 'r2 >>= aOrientation2' is used inside condition.
↑ V1019 Compound assignment expression 'r2 >>= aHoriJustify2' is used inside condition.
↑ V1019 Compound assignment expression 'r2 >>= aHoriJustify2' is used inside condition.
↑ V1019 Compound assignment expression 'r2 >>= aHoriJustify2' is used inside condition.
↑ V1019 Compound assignment expression 'r2 >>= nVal2' is used inside condition.
↑ V1019 Compound assignment expression 'r2 >>= aCellProtection2' is used inside condition.
↑ V1019 Compound assignment expression 'r2 >>= aBreak2' is used inside condition.