sc/source/filter/xml/xmlrowi.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 "xmlrowi.hxx"
  21 #include "xmlimprt.hxx"
  22 #include "xmlcelli.hxx"
  23 #include "xmlstyli.hxx"
  24 #include "xmlstyle.hxx"
  25 #include <document.hxx>
  26 #include <docuno.hxx>
  27 #include <olinetab.hxx>
  28 #include <sheetdata.hxx>
  29 #include <documentimport.hxx>
  30 #include <unonames.hxx>
  31
  32 #include <comphelper/extract.hxx>
  33 #include <comphelper/configuration.hxx>
  34 #include <xmloff/xmlnamespace.hxx>
  35 #include <xmloff/families.hxx>
  36 #include <xmloff/xmltoken.hxx>
  37 #include <sax/fastattribs.hxx>
  38 #include <com/sun/star/sheet/XSpreadsheet.hpp>
  39 #include <com/sun/star/table/XColumnRowRange.hpp>
  40 #include <com/sun/star/sheet/XPrintAreas.hpp>
  41 #include <comphelper/servicehelper.hxx>
  42 #include <osl/diagnose.h>
  43
  44 constexpr OUStringLiteral SC_ISFILTERED = u"IsFiltered";
  45
  46 using namespace com::sun::star;
  47 using namespace xmloff::token;
  48
  49 ScXMLTableRowContext::ScXMLTableRowContext( ScXMLImport& rImport,
  50                                       const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList ) :
  51     ScXMLImportContext( rImport ),
  52     sVisibility(GetXMLToken(XML_VISIBLE)),
  53     nRepeatedRows(1),
  54     bHasCell(false)
  55 {
  56     OUString sCellStyleName;
  57     if ( rAttrList.is() )
  58     {
  59         for (auto &it : *rAttrList)
  60         {
  61             switch (it.getToken())
  62             {
  63                 case XML_ELEMENT( TABLE, XML_STYLE_NAME ):
  64                 {
  65                     sStyleName = it.toString();
  66                 }
  67                 break;
  68                 case XML_ELEMENT( TABLE, XML_VISIBILITY ):
  69                 {
  70                     sVisibility = it.toString();
  71                 }
  72                 break;
  73                 case XML_ELEMENT( TABLE, XML_NUMBER_ROWS_REPEATED ):
  74                 {
  75                     if (ScDocument* pDoc = rImport.GetDocument())
  76                     {
  77                         nRepeatedRows = std::max( it.toInt32(), sal_Int32(1) );
  78                         nRepeatedRows = std::min( nRepeatedRows, pDoc->GetSheetLimits().GetMaxRowCount() );
  79                         if (comphelper::IsFuzzing())
  80                             nRepeatedRows = std::min(nRepeatedRows, sal_Int32(1024));
  81                     }
  82                 }
  83                 break;
  84                 case XML_ELEMENT( TABLE, XML_DEFAULT_CELL_STYLE_NAME ):
  85                 {
  86                     sCellStyleName = it.toString();
  87                 }
  88                 break;
  89                 /*case XML_ELEMENT( TABLE, XML_USE_OPTIMAL_HEIGHT ):
  90                 {
  91                     sOptimalHeight = it.toString();
  92                 }
  93                 break;*/
  94             }
  95         }
  96     }
  97
  98     GetScImport().GetTables().AddRow();
  99     GetScImport().GetTables().SetRowStyle(sCellStyleName);
 100 }
 101
 102 ScXMLTableRowContext::~ScXMLTableRowContext()
 103 {
 104 }
 105
 106 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL
 107         ScXMLTableRowContext::createFastChildContext( sal_Int32 nElement,
 108         const uno::Reference< xml::sax::XFastAttributeList > & xAttrList )
 109 {
 110     SvXMLImportContext *pContext(nullptr);
 111     sax_fastparser::FastAttributeList *pAttribList =
 112         &sax_fastparser::castToFastAttributeList( xAttrList );
 113
 114     switch( nElement )
 115     {
 116     case XML_ELEMENT( TABLE, XML_TABLE_CELL ):
 117 //      if( IsInsertCellPossible() )
 118         {
 119             bHasCell = true;
 120             pContext = new ScXMLTableRowCellContext( GetScImport(),
 121                                                        pAttribList, false, static_cast<SCROW>(nRepeatedRows)
 122                                                       //this
 123                                                       );
 124         }
 125         break;
 126     case XML_ELEMENT( TABLE, XML_COVERED_TABLE_CELL ):
 127 //      if( IsInsertCellPossible() )
 128         {
 129             bHasCell = true;
 130             pContext = new ScXMLTableRowCellContext( GetScImport(),
 131                                                       pAttribList, true, static_cast<SCROW>(nRepeatedRows)
 132                                                       //this
 133                                                       );
 134         }
 135         break;
 136     }
 137
 138     return pContext;
 139 }
 140
 141 void SAL_CALL ScXMLTableRowContext::endFastElement(sal_Int32 /*nElement*/)
 142 {
 143     ScXMLImport& rXMLImport(GetScImport());
 144     ScDocument* pDoc(rXMLImport.GetDocument());
 145     if (!pDoc)
 146         return;
 147
 148     if (!bHasCell && nRepeatedRows > 1)
 149     {
 150         for (sal_Int32 i = 0; i < nRepeatedRows - 1; ++i) //one row is always added
 151             GetScImport().GetTables().AddRow();
 152         OSL_FAIL("it seems here is a nonvalid file; possible missing of table:table-cell element");
 153     }
 154     SCTAB nSheet = rXMLImport.GetTables().GetCurrentSheet();
 155     sal_Int32 nCurrentRow(rXMLImport.GetTables().GetCurrentRow());
 156     uno::Reference<sheet::XSpreadsheet> xSheet(rXMLImport.GetTables().GetCurrentXSheet());
 157     if(!xSheet.is())
 158         return;
 159
 160     sal_Int32 nFirstRow(nCurrentRow - nRepeatedRows + 1);
 161     if (nFirstRow > pDoc->MaxRow())
 162         nFirstRow = pDoc->MaxRow();
 163     if (nCurrentRow > pDoc->MaxRow())
 164         nCurrentRow = pDoc->MaxRow();
 165     uno::Reference <table::XCellRange> xCellRange(xSheet->getCellRangeByPosition(0, nFirstRow, 0, nCurrentRow));
 166     if (!xCellRange.is())
 167         return;
 168
 169     uno::Reference<table::XColumnRowRange> xColumnRowRange (xCellRange, uno::UNO_QUERY);
 170     if (!xColumnRowRange.is())
 171         return;
 172
 173     uno::Reference <beans::XPropertySet> xRowProperties(xColumnRowRange->getRows(), uno::UNO_QUERY);
 174     if (!xRowProperties.is())
 175         return;
 176
 177     XMLTableStyleContext* ptmpStyle = nullptr;
 178
 179     if (!sStyleName.isEmpty())
 180     {
 181         XMLTableStylesContext *pStyles(static_cast<XMLTableStylesContext *>(rXMLImport.GetAutoStyles()));
 182         if ( pStyles )
 183         {
 184             XMLTableStyleContext* pStyle(const_cast<XMLTableStyleContext*>(static_cast<const XMLTableStyleContext *>(pStyles->FindStyleChildContext(
 185                 XmlStyleFamily::TABLE_ROW, sStyleName, true))));
 186             if (pStyle)
 187             {
 188                 pStyle->FillPropertySet(xRowProperties);
 189
 190                 if ( nSheet != pStyle->GetLastSheet() )
 191                 {
 192                     ScSheetSaveData* pSheetData = rXMLImport.GetScModel()->GetSheetSaveData();
 193                     pSheetData->AddRowStyle( sStyleName, ScAddress( 0, static_cast<SCROW>(nFirstRow), nSheet ) );
 194                     pStyle->SetLastSheet(nSheet);
 195                 }
 196
 197                 // for later checking of optimal row height
 198                 ptmpStyle = pStyle;
 199             }
 200         }
 201     }
 202     bool bVisible (true);
 203     bool bFiltered (false);
 204     if (IsXMLToken(sVisibility, XML_COLLAPSE))
 205     {
 206         bVisible = false;
 207     }
 208     else if (IsXMLToken(sVisibility, XML_FILTER))
 209     {
 210         bVisible = false;
 211         bFiltered = true;
 212     }
 213     if (!bVisible)
 214     {
 215         rXMLImport.GetDoc().setRowsVisible(nSheet, nFirstRow, nCurrentRow, false);
 216     }
 217     if (bFiltered)
 218         xRowProperties->setPropertyValue(SC_ISFILTERED, uno::Any(bFiltered));
 219
 220     uno::Any any = xRowProperties->getPropertyValue(SC_UNONAME_OHEIGHT);
 221     bool bOptionalHeight = false;
 222     any >>= bOptionalHeight;
 223     if (bOptionalHeight)
 224     {
 225         // Save this row for later height update, only if we have no already optimal row heights
 226         // If we have already optimal row heights, recalc only the first 200 row in case of optimal document loading
 227         std::vector<ScDocRowHeightUpdater::TabRanges>& rRecalcRanges = rXMLImport.GetRecalcRowRanges();
 228         while (static_cast<SCTAB>(rRecalcRanges.size()) <= nSheet)
 229         {
 230             rRecalcRanges.emplace_back(0, pDoc->MaxRow());
 231         }
 232         rRecalcRanges.at(nSheet).mnTab = nSheet;
 233
 234         // check that, we already have valid optimal row heights
 235         if (nCurrentRow > 200 && ptmpStyle && !ptmpStyle->FindProperty(CTF_SC_ROWHEIGHT))
 236         {
 237             XMLPropertyState* pOptimalHeight = ptmpStyle->FindProperty(CTF_SC_ROWOPTIMALHEIGHT);
 238             if (pOptimalHeight && ::cppu::any2bool(pOptimalHeight->maValue))
 239             {
 240                 rRecalcRanges.at(nSheet).maRanges.setFalse(nFirstRow, nCurrentRow);
 241             }
 242             else
 243             {
 244                 rRecalcRanges.at(nSheet).maRanges.setTrue(nFirstRow, nCurrentRow);
 245             }
 246         }
 247         else
 248         {
 249             rRecalcRanges.at(nSheet).maRanges.setTrue(nFirstRow, nCurrentRow);
 250         }
 251     }
 252 }
 253
 254 ScXMLTableRowsContext::ScXMLTableRowsContext( ScXMLImport& rImport,
 255                                       const rtl::Reference<sax_fastparser::FastAttributeList>& rAttrList,
 256                                       const bool bTempHeader,
 257                                       const bool bTempGroup ) :
 258     ScXMLImportContext( rImport ),
 259     nHeaderStartRow(0),
 260     nGroupStartRow(0),
 261     bHeader(bTempHeader),
 262     bGroup(bTempGroup),
 263     bGroupDisplay(true)
 264 {
 265     // don't have any attributes
 266     if (bHeader)
 267     {
 268         ScAddress aAddr = rImport.GetTables().GetCurrentCellPos();
 269         nHeaderStartRow = aAddr.Row();
 270         ++nHeaderStartRow;
 271     }
 272     else if (bGroup)
 273     {
 274         nGroupStartRow = rImport.GetTables().GetCurrentRow();
 275         ++nGroupStartRow;
 276         if ( rAttrList.is() )
 277         {
 278             auto aIter( rAttrList->find( XML_ELEMENT( TABLE, XML_DISPLAY ) ) );
 279             if (aIter != rAttrList->end())
 280                 bGroupDisplay = IsXMLToken( aIter, XML_TRUE );
 281         }
 282     }
 283 }
 284
 285 ScXMLTableRowsContext::~ScXMLTableRowsContext()
 286 {
 287 }
 288
 289 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL
 290         ScXMLTableRowsContext::createFastChildContext( sal_Int32 nElement,
 291         const uno::Reference< xml::sax::XFastAttributeList > & xAttrList )
 292 {
 293     SvXMLImportContext *pContext(nullptr);
 294     sax_fastparser::FastAttributeList *pAttribList =
 295         &sax_fastparser::castToFastAttributeList( xAttrList );
 296
 297     switch( nElement )
 298     {
 299     case XML_ELEMENT( TABLE, XML_TABLE_ROW_GROUP ):
 300         pContext = new ScXMLTableRowsContext( GetScImport(), pAttribList,
 301                                                    false, true );
 302         break;
 303     case XML_ELEMENT( TABLE, XML_TABLE_HEADER_ROWS ):
 304         pContext = new ScXMLTableRowsContext( GetScImport(), pAttribList,
 305                                                    true, false );
 306         break;
 307     case XML_ELEMENT( TABLE, XML_TABLE_ROWS ):
 308         pContext = new ScXMLTableRowsContext( GetScImport(), pAttribList,
 309                                                    false, false );
 310         break;
 311     case XML_ELEMENT( TABLE, XML_TABLE_ROW ):
 312         pContext = new ScXMLTableRowContext( GetScImport(), pAttribList );
 313         break;
 314     }
 315
 316     return pContext;
 317 }
 318
 319 void SAL_CALL ScXMLTableRowsContext::endFastElement(sal_Int32 /*nElement*/)
 320 {
 321     ScXMLImport& rXMLImport(GetScImport());
 322     if (bHeader)
 323     {
 324         SCROW nHeaderEndRow = rXMLImport.GetTables().GetCurrentRow();
 325         if (nHeaderStartRow <= nHeaderEndRow)
 326         {
 327             uno::Reference <sheet::XPrintAreas> xPrintAreas (rXMLImport.GetTables().GetCurrentXSheet(), uno::UNO_QUERY);
 328             if (xPrintAreas.is())
 329             {
 330                 if (!xPrintAreas->getPrintTitleRows())
 331                 {
 332                     xPrintAreas->setPrintTitleRows(true);
 333                     table::CellRangeAddress aRowHeaderRange;
 334                     aRowHeaderRange.StartRow = nHeaderStartRow;
 335                     aRowHeaderRange.EndRow = nHeaderEndRow;
 336                     xPrintAreas->setTitleRows(aRowHeaderRange);
 337                 }
 338                 else
 339                 {
 340                     table::CellRangeAddress aRowHeaderRange(xPrintAreas->getTitleRows());
 341                     aRowHeaderRange.EndRow = nHeaderEndRow;
 342                     xPrintAreas->setTitleRows(aRowHeaderRange);
 343                 }
 344             }
 345         }
 346     }
 347     else if (bGroup)
 348     {
 349         SCROW nGroupEndRow = rXMLImport.GetTables().GetCurrentRow();
 350         SCTAB nSheet(rXMLImport.GetTables().GetCurrentSheet());
 351         if (nGroupStartRow <= nGroupEndRow)
 352         {
 353             ScDocument* pDoc(GetScImport().GetDocument());
 354             if (pDoc)
 355             {
 356                 ScXMLImport::MutexGuard aGuard(GetScImport());
 357                 ScOutlineTable* pOutlineTable(pDoc->GetOutlineTable(nSheet, true));
 358                 ScOutlineArray& rRowArray(pOutlineTable->GetRowArray());
 359                 bool bResized;
 360                 rRowArray.Insert(nGroupStartRow, nGroupEndRow, bResized, !bGroupDisplay);
 361             }
 362         }
 363     }
 364 }
 365
 366 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */