| /************************************************************** |
| * |
| * 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 "xmlstyli.hxx" |
| #include <xmloff/nmspmap.hxx> |
| #include <xmloff/xmlnmspe.hxx> |
| #include <xmloff/xmlimppr.hxx> |
| #include <xmloff/families.hxx> |
| #include <xmloff/xmlnumfi.hxx> |
| #include <xmloff/XMLGraphicsDefaultStyle.hxx> |
| #include <xmloff/xmltoken.hxx> |
| #include <com/sun/star/style/XStyleFamiliesSupplier.hpp> |
| #include <com/sun/star/container/XNameContainer.hpp> |
| #include <com/sun/star/sheet/XSheetConditionalEntries.hpp> |
| #include <com/sun/star/table/BorderLine.hpp> |
| #include <comphelper/extract.hxx> |
| #include <xmloff/xmlprcon.hxx> |
| #include <xmloff/xmluconv.hxx> |
| #include <tools/debug.hxx> |
| #include "XMLTableHeaderFooterContext.hxx" |
| #include "XMLConverter.hxx" |
| #include "XMLTableShapeImportHelper.hxx" |
| #include "sheetdata.hxx" |
| #include "xmlannoi.hxx" |
| #include "textuno.hxx" |
| #include "cellsuno.hxx" |
| |
| #include "docuno.hxx" |
| #include "unonames.hxx" |
| #include "document.hxx" |
| |
| #define XML_LINE_LEFT 0 |
| #define XML_LINE_RIGHT 1 |
| #define XML_LINE_TOP 2 |
| #define XML_LINE_BOTTOM 3 |
| |
| #define XML_LINE_TLBR 0 |
| #define XML_LINE_BLTR 1 |
| |
| using ::rtl::OUString; |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::xml::sax; |
| using namespace ::com::sun::star::style; |
| using namespace ::com::sun::star::frame; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::container; |
| using namespace xmloff::token; |
| //using namespace ::com::sun::star::text; |
| using namespace ::formula; |
| |
| ScXMLCellImportPropertyMapper::ScXMLCellImportPropertyMapper( |
| const UniReference< XMLPropertySetMapper >& rMapper, |
| SvXMLImport& rImportP) : |
| SvXMLImportPropertyMapper( rMapper, rImportP ) |
| { |
| } |
| |
| ScXMLCellImportPropertyMapper::~ScXMLCellImportPropertyMapper() |
| { |
| } |
| |
| void ScXMLCellImportPropertyMapper::finished(::std::vector< XMLPropertyState >& rProperties, sal_Int32 nStartIndex, sal_Int32 nEndIndex ) const |
| { |
| static const sal_Int16 aPaddingCTF[4] = { CTF_SC_LEFTPADDING, CTF_SC_RIGHTPADDING, |
| CTF_SC_TOPPADDING, CTF_SC_BOTTOMPADDING }; |
| static const sal_Int16 aBorderCTF[4] = { CTF_SC_LEFTBORDER, CTF_SC_RIGHTBORDER, |
| CTF_SC_TOPBORDER, CTF_SC_BOTTOMBORDER }; |
| |
| SvXMLImportPropertyMapper::finished(rProperties, nStartIndex, nEndIndex); |
| XMLPropertyState* pAllPaddingProperty(NULL); |
| XMLPropertyState* pPadding[4] = { NULL, NULL, NULL, NULL }; |
| XMLPropertyState* pNewPadding[4] = { NULL, NULL, NULL, NULL }; |
| XMLPropertyState* pAllBorderProperty = NULL; |
| XMLPropertyState* pBorders[4] = { NULL, NULL, NULL, NULL }; |
| XMLPropertyState* pNewBorders[4] = { NULL, NULL, NULL, NULL }; |
| XMLPropertyState* pAllBorderWidthProperty = NULL; |
| XMLPropertyState* pBorderWidths[4] = { NULL, NULL, NULL, NULL }; |
| XMLPropertyState* pDiagBorders[2] = { 0 }; |
| XMLPropertyState* pOldDiagBorderWidths[2] = { 0 }; // old attribute names without "s" |
| XMLPropertyState* pDiagBorderWidths[2] = { 0 }; |
| |
| ::std::vector< XMLPropertyState >::iterator endproperty(rProperties.end()); |
| for (::std::vector< XMLPropertyState >::iterator aIter = rProperties.begin(); |
| aIter != endproperty; ++aIter) |
| { |
| XMLPropertyState*property = &(*aIter); |
| if (property->mnIndex != -1) |
| { |
| sal_Int16 nContextID = getPropertySetMapper()->GetEntryContextId(property->mnIndex); |
| switch (nContextID) |
| { |
| case CTF_SC_ALLPADDING : pAllPaddingProperty = &*property; break; |
| case CTF_SC_LEFTPADDING : pPadding[XML_LINE_LEFT] = &*property; break; |
| case CTF_SC_RIGHTPADDING : pPadding[XML_LINE_RIGHT] = &*property; break; |
| case CTF_SC_TOPPADDING : pPadding[XML_LINE_TOP] = &*property; break; |
| case CTF_SC_BOTTOMPADDING : pPadding[XML_LINE_BOTTOM] = &*property; break; |
| case CTF_SC_ALLBORDER : pAllBorderProperty = &*property; break; |
| case CTF_SC_LEFTBORDER : pBorders[XML_LINE_LEFT] = &*property; break; |
| case CTF_SC_RIGHTBORDER : pBorders[XML_LINE_RIGHT] = &*property; break; |
| case CTF_SC_TOPBORDER : pBorders[XML_LINE_TOP] = &*property; break; |
| case CTF_SC_BOTTOMBORDER : pBorders[XML_LINE_BOTTOM] = &*property; break; |
| case CTF_SC_ALLBORDERWIDTH : pAllBorderWidthProperty = &*property; break; |
| case CTF_SC_LEFTBORDERWIDTH : pBorderWidths[XML_LINE_LEFT] = &*property; break; |
| case CTF_SC_RIGHTBORDERWIDTH : pBorderWidths[XML_LINE_RIGHT] = &*property; break; |
| case CTF_SC_TOPBORDERWIDTH : pBorderWidths[XML_LINE_TOP] = &*property; break; |
| case CTF_SC_BOTTOMBORDERWIDTH : pBorderWidths[XML_LINE_BOTTOM] = &*property; break; |
| case CTF_SC_DIAGONALTLBR : pDiagBorders[XML_LINE_TLBR] = &*property; break; |
| case CTF_SC_DIAGONALBLTR : pDiagBorders[XML_LINE_BLTR] = &*property; break; |
| case CTF_SC_DIAGONALTLBRWIDTH : pOldDiagBorderWidths[XML_LINE_TLBR] = &*property; break; |
| case CTF_SC_DIAGONALTLBRWIDTHS : pDiagBorderWidths[XML_LINE_TLBR] = &*property; break; |
| case CTF_SC_DIAGONALBLTRWIDTH : pOldDiagBorderWidths[XML_LINE_BLTR] = &*property; break; |
| case CTF_SC_DIAGONALBLTRWIDTHS : pDiagBorderWidths[XML_LINE_BLTR] = &*property; break; |
| } |
| } |
| } |
| sal_uInt16 i; |
| |
| // #i27594#; copy Value, but don't insert |
| if (pAllBorderWidthProperty) |
| pAllBorderWidthProperty->mnIndex = -1; |
| if (pAllBorderProperty) |
| pAllBorderProperty->mnIndex = -1; |
| if (pAllPaddingProperty) |
| pAllPaddingProperty->mnIndex = -1; |
| |
| for (i = 0; i < 4; ++i) |
| { |
| if (pAllPaddingProperty && !pPadding[i]) |
| pNewPadding[i] = new XMLPropertyState(maPropMapper->FindEntryIndex(aPaddingCTF[i]), pAllPaddingProperty->maValue); |
| if (pAllBorderProperty && !pBorders[i]) |
| { |
| pNewBorders[i] = new XMLPropertyState(maPropMapper->FindEntryIndex(aBorderCTF[i]), pAllBorderProperty->maValue); |
| pBorders[i] = pNewBorders[i]; |
| } |
| if( !pBorderWidths[i] ) |
| pBorderWidths[i] = pAllBorderWidthProperty; |
| else |
| pBorderWidths[i]->mnIndex = -1; |
| if( pBorders[i] ) |
| { |
| table::BorderLine aBorderLine; |
| pBorders[i]->maValue >>= aBorderLine; |
| if( pBorderWidths[i] ) |
| { |
| table::BorderLine aBorderLineWidth; |
| pBorderWidths[i]->maValue >>= aBorderLineWidth; |
| aBorderLine.OuterLineWidth = aBorderLineWidth.OuterLineWidth; |
| aBorderLine.InnerLineWidth = aBorderLineWidth.InnerLineWidth; |
| aBorderLine.LineDistance = aBorderLineWidth.LineDistance; |
| pBorders[i]->maValue <<= aBorderLine; |
| } |
| } |
| } |
| for( i = 0; i < 2; ++i ) |
| { |
| if( pDiagBorders[i] && ( pDiagBorderWidths[i] || pOldDiagBorderWidths[i] ) ) |
| { |
| table::BorderLine aBorderLine; |
| pDiagBorders[i]->maValue >>= aBorderLine; |
| table::BorderLine aBorderLineWidth; |
| if (pDiagBorderWidths[i]) |
| pDiagBorderWidths[i]->maValue >>= aBorderLineWidth; // prefer new attribute |
| else |
| pOldDiagBorderWidths[i]->maValue >>= aBorderLineWidth; |
| aBorderLine.OuterLineWidth = aBorderLineWidth.OuterLineWidth; |
| aBorderLine.InnerLineWidth = aBorderLineWidth.InnerLineWidth; |
| aBorderLine.LineDistance = aBorderLineWidth.LineDistance; |
| pDiagBorders[i]->maValue <<= aBorderLine; |
| if (pDiagBorderWidths[i]) |
| pDiagBorderWidths[i]->mnIndex = -1; |
| if (pOldDiagBorderWidths[i]) |
| pOldDiagBorderWidths[i]->mnIndex = -1; // reset mnIndex for old and new attribute if both are present |
| } |
| } |
| |
| for (i = 0; i < 4; ++i) |
| { |
| if (pNewPadding[i]) |
| { |
| rProperties.push_back(*pNewPadding[i]); |
| delete pNewPadding[i]; |
| } |
| if (pNewBorders[i]) |
| { |
| rProperties.push_back(*pNewBorders[i]); |
| delete pNewBorders[i]; |
| } |
| } |
| } |
| |
| ScXMLRowImportPropertyMapper::ScXMLRowImportPropertyMapper( |
| const UniReference< XMLPropertySetMapper >& rMapper, |
| SvXMLImport& rImportP) : |
| SvXMLImportPropertyMapper( rMapper, rImportP ) |
| { |
| } |
| |
| ScXMLRowImportPropertyMapper::~ScXMLRowImportPropertyMapper() |
| { |
| } |
| |
| void ScXMLRowImportPropertyMapper::finished(::std::vector< XMLPropertyState >& rProperties, sal_Int32 nStartIndex, sal_Int32 nEndIndex ) const |
| { |
| SvXMLImportPropertyMapper::finished(rProperties, nStartIndex, nEndIndex); |
| XMLPropertyState* pHeight(NULL); |
| XMLPropertyState* pOptimalHeight(NULL); |
| XMLPropertyState* pPageBreak(NULL); |
| ::std::vector< XMLPropertyState >::iterator endproperty(rProperties.end()); |
| for (::std::vector< XMLPropertyState >::iterator aIter = rProperties.begin(); |
| aIter != endproperty; ++aIter) |
| { |
| XMLPropertyState* property = &(*aIter); |
| if (property->mnIndex != -1) |
| { |
| sal_Int16 nContextID = getPropertySetMapper()->GetEntryContextId(property->mnIndex); |
| switch (nContextID) |
| { |
| case CTF_SC_ROWHEIGHT : pHeight = property; break; |
| case CTF_SC_ROWOPTIMALHEIGHT : pOptimalHeight = property; break; |
| case CTF_SC_ROWBREAKBEFORE : pPageBreak = property; break; |
| } |
| } |
| } |
| if (pPageBreak) |
| { |
| if(!(::cppu::any2bool(pPageBreak->maValue))) |
| pPageBreak->mnIndex = -1; |
| } |
| if (pOptimalHeight) |
| { |
| if (::cppu::any2bool(pOptimalHeight->maValue)) |
| { |
| if (pHeight) |
| { |
| // set the stored height, but keep "optimal" flag: |
| // pass the height value as OptimalHeight property (only allowed while loading!) |
| pOptimalHeight->maValue = pHeight->maValue; |
| pHeight->mnIndex = -1; |
| } |
| else |
| pOptimalHeight->mnIndex = -1; |
| } |
| } |
| else if (pHeight) |
| { |
| rProperties.push_back(XMLPropertyState(maPropMapper->FindEntryIndex(CTF_SC_ROWOPTIMALHEIGHT), ::cppu::bool2any( sal_False ))); |
| } |
| // don't access pointers to rProperties elements after push_back! |
| } |
| |
| class ScXMLMapContext : public SvXMLImportContext |
| { |
| rtl::OUString sApplyStyle; |
| rtl::OUString sCondition; |
| rtl::OUString sBaseCell; |
| public: |
| |
| ScXMLMapContext( |
| SvXMLImport& rImport, sal_uInt16 nPrfx, |
| const rtl::OUString& rLName, |
| const uno::Reference< xml::sax::XAttributeList > & xAttrList ); |
| virtual ~ScXMLMapContext(); |
| |
| const rtl::OUString& GetApplyStyle() const { return sApplyStyle; } |
| const rtl::OUString& GetCondition() const { return sCondition; } |
| const rtl::OUString& GetBaseCell() const { return sBaseCell; } |
| }; |
| |
| ScXMLMapContext::ScXMLMapContext(SvXMLImport& rImport, sal_uInt16 nPrfx, |
| const OUString& rLName, const uno::Reference< xml::sax::XAttributeList > & xAttrList ) |
| : SvXMLImportContext( rImport, nPrfx, rLName ) |
| { |
| sal_Int16 nAttrCount(xAttrList.is() ? xAttrList->getLength() : 0); |
| for( sal_Int16 i=0; i < nAttrCount; ++i ) |
| { |
| const OUString& rAttrName(xAttrList->getNameByIndex( i )); |
| OUString aLocalName; |
| sal_uInt16 nPrefix(GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName, &aLocalName )); |
| const OUString& rValue(xAttrList->getValueByIndex( i )); |
| |
| // TODO: use a map here |
| if( XML_NAMESPACE_STYLE == nPrefix ) |
| { |
| if( IsXMLToken(aLocalName, XML_CONDITION ) ) |
| sCondition = rValue; |
| else if( IsXMLToken(aLocalName, XML_APPLY_STYLE_NAME ) ) |
| sApplyStyle = GetImport().GetStyleDisplayName( XML_STYLE_FAMILY_TABLE_CELL, rValue); |
| else if ( IsXMLToken(aLocalName, XML_BASE_CELL_ADDRESS ) ) |
| sBaseCell = rValue; |
| } |
| } |
| } |
| |
| ScXMLMapContext::~ScXMLMapContext() |
| { |
| } |
| |
| namespace { |
| |
| template< typename Type > |
| inline void lclAppendProperty( uno::Sequence< beans::PropertyValue >& rProps, const OUString& rPropName, const Type& rValue ) |
| { |
| sal_Int32 nLength = rProps.getLength(); |
| rProps.realloc( nLength + 1 ); |
| rProps[ nLength ].Name = rPropName; |
| rProps[ nLength ].Value <<= rValue; |
| } |
| |
| } // namespace |
| |
| void XMLTableStyleContext::SetOperator( uno::Sequence< beans::PropertyValue >& rProps, sheet::ConditionOperator eOp ) const |
| { |
| lclAppendProperty( rProps, OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_OPERATOR ) ), eOp ); |
| } |
| |
| void XMLTableStyleContext::SetBaseCellAddress( uno::Sequence< beans::PropertyValue >& rProps, const OUString& rBaseCell ) const |
| { |
| /* #b4974740# Source position must be set as string, because it may refer |
| to a sheet that hasn't been loaded yet. */ |
| lclAppendProperty( rProps, OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_SOURCESTR ) ), rBaseCell ); |
| } |
| |
| void XMLTableStyleContext::SetStyle( uno::Sequence<beans::PropertyValue>& rProps, const OUString& rApplyStyle ) const |
| { |
| lclAppendProperty( rProps, OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_STYLENAME ) ), rApplyStyle ); |
| } |
| |
| void XMLTableStyleContext::SetFormula( uno::Sequence< beans::PropertyValue >& rProps, |
| sal_Int32 nFormulaIdx, const OUString& rFormula, const OUString& rFormulaNmsp, |
| FormulaGrammar::Grammar eGrammar, bool bHasNmsp ) const |
| { |
| OUString aFormula, aFormulaNmsp; |
| FormulaGrammar::Grammar eNewGrammar = FormulaGrammar::GRAM_UNSPECIFIED; |
| if( bHasNmsp ) |
| { |
| // the entire attribute contains a namespace: internal namespace not allowed |
| aFormula = rFormula; |
| aFormulaNmsp = rFormulaNmsp; |
| eNewGrammar = eGrammar; |
| } |
| else |
| { |
| // the attribute does not contain a namespace: try to find a namespace of an external grammar |
| GetScImport().ExtractFormulaNamespaceGrammar( aFormula, aFormulaNmsp, eNewGrammar, rFormula, true ); |
| if( eNewGrammar != FormulaGrammar::GRAM_EXTERNAL ) |
| eNewGrammar = eGrammar; |
| } |
| |
| // add formula, formula namespace, and grammar with appropriate property names |
| sal_Int32 nGrammar = static_cast< sal_Int32 >( eNewGrammar ); |
| switch( nFormulaIdx ) |
| { |
| case 1: |
| lclAppendProperty( rProps, OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_FORMULA1 ) ), aFormula ); |
| lclAppendProperty( rProps, OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_FORMULANMSP1 ) ), aFormulaNmsp ); |
| lclAppendProperty( rProps, OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_GRAMMAR1 ) ), nGrammar ); |
| break; |
| case 2: |
| lclAppendProperty( rProps, OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_FORMULA2 ) ), aFormula ); |
| lclAppendProperty( rProps, OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_FORMULANMSP2 ) ), aFormulaNmsp ); |
| lclAppendProperty( rProps, OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNONAME_GRAMMAR2 ) ), nGrammar ); |
| break; |
| default: |
| OSL_ENSURE( false, "XMLTableStyleContext::SetFormula - invalid formula index" ); |
| } |
| } |
| |
| void XMLTableStyleContext::GetConditionalFormat(uno::Any& aAny, |
| const rtl::OUString& sTempCondition, |
| const rtl::OUString& sApplyStyle, const rtl::OUString& sBaseCell) const |
| { |
| if (sTempCondition.getLength() && sApplyStyle.getLength()) |
| { |
| uno::Reference<sheet::XSheetConditionalEntries> xConditionalEntries(aAny, uno::UNO_QUERY); |
| if (xConditionalEntries.is()) |
| { |
| uno::Sequence<beans::PropertyValue> aProps; |
| if (sBaseCell.getLength()) |
| SetBaseCellAddress(aProps, sBaseCell); |
| SetStyle(aProps, sApplyStyle); |
| |
| // extract leading namespace from condition string |
| OUString aCondition, aConditionNmsp; |
| FormulaGrammar::Grammar eGrammar = FormulaGrammar::GRAM_UNSPECIFIED; |
| GetScImport().ExtractFormulaNamespaceGrammar( aCondition, aConditionNmsp, eGrammar, sTempCondition ); |
| bool bHasNmsp = aCondition.getLength() < sTempCondition.getLength(); |
| |
| // parse a condition from the attribute string |
| ScXMLConditionParseResult aParseResult; |
| ScXMLConditionHelper::parseCondition( aParseResult, aCondition, 0 ); |
| |
| /* Check the result. A valid value in aParseResult.meToken implies |
| that the other members of aParseResult are filled with valid |
| data for that token. */ |
| switch( aParseResult.meToken ) |
| { |
| case XML_COND_CELLCONTENT: // condition is 'cell-content()<operator><expression>' |
| case XML_COND_ISTRUEFORMULA: // condition is 'is-true-formula(<expression>)' |
| case XML_COND_ISBETWEEN: // condition is 'cell-content-is-between(<expression1>,<expression2>)' |
| case XML_COND_ISNOTBETWEEN: // condition is 'cell-content-is-not-between(<expression1>,<expression2>)' |
| SetOperator( aProps, aParseResult.meOperator ); |
| SetFormula( aProps, 1, aParseResult.maOperand1, aConditionNmsp, eGrammar, bHasNmsp ); |
| SetFormula( aProps, 2, aParseResult.maOperand2, aConditionNmsp, eGrammar, bHasNmsp ); |
| break; |
| |
| default:; // unacceptable or unknown condition |
| } |
| |
| xConditionalEntries->addNew( aProps ); |
| aAny <<= xConditionalEntries; |
| } |
| } |
| } |
| |
| void XMLTableStyleContext::SetAttribute( sal_uInt16 nPrefixKey, |
| const OUString& rLocalName, |
| const OUString& rValue ) |
| { |
| // TODO: use a map here |
| if( IsXMLToken(rLocalName, XML_DATA_STYLE_NAME ) ) |
| sDataStyleName = rValue; |
| else if ( IsXMLToken(rLocalName, XML_MASTER_PAGE_NAME ) ) |
| sPageStyle = rValue; |
| else |
| XMLPropStyleContext::SetAttribute( nPrefixKey, rLocalName, rValue ); |
| } |
| |
| struct ScXMLMapContent |
| { |
| rtl::OUString sCondition; |
| rtl::OUString sApplyStyle; |
| rtl::OUString sBaseCell; |
| }; |
| |
| TYPEINIT1( XMLTableStyleContext, XMLPropStyleContext ); |
| |
| XMLTableStyleContext::XMLTableStyleContext( ScXMLImport& rImport, |
| sal_uInt16 nPrfx, const OUString& rLName, |
| const uno::Reference< XAttributeList > & xAttrList, |
| SvXMLStylesContext& rStyles, sal_uInt16 nFamily, sal_Bool bDefaultStyle ) : |
| XMLPropStyleContext( rImport, nPrfx, rLName, xAttrList, rStyles, nFamily, bDefaultStyle ), |
| sDataStyleName(), |
| sNumberFormat(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("NumberFormat"))), |
| pStyles(&rStyles), |
| nNumberFormat(-1), |
| nLastSheet(-1), |
| bConditionalFormatCreated(sal_False), |
| bParentSet(sal_False) |
| { |
| } |
| |
| XMLTableStyleContext::~XMLTableStyleContext() |
| { |
| } |
| |
| SvXMLImportContext *XMLTableStyleContext::CreateChildContext( |
| sal_uInt16 nPrefix, |
| const OUString& rLocalName, |
| const uno::Reference< XAttributeList > & xAttrList ) |
| { |
| SvXMLImportContext *pContext(NULL); |
| |
| if( (XML_NAMESPACE_STYLE == nPrefix) && |
| IsXMLToken(rLocalName, XML_MAP ) ) |
| { |
| pContext = new ScXMLMapContext(GetImport(), nPrefix, rLocalName, xAttrList); |
| |
| ScXMLMapContent aMap; |
| aMap.sCondition = ((ScXMLMapContext*)pContext)->GetCondition(); |
| aMap.sApplyStyle = ((ScXMLMapContext*)pContext)->GetApplyStyle(); |
| aMap.sBaseCell = ((ScXMLMapContext*)pContext)->GetBaseCell(); |
| aMaps.push_back(aMap); |
| } |
| if (!pContext) |
| pContext = XMLPropStyleContext::CreateChildContext( nPrefix, rLocalName, |
| xAttrList ); |
| return pContext; |
| } |
| |
| void XMLTableStyleContext::FillPropertySet( |
| const uno::Reference< XPropertySet > & rPropSet ) |
| { |
| if (!IsDefaultStyle()) |
| { |
| if (GetFamily() == XML_STYLE_FAMILY_TABLE_CELL) |
| { |
| if (!bParentSet) |
| { |
| AddProperty(CTF_SC_CELLSTYLE, uno::makeAny(GetImport().GetStyleDisplayName( XML_STYLE_FAMILY_TABLE_CELL, GetParentName() ))); |
| bParentSet = sal_True; |
| } |
| sal_Int32 nNumFmt = GetNumberFormat(); |
| if (nNumFmt >= 0) |
| AddProperty(CTF_SC_NUMBERFORMAT, uno::makeAny(nNumFmt)); |
| if (!bConditionalFormatCreated && (aMaps.size() > 0)) |
| { |
| aConditionalFormat = rPropSet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_CONDXML))); |
| std::vector<ScXMLMapContent>::iterator aItr(aMaps.begin()); |
| std::vector<ScXMLMapContent>::iterator aEndItr(aMaps.end()); |
| while(aItr != aEndItr) |
| { |
| //rPropSet->setPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_CONDITIONALFORMAT)), |
| GetConditionalFormat(aConditionalFormat, aItr->sCondition, aItr->sApplyStyle, aItr->sBaseCell); |
| |
| ++aItr; |
| } |
| AddProperty(CTF_SC_IMPORT_MAP, aConditionalFormat); |
| bConditionalFormatCreated = sal_True; |
| } |
| } |
| else if (GetFamily() == XML_STYLE_FAMILY_TABLE_TABLE) |
| { |
| if (sPageStyle.getLength()) |
| AddProperty(CTF_SC_MASTERPAGENAME, uno::makeAny(GetImport().GetStyleDisplayName( XML_STYLE_FAMILY_MASTER_PAGE, sPageStyle ))); |
| } |
| } |
| XMLPropStyleContext::FillPropertySet(rPropSet); |
| } |
| |
| void XMLTableStyleContext::SetDefaults() |
| { |
| if ((GetFamily() == XML_STYLE_FAMILY_TABLE_CELL) && GetImport().GetModel().is()) |
| { |
| uno::Reference <lang::XMultiServiceFactory> xMultiServiceFactory(GetImport().GetModel(), uno::UNO_QUERY); |
| if (xMultiServiceFactory.is()) |
| { |
| uno::Reference <beans::XPropertySet> xProperties(xMultiServiceFactory->createInstance(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.sheet.Defaults"))), uno::UNO_QUERY); |
| if (xProperties.is()) |
| FillPropertySet(xProperties); |
| } |
| } |
| } |
| |
| void XMLTableStyleContext::AddProperty(const sal_Int16 nContextID, const uno::Any& rValue) |
| { |
| XMLPropertyState* property = FindProperty(nContextID); |
| if (property) |
| property->mnIndex = -1; // #i46996# remove old property, so it isn't double |
| sal_Int32 nIndex(static_cast<XMLTableStylesContext *>(pStyles)->GetIndex(nContextID)); |
| DBG_ASSERT(nIndex != -1, "Property not found in Map"); |
| XMLPropertyState aPropState(nIndex, rValue); |
| GetProperties().push_back(aPropState); // has to be insertes in a sort order later |
| } |
| |
| XMLPropertyState* XMLTableStyleContext::FindProperty(const sal_Int16 nContextID) |
| { |
| XMLPropertyState* pRet = NULL; |
| UniReference < XMLPropertySetMapper > xPrMap; |
| UniReference < SvXMLImportPropertyMapper > xImpPrMap = |
| pStyles->GetImportPropertyMapper( GetFamily() ); |
| DBG_ASSERT( xImpPrMap.is(), "There is the import prop mapper" ); |
| if( xImpPrMap.is() ) |
| xPrMap = xImpPrMap->getPropertySetMapper(); |
| if( xPrMap.is() ) |
| { |
| ::std::vector< XMLPropertyState >::iterator endproperty(GetProperties().end()); |
| ::std::vector< XMLPropertyState >::iterator aIter(GetProperties().begin()); |
| while(!pRet && aIter != endproperty) |
| { |
| XMLPropertyState* property = &(*aIter); |
| if (property->mnIndex != -1 && xPrMap->GetEntryContextId(property->mnIndex) == nContextID) |
| { |
| pRet = property; |
| } |
| else |
| ++aIter; |
| } |
| } |
| return pRet; |
| } |
| |
| sal_Int32 XMLTableStyleContext::GetNumberFormat() |
| { |
| if (nNumberFormat < 0 && sDataStyleName.getLength()) |
| { |
| const SvXMLNumFormatContext* pStyle = static_cast<const SvXMLNumFormatContext*>( |
| pStyles->FindStyleChildContext(XML_STYLE_FAMILY_DATA_STYLE, sDataStyleName, sal_True)); |
| |
| if (!pStyle) |
| { |
| XMLTableStylesContext* pMyStyles = static_cast<XMLTableStylesContext*>(GetScImport().GetStyles()); |
| if (pMyStyles) |
| pStyle = static_cast<const SvXMLNumFormatContext*>( |
| pMyStyles->FindStyleChildContext(XML_STYLE_FAMILY_DATA_STYLE, sDataStyleName, sal_True)); |
| else |
| { |
| DBG_ERROR("not possible to get style"); |
| } |
| } |
| if (pStyle) |
| nNumberFormat = const_cast<SvXMLNumFormatContext*>(pStyle)->GetKey(); |
| } |
| return nNumberFormat; |
| } |
| |
| // ---------------------------------------------------------------------------- |
| |
| SvXMLStyleContext *XMLTableStylesContext::CreateStyleStyleChildContext( |
| sal_uInt16 nFamily, sal_uInt16 nPrefix, const OUString& rLocalName, |
| const uno::Reference< xml::sax::XAttributeList > & xAttrList ) |
| { |
| SvXMLStyleContext *pStyle; |
| // use own wrapper for text and paragraph, to record style usage |
| if (nFamily == XML_STYLE_FAMILY_TEXT_PARAGRAPH || nFamily == XML_STYLE_FAMILY_TEXT_TEXT) |
| pStyle = new ScCellTextStyleContext( GetImport(), nPrefix, rLocalName, |
| xAttrList, *this, nFamily ); |
| else |
| pStyle = SvXMLStylesContext::CreateStyleStyleChildContext( |
| nFamily, nPrefix, rLocalName, xAttrList ); |
| |
| if (!pStyle) |
| { |
| switch( nFamily ) |
| { |
| case XML_STYLE_FAMILY_TABLE_CELL: |
| case XML_STYLE_FAMILY_TABLE_COLUMN: |
| case XML_STYLE_FAMILY_TABLE_ROW: |
| case XML_STYLE_FAMILY_TABLE_TABLE: |
| pStyle = new XMLTableStyleContext( GetScImport(), nPrefix, rLocalName, |
| xAttrList, *this, nFamily ); |
| break; |
| } |
| } |
| |
| return pStyle; |
| } |
| |
| SvXMLStyleContext *XMLTableStylesContext::CreateDefaultStyleStyleChildContext( |
| sal_uInt16 nFamily, sal_uInt16 nPrefix, const OUString& rLocalName, |
| const uno::Reference< xml::sax::XAttributeList > & xAttrList ) |
| { |
| SvXMLStyleContext *pStyle(SvXMLStylesContext::CreateDefaultStyleStyleChildContext( nFamily, nPrefix, |
| rLocalName, |
| xAttrList )); |
| if (!pStyle) |
| { |
| switch( nFamily ) |
| { |
| case XML_STYLE_FAMILY_TABLE_CELL: |
| pStyle = new XMLTableStyleContext( GetScImport(), nPrefix, rLocalName, |
| xAttrList, *this, nFamily, sal_True); |
| break; |
| case XML_STYLE_FAMILY_SD_GRAPHICS_ID: |
| pStyle = new XMLGraphicsDefaultStyle( GetScImport(), nPrefix, rLocalName, |
| xAttrList, *this); |
| break; |
| } |
| } |
| |
| return pStyle; |
| } |
| |
| XMLTableStylesContext::XMLTableStylesContext( SvXMLImport& rImport, |
| sal_uInt16 nPrfx , |
| const OUString& rLName , |
| const uno::Reference< XAttributeList > & xAttrList, |
| const sal_Bool bTempAutoStyles ) : |
| SvXMLStylesContext( rImport, nPrfx, rLName, xAttrList ), |
| sCellStyleServiceName( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.style.CellStyle" ) )), |
| sColumnStyleServiceName( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( XML_STYLE_FAMILY_TABLE_COLUMN_STYLES_NAME ))), |
| sRowStyleServiceName( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( XML_STYLE_FAMILY_TABLE_ROW_STYLES_NAME ))), |
| sTableStyleServiceName( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( XML_STYLE_FAMILY_TABLE_TABLE_STYLES_NAME ))), |
| nNumberFormatIndex(-1), |
| nConditionalFormatIndex(-1), |
| nCellStyleIndex(-1), |
| nMasterPageNameIndex(-1), |
| bAutoStyles(bTempAutoStyles) |
| { |
| } |
| |
| XMLTableStylesContext::~XMLTableStylesContext() |
| { |
| } |
| |
| void XMLTableStylesContext::EndElement() |
| { |
| SvXMLStylesContext::EndElement(); |
| if (bAutoStyles) |
| GetImport().GetTextImport()->SetAutoStyles( this ); |
| else |
| ((ScXMLImport&)GetImport()).InsertStyles(); |
| } |
| |
| UniReference < SvXMLImportPropertyMapper > |
| XMLTableStylesContext::GetImportPropertyMapper( |
| sal_uInt16 nFamily ) const |
| { |
| UniReference < SvXMLImportPropertyMapper > xMapper(SvXMLStylesContext::GetImportPropertyMapper(nFamily)); |
| |
| if (!xMapper.is()) |
| { |
| switch( nFamily ) |
| { |
| case XML_STYLE_FAMILY_TABLE_CELL: |
| { |
| if( !xCellImpPropMapper.is() ) |
| { |
| ((XMLTableStylesContext *)this)->xCellImpPropMapper = |
| new ScXMLCellImportPropertyMapper( GetScImport().GetCellStylesPropertySetMapper(), const_cast<SvXMLImport&>(GetImport()) ); |
| xCellImpPropMapper->ChainImportMapper(XMLTextImportHelper::CreateParaExtPropMapper(const_cast<SvXMLImport&>(GetImport()), const_cast<XMLFontStylesContext*>(GetScImport().GetFontDecls()))); |
| } |
| xMapper = xCellImpPropMapper; |
| } |
| break; |
| case XML_STYLE_FAMILY_TABLE_COLUMN: |
| { |
| if( !xColumnImpPropMapper.is() ) |
| ((XMLTableStylesContext *)this)->xColumnImpPropMapper = |
| new SvXMLImportPropertyMapper( GetScImport().GetColumnStylesPropertySetMapper(), const_cast<SvXMLImport&>(GetImport()) ); |
| xMapper = xColumnImpPropMapper; |
| } |
| break; |
| case XML_STYLE_FAMILY_TABLE_ROW: |
| { |
| if( !xRowImpPropMapper.is() ) |
| ((XMLTableStylesContext *)this)->xRowImpPropMapper = |
| new ScXMLRowImportPropertyMapper( GetScImport().GetRowStylesPropertySetMapper(), const_cast<SvXMLImport&>(GetImport()) ); |
| xMapper = xRowImpPropMapper; |
| } |
| break; |
| case XML_STYLE_FAMILY_TABLE_TABLE: |
| { |
| if( !xTableImpPropMapper.is() ) |
| ((XMLTableStylesContext *)this)->xTableImpPropMapper = |
| new SvXMLImportPropertyMapper( GetScImport().GetTableStylesPropertySetMapper(), const_cast<SvXMLImport&>(GetImport()) ); |
| xMapper = xTableImpPropMapper; |
| } |
| break; |
| } |
| } |
| |
| return xMapper; |
| } |
| |
| uno::Reference < XNameContainer > |
| XMLTableStylesContext::GetStylesContainer( sal_uInt16 nFamily ) const |
| { |
| uno::Reference < XNameContainer > xStyles(SvXMLStylesContext::GetStylesContainer(nFamily)); |
| if (!xStyles.is()) |
| { |
| OUString sName; |
| switch( nFamily ) |
| { |
| case XML_STYLE_FAMILY_TABLE_TABLE: |
| { |
| if( xTableStyles.is() ) |
| xStyles.set(xTableStyles); |
| else |
| sName = |
| OUString( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "TableStyles" ) )); |
| } |
| break; |
| case XML_STYLE_FAMILY_TABLE_CELL: |
| { |
| if( xCellStyles.is() ) |
| xStyles.set(xCellStyles); |
| else |
| sName = |
| OUString( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "CellStyles" ) )); |
| } |
| break; |
| case XML_STYLE_FAMILY_TABLE_COLUMN: |
| { |
| if( xColumnStyles.is() ) |
| xStyles.set(xColumnStyles); |
| else |
| sName = |
| OUString( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "ColumnStyles" ) )); |
| } |
| break; |
| case XML_STYLE_FAMILY_TABLE_ROW: |
| { |
| if( xRowStyles.is() ) |
| xStyles.set(xRowStyles); |
| else |
| sName = |
| OUString( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "RowStyles" ) )); |
| } |
| break; |
| } |
| if( !xStyles.is() && sName.getLength() && GetScImport().GetModel().is() ) |
| { |
| uno::Reference< XStyleFamiliesSupplier > xFamiliesSupp( |
| GetScImport().GetModel(), UNO_QUERY ); |
| if (xFamiliesSupp.is()) |
| { |
| uno::Reference< XNameAccess > xFamilies(xFamiliesSupp->getStyleFamilies()); |
| |
| try |
| { |
| xStyles.set(xFamilies->getByName( sName ), uno::UNO_QUERY); |
| } |
| catch ( uno::Exception& ) |
| { |
| // #i97680# Named table/column/row styles aren't supported, getByName will throw an exception. |
| // For better interoperability, these styles should then be handled as automatic styles. |
| // For now, NULL is returned (and the style is ignored). |
| } |
| switch( nFamily ) |
| { |
| case XML_STYLE_FAMILY_TABLE_TABLE: |
| ((XMLTableStylesContext *)this)->xTableStyles.set(xStyles); |
| break; |
| case XML_STYLE_FAMILY_TABLE_CELL: |
| ((XMLTableStylesContext *)this)->xCellStyles.set(xStyles); |
| break; |
| case XML_STYLE_FAMILY_TABLE_COLUMN: |
| ((XMLTableStylesContext *)this)->xColumnStyles.set(xStyles); |
| break; |
| case XML_STYLE_FAMILY_TABLE_ROW: |
| ((XMLTableStylesContext *)this)->xRowStyles.set(xStyles); |
| break; |
| } |
| } |
| } |
| } |
| |
| return xStyles; |
| } |
| |
| OUString XMLTableStylesContext::GetServiceName( sal_uInt16 nFamily ) const |
| { |
| rtl::OUString sServiceName(SvXMLStylesContext::GetServiceName(nFamily)); |
| if (!sServiceName.getLength()) |
| { |
| switch( nFamily ) |
| { |
| case XML_STYLE_FAMILY_TABLE_COLUMN: |
| sServiceName = sColumnStyleServiceName; |
| break; |
| case XML_STYLE_FAMILY_TABLE_ROW: |
| sServiceName = sRowStyleServiceName; |
| break; |
| case XML_STYLE_FAMILY_TABLE_CELL: |
| sServiceName = sCellStyleServiceName; |
| break; |
| case XML_STYLE_FAMILY_TABLE_TABLE: |
| sServiceName = sTableStyleServiceName; |
| break; |
| } |
| } |
| return sServiceName; |
| } |
| |
| sal_Int32 XMLTableStylesContext::GetIndex(const sal_Int16 nContextID) |
| { |
| if (nContextID == CTF_SC_CELLSTYLE) |
| { |
| if (nCellStyleIndex == -1) |
| nCellStyleIndex = |
| GetImportPropertyMapper(XML_STYLE_FAMILY_TABLE_CELL)->getPropertySetMapper()->FindEntryIndex(nContextID); |
| return nCellStyleIndex; |
| } |
| else if (nContextID == CTF_SC_NUMBERFORMAT) |
| { |
| if (nNumberFormatIndex == -1) |
| nNumberFormatIndex = |
| GetImportPropertyMapper(XML_STYLE_FAMILY_TABLE_CELL)->getPropertySetMapper()->FindEntryIndex(nContextID); |
| return nNumberFormatIndex; |
| } |
| else if (nContextID == CTF_SC_IMPORT_MAP) |
| { |
| if (nConditionalFormatIndex == -1) |
| nConditionalFormatIndex = |
| GetImportPropertyMapper(XML_STYLE_FAMILY_TABLE_CELL)->getPropertySetMapper()->FindEntryIndex(nContextID); |
| return nConditionalFormatIndex; |
| } |
| else if (nContextID == CTF_SC_MASTERPAGENAME) |
| { |
| if (nMasterPageNameIndex == -1) |
| nMasterPageNameIndex = |
| GetImportPropertyMapper(XML_STYLE_FAMILY_TABLE_TABLE)->getPropertySetMapper()->FindEntryIndex(nContextID); |
| return nMasterPageNameIndex; |
| } |
| else |
| return -1; |
| } |
| |
| // --------------------------------------------------------------------------- |
| TYPEINIT1( ScXMLMasterStylesContext, SvXMLStylesContext ); |
| |
| sal_Bool ScXMLMasterStylesContext::InsertStyleFamily( sal_uInt16 ) const |
| { |
| return sal_True; |
| } |
| |
| ScXMLMasterStylesContext::ScXMLMasterStylesContext( |
| SvXMLImport& rImport, |
| sal_uInt16 nPrfx, const OUString& rLName, |
| const uno::Reference< XAttributeList > & xAttrList ) : |
| SvXMLStylesContext( rImport, nPrfx, rLName, xAttrList ) |
| { |
| } |
| |
| ScXMLMasterStylesContext::~ScXMLMasterStylesContext() |
| { |
| } |
| |
| SvXMLStyleContext *ScXMLMasterStylesContext::CreateStyleChildContext( |
| sal_uInt16 nPrefix, |
| const OUString& rLocalName, |
| const uno::Reference< XAttributeList > & xAttrList ) |
| { |
| SvXMLStyleContext *pContext(0); |
| |
| if( (XML_NAMESPACE_STYLE == nPrefix) && |
| IsXMLToken(rLocalName, XML_MASTER_PAGE) && |
| InsertStyleFamily( XML_STYLE_FAMILY_MASTER_PAGE ) ) |
| pContext = new ScMasterPageContext( |
| GetImport(), nPrefix, rLocalName, xAttrList, |
| !GetImport().GetTextImport()->IsInsertMode() ); |
| |
| // any other style will be ignored here! |
| |
| return pContext; |
| } |
| |
| SvXMLStyleContext *ScXMLMasterStylesContext::CreateStyleStyleChildContext( |
| sal_uInt16 /* nFamily */, |
| sal_uInt16 /* nPrefix */, |
| const OUString& /* rLocalName */, |
| const uno::Reference< XAttributeList > & /* xAttrList */ ) |
| { |
| return 0; |
| } |
| |
| void ScXMLMasterStylesContext::EndElement() |
| { |
| FinishStyles(sal_True); |
| } |
| |
| TYPEINIT1( ScMasterPageContext, XMLTextMasterPageContext ); |
| |
| ScMasterPageContext::ScMasterPageContext( SvXMLImport& rImport, |
| sal_uInt16 nPrfx, const OUString& rLName, |
| const uno::Reference< XAttributeList > & xAttrList, |
| sal_Bool bOverwrite ) : |
| XMLTextMasterPageContext( rImport, nPrfx, rLName, xAttrList, bOverwrite ), |
| bContainsRightHeader(sal_False), |
| bContainsRightFooter(sal_False) |
| { |
| } |
| |
| ScMasterPageContext::~ScMasterPageContext() |
| { |
| } |
| |
| SvXMLImportContext *ScMasterPageContext::CreateChildContext( |
| sal_uInt16 nPrefix, |
| const OUString& rLocalName, |
| const uno::Reference< XAttributeList > & xAttrList ) |
| { |
| return XMLTextMasterPageContext::CreateChildContext( nPrefix, rLocalName, xAttrList ); |
| } |
| |
| SvXMLImportContext *ScMasterPageContext::CreateHeaderFooterContext( |
| sal_uInt16 nPrefix, |
| const ::rtl::OUString& rLocalName, |
| const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XAttributeList > & xAttrList, |
| const sal_Bool bFooter, |
| const sal_Bool bLeft ) |
| { |
| if (!bLeft) |
| { |
| if (bFooter) |
| bContainsRightFooter = sal_True; |
| else |
| bContainsRightHeader = sal_True; |
| } |
| if (!xPropSet.is()) |
| xPropSet.set(GetStyle(), UNO_QUERY ); |
| return new XMLTableHeaderFooterContext( GetImport(), |
| nPrefix, rLocalName, |
| xAttrList, |
| xPropSet, |
| bFooter, bLeft ); |
| } |
| |
| void ScMasterPageContext::ClearContent(const rtl::OUString& rContent) |
| { |
| if (!xPropSet.is()) |
| xPropSet.set(GetStyle(), UNO_QUERY ); |
| |
| if (xPropSet.is()) |
| { |
| uno::Reference < sheet::XHeaderFooterContent > xHeaderFooterContent(xPropSet->getPropertyValue( rContent ), uno::UNO_QUERY); |
| if (xHeaderFooterContent.is()) |
| { |
| xHeaderFooterContent->getLeftText()->setString(sEmpty); |
| xHeaderFooterContent->getCenterText()->setString(sEmpty); |
| xHeaderFooterContent->getRightText()->setString(sEmpty); |
| xPropSet->setPropertyValue( rContent, uno::makeAny(xHeaderFooterContent) ); |
| } |
| } |
| } |
| |
| void ScMasterPageContext::Finish( sal_Bool bOverwrite ) |
| { |
| XMLTextMasterPageContext::Finish(bOverwrite); |
| if (!bContainsRightFooter) |
| ClearContent(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_PAGE_RIGHTFTRCON))); |
| if (!bContainsRightHeader) |
| ClearContent(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_PAGE_RIGHTHDRCON))); |
| } |
| |
| // --------------------------------------------------------------------------- |
| |
| ScCellTextStyleContext::ScCellTextStyleContext( SvXMLImport& rImport, sal_uInt16 nPrfx, |
| const rtl::OUString& rLName, const uno::Reference<xml::sax::XAttributeList> & xAttrList, |
| SvXMLStylesContext& rStyles, sal_uInt16 nFamily, sal_Bool bDefaultStyle ) : |
| XMLTextStyleContext( rImport, nPrfx, rLName, xAttrList, rStyles, nFamily, bDefaultStyle ), |
| nLastSheet(-1) |
| { |
| } |
| |
| ScCellTextStyleContext::~ScCellTextStyleContext() |
| { |
| } |
| |
| void ScCellTextStyleContext::FillPropertySet( const uno::Reference<beans::XPropertySet>& xPropSet ) |
| { |
| XMLTextStyleContext::FillPropertySet( xPropSet ); |
| |
| ScXMLImport& rXMLImport = GetScImport(); |
| |
| ScCellTextCursor* pCellImp = ScCellTextCursor::getImplementation( xPropSet ); |
| if (pCellImp) |
| { |
| ScAddress aPos = pCellImp->GetCellObj().GetPosition(); |
| if ( static_cast<sal_Int32>(aPos.Tab()) != nLastSheet ) |
| { |
| ESelection aSel = pCellImp->GetSelection(); |
| |
| ScSheetSaveData* pSheetData = ScModelObj::getImplementation(GetImport().GetModel())->GetSheetSaveData(); |
| pSheetData->AddTextStyle( GetName(), aPos, aSel ); |
| |
| nLastSheet = static_cast<sal_Int32>(aPos.Tab()); |
| } |
| } |
| else if ( rXMLImport.GetTables().GetCurrentSheet() != nLastSheet ) |
| { |
| ScDrawTextCursor* pDrawImp = ScDrawTextCursor::getImplementation( xPropSet ); |
| if (pDrawImp) |
| { |
| XMLTableShapeImportHelper* pTableShapeImport = (XMLTableShapeImportHelper*)GetScImport().GetShapeImport().get(); |
| ScXMLAnnotationContext* pAnnotationContext = pTableShapeImport->GetAnnotationContext(); |
| if (pAnnotationContext) |
| { |
| pAnnotationContext->AddContentStyle( GetFamily(), GetName(), pDrawImp->GetSelection() ); |
| nLastSheet = rXMLImport.GetTables().GetCurrentSheet(); |
| } |
| } |
| |
| // if it's a different shape, BlockSheet is called from XMLTableShapeImportHelper::finishShape |
| // formatted text in page headers/footers can be ignored |
| } |
| } |
| |