sc/source/filter/xml/xmlstyli.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "xmlstyli.hxx"
  21 #include <xmloff/xmlnamespace.hxx>
  22 #include <xmloff/xmlimppr.hxx>
  23 #include <xmloff/families.hxx>
  24 #include <xmloff/xmlnumfi.hxx>
  25 #include <xmloff/XMLGraphicsDefaultStyle.hxx>
  26 #include <xmloff/xmltoken.hxx>
  27 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
  28 #include <com/sun/star/table/BorderLine2.hpp>
  29 #include <comphelper/extract.hxx>
  30 #include <xmloff/xmlprcon.hxx>
  31 #include "XMLTableHeaderFooterContext.hxx"
  32 #include "XMLConverter.hxx"
  33 #include "XMLTableShapeImportHelper.hxx"
  34 #include <sheetdata.hxx>
  35 #include "xmlannoi.hxx"
  36 #include <textuno.hxx>
  37 #include <cellsuno.hxx>
  38 #include "xmlstyle.hxx"
  39
  40 #include <docuno.hxx>
  41 #include <unonames.hxx>
  42 #include <document.hxx>
  43 #include <conditio.hxx>
  44 #include <rangelst.hxx>
  45
  46 #define XML_LINE_LEFT 0
  47 #define XML_LINE_RIGHT 1
  48 #define XML_LINE_TOP 2
  49 #define XML_LINE_BOTTOM 3
  50
  51 #define XML_LINE_TLBR 0
  52 #define XML_LINE_BLTR 1
  53
  54 using namespace ::com::sun::star;
  55 using namespace ::com::sun::star::xml::sax;
  56 using namespace ::com::sun::star::style;
  57 using namespace ::com::sun::star::beans;
  58 using namespace ::com::sun::star::container;
  59 using namespace xmloff::token;
  60 using namespace ::formula;
  61
  62 using com::sun::star::uno::UNO_QUERY;
  63 ScXMLCellImportPropertyMapper::ScXMLCellImportPropertyMapper(
  64         const rtl::Reference< XMLPropertySetMapper >& rMapper,
  65         SvXMLImport& rImportP) :
  66     SvXMLImportPropertyMapper( rMapper, rImportP )
  67 {
  68 }
  69
  70 ScXMLCellImportPropertyMapper::~ScXMLCellImportPropertyMapper()
  71 {
  72 }
  73
  74 void ScXMLCellImportPropertyMapper::finished(::std::vector< XMLPropertyState >& rProperties, sal_Int32 nStartIndex, sal_Int32 nEndIndex ) const
  75 {
  76     static const sal_Int16 aPaddingCTF[4] = { CTF_SC_LEFTPADDING, CTF_SC_RIGHTPADDING,
  77                                             CTF_SC_TOPPADDING, CTF_SC_BOTTOMPADDING };
  78     static const sal_Int16 aBorderCTF[4] = { CTF_SC_LEFTBORDER, CTF_SC_RIGHTBORDER,
  79                                             CTF_SC_TOPBORDER, CTF_SC_BOTTOMBORDER };
  80
  81     SvXMLImportPropertyMapper::finished(rProperties, nStartIndex, nEndIndex);
  82     XMLPropertyState* pAllPaddingProperty(nullptr);
  83     XMLPropertyState* pPadding[4] = { nullptr, nullptr, nullptr, nullptr };
  84     XMLPropertyState* pNewPadding[4] = { nullptr, nullptr, nullptr, nullptr };
  85     XMLPropertyState* pAllBorderProperty = nullptr;
  86     XMLPropertyState* pBorders[4] = { nullptr, nullptr, nullptr, nullptr };
  87     XMLPropertyState* pNewBorders[4] = { nullptr, nullptr, nullptr, nullptr };
  88     XMLPropertyState* pAllBorderWidthProperty = nullptr;
  89     XMLPropertyState* pBorderWidths[4] = { nullptr, nullptr, nullptr, nullptr };
  90     XMLPropertyState* pDiagBorders[2] = { nullptr };
  91     XMLPropertyState* pOldDiagBorderWidths[2] = { nullptr };      // old attribute names without "s"
  92     XMLPropertyState* pDiagBorderWidths[2] = { nullptr };
  93
  94     for (auto& rProperty : rProperties)
  95     {
  96         XMLPropertyState*property = &rProperty;
  97         if (property->mnIndex != -1)
  98         {
  99             sal_Int16 nContextID = getPropertySetMapper()->GetEntryContextId(property->mnIndex);
 100             switch (nContextID)
 101             {
 102                 case CTF_SC_ALLPADDING                  : pAllPaddingProperty = property; break;
 103                 case CTF_SC_LEFTPADDING                 : pPadding[XML_LINE_LEFT] = property; break;
 104                 case CTF_SC_RIGHTPADDING                : pPadding[XML_LINE_RIGHT] = property; break;
 105                 case CTF_SC_TOPPADDING                  : pPadding[XML_LINE_TOP] = property; break;
 106                 case CTF_SC_BOTTOMPADDING               : pPadding[XML_LINE_BOTTOM] = property; break;
 107                 case CTF_SC_ALLBORDER                   : pAllBorderProperty = property; break;
 108                 case CTF_SC_LEFTBORDER                  : pBorders[XML_LINE_LEFT] = property; break;
 109                 case CTF_SC_RIGHTBORDER                 : pBorders[XML_LINE_RIGHT] = property; break;
 110                 case CTF_SC_TOPBORDER                   : pBorders[XML_LINE_TOP] = property; break;
 111                 case CTF_SC_BOTTOMBORDER                : pBorders[XML_LINE_BOTTOM] = property; break;
 112                 case CTF_SC_ALLBORDERWIDTH              : pAllBorderWidthProperty = property; break;
 113                 case CTF_SC_LEFTBORDERWIDTH             : pBorderWidths[XML_LINE_LEFT] = property; break;
 114                 case CTF_SC_RIGHTBORDERWIDTH            : pBorderWidths[XML_LINE_RIGHT] = property; break;
 115                 case CTF_SC_TOPBORDERWIDTH              : pBorderWidths[XML_LINE_TOP] = property; break;
 116                 case CTF_SC_BOTTOMBORDERWIDTH           : pBorderWidths[XML_LINE_BOTTOM] = property; break;
 117                 case CTF_SC_DIAGONALTLBR                : pDiagBorders[XML_LINE_TLBR] = property; break;
 118                 case CTF_SC_DIAGONALBLTR                : pDiagBorders[XML_LINE_BLTR] = property; break;
 119                 case CTF_SC_DIAGONALTLBRWIDTH           : pOldDiagBorderWidths[XML_LINE_TLBR] = property; break;
 120                 case CTF_SC_DIAGONALTLBRWIDTHS          : pDiagBorderWidths[XML_LINE_TLBR] = property; break;
 121                 case CTF_SC_DIAGONALBLTRWIDTH           : pOldDiagBorderWidths[XML_LINE_BLTR] = property; break;
 122                 case CTF_SC_DIAGONALBLTRWIDTHS          : pDiagBorderWidths[XML_LINE_BLTR] = property; break;
 123             }
 124         }
 125     }
 126     sal_uInt16 i;
 127
 128     // #i27594#; copy Value, but don't insert
 129     if (pAllBorderWidthProperty)
 130         pAllBorderWidthProperty->mnIndex = -1;
 131     if (pAllBorderProperty)
 132         pAllBorderProperty->mnIndex = -1;
 133     if (pAllPaddingProperty)
 134         pAllPaddingProperty->mnIndex = -1;
 135
 136     for (i = 0; i < 4; ++i)
 137     {
 138         if (pAllPaddingProperty && !pPadding[i])
 139             pNewPadding[i] = new XMLPropertyState(maPropMapper->FindEntryIndex(aPaddingCTF[i]), pAllPaddingProperty->maValue);
 140         if (pAllBorderProperty && !pBorders[i])
 141         {
 142             pNewBorders[i] = new XMLPropertyState(maPropMapper->FindEntryIndex(aBorderCTF[i]), pAllBorderProperty->maValue);
 143             pBorders[i] = pNewBorders[i];
 144         }
 145         if( !pBorderWidths[i] )
 146             pBorderWidths[i] = pAllBorderWidthProperty;
 147         else
 148             pBorderWidths[i]->mnIndex = -1;
 149         if( pBorders[i] )
 150         {
 151             table::BorderLine2 aBorderLine;
 152             pBorders[i]->maValue >>= aBorderLine;
 153             if( pBorderWidths[i] )
 154             {
 155                 // Merge style:border-line-width values to fo:border values. Do
 156                 // not override fo:border line width or line style with an
 157                 // empty value!
 158                 table::BorderLine2 aBorderLineWidth;
 159                 pBorderWidths[i]->maValue >>= aBorderLineWidth;
 160                 aBorderLine.OuterLineWidth = aBorderLineWidth.OuterLineWidth;
 161                 aBorderLine.InnerLineWidth = aBorderLineWidth.InnerLineWidth;
 162                 aBorderLine.LineDistance = aBorderLineWidth.LineDistance;
 163                 pBorders[i]->maValue <<= aBorderLine;
 164             }
 165         }
 166     }
 167     for( i = 0; i < 2; ++i )
 168     {
 169         if( pDiagBorders[i] && ( pDiagBorderWidths[i] || pOldDiagBorderWidths[i] ) )
 170         {
 171             table::BorderLine2 aBorderLine;
 172             pDiagBorders[i]->maValue >>= aBorderLine;
 173             table::BorderLine2 aBorderLineWidth;
 174             if (pDiagBorderWidths[i])
 175                 pDiagBorderWidths[i]->maValue >>= aBorderLineWidth;     // prefer new attribute
 176             else
 177                 pOldDiagBorderWidths[i]->maValue >>= aBorderLineWidth;
 178             aBorderLine.OuterLineWidth = aBorderLineWidth.OuterLineWidth;
 179             aBorderLine.InnerLineWidth = aBorderLineWidth.InnerLineWidth;
 180             aBorderLine.LineDistance = aBorderLineWidth.LineDistance;
 181             pDiagBorders[i]->maValue <<= aBorderLine;
 182             if (pDiagBorderWidths[i])
 183                 pDiagBorderWidths[i]->mnIndex = -1;
 184             if (pOldDiagBorderWidths[i])
 185                 pOldDiagBorderWidths[i]->mnIndex = -1;      // reset mnIndex for old and new attribute if both are present
 186         }
 187     }
 188
 189     for (i = 0; i < 4; ++i)
 190     {
 191         if (pNewPadding[i])
 192         {
 193             rProperties.push_back(*pNewPadding[i]);
 194             delete pNewPadding[i];
 195         }
 196         if (pNewBorders[i])
 197         {
 198             rProperties.push_back(*pNewBorders[i]);
 199             delete pNewBorders[i];
 200         }
 201     }
 202 }
 203
 204 ScXMLRowImportPropertyMapper::ScXMLRowImportPropertyMapper(
 205         const rtl::Reference< XMLPropertySetMapper >& rMapper,
 206         SvXMLImport& rImportP) :
 207     SvXMLImportPropertyMapper( rMapper, rImportP )
 208 {
 209 }
 210
 211 ScXMLRowImportPropertyMapper::~ScXMLRowImportPropertyMapper()
 212 {
 213 }
 214
 215 void ScXMLRowImportPropertyMapper::finished(::std::vector< XMLPropertyState >& rProperties, sal_Int32 nStartIndex, sal_Int32 nEndIndex ) const
 216 {
 217     SvXMLImportPropertyMapper::finished(rProperties, nStartIndex, nEndIndex);
 218     XMLPropertyState* pHeight(nullptr);
 219     XMLPropertyState* pOptimalHeight(nullptr);
 220     XMLPropertyState* pPageBreak(nullptr);
 221     for (auto& rProperty : rProperties)
 222     {
 223         XMLPropertyState* property = &rProperty;
 224         if (property->mnIndex != -1)
 225         {
 226             sal_Int16 nContextID = getPropertySetMapper()->GetEntryContextId(property->mnIndex);
 227             switch (nContextID)
 228             {
 229                 case CTF_SC_ROWHEIGHT                   : pHeight = property; break;
 230                 case CTF_SC_ROWOPTIMALHEIGHT            : pOptimalHeight = property; break;
 231                 case CTF_SC_ROWBREAKBEFORE              : pPageBreak = property; break;
 232             }
 233         }
 234     }
 235     if (pPageBreak)
 236     {
 237         if(!(::cppu::any2bool(pPageBreak->maValue)))
 238             pPageBreak->mnIndex = -1;
 239     }
 240     if (pOptimalHeight)
 241     {
 242         if (::cppu::any2bool(pOptimalHeight->maValue))
 243         {
 244             if (pHeight)
 245             {
 246                 // set the stored height, but keep "optimal" flag:
 247                 // pass the height value as OptimalHeight property (only allowed while loading!)
 248                 pOptimalHeight->maValue = pHeight->maValue;
 249                 pHeight->mnIndex = -1;
 250             }
 251             else
 252                 pOptimalHeight->mnIndex = -1;
 253         }
 254     }
 255     else if (pHeight)
 256     {
 257         rProperties.emplace_back(maPropMapper->FindEntryIndex(CTF_SC_ROWOPTIMALHEIGHT), css::uno::Any(false));
 258     }
 259     // don't access pointers to rProperties elements after push_back!
 260 }
 261
 262 namespace {
 263
 264 class XMLTableCellPropsContext : public SvXMLPropertySetContext
 265 {
 266     public:
 267         XMLTableCellPropsContext(
 268              SvXMLImport& rImport, sal_Int32 nElement,
 269              const uno::Reference< xml::sax::XFastAttributeList >& xAttrList,
 270              sal_uInt32 nFamily,
 271              ::std::vector< XMLPropertyState > &rProps,
 272              const rtl::Reference < SvXMLImportPropertyMapper > &rMap);
 273
 274     using SvXMLPropertySetContext::createFastChildContext;
 275     virtual css::uno::Reference< css::xml::sax::XFastContextHandler > createFastChildContext(
 276         sal_Int32 nElement,
 277         const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList,
 278         ::std::vector< XMLPropertyState > &rProperties,
 279         const XMLPropertyState& rProp ) override;
 280 };
 281
 282 }
 283
 284 XMLTableCellPropsContext::XMLTableCellPropsContext(
 285              SvXMLImport& rImport, sal_Int32 nElement,
 286              const uno::Reference< xml::sax::XFastAttributeList >& xAttrList,
 287              sal_uInt32 nFamily,
 288              ::std::vector< XMLPropertyState > &rProps,
 289              const rtl::Reference < SvXMLImportPropertyMapper > &rMap)
 290           : SvXMLPropertySetContext( rImport, nElement, xAttrList, nFamily,
 291                rProps, rMap )
 292 {
 293 }
 294
 295 css::uno::Reference< css::xml::sax::XFastContextHandler > XMLTableCellPropsContext::createFastChildContext(
 296     sal_Int32 nElement,
 297     const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList,
 298     ::std::vector< XMLPropertyState > &rProperties,
 299     const XMLPropertyState& rProp )
 300 {
 301     // no need for a custom context or indeed a SvXMLTokenMap to grab just the
 302     // single attribute ( href ) that we are interested in.
 303     // still though, we will check namespaces etc.
 304     if (nElement == XML_ELEMENT(STYLE, XML_HYPERLINK) ||
 305         nElement == XML_ELEMENT(LO_EXT, XML_HYPERLINK) )
 306     {
 307         OUString sURL;
 308         for (auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ))
 309         {
 310             if ( aIter.getToken() == XML_ELEMENT(XLINK, XML_HREF) )
 311                 sURL = aIter.toString();
 312             else
 313                 XMLOFF_WARN_UNKNOWN("sc", aIter);
 314         }
 315         if ( !sURL.isEmpty() )
 316         {
 317             XMLPropertyState aProp( rProp );
 318             aProp.maValue <<=  sURL;
 319             rProperties.push_back( aProp );
 320         }
 321     }
 322     return SvXMLPropertySetContext::createFastChildContext( nElement, xAttrList, rProperties, rProp );
 323 }
 324
 325 namespace {
 326
 327 class ScXMLMapContext : public SvXMLImportContext
 328 {
 329     OUString msApplyStyle;
 330     OUString msCondition;
 331     OUString msBaseCell;
 332
 333     ScXMLImport& GetScImport() { return static_cast<ScXMLImport&>(GetImport()); }
 334 public:
 335
 336     ScXMLMapContext(
 337             SvXMLImport& rImport, sal_Int32 nElement,
 338             const uno::Reference< xml::sax::XFastAttributeList > & xAttrList );
 339
 340     ScCondFormatEntry* CreateConditionEntry();
 341 };
 342
 343 }
 344
 345 ScXMLMapContext::ScXMLMapContext(SvXMLImport& rImport, sal_Int32 /*nElement*/,
 346             const uno::Reference< xml::sax::XFastAttributeList > & xAttrList )
 347     : SvXMLImportContext( rImport )
 348 {
 349     for( auto &aIter : sax_fastparser::castToFastAttributeList( xAttrList ) )
 350     {
 351         OUString sValue = aIter.toString();
 352         switch (aIter.getToken())
 353         {
 354             case XML_ELEMENT(STYLE, XML_CONDITION):
 355                 msCondition = sValue;
 356                 break;
 357             case XML_ELEMENT(STYLE, XML_APPLY_STYLE_NAME):
 358                 msApplyStyle = GetImport().GetStyleDisplayName( XmlStyleFamily::TABLE_CELL, sValue);
 359                 break;
 360             case XML_ELEMENT(STYLE, XML_BASE_CELL_ADDRESS):
 361                 msBaseCell = sValue;
 362                 break;
 363             default:
 364                 XMLOFF_WARN_UNKNOWN("sc", aIter);
 365         }
 366     }
 367 }
 368
 369 ScCondFormatEntry* ScXMLMapContext::CreateConditionEntry()
 370 {
 371     OUString aCondition, aConditionNmsp;
 372     FormulaGrammar::Grammar eGrammar = FormulaGrammar::GRAM_UNSPECIFIED;
 373     GetScImport().ExtractFormulaNamespaceGrammar( aCondition, aConditionNmsp, eGrammar, msCondition );
 374     bool bHasNmsp = aCondition.getLength() < msCondition.getLength();
 375
 376     // parse a condition from the attribute string
 377     ScXMLConditionParseResult aParseResult;
 378     ScXMLConditionHelper::parseCondition( aParseResult, aCondition, 0 );
 379
 380     if( !bHasNmsp )
 381     {
 382         // the attribute does not contain a namespace: try to find a namespace of an external grammar
 383         FormulaGrammar::Grammar eNewGrammar = FormulaGrammar::GRAM_UNSPECIFIED;
 384         GetScImport().ExtractFormulaNamespaceGrammar( aCondition, aConditionNmsp, eNewGrammar, aCondition, true );
 385         if( eNewGrammar != FormulaGrammar::GRAM_EXTERNAL )
 386             eGrammar = eNewGrammar;
 387     }
 388
 389     ScConditionMode eMode = ScConditionEntry::GetModeFromApi(aParseResult.meOperator);
 390     ScDocument* pDoc = GetScImport().GetDocument();
 391
 392     ScCondFormatEntry* pEntry =  new ScCondFormatEntry(eMode, aParseResult.maOperand1, aParseResult.maOperand2, *pDoc, ScAddress(), msApplyStyle,
 393                                                     OUString(), OUString(), eGrammar, eGrammar);
 394
 395     pEntry->SetSrcString(msBaseCell);
 396     return pEntry;
 397 }
 398
 399 void XMLTableStyleContext::SetAttribute( sal_Int32 nElement,
 400                                         const OUString& rValue )
 401 {
 402     switch(nElement & TOKEN_MASK)
 403     {
 404         case XML_DATA_STYLE_NAME:
 405             sDataStyleName = rValue;
 406             break;
 407         case XML_MASTER_PAGE_NAME:
 408             sPageStyle = rValue;
 409             break;
 410         default:
 411             XMLPropStyleContext::SetAttribute( nElement, rValue );
 412     }
 413 }
 414
 415
 416 XMLTableStyleContext::XMLTableStyleContext( ScXMLImport& rImport,
 417         SvXMLStylesContext& rStyles, XmlStyleFamily nFamily, bool bDefaultStyle ) :
 418     XMLPropStyleContext( rImport, rStyles, nFamily, bDefaultStyle ),
 419     pStyles(&rStyles),
 420     nNumberFormat(-1),
 421     nLastSheet(-1),
 422     bParentSet(false),
 423     mpCondFormat(nullptr),
 424     mbDeleteCondFormat(true)
 425 {
 426 }
 427
 428 XMLTableStyleContext::~XMLTableStyleContext()
 429 {
 430     if(mbDeleteCondFormat)
 431         delete mpCondFormat;
 432 }
 433
 434 css::uno::Reference< css::xml::sax::XFastContextHandler > XMLTableStyleContext::createFastChildContext(
 435     sal_Int32 nElement,
 436     const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
 437 {
 438     css::uno::Reference< css::xml::sax::XFastContextHandler > xContext;
 439
 440     if( nElement == XML_ELEMENT(STYLE, XML_MAP) )
 441     {
 442         if(!mpCondFormat)
 443             mpCondFormat = new ScConditionalFormat( 0, GetScImport().GetDocument() );
 444         ScXMLMapContext* pMapContext = new ScXMLMapContext(GetImport(), nElement, xAttrList);
 445         xContext = pMapContext;
 446         mpCondFormat->AddEntry(pMapContext->CreateConditionEntry());
 447     }
 448     else if ( nElement == XML_ELEMENT(STYLE, XML_TABLE_CELL_PROPERTIES) )
 449     {
 450         rtl::Reference < SvXMLImportPropertyMapper > xImpPrMap =
 451             GetStyles()->GetImportPropertyMapper(
 452                 GetFamily() );
 453         if( xImpPrMap.is() )
 454             xContext = new XMLTableCellPropsContext( GetImport(), nElement,
 455                 xAttrList,
 456                 XML_TYPE_PROP_TABLE_CELL,
 457                 GetProperties(),
 458                 xImpPrMap );
 459     }
 460
 461     if (!xContext)
 462         xContext = XMLPropStyleContext::createFastChildContext( nElement, xAttrList );
 463     return xContext;
 464 }
 465
 466 void XMLTableStyleContext::ApplyCondFormat( const uno::Sequence<table::CellRangeAddress>& xCellRanges )
 467 {
 468     if(!mpCondFormat || GetScImport().HasNewCondFormatData())
 469         return;
 470
 471     ScRangeList aRangeList;
 472     for(const table::CellRangeAddress& aAddress : xCellRanges)
 473     {
 474         ScRange aRange( aAddress.StartColumn, aAddress.StartRow, aAddress.Sheet, aAddress.EndColumn, aAddress.EndRow, aAddress.Sheet );
 475         aRangeList.Join( aRange );
 476     }
 477
 478     ScDocument* pDoc = GetScImport().GetDocument();
 479     SCTAB nTab = GetScImport().GetTables().GetCurrentSheet();
 480     ScConditionalFormatList* pFormatList = pDoc->GetCondFormList(nTab);
 481     auto itr = std::find_if(pFormatList->begin(), pFormatList->end(),
 482         [this](const std::unique_ptr<ScConditionalFormat>& rxFormat) { return rxFormat->EqualEntries(*mpCondFormat); });
 483     if (itr != pFormatList->end())
 484     {
 485         ScRangeList& rRangeList = (*itr)->GetRangeList();
 486         sal_uInt32 nCondId = (*itr)->GetKey();
 487         size_t n = aRangeList.size();
 488         for(size_t i = 0; i < n; ++i)
 489         {
 490             const ScRange & rRange = aRangeList[i];
 491             rRangeList.Join(rRange);
 492         }
 493
 494         pDoc->AddCondFormatData( aRangeList, nTab, nCondId );
 495         return;
 496     }
 497
 498     if(mpCondFormat && mbDeleteCondFormat)
 499     {
 500         sal_uLong nIndex = pDoc->AddCondFormat(std::unique_ptr<ScConditionalFormat>(mpCondFormat), nTab );
 501         mpCondFormat->SetKey(nIndex);
 502         mpCondFormat->SetRange(aRangeList);
 503
 504         pDoc->AddCondFormatData( aRangeList, nTab, nIndex );
 505         mbDeleteCondFormat = false;
 506     }
 507
 508 }
 509
 510 void XMLTableStyleContext::FillPropertySet(
 511     const uno::Reference< XPropertySet > & rPropSet )
 512 {
 513     if (!IsDefaultStyle())
 514     {
 515         if (GetFamily() == XmlStyleFamily::TABLE_CELL)
 516         {
 517             if (!bParentSet)
 518             {
 519                 AddProperty(CTF_SC_CELLSTYLE, uno::Any(GetImport().GetStyleDisplayName( XmlStyleFamily::TABLE_CELL, GetParentName() )));
 520                 bParentSet = true;
 521             }
 522             sal_Int32 nNumFmt = GetNumberFormat();
 523             if (nNumFmt >= 0)
 524                 AddProperty(CTF_SC_NUMBERFORMAT, uno::Any(nNumFmt));
 525         }
 526         else if (GetFamily() == XmlStyleFamily::TABLE_TABLE)
 527         {
 528             if (!sPageStyle.isEmpty())
 529                 AddProperty(CTF_SC_MASTERPAGENAME, uno::Any(GetImport().GetStyleDisplayName( XmlStyleFamily::MASTER_PAGE, sPageStyle )));
 530         }
 531     }
 532     XMLPropStyleContext::FillPropertySet(rPropSet);
 533 }
 534
 535 void XMLTableStyleContext::SetDefaults()
 536 {
 537     if ((GetFamily() == XmlStyleFamily::TABLE_CELL) && GetImport().GetModel().is())
 538     {
 539         uno::Reference <lang::XMultiServiceFactory> xMultiServiceFactory(GetImport().GetModel(), uno::UNO_QUERY);
 540         if (xMultiServiceFactory.is())
 541         {
 542             uno::Reference <beans::XPropertySet> xProperties(xMultiServiceFactory->createInstance("com.sun.star.sheet.Defaults"), uno::UNO_QUERY);
 543             if (xProperties.is())
 544                 FillPropertySet(xProperties);
 545         }
 546     }
 547 }
 548
 549 void XMLTableStyleContext::AddProperty(const sal_Int16 nContextID, const uno::Any& rValue)
 550 {
 551     XMLPropertyState* property = FindProperty(nContextID);
 552     if (property)
 553         property->mnIndex = -1; // #i46996# remove old property, so it isn't double
 554     sal_Int32 nIndex(static_cast<XMLTableStylesContext *>(pStyles)->GetIndex(nContextID));
 555     OSL_ENSURE(nIndex != -1, "Property not found in Map");
 556     XMLPropertyState aPropState(nIndex, rValue);
 557     GetProperties().push_back(aPropState); // has to be inserted in a sort order later
 558 }
 559
 560 XMLPropertyState* XMLTableStyleContext::FindProperty(const sal_Int16 nContextID)
 561 {
 562     XMLPropertyState* pRet = nullptr;
 563     rtl::Reference < XMLPropertySetMapper > xPrMap;
 564     rtl::Reference < SvXMLImportPropertyMapper > xImpPrMap =
 565         pStyles->GetImportPropertyMapper( GetFamily() );
 566     OSL_ENSURE( xImpPrMap.is(), "There is the import prop mapper" );
 567     if( xImpPrMap.is() )
 568         xPrMap = xImpPrMap->getPropertySetMapper();
 569     if( xPrMap.is() )
 570     {
 571         auto aIter = std::find_if(GetProperties().begin(), GetProperties().end(),
 572             [&xPrMap, &nContextID](const XMLPropertyState& rProp) {
 573                 return rProp.mnIndex != -1 && xPrMap->GetEntryContextId(rProp.mnIndex) == nContextID;
 574             });
 575         if (aIter != GetProperties().end())
 576             pRet = &(*aIter);
 577     }
 578     return pRet;
 579 }
 580
 581 sal_Int32 XMLTableStyleContext::GetNumberFormat()
 582 {
 583     if (nNumberFormat < 0 && !sDataStyleName.isEmpty())
 584     {
 585         const SvXMLNumFormatContext* pStyle = static_cast<const SvXMLNumFormatContext*>(
 586             pStyles->FindStyleChildContext(XmlStyleFamily::DATA_STYLE, sDataStyleName, true));
 587
 588         if (!pStyle)
 589         {
 590             XMLTableStylesContext* pMyStyles = static_cast<XMLTableStylesContext*>(GetScImport().GetStyles());
 591             if (pMyStyles)
 592                 pStyle = static_cast<const SvXMLNumFormatContext*>(
 593                     pMyStyles->FindStyleChildContext(XmlStyleFamily::DATA_STYLE, sDataStyleName, true));
 594             else
 595             {
 596                 OSL_FAIL("not possible to get style");
 597             }
 598         }
 599         if (pStyle)
 600             nNumberFormat = const_cast<SvXMLNumFormatContext*>(pStyle)->GetKey();
 601     }
 602     return nNumberFormat;
 603 }
 604
 605 SvXMLStyleContext *XMLTableStylesContext::CreateStyleStyleChildContext(
 606         XmlStyleFamily nFamily, sal_Int32 nElement,
 607         const uno::Reference< xml::sax::XFastAttributeList > & xAttrList )
 608 {
 609     SvXMLStyleContext *pStyle;
 610     // use own wrapper for text and paragraph, to record style usage
 611     if (nFamily == XmlStyleFamily::TEXT_PARAGRAPH || nFamily == XmlStyleFamily::TEXT_TEXT)
 612         pStyle = new  ScCellTextStyleContext( GetImport(),*this, nFamily );
 613     else
 614         pStyle = SvXMLStylesContext::CreateStyleStyleChildContext(
 615                     nFamily, nElement, xAttrList );
 616
 617     if (!pStyle)
 618     {
 619         switch( nFamily )
 620         {
 621         case XmlStyleFamily::TABLE_CELL:
 622         case XmlStyleFamily::TABLE_COLUMN:
 623         case XmlStyleFamily::TABLE_ROW:
 624         case XmlStyleFamily::TABLE_TABLE:
 625             pStyle = new XMLTableStyleContext( GetScImport(), *this, nFamily );
 626             break;
 627         default: break;
 628         }
 629     }
 630
 631     return pStyle;
 632 }
 633
 634 SvXMLStyleContext *XMLTableStylesContext::CreateDefaultStyleStyleChildContext(
 635         XmlStyleFamily nFamily, sal_Int32 nElement,
 636         const uno::Reference< xml::sax::XFastAttributeList > & xAttrList )
 637 {
 638     SvXMLStyleContext *pStyle(SvXMLStylesContext::CreateDefaultStyleStyleChildContext( nFamily, nElement,
 639                                                             xAttrList ));
 640     if (!pStyle)
 641     {
 642         switch( nFamily )
 643         {
 644             case XmlStyleFamily::TABLE_CELL:
 645                 pStyle = new XMLTableStyleContext( GetScImport(), *this, nFamily, true);
 646             break;
 647             case XmlStyleFamily::SD_GRAPHICS_ID:
 648                 pStyle = new XMLGraphicsDefaultStyle( GetScImport(), *this);
 649             break;
 650             default: break;
 651         }
 652     }
 653
 654     return pStyle;
 655 }
 656
 657 constexpr OUStringLiteral gsCellStyleServiceName(u"com.sun.star.style.CellStyle");
 658
 659 XMLTableStylesContext::XMLTableStylesContext( SvXMLImport& rImport,
 660         const bool bTempAutoStyles )
 661     : SvXMLStylesContext( rImport )
 662     , nNumberFormatIndex(-1)
 663     , nConditionalFormatIndex(-1)
 664     , nCellStyleIndex(-1)
 665     , nMasterPageNameIndex(-1)
 666     , bAutoStyles(bTempAutoStyles)
 667 {
 668 }
 669
 670 XMLTableStylesContext::~XMLTableStylesContext()
 671 {
 672 }
 673
 674 void XMLTableStylesContext::endFastElement(sal_Int32 )
 675 {
 676     if (bAutoStyles)
 677         GetImport().GetTextImport()->SetAutoStyles( this );
 678     else
 679         GetScImport().InsertStyles();
 680 }
 681
 682 rtl::Reference < SvXMLImportPropertyMapper >
 683     XMLTableStylesContext::GetImportPropertyMapper(
 684                     XmlStyleFamily nFamily ) const
 685 {
 686     rtl::Reference < SvXMLImportPropertyMapper > xMapper(SvXMLStylesContext::GetImportPropertyMapper(nFamily));
 687
 688     if (!xMapper.is())
 689     {
 690         switch( nFamily )
 691         {
 692             case XmlStyleFamily::TABLE_CELL:
 693             {
 694                 if( !xCellImpPropMapper.is() )
 695                 {
 696                     const_cast<XMLTableStylesContext *>(this)->xCellImpPropMapper =
 697                         new ScXMLCellImportPropertyMapper( GetScImport().GetCellStylesPropertySetMapper(), const_cast<SvXMLImport&>(GetImport()) );
 698                     xCellImpPropMapper->ChainImportMapper(XMLTextImportHelper::CreateParaExtPropMapper(const_cast<SvXMLImport&>(GetImport())));
 699                 }
 700                 xMapper = xCellImpPropMapper;
 701             }
 702             break;
 703             case XmlStyleFamily::TABLE_COLUMN:
 704             {
 705                 if( !xColumnImpPropMapper.is() )
 706                     const_cast<XMLTableStylesContext *>(this)->xColumnImpPropMapper =
 707                         new SvXMLImportPropertyMapper( GetScImport().GetColumnStylesPropertySetMapper(), const_cast<SvXMLImport&>(GetImport()) );
 708                 xMapper = xColumnImpPropMapper;
 709             }
 710              break;
 711             case XmlStyleFamily::TABLE_ROW:
 712             {
 713                 if( !xRowImpPropMapper.is() )
 714                     const_cast<XMLTableStylesContext *>(this)->xRowImpPropMapper =
 715                         new ScXMLRowImportPropertyMapper( GetScImport().GetRowStylesPropertySetMapper(), const_cast<SvXMLImport&>(GetImport()) );
 716                 xMapper = xRowImpPropMapper;
 717             }
 718              break;
 719             case XmlStyleFamily::TABLE_TABLE:
 720             {
 721                 if( !xTableImpPropMapper.is() )
 722                     const_cast<XMLTableStylesContext *>(this)->xTableImpPropMapper =
 723                         new SvXMLImportPropertyMapper( GetScImport().GetTableStylesPropertySetMapper(), const_cast<SvXMLImport&>(GetImport()) );
 724                 xMapper = xTableImpPropMapper;
 725             }
 726              break;
 727             default: break;
 728         }
 729     }
 730
 731     return xMapper;
 732 }
 733
 734 uno::Reference < XNameContainer >
 735         XMLTableStylesContext::GetStylesContainer( XmlStyleFamily nFamily ) const
 736 {
 737     uno::Reference < XNameContainer > xStyles(SvXMLStylesContext::GetStylesContainer(nFamily));
 738     if (!xStyles.is())
 739     {
 740         OUString sName;
 741         switch( nFamily )
 742         {
 743             case XmlStyleFamily::TABLE_TABLE:
 744             {
 745                 if( xTableStyles.is() )
 746                     xStyles.set(xTableStyles);
 747                 else
 748                     sName = "TableStyles";
 749             }
 750             break;
 751             case XmlStyleFamily::TABLE_CELL:
 752             {
 753                 if( xCellStyles.is() )
 754                     xStyles.set(xCellStyles);
 755                 else
 756                     sName = "CellStyles";
 757             }
 758             break;
 759             case XmlStyleFamily::TABLE_COLUMN:
 760             {
 761                 if( xColumnStyles.is() )
 762                     xStyles.set(xColumnStyles);
 763                 else
 764                     sName = "ColumnStyles";
 765             }
 766             break;
 767             case XmlStyleFamily::TABLE_ROW:
 768             {
 769                 if( xRowStyles.is() )
 770                     xStyles.set(xRowStyles);
 771                 else
 772                     sName = "RowStyles";
 773             }
 774             break;
 775             default: break;
 776         }
 777         if( !xStyles.is() && !sName.isEmpty() && GetScImport().GetModel().is() )
 778         {
 779             uno::Reference< XStyleFamiliesSupplier > xFamiliesSupp(
 780                                             GetScImport().GetModel(), UNO_QUERY );
 781             if (xFamiliesSupp.is())
 782             {
 783                 uno::Reference< XNameAccess > xFamilies(xFamiliesSupp->getStyleFamilies());
 784
 785                 try
 786                 {
 787                     xStyles.set(xFamilies->getByName( sName ), uno::UNO_QUERY);
 788                 }
 789                 catch ( uno::Exception& )
 790                 {
 791                     // #i97680# Named table/column/row styles aren't supported, getByName will throw an exception.
 792                     // For better interoperability, these styles should then be handled as automatic styles.
 793                     // For now, NULL is returned (and the style is ignored).
 794                 }
 795                 switch( nFamily )
 796                 {
 797                 case XmlStyleFamily::TABLE_TABLE:
 798                     const_cast<XMLTableStylesContext *>(this)->xTableStyles.set(xStyles);
 799                     break;
 800                 case XmlStyleFamily::TABLE_CELL:
 801                     const_cast<XMLTableStylesContext *>(this)->xCellStyles.set(xStyles);
 802                     break;
 803                 case XmlStyleFamily::TABLE_COLUMN:
 804                     const_cast<XMLTableStylesContext *>(this)->xColumnStyles.set(xStyles);
 805                     break;
 806                 case XmlStyleFamily::TABLE_ROW:
 807                     const_cast<XMLTableStylesContext *>(this)->xRowStyles.set(xStyles);
 808                     break;
 809                 default: break;
 810                 }
 811             }
 812         }
 813     }
 814
 815     return xStyles;
 816 }
 817
 818 OUString XMLTableStylesContext::GetServiceName( XmlStyleFamily nFamily ) const
 819 {
 820     OUString sServiceName(SvXMLStylesContext::GetServiceName(nFamily));
 821     if (sServiceName.isEmpty())
 822     {
 823         switch( nFamily )
 824         {
 825         case XmlStyleFamily::TABLE_COLUMN:
 826             sServiceName = XML_STYLE_FAMILY_TABLE_COLUMN_STYLES_NAME;
 827             break;
 828         case XmlStyleFamily::TABLE_ROW:
 829             sServiceName = XML_STYLE_FAMILY_TABLE_ROW_STYLES_NAME;
 830             break;
 831         case XmlStyleFamily::TABLE_CELL:
 832             sServiceName = gsCellStyleServiceName;
 833             break;
 834         case XmlStyleFamily::TABLE_TABLE:
 835             sServiceName = XML_STYLE_FAMILY_TABLE_TABLE_STYLES_NAME;
 836             break;
 837         default: break;
 838         }
 839     }
 840     return sServiceName;
 841 }
 842
 843 sal_Int32 XMLTableStylesContext::GetIndex(const sal_Int16 nContextID)
 844 {
 845     if (nContextID == CTF_SC_CELLSTYLE)
 846     {
 847         if (nCellStyleIndex == -1)
 848             nCellStyleIndex =
 849                 GetImportPropertyMapper(XmlStyleFamily::TABLE_CELL)->getPropertySetMapper()->FindEntryIndex(nContextID);
 850         return nCellStyleIndex;
 851     }
 852     else if (nContextID == CTF_SC_NUMBERFORMAT)
 853     {
 854         if (nNumberFormatIndex == -1)
 855             nNumberFormatIndex =
 856                 GetImportPropertyMapper(XmlStyleFamily::TABLE_CELL)->getPropertySetMapper()->FindEntryIndex(nContextID);
 857         return nNumberFormatIndex;
 858     }
 859     else if (nContextID == CTF_SC_IMPORT_MAP)
 860     {
 861         if (nConditionalFormatIndex == -1)
 862             nConditionalFormatIndex =
 863                 GetImportPropertyMapper(XmlStyleFamily::TABLE_CELL)->getPropertySetMapper()->FindEntryIndex(nContextID);
 864         return nConditionalFormatIndex;
 865     }
 866     else if (nContextID == CTF_SC_MASTERPAGENAME)
 867     {
 868         if (nMasterPageNameIndex == -1)
 869                 nMasterPageNameIndex =
 870                 GetImportPropertyMapper(XmlStyleFamily::TABLE_TABLE)->getPropertySetMapper()->FindEntryIndex(nContextID);
 871         return nMasterPageNameIndex;
 872     }
 873     else
 874         return -1;
 875 }
 876
 877
 878 bool ScXMLMasterStylesContext::InsertStyleFamily( XmlStyleFamily ) const
 879 {
 880     return true;
 881 }
 882
 883 ScXMLMasterStylesContext::ScXMLMasterStylesContext( SvXMLImport& rImport ) :
 884     SvXMLStylesContext( rImport )
 885 {
 886 }
 887
 888 ScXMLMasterStylesContext::~ScXMLMasterStylesContext()
 889 {
 890 }
 891
 892 SvXMLStyleContext *ScXMLMasterStylesContext::CreateStyleChildContext(
 893         sal_Int32 nElement,
 894         const uno::Reference< XFastAttributeList > & xAttrList )
 895 {
 896     SvXMLStyleContext *pContext(nullptr);
 897
 898     if( nElement == XML_ELEMENT(STYLE, XML_MASTER_PAGE) &&
 899          InsertStyleFamily( XmlStyleFamily::MASTER_PAGE ) )
 900         pContext = new ScMasterPageContext(
 901                         GetImport(), nElement, xAttrList,
 902                         !GetImport().GetTextImport()->IsInsertMode() );
 903
 904     // any other style will be ignored here!
 905
 906     return pContext;
 907 }
 908
 909 SvXMLStyleContext *ScXMLMasterStylesContext::CreateStyleStyleChildContext(
 910         XmlStyleFamily /* nFamily */,
 911         sal_Int32 /* nElement */,
 912         const uno::Reference< XFastAttributeList > & /* xAttrList */ )
 913 {
 914     return nullptr;
 915 }
 916
 917 void ScXMLMasterStylesContext::endFastElement(sal_Int32 )
 918 {
 919     FinishStyles(true);
 920 }
 921
 922
 923 ScMasterPageContext::ScMasterPageContext( SvXMLImport& rImport,
 924         sal_Int32 nElement,
 925         const uno::Reference< XFastAttributeList > & xAttrList,
 926         bool bOverwrite ) :
 927     XMLTextMasterPageContext( rImport, nElement, xAttrList, bOverwrite ),
 928     bContainsRightHeader(false),
 929     bContainsRightFooter(false)
 930 {
 931 }
 932
 933 ScMasterPageContext::~ScMasterPageContext()
 934 {
 935 }
 936
 937 SvXMLImportContext *ScMasterPageContext::CreateHeaderFooterContext(
 938             sal_Int32 nElement,
 939             const css::uno::Reference< css::xml::sax::XFastAttributeList > & xAttrList,
 940             const bool bFooter,
 941             const bool bLeft,
 942             const bool bFirst )
 943 {
 944     if (!bLeft)
 945     {
 946         if (bFooter)
 947             bContainsRightFooter = true;
 948         else
 949             bContainsRightHeader = true;
 950     }
 951     if (!xPropSet.is())
 952         xPropSet.set(GetStyle(), UNO_QUERY );
 953     return new XMLTableHeaderFooterContext( GetImport(),
 954                                                 nElement,
 955                                                 xAttrList,
 956                                                 xPropSet,
 957                                                 bFooter, bLeft, bFirst );
 958 }
 959
 960 void ScMasterPageContext::ClearContent(const OUString& rContent)
 961 {
 962     if (!xPropSet.is())
 963         xPropSet.set(GetStyle(), UNO_QUERY );
 964
 965     if (xPropSet.is())
 966     {
 967         uno::Reference < sheet::XHeaderFooterContent > xHeaderFooterContent(xPropSet->getPropertyValue( rContent ), uno::UNO_QUERY);
 968         if (xHeaderFooterContent.is())
 969         {
 970             xHeaderFooterContent->getLeftText()->setString("");
 971             xHeaderFooterContent->getCenterText()->setString("");
 972             xHeaderFooterContent->getRightText()->setString("");
 973             xPropSet->setPropertyValue( rContent, uno::Any(xHeaderFooterContent) );
 974         }
 975     }
 976 }
 977
 978 void ScMasterPageContext::Finish( bool bOverwrite )
 979 {
 980     XMLTextMasterPageContext::Finish(bOverwrite);
 981     if (!bContainsRightFooter)
 982         ClearContent(SC_UNO_PAGE_RIGHTFTRCON);
 983     if (!bContainsRightHeader)
 984         ClearContent(SC_UNO_PAGE_RIGHTHDRCON);
 985 }
 986
 987 ScCellTextStyleContext::ScCellTextStyleContext( SvXMLImport& rImport,
 988             SvXMLStylesContext& rStyles, XmlStyleFamily nFamily ) :
 989     XMLTextStyleContext( rImport, rStyles, nFamily, false/*bDefaultStyle*/ ),
 990     nLastSheet(-1)
 991 {
 992 }
 993
 994 ScCellTextStyleContext::~ScCellTextStyleContext()
 995 {
 996 }
 997
 998 void ScCellTextStyleContext::FillPropertySet( const uno::Reference<beans::XPropertySet>& xPropSet )
 999 {
1000     XMLTextStyleContext::FillPropertySet( xPropSet );
1001
1002     ScXMLImport& rXMLImport = GetScImport();
1003
1004     ScCellTextCursor* pCellImp = comphelper::getFromUnoTunnel<ScCellTextCursor>( xPropSet );
1005     if (pCellImp)
1006     {
1007         ScAddress aPos = pCellImp->GetCellObj().GetPosition();
1008         if ( aPos.Tab() != nLastSheet )
1009         {
1010             ESelection aSel = pCellImp->GetSelection();
1011
1012             ScSheetSaveData* pSheetData = comphelper::getFromUnoTunnel<ScModelObj>(GetImport().GetModel())->GetSheetSaveData();
1013             pSheetData->AddTextStyle( GetName(), aPos, aSel );
1014
1015             nLastSheet = aPos.Tab();
1016         }
1017     }
1018     else if ( rXMLImport.GetTables().GetCurrentSheet() != nLastSheet )
1019     {
1020         ScDrawTextCursor* pDrawImp = comphelper::getFromUnoTunnel<ScDrawTextCursor>( xPropSet );
1021         if (pDrawImp)
1022         {
1023             XMLTableShapeImportHelper* pTableShapeImport = static_cast<XMLTableShapeImportHelper*>(GetScImport().GetShapeImport().get());
1024             ScXMLAnnotationContext* pAnnotationContext = pTableShapeImport->GetAnnotationContext();
1025             if (pAnnotationContext)
1026             {
1027                 pAnnotationContext->AddContentStyle( GetFamily(), GetName(), pDrawImp->GetSelection() );
1028                 nLastSheet = rXMLImport.GetTables().GetCurrentSheet();
1029             }
1030         }
1031
1032         // if it's a different shape, BlockSheet is called from XMLTableShapeImportHelper::finishShape
1033         // formatted text in page headers/footers can be ignored
1034     }
1035 }
1036
1037 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */