| /************************************************************** |
| * |
| * 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 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sc.hxx" |
| |
| |
| #include "xmlstyle.hxx" |
| #include "xmlexprt.hxx" |
| #include "xmlimprt.hxx" |
| |
| #include "XMLConverter.hxx" |
| #include "rangeutl.hxx" |
| |
| #include <xmloff/xmlnmspe.hxx> |
| #include <xmloff/xmluconv.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 <tools/debug.hxx> |
| #include <com/sun/star/util/CellProtection.hpp> |
| #include <com/sun/star/table/CellOrientation.hpp> |
| #include <com/sun/star/table/CellVertJustify.hpp> |
| #include <com/sun/star/table/CellHoriJustify.hpp> |
| #include <com/sun/star/table/TableBorder.hpp> |
| #include <com/sun/star/sheet/XSheetConditionalEntries.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; |
| using ::rtl::OUString; |
| |
| #define MAP(name,prefix,token,type,context) { name, sizeof(name)-1, prefix, token, static_cast<sal_Int32>(type), context, SvtSaveOptions::ODFVER_010 } |
| #define MAP_EXT(name,prefix,token,type,context) { name, sizeof(name)-1, prefix, token, type, context, SvtSaveOptions::ODFVER_LATEST } |
| #define MAP_END() { NULL, 0, 0, XML_TOKEN_INVALID, 0, 0, SvtSaveOptions::ODFVER_010 } |
| |
| 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( "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( "ParaIsHyphenation", XML_NAMESPACE_FO, XML_HYPHENATE, XML_TYPE_PROP_TEXT|XML_TYPE_BOOL, 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( "WritingMode", XML_NAMESPACE_STYLE, XML_WRITING_MODE, XML_TYPE_PROP_PARAGRAPH|XML_TYPE_TEXT_WRITING_MODE_WITH_DEFAULT, 0 ), |
| 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( "OptimalWidth", XML_NAMESPACE_STYLE, XML_USE_OPTIMAL_COLUMN_WIDTH, XML_TYPE_PROP_TABLE_COLUMN|XML_TYPE_BOOL, 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 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 UniReference< XMLPropertySetMapper >& rMapper ) |
| : SvXMLExportPropertyMapper(rMapper) |
| { |
| } |
| |
| ScXMLCellExportPropertyMapper::~ScXMLCellExportPropertyMapper() |
| { |
| } |
| |
| void ScXMLCellExportPropertyMapper::ContextFilter( |
| ::std::vector< XMLPropertyState >& rProperties, |
| uno::Reference< beans::XPropertySet > rPropSet ) const |
| { |
| XMLPropertyState* pPadding = NULL; |
| XMLPropertyState* pPadding_Bottom = NULL; |
| XMLPropertyState* pPadding_Left = NULL; |
| XMLPropertyState* pPadding_Right = NULL; |
| XMLPropertyState* pPadding_Top = NULL; |
| |
| XMLPropertyState* pBorder = NULL; |
| XMLPropertyState* pBorder_Bottom = NULL; |
| XMLPropertyState* pBorder_Left = NULL; |
| XMLPropertyState* pBorder_Right = NULL; |
| XMLPropertyState* pBorder_Top = NULL; |
| XMLPropertyState* pSWBorder = NULL; |
| XMLPropertyState* pSWBorder_Bottom = NULL; |
| XMLPropertyState* pSWBorder_Left = NULL; |
| XMLPropertyState* pSWBorder_Right = NULL; |
| XMLPropertyState* pSWBorder_Top = NULL; |
| XMLPropertyState* pDiagonalTLBR = NULL; |
| XMLPropertyState* pDiagonalBLTR = NULL; |
| |
| XMLPropertyState* pAllBorderWidthState = NULL; |
| XMLPropertyState* pLeftBorderWidthState = NULL; |
| XMLPropertyState* pRightBorderWidthState = NULL; |
| XMLPropertyState* pTopBorderWidthState = NULL; |
| XMLPropertyState* pBottomBorderWidthState = NULL; |
| XMLPropertyState* pSWAllBorderWidthState = NULL; |
| XMLPropertyState* pSWLeftBorderWidthState = NULL; |
| XMLPropertyState* pSWRightBorderWidthState = NULL; |
| XMLPropertyState* pSWTopBorderWidthState = NULL; |
| XMLPropertyState* pSWBottomBorderWidthState = NULL; |
| XMLPropertyState* pDiagonalTLBRWidthState = NULL; |
| XMLPropertyState* pDiagonalBLTRWidthState = NULL; |
| |
| XMLPropertyState* pParaMarginLeft = NULL; |
| XMLPropertyState* pParaMarginLeftRel = NULL; |
| XMLPropertyState* pParaMarginRight = NULL; |
| XMLPropertyState* pParaMarginRightRel = NULL; |
| XMLPropertyState* pParaMarginTop = NULL; |
| XMLPropertyState* pParaMarginTopRel = NULL; |
| XMLPropertyState* pParaMarginBottom = NULL; |
| XMLPropertyState* pParaMarginBottomRel = NULL; |
| |
| XMLPropertyState* pParaAdjust = NULL; |
| XMLPropertyState* pParaAdjustLast = NULL; |
| |
| ::std::vector< XMLPropertyState >::iterator aEndIter(rProperties.end()); |
| for( ::std::vector< XMLPropertyState >::iterator aIter = rProperties.begin(); |
| aIter != aEndIter; ++aIter ) |
| { |
| XMLPropertyState* propertie = &(*aIter); |
| if (propertie->mnIndex != -1) |
| { |
| switch( getPropertySetMapper()->GetEntryContextId( propertie->mnIndex ) ) |
| { |
| case CTF_SC_ALLPADDING: pPadding = propertie; break; |
| case CTF_SC_BOTTOMPADDING: pPadding_Bottom = propertie; break; |
| case CTF_SC_LEFTPADDING: pPadding_Left = propertie; break; |
| case CTF_SC_RIGHTPADDING: pPadding_Right = propertie; break; |
| case CTF_SC_TOPPADDING: pPadding_Top = propertie; break; |
| case CTF_SC_ALLBORDER: pBorder = propertie; break; |
| case CTF_SC_LEFTBORDER: pBorder_Left = propertie; break; |
| case CTF_SC_RIGHTBORDER: pBorder_Right = propertie; break; |
| case CTF_SC_BOTTOMBORDER: pBorder_Bottom = propertie; break; |
| case CTF_SC_TOPBORDER: pBorder_Top = propertie; break; |
| case CTF_SC_ALLBORDERWIDTH: pAllBorderWidthState = propertie; break; |
| case CTF_SC_LEFTBORDERWIDTH: pLeftBorderWidthState = propertie; break; |
| case CTF_SC_RIGHTBORDERWIDTH: pRightBorderWidthState = propertie; break; |
| case CTF_SC_TOPBORDERWIDTH: pTopBorderWidthState = propertie; break; |
| case CTF_SC_BOTTOMBORDERWIDTH: pBottomBorderWidthState = propertie; break; |
| case CTF_ALLBORDER: pSWBorder = propertie; break; |
| case CTF_LEFTBORDER: pSWBorder_Left = propertie; break; |
| case CTF_RIGHTBORDER: pSWBorder_Right = propertie; break; |
| case CTF_BOTTOMBORDER: pSWBorder_Bottom = propertie; break; |
| case CTF_TOPBORDER: pSWBorder_Top = propertie; break; |
| case CTF_ALLBORDERWIDTH: pSWAllBorderWidthState = propertie; break; |
| case CTF_LEFTBORDERWIDTH: pSWLeftBorderWidthState = propertie; break; |
| case CTF_RIGHTBORDERWIDTH: pSWRightBorderWidthState = propertie; break; |
| case CTF_TOPBORDERWIDTH: pSWTopBorderWidthState = propertie; break; |
| case CTF_BOTTOMBORDERWIDTH: pSWBottomBorderWidthState = propertie; break; |
| case CTF_SC_DIAGONALTLBR: pDiagonalTLBR = propertie; break; |
| case CTF_SC_DIAGONALTLBRWIDTH: pDiagonalTLBRWidthState = propertie; break; |
| case CTF_SC_DIAGONALBLTR: pDiagonalBLTR = propertie; break; |
| case CTF_SC_DIAGONALBLTRWIDTH: pDiagonalBLTRWidthState = propertie; break; |
| case CTF_SD_SHAPE_PARA_ADJUST: pParaAdjust = propertie; break; |
| case CTF_PARA_ADJUSTLAST: pParaAdjustLast = propertie; break; |
| case CTF_PARALEFTMARGIN: pParaMarginLeft = propertie; break; |
| case CTF_PARALEFTMARGIN_REL: pParaMarginLeftRel = propertie; break; |
| case CTF_PARARIGHTMARGIN: pParaMarginRight = propertie; break; |
| case CTF_PARARIGHTMARGIN_REL: pParaMarginRightRel = propertie; break; |
| case CTF_PARATOPMARGIN: pParaMarginTop = propertie; break; |
| case CTF_PARATOPMARGIN_REL: pParaMarginTopRel = propertie; break; |
| case CTF_PARABOTTOMMARGIN: pParaMarginBottom = propertie; break; |
| case CTF_PARABOTTOMMARGIN_REL: pParaMarginBottomRel = propertie; 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::BorderLine 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 ) |
| { |
| 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::BorderLine 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 ) |
| { |
| 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(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 |
| } |
| |
| ScXMLRowExportPropertyMapper::ScXMLRowExportPropertyMapper( |
| const UniReference< XMLPropertySetMapper >& rMapper ) |
| : SvXMLExportPropertyMapper(rMapper) |
| { |
| } |
| |
| ScXMLRowExportPropertyMapper::~ScXMLRowExportPropertyMapper() |
| { |
| } |
| |
| void ScXMLRowExportPropertyMapper::ContextFilter( |
| ::std::vector< XMLPropertyState >& /* rProperties */, |
| uno::Reference< beans::XPropertySet > /* rPropSet */ ) const |
| { |
| //#108550#; don't filter the height, so other applications know the calculated height |
| |
| /* XMLPropertyState* pHeight = NULL; |
| XMLPropertyState* pOptimalHeight = NULL; |
| |
| for( ::std::vector< XMLPropertyState >::iterator propertie = rProperties.begin(); |
| propertie != rProperties.end(); |
| ++propertie ) |
| { |
| switch( getPropertySetMapper()->GetEntryContextId( propertie->mnIndex ) ) |
| { |
| case CTF_SC_ROWHEIGHT: pHeight = propertie; break; |
| case CTF_SC_ROWOPTIMALHEIGHT: pOptimalHeight = propertie; break; |
| } |
| } |
| if ((pHeight && pOptimalHeight && ::cppu::any2bool( pOptimalHeight->maValue )) || |
| (pHeight && !pOptimalHeight)) |
| { |
| pHeight->mnIndex = -1; |
| pHeight->maValue.clear(); |
| } |
| if (pOptimalHeight) |
| { |
| pOptimalHeight->mnIndex = -1; |
| pOptimalHeight->maValue.clear(); |
| }*/ |
| } |
| |
| ScXMLColumnExportPropertyMapper::ScXMLColumnExportPropertyMapper( |
| const UniReference< 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 UniReference< 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()); |
| while (i != endi) |
| { |
| UniReference< 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) |
| { |
| rtl::OUString sAttrValue(rScXMLExport.getDataStyleName(nNumberFormat)); |
| if (sAttrValue.getLength()) |
| { |
| GetExport().AddAttribute( |
| aPropMapper->GetEntryNameSpace(i->mnIndex), |
| aPropMapper->GetEntryXMLName(i->mnIndex), |
| sAttrValue ); |
| } |
| } |
| } |
| break; |
| } |
| ++i; |
| } |
| } |
| else if (nFamily == XML_STYLE_FAMILY_TABLE_TABLE) |
| { |
| ::std::vector< XMLPropertyState >::const_iterator i(rProperties.begin()); |
| ::std::vector< XMLPropertyState >::const_iterator endi(rProperties.end()); |
| while(i != endi) |
| { |
| UniReference< XMLPropertySetMapper > aPropMapper(rScXMLExport.GetTableStylesPropertySetMapper()); |
| sal_Int16 nContextID(aPropMapper->GetEntryContextId(i->mnIndex)); |
| switch (nContextID) |
| { |
| case CTF_SC_MASTERPAGENAME : |
| { |
| rtl::OUString sName; |
| if (i->maValue >>= sName) |
| { |
| GetExport().AddAttribute( |
| aPropMapper->GetEntryNameSpace(i->mnIndex), |
| aPropMapper->GetEntryXMLName(i->mnIndex), |
| GetExport().EncodeStyleName( sName )); |
| } |
| } |
| break; |
| } |
| ++i; |
| } |
| } |
| } |
| |
| void ScXMLAutoStylePoolP::exportStyleContent( |
| const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XDocumentHandler > & rHandler, |
| sal_Int32 nFamily, |
| const std::vector< XMLPropertyState >& rProperties, |
| const SvXMLExportPropertyMapper& rPropExp |
| , const SvXMLUnitConverter& rUnitConverter, |
| const SvXMLNamespaceMap& rNamespaceMap |
| ) const |
| { |
| SvXMLAutoStylePoolP::exportStyleContent( rHandler, nFamily, rProperties, rPropExp, rUnitConverter, rNamespaceMap ); |
| if (nFamily == XML_STYLE_FAMILY_TABLE_CELL) |
| { |
| sal_Bool bNotFound = sal_True; |
| ::std::vector< XMLPropertyState >::const_iterator i(rProperties.begin()); |
| ::std::vector< XMLPropertyState >::const_iterator endi(rProperties.end()); |
| while ((i != endi) && bNotFound) |
| { |
| 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()) |
| { |
| rtl::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) |
| { |
| rtl::OUString sCondition(RTL_CONSTASCII_USTRINGPARAM("is-true-formula(")); |
| sCondition += xSheetCondition->getFormula1(); |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(")")); |
| 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, sal_True, sal_True); |
| } |
| else |
| { |
| rtl::OUString sCondition; |
| if (aOperator == sheet::ConditionOperator_BETWEEN || |
| aOperator == sheet::ConditionOperator_NOT_BETWEEN) |
| { |
| if (aOperator == sheet::ConditionOperator_BETWEEN) |
| sCondition = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("cell-content-is-between(")); |
| else |
| sCondition = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("cell-content-is-not-between(")); |
| sCondition += xSheetCondition->getFormula1(); |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(",")); |
| sCondition += xSheetCondition->getFormula2(); |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(")")); |
| } |
| else |
| { |
| sCondition = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("cell-content()")); |
| switch (aOperator) |
| { |
| case sheet::ConditionOperator_LESS: |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("<")); |
| break; |
| case sheet::ConditionOperator_GREATER: |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(">")); |
| break; |
| case sheet::ConditionOperator_LESS_EQUAL: |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("<=")); |
| break; |
| case sheet::ConditionOperator_GREATER_EQUAL: |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(">=")); |
| break; |
| case sheet::ConditionOperator_EQUAL: |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("=")); |
| break; |
| case sheet::ConditionOperator_NOT_EQUAL: |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("!=")); |
| 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, sal_True, sal_True); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| break; |
| } |
| } |
| ++i; |
| } |
| } |
| } |
| |
| ScXMLAutoStylePoolP::ScXMLAutoStylePoolP(ScXMLExport& rTempScXMLExport): |
| SvXMLAutoStylePoolP(rTempScXMLExport), |
| rScXMLExport(rTempScXMLExport) |
| { |
| } |
| |
| ScXMLAutoStylePoolP::~ScXMLAutoStylePoolP() |
| { |
| } |
| |
| |
| void ScXMLStyleExport::exportStyleAttributes( |
| const ::com::sun::star::uno::Reference< |
| ::com::sun::star::style::XStyle > & rStyle ) |
| { |
| uno::Reference< beans::XPropertySet > xPropSet( rStyle, uno::UNO_QUERY ); |
| if (xPropSet.is()) |
| { |
| uno::Reference< beans::XPropertySetInfo > xPropSetInfo(xPropSet->getPropertySetInfo()); |
| rtl::OUString sNumberFormat(RTL_CONSTASCII_USTRINGPARAM("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 ::com::sun::star::uno::Reference< |
| ::com::sun::star::style::XStyle > & /* rStyle */ ) |
| { |
| } |
| |
| ScXMLStyleExport::ScXMLStyleExport( |
| SvXMLExport& rExp, |
| const ::rtl::OUString& rPoolStyleName, |
| SvXMLAutoStylePoolP *pAutoStyleP ) |
| : XMLStyleExport(rExp, rPoolStyleName, pAutoStyleP) |
| { |
| } |
| |
| ScXMLStyleExport::~ScXMLStyleExport() |
| { |
| } |
| |
| XMLScPropHdlFactory::XMLScPropHdlFactory() |
| : XMLPropertyHandlerFactory() |
| { |
| } |
| |
| XMLScPropHdlFactory::~XMLScPropHdlFactory() |
| { |
| } |
| |
| const XMLPropertyHandler* XMLScPropHdlFactory::GetPropertyHandler( sal_Int32 nType ) const |
| { |
| nType &= MID_FLAG_MASK; |
| |
| XMLPropertyHandler* pHdl((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 : |
| { |
| 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 ::com::sun::star::uno::Any& r1, |
| const ::com::sun::star::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 sal_False; |
| } |
| |
| sal_Bool XmlScPropHdl_CellProtection::importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| sal_Bool bRetval(sal_False); |
| |
| util::CellProtection aCellProtection; |
| sal_Bool bDefault(sal_False); |
| if (!rValue.hasValue()) |
| { |
| aCellProtection.IsHidden = sal_False; |
| aCellProtection.IsLocked = sal_True; |
| aCellProtection.IsFormulaHidden = sal_False; |
| aCellProtection.IsPrintHidden = sal_False; |
| bDefault = sal_True; |
| } |
| if ((rValue >>= aCellProtection) || bDefault) |
| { |
| if (!IsXMLToken(rStrImpValue, XML_NONE)) |
| { |
| if (!IsXMLToken(rStrImpValue, XML_HIDDEN_AND_PROTECTED)) |
| { |
| if (!IsXMLToken(rStrImpValue, XML_PROTECTED)) |
| { |
| if (!IsXMLToken(rStrImpValue, XML_FORMULA_HIDDEN)) |
| { |
| sal_Int16 i(0); |
| while (i < rStrImpValue.getLength() && rStrImpValue[i] != ' ') |
| ++i; |
| rtl::OUString sFirst(rStrImpValue.copy(0, i)); |
| rtl::OUString sSecond(rStrImpValue.copy(i + 1)); |
| aCellProtection.IsFormulaHidden = sal_False; |
| aCellProtection.IsHidden = sal_False; |
| aCellProtection.IsLocked = sal_False; |
| if ((IsXMLToken(sFirst, XML_PROTECTED)) || (IsXMLToken(sSecond, XML_PROTECTED))) |
| aCellProtection.IsLocked = sal_True; |
| if ((IsXMLToken(sFirst, XML_FORMULA_HIDDEN)) || (IsXMLToken(sSecond, XML_FORMULA_HIDDEN))) |
| aCellProtection.IsFormulaHidden = sal_True; |
| rValue <<= aCellProtection; |
| bRetval = sal_True; |
| } |
| else |
| { |
| aCellProtection.IsFormulaHidden = sal_True; |
| aCellProtection.IsHidden = sal_False; |
| aCellProtection.IsLocked = sal_False; |
| rValue <<= aCellProtection; |
| bRetval = sal_True; |
| } |
| } |
| else |
| { |
| aCellProtection.IsFormulaHidden = sal_False; |
| aCellProtection.IsHidden = sal_False; |
| aCellProtection.IsLocked = sal_True; |
| rValue <<= aCellProtection; |
| bRetval = sal_True; |
| } |
| } |
| else |
| { |
| aCellProtection.IsFormulaHidden = sal_True; |
| aCellProtection.IsHidden = sal_True; |
| aCellProtection.IsLocked = sal_True; |
| rValue <<= aCellProtection; |
| bRetval = sal_True; |
| } |
| } |
| else |
| { |
| aCellProtection.IsFormulaHidden = sal_False; |
| aCellProtection.IsHidden = sal_False; |
| aCellProtection.IsLocked = sal_False; |
| rValue <<= aCellProtection; |
| bRetval = sal_True; |
| } |
| } |
| |
| return bRetval; |
| } |
| |
| sal_Bool XmlScPropHdl_CellProtection::exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| sal_Bool bRetval(sal_False); |
| util::CellProtection aCellProtection; |
| |
| if(rValue >>= aCellProtection) |
| { |
| if (!(aCellProtection.IsFormulaHidden || aCellProtection.IsHidden || aCellProtection.IsLocked)) |
| { |
| rStrExpValue = GetXMLToken(XML_NONE); |
| bRetval = sal_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 = sal_True; |
| } |
| else if (aCellProtection.IsLocked && !(aCellProtection.IsFormulaHidden || aCellProtection.IsHidden)) |
| { |
| rStrExpValue = GetXMLToken(XML_PROTECTED); |
| bRetval = sal_True; |
| } |
| else if (aCellProtection.IsFormulaHidden && !(aCellProtection.IsLocked || aCellProtection.IsHidden)) |
| { |
| rStrExpValue = GetXMLToken(XML_FORMULA_HIDDEN); |
| bRetval = sal_True; |
| } |
| else if (aCellProtection.IsFormulaHidden && aCellProtection.IsLocked) |
| { |
| rStrExpValue = GetXMLToken(XML_PROTECTED); |
| rStrExpValue += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" ")); |
| rStrExpValue += GetXMLToken(XML_FORMULA_HIDDEN); |
| bRetval = sal_True; |
| } |
| } |
| |
| return bRetval; |
| } |
| |
| XmlScPropHdl_PrintContent::~XmlScPropHdl_PrintContent() |
| { |
| } |
| |
| bool XmlScPropHdl_PrintContent::equals( |
| const ::com::sun::star::uno::Any& r1, |
| const ::com::sun::star::uno::Any& r2 ) const |
| { |
| util::CellProtection aCellProtection1, aCellProtection2; |
| |
| if((r1 >>= aCellProtection1) && (r2 >>= aCellProtection2)) |
| { |
| return (aCellProtection1.IsPrintHidden == aCellProtection2.IsPrintHidden); |
| } |
| return sal_False; |
| } |
| |
| sal_Bool XmlScPropHdl_PrintContent::importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| sal_Bool bRetval(sal_False); |
| util::CellProtection aCellProtection; |
| sal_Bool bDefault(sal_False); |
| if (!rValue.hasValue()) |
| { |
| aCellProtection.IsHidden = sal_False; |
| aCellProtection.IsLocked = sal_True; |
| aCellProtection.IsFormulaHidden = sal_False; |
| aCellProtection.IsPrintHidden = sal_False; |
| bDefault = sal_True; |
| } |
| if ((rValue >>= aCellProtection) || bDefault) |
| { |
| sal_Bool bValue; |
| if (SvXMLUnitConverter::convertBool(bValue, rStrImpValue)) |
| { |
| aCellProtection.IsPrintHidden = !bValue; |
| rValue <<= aCellProtection; |
| bRetval = sal_True; |
| } |
| } |
| |
| return bRetval; |
| } |
| |
| sal_Bool XmlScPropHdl_PrintContent::exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| sal_Bool bRetval(sal_False); |
| |
| util::CellProtection aCellProtection; |
| if(rValue >>= aCellProtection) |
| { |
| rtl::OUStringBuffer sValue; |
| SvXMLUnitConverter::convertBool(sValue, !aCellProtection.IsPrintHidden); |
| rStrExpValue = sValue.makeStringAndClear(); |
| bRetval = sal_True; |
| } |
| |
| return bRetval; |
| } |
| |
| XmlScPropHdl_HoriJustify::~XmlScPropHdl_HoriJustify() |
| { |
| } |
| |
| bool XmlScPropHdl_HoriJustify::equals( |
| const ::com::sun::star::uno::Any& r1, |
| const ::com::sun::star::uno::Any& r2 ) const |
| { |
| table::CellHoriJustify aHoriJustify1, aHoriJustify2; |
| |
| if((r1 >>= aHoriJustify1) && (r2 >>= aHoriJustify2)) |
| return (aHoriJustify1 == aHoriJustify2); |
| return sal_False; |
| } |
| |
| sal_Bool XmlScPropHdl_HoriJustify::importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| sal_Bool bRetval(sal_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 = sal_True; |
| } |
| else if (IsXMLToken(rStrImpValue, XML_END)) |
| { |
| nValue = table::CellHoriJustify_RIGHT; |
| rValue <<= nValue; |
| bRetval = sal_True; |
| } |
| else if (IsXMLToken(rStrImpValue, XML_CENTER)) |
| { |
| nValue = table::CellHoriJustify_CENTER; |
| rValue <<= nValue; |
| bRetval = sal_True; |
| } |
| else if (IsXMLToken(rStrImpValue, XML_JUSTIFY)) |
| { |
| nValue = table::CellHoriJustify_BLOCK; |
| rValue <<= nValue; |
| bRetval = sal_True; |
| } |
| } |
| else |
| bRetval = sal_True; |
| |
| return bRetval; |
| } |
| |
| sal_Bool XmlScPropHdl_HoriJustify::exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| table::CellHoriJustify nVal; |
| sal_Bool bRetval(sal_False); |
| |
| if(rValue >>= nVal) |
| { |
| switch (nVal) |
| { |
| case table::CellHoriJustify_REPEAT: |
| case table::CellHoriJustify_LEFT: |
| { |
| rStrExpValue = GetXMLToken(XML_START); |
| bRetval = sal_True; |
| } |
| break; |
| case table::CellHoriJustify_RIGHT: |
| { |
| rStrExpValue = GetXMLToken(XML_END); |
| bRetval = sal_True; |
| } |
| break; |
| case table::CellHoriJustify_CENTER: |
| { |
| rStrExpValue = GetXMLToken(XML_CENTER); |
| bRetval = sal_True; |
| } |
| break; |
| case table::CellHoriJustify_BLOCK: |
| { |
| rStrExpValue = GetXMLToken(XML_JUSTIFY); |
| bRetval = sal_True; |
| } |
| break; |
| default: |
| { |
| // added to avoid warnings |
| } |
| } |
| } |
| |
| return bRetval; |
| } |
| |
| XmlScPropHdl_HoriJustifySource::~XmlScPropHdl_HoriJustifySource() |
| { |
| } |
| |
| bool XmlScPropHdl_HoriJustifySource::equals( |
| const ::com::sun::star::uno::Any& r1, |
| const ::com::sun::star::uno::Any& r2 ) const |
| { |
| table::CellHoriJustify aHoriJustify1, aHoriJustify2; |
| |
| if((r1 >>= aHoriJustify1) && (r2 >>= aHoriJustify2)) |
| return (aHoriJustify1 == aHoriJustify2); |
| return sal_False; |
| } |
| |
| sal_Bool XmlScPropHdl_HoriJustifySource::importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| sal_Bool bRetval(sal_False); |
| |
| if (IsXMLToken(rStrImpValue, XML_FIX)) |
| { |
| bRetval = sal_True; |
| } |
| else if (IsXMLToken(rStrImpValue, XML_VALUE_TYPE)) |
| { |
| table::CellHoriJustify nValue(table::CellHoriJustify_STANDARD); |
| rValue <<= nValue; |
| bRetval = sal_True; |
| } |
| |
| return bRetval; |
| } |
| |
| sal_Bool XmlScPropHdl_HoriJustifySource::exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| table::CellHoriJustify nVal; |
| sal_Bool bRetval(sal_False); |
| |
| if(rValue >>= nVal) |
| { |
| if (nVal == table::CellHoriJustify_STANDARD) |
| { |
| rStrExpValue = GetXMLToken(XML_VALUE_TYPE); |
| bRetval = sal_True; |
| } |
| else |
| { |
| rStrExpValue = GetXMLToken(XML_FIX); |
| bRetval = sal_True; |
| } |
| } |
| |
| return bRetval; |
| } |
| |
| XmlScPropHdl_HoriJustifyRepeat::~XmlScPropHdl_HoriJustifyRepeat() |
| { |
| } |
| |
| bool XmlScPropHdl_HoriJustifyRepeat::equals( |
| const ::com::sun::star::uno::Any& r1, |
| const ::com::sun::star::uno::Any& r2 ) const |
| { |
| table::CellHoriJustify aHoriJustify1, aHoriJustify2; |
| |
| if((r1 >>= aHoriJustify1) && (r2 >>= aHoriJustify2)) |
| return (aHoriJustify1 == aHoriJustify2); |
| return sal_False; |
| } |
| |
| sal_Bool XmlScPropHdl_HoriJustifyRepeat::importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| sal_Bool bRetval(sal_False); |
| |
| if (IsXMLToken(rStrImpValue, XML_FALSE)) |
| { |
| bRetval = sal_True; |
| } |
| else if (IsXMLToken(rStrImpValue, XML_TRUE)) |
| { |
| table::CellHoriJustify nValue = table::CellHoriJustify_REPEAT; |
| rValue <<= nValue; |
| bRetval = sal_True; |
| } |
| |
| return bRetval; |
| } |
| |
| sal_Bool XmlScPropHdl_HoriJustifyRepeat::exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| table::CellHoriJustify nVal; |
| sal_Bool bRetval(sal_False); |
| |
| if(rValue >>= nVal) |
| { |
| if (nVal == table::CellHoriJustify_REPEAT) |
| { |
| rStrExpValue = GetXMLToken(XML_TRUE); |
| bRetval = sal_True; |
| } |
| else |
| { |
| rStrExpValue = GetXMLToken(XML_FALSE); |
| bRetval = sal_True; |
| } |
| } |
| |
| return bRetval; |
| } |
| |
| XmlScPropHdl_Orientation::~XmlScPropHdl_Orientation() |
| { |
| } |
| |
| bool XmlScPropHdl_Orientation::equals( |
| const ::com::sun::star::uno::Any& r1, |
| const ::com::sun::star::uno::Any& r2 ) const |
| { |
| table::CellOrientation aOrientation1, aOrientation2; |
| |
| if((r1 >>= aOrientation1) && (r2 >>= aOrientation2)) |
| return (aOrientation1 == aOrientation2); |
| return sal_False; |
| } |
| |
| sal_Bool XmlScPropHdl_Orientation::importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| sal_Bool bRetval(sal_False); |
| |
| table::CellOrientation nValue; |
| if (IsXMLToken(rStrImpValue, XML_LTR)) |
| { |
| nValue = table::CellOrientation_STANDARD; |
| rValue <<= nValue; |
| bRetval = sal_True; |
| } |
| else if (IsXMLToken(rStrImpValue, XML_TTB)) |
| { |
| nValue = table::CellOrientation_STACKED; |
| rValue <<= nValue; |
| bRetval = sal_True; |
| } |
| |
| return bRetval; |
| } |
| |
| sal_Bool XmlScPropHdl_Orientation::exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| table::CellOrientation nVal; |
| sal_Bool bRetval(sal_False); |
| |
| if(rValue >>= nVal) |
| { |
| switch (nVal) |
| { |
| case table::CellOrientation_STACKED : |
| { |
| rStrExpValue = GetXMLToken(XML_TTB); |
| bRetval = sal_True; |
| } |
| break; |
| default: |
| { |
| rStrExpValue = GetXMLToken(XML_LTR); |
| bRetval = sal_True; |
| } |
| break; |
| } |
| } |
| |
| return bRetval; |
| } |
| |
| XmlScPropHdl_RotateAngle::~XmlScPropHdl_RotateAngle() |
| { |
| } |
| |
| bool XmlScPropHdl_RotateAngle::equals( |
| const ::com::sun::star::uno::Any& r1, |
| const ::com::sun::star::uno::Any& r2 ) const |
| { |
| sal_Int32 aAngle1 = 0, aAngle2 = 0; |
| |
| if((r1 >>= aAngle1) && (r2 >>= aAngle2)) |
| return (aAngle1 == aAngle2); |
| return sal_False; |
| } |
| |
| sal_Bool XmlScPropHdl_RotateAngle::importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| sal_Bool bRetval(sal_False); |
| |
| sal_Int32 nValue; |
| if (SvXMLUnitConverter::convertNumber(nValue, rStrImpValue)) |
| { |
| nValue *= 100; |
| rValue <<= nValue; |
| bRetval = sal_True; |
| } |
| |
| return bRetval; |
| } |
| |
| sal_Bool XmlScPropHdl_RotateAngle::exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| sal_Int32 nVal = 0; |
| sal_Bool bRetval(sal_False); |
| |
| if(rValue >>= nVal) |
| { |
| rtl::OUStringBuffer sValue; |
| SvXMLUnitConverter::convertNumber(sValue, sal_Int32(nVal / 100)); |
| rStrExpValue = sValue.makeStringAndClear(); |
| bRetval = sal_True; |
| } |
| |
| return bRetval; |
| } |
| |
| XmlScPropHdl_RotateReference::~XmlScPropHdl_RotateReference() |
| { |
| } |
| |
| bool XmlScPropHdl_RotateReference::equals( |
| const ::com::sun::star::uno::Any& r1, |
| const ::com::sun::star::uno::Any& r2 ) const |
| { |
| table::CellVertJustify aReference1, aReference2; |
| |
| if((r1 >>= aReference1) && (r2 >>= aReference2)) |
| return (aReference1 == aReference2); |
| return sal_False; |
| } |
| |
| sal_Bool XmlScPropHdl_RotateReference::importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| sal_Bool bRetval(sal_False); |
| |
| table::CellVertJustify nValue; |
| if (IsXMLToken(rStrImpValue, XML_NONE)) |
| { |
| nValue = table::CellVertJustify_STANDARD; |
| rValue <<= nValue; |
| bRetval = sal_True; |
| } |
| else if (IsXMLToken(rStrImpValue, XML_BOTTOM)) |
| { |
| nValue = table::CellVertJustify_BOTTOM; |
| rValue <<= nValue; |
| bRetval = sal_True; |
| } |
| else if (IsXMLToken(rStrImpValue, XML_TOP)) |
| { |
| nValue = table::CellVertJustify_TOP; |
| rValue <<= nValue; |
| bRetval = sal_True; |
| } |
| else if (IsXMLToken(rStrImpValue, XML_CENTER)) |
| { |
| nValue = table::CellVertJustify_CENTER; |
| rValue <<= nValue; |
| bRetval = sal_True; |
| } |
| |
| return bRetval; |
| } |
| |
| sal_Bool XmlScPropHdl_RotateReference::exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| table::CellVertJustify nVal; |
| sal_Bool bRetval(sal_False); |
| |
| if(rValue >>= nVal) |
| { |
| switch (nVal) |
| { |
| case table::CellVertJustify_BOTTOM : |
| { |
| rStrExpValue = GetXMLToken(XML_BOTTOM); |
| bRetval = sal_True; |
| } |
| break; |
| case table::CellVertJustify_CENTER : |
| { |
| rStrExpValue = GetXMLToken(XML_CENTER); |
| bRetval = sal_True; |
| } |
| break; |
| case table::CellVertJustify_STANDARD : |
| { |
| rStrExpValue = GetXMLToken(XML_NONE); |
| bRetval = sal_True; |
| } |
| break; |
| case table::CellVertJustify_TOP : |
| { |
| rStrExpValue = GetXMLToken(XML_TOP); |
| bRetval = sal_True; |
| } |
| break; |
| default: |
| { |
| // added to avoid warnings |
| } |
| } |
| } |
| |
| return bRetval; |
| } |
| |
| XmlScPropHdl_VertJustify::~XmlScPropHdl_VertJustify() |
| { |
| } |
| |
| bool XmlScPropHdl_VertJustify::equals( |
| const ::com::sun::star::uno::Any& r1, |
| const ::com::sun::star::uno::Any& r2 ) const |
| { |
| table::CellVertJustify aReference1, aReference2; |
| |
| if((r1 >>= aReference1) && (r2 >>= aReference2)) |
| return (aReference1 == aReference2); |
| return sal_False; |
| } |
| |
| sal_Bool XmlScPropHdl_VertJustify::importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| sal_Bool bRetval(sal_False); |
| |
| table::CellVertJustify nValue; |
| if (IsXMLToken(rStrImpValue, XML_AUTOMATIC)) |
| { |
| nValue = table::CellVertJustify_STANDARD; |
| rValue <<= nValue; |
| bRetval = sal_True; |
| } |
| else if (IsXMLToken(rStrImpValue, XML_BOTTOM)) |
| { |
| nValue = table::CellVertJustify_BOTTOM; |
| rValue <<= nValue; |
| bRetval = sal_True; |
| } |
| else if (IsXMLToken(rStrImpValue, XML_TOP)) |
| { |
| nValue = table::CellVertJustify_TOP; |
| rValue <<= nValue; |
| bRetval = sal_True; |
| } |
| else if (IsXMLToken(rStrImpValue, XML_MIDDLE)) |
| { |
| nValue = table::CellVertJustify_CENTER; |
| rValue <<= nValue; |
| bRetval = sal_True; |
| } |
| |
| return bRetval; |
| } |
| |
| sal_Bool XmlScPropHdl_VertJustify::exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| table::CellVertJustify nVal; |
| sal_Bool bRetval(sal_False); |
| |
| if(rValue >>= nVal) |
| { |
| switch (nVal) |
| { |
| case table::CellVertJustify_BOTTOM : |
| { |
| rStrExpValue = GetXMLToken(XML_BOTTOM); |
| bRetval = sal_True; |
| } |
| break; |
| case table::CellVertJustify_CENTER : |
| { |
| rStrExpValue = GetXMLToken(XML_MIDDLE); |
| bRetval = sal_True; |
| } |
| break; |
| case table::CellVertJustify_STANDARD : |
| { |
| rStrExpValue = GetXMLToken(XML_AUTOMATIC); |
| bRetval = sal_True; |
| } |
| break; |
| case table::CellVertJustify_TOP : |
| { |
| rStrExpValue = GetXMLToken(XML_TOP); |
| bRetval = sal_True; |
| } |
| break; |
| default: |
| { |
| // added to avoid warnings |
| } |
| } |
| } |
| |
| return bRetval; |
| } |
| |
| XmlScPropHdl_BreakBefore::~XmlScPropHdl_BreakBefore() |
| { |
| } |
| |
| bool XmlScPropHdl_BreakBefore::equals( |
| const ::com::sun::star::uno::Any& r1, |
| const ::com::sun::star::uno::Any& r2 ) const |
| { |
| sal_Bool aBreak1 = 0, aBreak2 = 0; |
| |
| if((r1 >>= aBreak1) && (r2 >>= aBreak2)) |
| return (aBreak1 == aBreak2); |
| return sal_False; |
| } |
| |
| sal_Bool XmlScPropHdl_BreakBefore::importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| sal_Bool bRetval(sal_False); |
| |
| sal_Bool bValue; |
| if (IsXMLToken(rStrImpValue, XML_AUTO)) |
| { |
| bValue = sal_False; |
| rValue = ::cppu::bool2any(bValue); |
| bRetval = sal_True; |
| } |
| else if (IsXMLToken(rStrImpValue, XML_PAGE)) |
| { |
| bValue = sal_True; |
| rValue = ::cppu::bool2any(bValue); |
| bRetval = sal_True; |
| } |
| |
| return bRetval; |
| } |
| |
| sal_Bool XmlScPropHdl_BreakBefore::exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| sal_Bool bRetval(sal_False); |
| |
| if(::cppu::any2bool(rValue)) |
| { |
| rStrExpValue = GetXMLToken(XML_PAGE); |
| bRetval = sal_True; |
| } |
| else |
| { |
| rStrExpValue = GetXMLToken(XML_AUTO); |
| bRetval = sal_True; |
| } |
| |
| return bRetval; |
| } |
| |
| XmlScPropHdl_IsTextWrapped::~XmlScPropHdl_IsTextWrapped() |
| { |
| } |
| |
| bool XmlScPropHdl_IsTextWrapped::equals( |
| const ::com::sun::star::uno::Any& r1, |
| const ::com::sun::star::uno::Any& r2 ) const |
| { |
| return (::cppu::any2bool(r1) == ::cppu::any2bool(r2)); |
| } |
| |
| sal_Bool XmlScPropHdl_IsTextWrapped::importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| sal_Bool bRetval(sal_False); |
| |
| if (IsXMLToken(rStrImpValue, XML_WRAP)) |
| { |
| rValue = ::cppu::bool2any(sal_True); |
| bRetval = sal_True; |
| } |
| else if (IsXMLToken(rStrImpValue, XML_NO_WRAP)) |
| { |
| rValue = ::cppu::bool2any(sal_False); |
| bRetval = sal_True; |
| } |
| |
| return bRetval; |
| } |
| |
| sal_Bool XmlScPropHdl_IsTextWrapped::exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| sal_Bool bRetval(sal_False); |
| |
| if (::cppu::any2bool(rValue)) |
| { |
| rStrExpValue = GetXMLToken(XML_WRAP); |
| bRetval = sal_True; |
| } |
| else |
| { |
| rStrExpValue = GetXMLToken(XML_NO_WRAP); |
| bRetval = sal_True; |
| } |
| |
| return bRetval; |
| } |
| |
| sal_Bool XmlScPropHdl_IsEqual::importXML( const ::rtl::OUString& /* rStrImpValue */, |
| ::com::sun::star::uno::Any& /* rValue */, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| DBG_ERROR("should never be called"); |
| return sal_False; |
| } |
| |
| sal_Bool XmlScPropHdl_IsEqual::exportXML( ::rtl::OUString& /* rStrExpValue */, |
| const ::com::sun::star::uno::Any& /* rValue */, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| DBG_ERROR("should never be called"); |
| return sal_False; |
| } |
| |
| XmlScPropHdl_Vertical::~XmlScPropHdl_Vertical() |
| { |
| } |
| |
| bool XmlScPropHdl_Vertical::equals( |
| const ::com::sun::star::uno::Any& r1, |
| const ::com::sun::star::uno::Any& r2 ) const |
| { |
| return (::cppu::any2bool(r1) == ::cppu::any2bool(r2)); |
| } |
| |
| sal_Bool XmlScPropHdl_Vertical::importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| sal_Bool bRetval(sal_False); |
| |
| if (IsXMLToken(rStrImpValue, XML_AUTO)) |
| { |
| rValue = ::cppu::bool2any(sal_True); |
| bRetval = sal_True; |
| } |
| else if (IsXMLToken(rStrImpValue, XML_0)) |
| { |
| rValue = ::cppu::bool2any(sal_False); |
| bRetval = sal_True; |
| } |
| |
| return bRetval; |
| } |
| |
| sal_Bool XmlScPropHdl_Vertical::exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& /* rUnitConverter */ ) const |
| { |
| sal_Bool bRetval(sal_False); |
| |
| if (::cppu::any2bool(rValue)) |
| { |
| rStrExpValue = GetXMLToken(XML_AUTO); |
| bRetval = sal_True; |
| } |
| else |
| { |
| rStrExpValue = GetXMLToken(XML_0); |
| bRetval = sal_True; |
| } |
| |
| return bRetval; |
| } |