sc/source/filter/xml/xmlsubti.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 "xmlsubti.hxx"
  21 #include "xmlstyli.hxx"
  22 #include "xmlimprt.hxx"
  23 #include <document.hxx>
  24 #include "XMLConverter.hxx"
  25 #include <docuno.hxx>
  26 #include "XMLStylesImportHelper.hxx"
  27 #include <sheetdata.hxx>
  28 #include <tabprotection.hxx>
  29 #include <tokenarray.hxx>
  30 #include <documentimport.hxx>
  31
  32 #include <sal/log.hxx>
  33 #include <osl/diagnose.h>
  34
  35 #include <comphelper/base64.hxx>
  36 #include <comphelper/servicehelper.hxx>
  37 #include <com/sun/star/sheet/XSpreadsheet.hpp>
  38 #include <com/sun/star/sheet/XSpreadsheetDocument.hpp>
  39 #include <com/sun/star/drawing/XDrawPageSupplier.hpp>
  40
  41 #include <memory>
  42
  43 using namespace com::sun::star;
  44
  45 ScXMLTabProtectionData::ScXMLTabProtectionData() :
  46     meHash1(PASSHASH_SHA1),
  47     meHash2(PASSHASH_UNSPECIFIED),
  48     mbProtected(false),
  49     mbSelectProtectedCells(true),
  50     mbSelectUnprotectedCells(true),
  51     mbInsertColumns(false),
  52     mbInsertRows(false),
  53     mbDeleteColumns(false),
  54     mbDeleteRows(false)
  55 {
  56 }
  57
  58 ScMyTables::ScMyTables(ScXMLImport& rTempImport)
  59     : rImport(rTempImport),
  60     aFixupOLEs(rTempImport),
  61     maCurrentCellPos(ScAddress::INITIALIZE_INVALID),
  62     nCurrentColCount(0),
  63     nCurrentDrawPage( -1 ),
  64     nCurrentXShapes( -1 )
  65 {
  66 }
  67
  68 ScMyTables::~ScMyTables()
  69 {
  70 }
  71
  72 namespace {
  73
  74 uno::Reference<sheet::XSpreadsheet> getCurrentSheet(const uno::Reference<frame::XModel>& xModel, SCTAB nSheet)
  75 {
  76     uno::Reference<sheet::XSpreadsheet> xSheet;
  77     uno::Reference<sheet::XSpreadsheetDocument> xSpreadDoc(xModel, uno::UNO_QUERY);
  78     if (!xSpreadDoc.is())
  79         return xSheet;
  80
  81     uno::Reference <sheet::XSpreadsheets> xSheets(xSpreadDoc->getSheets());
  82     if (!xSheets.is())
  83         return xSheet;
  84
  85     uno::Reference <container::XIndexAccess> xIndex(xSheets, uno::UNO_QUERY);
  86     if (!xIndex.is())
  87         return xSheet;
  88
  89     xSheet.set(xIndex->getByIndex(nSheet), uno::UNO_QUERY);
  90     return xSheet;
  91 }
  92
  93 }
  94
  95 void ScMyTables::NewSheet(const OUString& sTableName, const OUString& sStyleName,
  96                           const ScXMLTabProtectionData& rProtectData)
  97 {
  98     if (rImport.GetModel().is())
  99     {
 100         nCurrentColCount = 0;
 101         sCurrentSheetName = sTableName;
 102         //reset cols and rows for new sheet, but increment tab
 103         maCurrentCellPos.SetCol(-1);
 104         maCurrentCellPos.SetRow(-1);
 105         maCurrentCellPos.SetTab(maCurrentCellPos.Tab() + 1);
 106
 107         maProtectionData = rProtectData;
 108         ScDocument *pDoc = ScXMLConverter::GetScDocument(rImport.GetModel());
 109
 110         // The document contains one sheet when created. So for the first
 111         // sheet, we only need to set its name.
 112         if (maCurrentCellPos.Tab() > 0)
 113             pDoc->AppendTabOnLoad(sTableName);
 114         else
 115             pDoc->SetTabNameOnLoad(maCurrentCellPos.Tab(), sTableName);
 116
 117         xCurrentSheet = getCurrentSheet(rImport.GetModel(), maCurrentCellPos.Tab());
 118         if (xCurrentSheet.is())
 119         {
 120             // We need to set the current cell range here regardless of
 121             // presence of style name.
 122             SetTableStyle(sStyleName);
 123         }
 124     }
 125 }
 126
 127 void ScMyTables::SetTableStyle(const OUString& sStyleName)
 128 {
 129     //these uno calls are a bit difficult to remove, XMLTableStyleContext::FillPropertySet uses
 130     //SvXMLImportPropertyMapper::FillPropertySet
 131     if ( !sStyleName.isEmpty() )
 132     {
 133         // #i57869# All table style properties for all sheets are now applied here,
 134         // before importing the contents.
 135         // This is needed for the background color.
 136         // Sheet visibility has special handling in ScDocFunc::SetTableVisible to
 137         // allow hiding the first sheet.
 138         // RTL layout is only remembered, not actually applied, so the shapes can
 139         // be loaded before mirroring.
 140
 141         if ( xCurrentSheet.is() )
 142         {
 143             uno::Reference <beans::XPropertySet> xProperties(xCurrentSheet, uno::UNO_QUERY);
 144             if ( xProperties.is() )
 145             {
 146                 XMLTableStylesContext *pStyles = static_cast<XMLTableStylesContext *>(rImport.GetAutoStyles());
 147                 if ( pStyles )
 148                 {
 149                     XMLTableStyleContext* pStyle = const_cast<XMLTableStyleContext*>(static_cast<const XMLTableStyleContext *>(pStyles->FindStyleChildContext(
 150                             XML_STYLE_FAMILY_TABLE_TABLE, sStyleName, true)));
 151                     if ( pStyle )
 152                     {
 153                         pStyle->FillPropertySet(xProperties);
 154
 155                         ScSheetSaveData* pSheetData = comphelper::getUnoTunnelImplementation<ScModelObj>(rImport.GetModel())->GetSheetSaveData();
 156                         pSheetData->AddTableStyle( sStyleName, ScAddress( 0, 0, maCurrentCellPos.Tab() ) );
 157                     }
 158                 }
 159             }
 160         }
 161     }
 162 }
 163
 164 void ScMyTables::AddRow()
 165 {
 166     maCurrentCellPos.SetRow(maCurrentCellPos.Row() + 1);
 167     maCurrentCellPos.SetCol(-1); //reset columns for new row
 168 }
 169
 170 void ScMyTables::SetRowStyle(const OUString& rCellStyleName)
 171 {
 172     rImport.GetStylesImportHelper()->SetRowStyle(rCellStyleName);
 173 }
 174
 175 void ScMyTables::AddColumn(bool bIsCovered)
 176 {
 177     maCurrentCellPos.SetCol( maCurrentCellPos.Col() + 1 );
 178     //here only need to set column style if this is the first row and
 179     //the cell is not covered.
 180     if(maCurrentCellPos.Row() == 0 && !bIsCovered)
 181         rImport.GetStylesImportHelper()->InsertCol(maCurrentCellPos.Col(), maCurrentCellPos.Tab());
 182 }
 183
 184 void ScMyTables::DeleteTable()
 185 {
 186     ScXMLImport::MutexGuard aGuard(rImport);
 187
 188     rImport.GetStylesImportHelper()->SetStylesToRanges();
 189     rImport.SetStylesToRangesFinished();
 190
 191     maMatrixRangeList.RemoveAll();
 192
 193     if (rImport.GetDocument() && maProtectionData.mbProtected)
 194     {
 195         uno::Sequence<sal_Int8> aHash;
 196         ::comphelper::Base64::decode(aHash, maProtectionData.maPassword);
 197
 198         std::unique_ptr<ScTableProtection> pProtect(new ScTableProtection);
 199         pProtect->setProtected(maProtectionData.mbProtected);
 200         pProtect->setPasswordHash(aHash, maProtectionData.meHash1, maProtectionData.meHash2);
 201         pProtect->setOption(ScTableProtection::SELECT_LOCKED_CELLS,   maProtectionData.mbSelectProtectedCells);
 202         pProtect->setOption(ScTableProtection::SELECT_UNLOCKED_CELLS, maProtectionData.mbSelectUnprotectedCells);
 203         pProtect->setOption(ScTableProtection::INSERT_COLUMNS, maProtectionData.mbInsertColumns);
 204         pProtect->setOption(ScTableProtection::INSERT_ROWS,    maProtectionData.mbInsertRows);
 205         pProtect->setOption(ScTableProtection::DELETE_COLUMNS, maProtectionData.mbDeleteColumns);
 206         pProtect->setOption(ScTableProtection::DELETE_ROWS,    maProtectionData.mbDeleteRows);
 207         rImport.GetDocument()->SetTabProtection(maCurrentCellPos.Tab(), pProtect.get());
 208     }
 209 }
 210
 211 void ScMyTables::AddColStyle(const sal_Int32 nRepeat, const OUString& rCellStyleName)
 212 {
 213     rImport.GetStylesImportHelper()->AddColumnStyle(rCellStyleName, nCurrentColCount, nRepeat);
 214     nCurrentColCount += nRepeat;
 215     SAL_WARN_IF(nCurrentColCount > MAXCOLCOUNT, "sc", "more columns than fit into SCCOL");
 216     nCurrentColCount = std::min<sal_Int32>( nCurrentColCount, MAXCOLCOUNT );
 217 }
 218
 219 uno::Reference< drawing::XDrawPage > const & ScMyTables::GetCurrentXDrawPage()
 220 {
 221     if( (maCurrentCellPos.Tab() != nCurrentDrawPage) || !xDrawPage.is() )
 222     {
 223         uno::Reference<drawing::XDrawPageSupplier> xDrawPageSupplier( xCurrentSheet, uno::UNO_QUERY );
 224         if( xDrawPageSupplier.is() )
 225             xDrawPage.set(xDrawPageSupplier->getDrawPage());
 226         nCurrentDrawPage = sal::static_int_cast<sal_Int16>(maCurrentCellPos.Tab());
 227     }
 228     return xDrawPage;
 229 }
 230
 231 uno::Reference< drawing::XShapes > const & ScMyTables::GetCurrentXShapes()
 232 {
 233     if( (maCurrentCellPos.Tab() != nCurrentXShapes) || !xShapes.is() )
 234     {
 235         xShapes = GetCurrentXDrawPage();
 236         rImport.GetShapeImport()->startPage(xShapes);
 237         rImport.GetShapeImport()->pushGroupForPostProcessing ( xShapes );
 238         nCurrentXShapes = sal::static_int_cast<sal_Int16>(maCurrentCellPos.Tab());
 239     }
 240     return xShapes;
 241 }
 242
 243 bool ScMyTables::HasDrawPage() const
 244 {
 245     return (maCurrentCellPos.Tab() == nCurrentDrawPage) && xDrawPage.is();
 246 }
 247
 248 bool ScMyTables::HasXShapes() const
 249 {
 250     return (maCurrentCellPos.Tab() == nCurrentXShapes) && xShapes.is();
 251 }
 252
 253 void ScMyTables::AddOLE(const uno::Reference <drawing::XShape>& rShape,
 254       const OUString &rRangeList)
 255 {
 256       aFixupOLEs.AddOLE(rShape, rRangeList);
 257 }
 258
 259 void ScMyTables::AddMatrixRange(
 260         const SCCOL nStartColumn, const SCROW nStartRow, const SCCOL nEndColumn, const SCROW nEndRow,
 261         const OUString& rFormula, const OUString& rFormulaNmsp, const formula::FormulaGrammar::Grammar eGrammar)
 262 {
 263     OSL_ENSURE(nEndRow >= nStartRow, "wrong row order");
 264     OSL_ENSURE(nEndColumn >= nStartColumn, "wrong column order");
 265     ScRange aScRange(
 266         nStartColumn, nStartRow, maCurrentCellPos.Tab(),
 267         nEndColumn, nEndRow, maCurrentCellPos.Tab()
 268     );
 269
 270     maMatrixRangeList.push_back(aScRange);
 271
 272     ScDocumentImport& rDoc = rImport.GetDoc();
 273     ScTokenArray aCode;
 274     aCode.AssignXMLString( rFormula,
 275             ((eGrammar == formula::FormulaGrammar::GRAM_EXTERNAL) ? rFormulaNmsp : OUString()));
 276     rDoc.setMatrixCells(aScRange, aCode, eGrammar);
 277     rDoc.getDoc().IncXMLImportedFormulaCount( rFormula.getLength() );
 278 }
 279
 280 bool ScMyTables::IsPartOfMatrix(const ScAddress& rScAddress) const
 281 {
 282     if (!maMatrixRangeList.empty())
 283         return maMatrixRangeList.In(rScAddress);
 284     return false;
 285 }
 286
 287 SCCOL ScMyTables::GetCurrentColCount() const
 288 {
 289     return std::min<sal_Int32>(nCurrentColCount, rImport.GetDocument()->MaxCol());
 290 }
 291
 292 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */