tdf#97177 speedup loading of large ODS file
drop ScSimpleRangeList and just use ScRangeList, which saves us a
conversion step.
Then teach ScRangeList to do a simple merge, since we are loading in row
order, and can just check the last few entries.
Then fix a case of optimisation doing the wrong thing in
ScAttrArray::SetPatternAreaImpl where std::vector::reserve repeatedly
resizes the data array and breaks the normal doubling-resizing inside
vector.
On my machine the time goes from 5.4s to 4.8s
Change-Id: I68a2204e0c02b673bbfe8aa0fdbe126e53ddbb41
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/96516
Tested-by: Noel Grandin <noel.grandin@collabora.co.uk>
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
diff --git a/sc/Library_sc.mk b/sc/Library_sc.mk
index 47b801f..ff649cf6 100644
--- a/sc/Library_sc.mk
+++ b/sc/Library_sc.mk
@@ -283,7 +283,6 @@
sc/source/core/tool/scmatrix \
sc/source/core/tool/scopetools \
sc/source/core/tool/sharedformula \
sc/source/core/tool/simplerangelist \
sc/source/core/tool/stringutil \
sc/source/core/tool/stylehelper \
sc/source/core/tool/subtotal \
diff --git a/sc/inc/rangelst.hxx b/sc/inc/rangelst.hxx
index 6558c95..6a74662d 100644
--- a/sc/inc/rangelst.hxx
+++ b/sc/inc/rangelst.hxx
@@ -60,6 +60,7 @@
void InsertRow( SCTAB nTab, SCCOL nColStart, SCCOL nColEnd, SCROW nRowPos, SCSIZE nSize );
void InsertCol( SCTAB nTab, SCROW nRowStart, SCROW nRowEnd, SCCOL nColPos, SCSIZE nSize );
void InsertCol( SCTAB nTab, SCCOL nColPos );
/** For now this method assumes that nTab1 == nTab2
* The algorithm will be much more complicated if nTab1 != nTab2
@@ -82,6 +83,8 @@
void RemoveAll();
ScRange Combine() const;
// Add new range, and do a partial combine up till one row back
void AddAndPartialCombine(const ScRange&);
bool empty() const { return maRanges.empty(); }
size_t size() const { return maRanges.size(); }
diff --git a/sc/inc/simplerangelist.hxx b/sc/inc/simplerangelist.hxx
deleted file mode 100644
index bb4ae9a..0000000
--- a/sc/inc/simplerangelist.hxx
+++ /dev/null
@@ -1,65 +0,0 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* 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 .
*/
#ifndef INCLUDED_SC_INC_SIMPLERANGELIST_HXX
#define INCLUDED_SC_INC_SIMPLERANGELIST_HXX
#include "address.hxx"
#include <list>
#include <map>
#include <memory>
/**
* This container is optimized for use in the ods import filter, to store
* ranges for cell styles. We may change the name of this class once we
* have a better name for what it does. Using this is way more efficient
* than ScRangeList.
*/
class ScSimpleRangeList
{
public:
struct Range
{
SCROW mnRow1;
SCROW mnRow2;
SCCOL mnCol1;
SCCOL mnCol2;
explicit Range(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2);
};
typedef std::shared_ptr<::std::list<Range>> RangeListRef;
typedef ::std::map<SCTAB, RangeListRef> TabType;
ScSimpleRangeList();
void addRange(const ScRange& rRange);
void insertCol(SCCOL nCol, SCTAB nTab);
void getRangeList(::std::list<ScRange>& rList) const;
void clear();
private:
RangeListRef findTab(SCTAB nTab);
private:
TabType maTabs;
};
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/core/data/attarray.cxx b/sc/source/core/data/attarray.cxx
index 1f174b5..a4c57ca 100644
--- a/sc/source/core/data/attarray.cxx
+++ b/sc/source/core/data/attarray.cxx
@@ -469,13 +469,6 @@
{
SCSIZE nNeeded = mvData.size() + 2;
SetDefaultIfNotInit( nNeeded );
if ( mvData.capacity() < nNeeded )
{
size_t nLimit = mvData.capacity() + SC_ATTRARRAY_DELTA;
if ( nLimit < nNeeded )
nLimit = nNeeded;
mvData.reserve(nLimit);
}
ScAddress aAdrStart( nCol, 0, nTab );
ScAddress aAdrEnd ( nCol, 0, nTab );
diff --git a/sc/source/core/tool/rangelst.cxx b/sc/source/core/tool/rangelst.cxx
index c4efb37..4810566 100644
--- a/sc/source/core/tool/rangelst.cxx
+++ b/sc/source/core/tool/rangelst.cxx
@@ -310,6 +310,51 @@
push_back( rNewRange );
}
void ScRangeList::AddAndPartialCombine( const ScRange& rNewRange )
{
if ( maRanges.empty() )
{
push_back( rNewRange );
return ;
}
// One common usage is to join ranges that actually are top to bottom
// appends but the caller doesn't exactly know about it, e.g. when invoked
// by ScMarkData::FillRangeListWithMarks(), check for this special case
// first and speed up things by not looping over all ranges for each range
// to be joined. We don't remember the exact encompassing range that would
// have to be updated on refupdates and insertions and deletions, instead
// remember just the maximum row used, even independently of the sheet.
// This satisfies most use cases.
const SCROW nRow1 = rNewRange.aStart.Row();
if (nRow1 > mnMaxRowUsed + 1)
{
push_back( rNewRange );
return;
}
// scan backwards 2 rows to see if we can merge with anything
auto it = maRanges.rbegin();
while (it != maRanges.rend() && it->aStart.Row() >= (rNewRange.aStart.Row() - 2))
{
// Check if we can simply enlarge this range.
ScRange & rLast = *it;
if (rLast.aEnd.Row() + 1 == nRow1 &&
rLast.aStart.Col() == rNewRange.aStart.Col() && rLast.aEnd.Col() == rNewRange.aEnd.Col() &&
rLast.aStart.Tab() == rNewRange.aStart.Tab() && rLast.aEnd.Tab() == rNewRange.aEnd.Tab())
{
const SCROW nRow2 = rNewRange.aEnd.Row();
rLast.aEnd.SetRow( nRow2 );
mnMaxRowUsed = std::max(mnMaxRowUsed, nRow2);
return;
}
++it;
}
push_back( rNewRange );
}
bool ScRangeList::operator==( const ScRangeList& r ) const
{
if ( this == &r )
@@ -458,6 +503,32 @@
}
}
void ScRangeList::InsertCol( SCTAB nTab, SCCOL nCol )
{
std::vector<ScRange> aNewRanges;
for(const auto & rRange : maRanges)
{
if(rRange.aStart.Tab() <= nTab && rRange.aEnd.Tab() >= nTab)
{
if(rRange.aEnd.Col() == nCol - 1)
{
SCCOL nNewRangeStartCol = rRange.aEnd.Col() + 1;
SCCOL nNewRangeEndCol = nCol;
aNewRanges.emplace_back(nNewRangeStartCol, rRange.aStart.Row(), nTab, nNewRangeEndCol,
rRange.aEnd.Row(), nTab);
}
}
}
for(const auto & rRange : aNewRanges)
{
if(!rRange.IsValid())
continue;
Join(rRange);
}
}
namespace {
/**
diff --git a/sc/source/core/tool/simplerangelist.cxx b/sc/source/core/tool/simplerangelist.cxx
deleted file mode 100644
index 671f91f..0000000
--- a/sc/source/core/tool/simplerangelist.cxx
+++ /dev/null
@@ -1,188 +0,0 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* 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 .
*/
#include <sal/config.h>
#include <algorithm>
#include <simplerangelist.hxx>
#include <rangelst.hxx>
using ::std::list;
using ::std::pair;
using ::std::max;
ScSimpleRangeList::Range::Range(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) :
mnRow1(nRow1), mnRow2(nRow2), mnCol1(nCol1), mnCol2(nCol2) {}
ScSimpleRangeList::ScSimpleRangeList()
{
}
namespace {
bool maybeJoin(ScSimpleRangeList::Range& rOld, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
{
if (rOld.mnRow1 == nRow1 && rOld.mnRow2 == nRow2)
{
// Check their column spans to see if they overlap.
if (rOld.mnCol1 == nCol1)
{
// Their share the start column position.
rOld.mnCol2 = max(rOld.mnCol2, nCol2);
return true;
}
else if (rOld.mnCol1 < nCol1)
{
// Old range sits on the left.
if (nCol1 - rOld.mnCol2 <= 1)
{
rOld.mnCol2 = max(rOld.mnCol2, nCol2);
return true;
}
}
else if (nCol1 < rOld.mnCol1)
{
// New range sits on the left.
if (nCol1 - rOld.mnCol2 <= 1)
{
rOld.mnCol1 = nCol1;
rOld.mnCol2 = max(rOld.mnCol2, nCol2);
return true;
}
}
}
if (rOld.mnCol1 == nCol1 && rOld.mnCol2 == nCol2)
{
if (rOld.mnRow1 == nRow1)
{
// Their share the start row position.
rOld.mnRow2 = max(rOld.mnRow2, nRow2);
return true;
}
else if (rOld.mnRow1 < nRow1)
{
// Old range sits above.
if (nRow1 - rOld.mnRow2 <= 1)
{
rOld.mnRow2 = max(rOld.mnRow2, nRow2);
return true;
}
}
else if (nRow1 < rOld.mnRow1)
{
// New range sits above.
if (nRow1 - rOld.mnRow2 <= 1)
{
rOld.mnRow1 = nRow1;
rOld.mnRow2 = max(rOld.mnRow2, nRow2);
return true;
}
}
}
return false;
}
}
void ScSimpleRangeList::addRange(const ScRange& rRange)
{
SCCOL nCol1 = rRange.aStart.Col();
SCROW nRow1 = rRange.aStart.Row();
SCTAB nTab1 = rRange.aStart.Tab();
SCCOL nCol2 = rRange.aEnd.Col();
SCROW nRow2 = rRange.aEnd.Row();
SCTAB nTab2 = rRange.aEnd.Tab();
for (SCTAB nTab = nTab1; nTab <= nTab2; ++nTab)
{
RangeListRef pRef = findTab(nTab);
if (!pRef)
// This should never happen!
return;
if (pRef->empty() || !maybeJoin(pRef->back(), nCol1, nRow1, nCol2, nRow2))
// Not joinable. Append it to the list.
pRef->push_back(Range(nCol1, nRow1, nCol2, nRow2));
}
}
void ScSimpleRangeList::insertCol(SCCOL nCol, SCTAB nTab)
{
RangeListRef pRef = findTab(nTab);
if (!pRef)
// This should never happen!
return;
for (Range& r : *pRef)
{
if (r.mnCol2 < nCol)
// insertion point to the right of the range.
continue;
if (nCol <= r.mnCol1)
{
// insertion point to the left of the range.
++r.mnCol1;
++r.mnCol2;
}
else if (nCol <= r.mnCol2)
{
// insertion point cuts through the range.
++r.mnCol2;
}
}
}
void ScSimpleRangeList::getRangeList(list<ScRange>& rList) const
{
list<ScRange> aList;
for (const auto& [nTab, pRanges] : maTabs)
{
for (const Range& r : *pRanges)
{
aList.emplace_back(r.mnCol1, r.mnRow1, nTab, r.mnCol2, r.mnRow2, nTab);
}
}
rList.swap(aList);
}
void ScSimpleRangeList::clear()
{
maTabs.clear();
}
ScSimpleRangeList::RangeListRef ScSimpleRangeList::findTab(SCTAB nTab)
{
TabType::iterator itr = maTabs.find(nTab);
if (itr == maTabs.end())
{
RangeListRef p = std::make_shared<list<Range>>();
pair<TabType::iterator, bool> r = maTabs.emplace(nTab, p);
if (!r.second)
return RangeListRef();
itr = r.first;
}
return itr->second;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/filter/xml/XMLStylesImportHelper.cxx b/sc/source/filter/xml/XMLStylesImportHelper.cxx
index be004af..e52466a 100644
--- a/sc/source/filter/xml/XMLStylesImportHelper.cxx
+++ b/sc/source/filter/xml/XMLStylesImportHelper.cxx
@@ -55,50 +55,50 @@
case util::NumberFormat::NUMBER:
{
if (!mpNumberList)
mpNumberList = std::make_shared<ScSimpleRangeList>();
mpNumberList->addRange(rRange);
mpNumberList = std::make_shared<ScRangeList>();
mpNumberList->AddAndPartialCombine(rRange);
}
break;
case util::NumberFormat::TEXT:
{
if (!mpTextList)
mpTextList = std::make_shared<ScSimpleRangeList>();
mpTextList->addRange(rRange);
mpTextList = std::make_shared<ScRangeList>();
mpTextList->AddAndPartialCombine(rRange);
}
break;
case util::NumberFormat::TIME:
{
if (!mpTimeList)
mpTimeList = std::make_shared<ScSimpleRangeList>();
mpTimeList->addRange(rRange);
mpTimeList = std::make_shared<ScRangeList>();
mpTimeList->AddAndPartialCombine(rRange);
}
break;
case util::NumberFormat::DATETIME:
{
if (!mpDateTimeList)
mpDateTimeList = std::make_shared<ScSimpleRangeList>();
mpDateTimeList->addRange(rRange);
mpDateTimeList = std::make_shared<ScRangeList>();
mpDateTimeList->AddAndPartialCombine(rRange);
}
break;
case util::NumberFormat::PERCENT:
{
if (!mpPercentList)
mpPercentList = std::make_shared<ScSimpleRangeList>();
mpPercentList->addRange(rRange);
mpPercentList = std::make_shared<ScRangeList>();
mpPercentList->AddAndPartialCombine(rRange);
}
break;
case util::NumberFormat::LOGICAL:
{
if (!mpLogicalList)
mpLogicalList = std::make_shared<ScSimpleRangeList>();
mpLogicalList->addRange(rRange);
mpLogicalList = std::make_shared<ScRangeList>();
mpLogicalList->AddAndPartialCombine(rRange);
}
break;
case util::NumberFormat::UNDEFINED:
{
if (!mpUndefinedList)
mpUndefinedList = std::make_shared<ScSimpleRangeList>();
mpUndefinedList->addRange(rRange);
mpUndefinedList = std::make_shared<ScRangeList>();
mpUndefinedList->AddAndPartialCombine(rRange);
}
break;
default:
@@ -117,101 +117,84 @@
if (pCurrency)
aStyle.sCurrency = *pCurrency;
auto itPair = pCurrencyList->insert(aStyle);
itPair.first->mpRanges->addRange(rRange);
itPair.first->mpRanges->AddAndPartialCombine(rRange);
}
void ScMyStyleRanges::InsertCol(const sal_Int32 nCol, const sal_Int32 nTab)
{
if (mpTextList)
mpTextList->insertCol(static_cast<SCCOL>(nCol), static_cast<SCTAB>(nTab));
mpTextList->InsertCol(static_cast<SCCOL>(nTab), static_cast<SCTAB>(nCol));
if (mpNumberList)
mpNumberList->insertCol(static_cast<SCCOL>(nCol), static_cast<SCTAB>(nTab));
mpNumberList->InsertCol(static_cast<SCCOL>(nTab), static_cast<SCTAB>(nCol));
if (mpTimeList)
mpTimeList->insertCol(static_cast<SCCOL>(nCol), static_cast<SCTAB>(nTab));
mpTimeList->InsertCol(static_cast<SCCOL>(nTab), static_cast<SCTAB>(nCol));
if (mpDateTimeList)
mpDateTimeList->insertCol(static_cast<SCCOL>(nCol), static_cast<SCTAB>(nTab));
mpDateTimeList->InsertCol(static_cast<SCCOL>(nTab), static_cast<SCTAB>(nCol));
if (mpPercentList)
mpPercentList->insertCol(static_cast<SCCOL>(nCol), static_cast<SCTAB>(nTab));
mpPercentList->InsertCol(static_cast<SCCOL>(nTab), static_cast<SCTAB>(nCol));
if (mpLogicalList)
mpLogicalList->insertCol(static_cast<SCCOL>(nCol), static_cast<SCTAB>(nTab));
mpLogicalList->InsertCol(static_cast<SCCOL>(nTab), static_cast<SCTAB>(nCol));
if (mpUndefinedList)
mpUndefinedList->insertCol(static_cast<SCCOL>(nCol), static_cast<SCTAB>(nTab));
mpUndefinedList->InsertCol(static_cast<SCCOL>(nTab), static_cast<SCTAB>(nCol));
if (pCurrencyList)
{
for (auto& rCurrency : *pCurrencyList)
{
rCurrency.mpRanges->insertCol(static_cast<SCCOL>(nCol), static_cast<SCTAB>(nTab));
rCurrency.mpRanges->InsertCol(static_cast<SCCOL>(nCol), static_cast<SCTAB>(nTab));
}
}
}
void ScMyStyleRanges::SetStylesToRanges(const list<ScRange>& rRanges,
void ScMyStyleRanges::SetStylesToRanges(const ScRangeList& rRanges,
const OUString* pStyleName, const sal_Int16 nCellType,
const OUString* pCurrency, ScXMLImport& rImport)
{
for (const auto& rRange : rRanges)
rImport.SetStyleToRange(rRange, pStyleName, nCellType, pCurrency);
rImport.SetStyleToRanges(rRanges, pStyleName, nCellType, pCurrency);
}
void ScMyStyleRanges::SetStylesToRanges(const OUString* pStyleName, ScXMLImport& rImport)
{
if (mpNumberList)
{
list<ScRange> aList;
mpNumberList->getRangeList(aList);
SetStylesToRanges(aList, pStyleName, util::NumberFormat::NUMBER, nullptr, rImport);
mpNumberList->clear();
SetStylesToRanges(*mpNumberList, pStyleName, util::NumberFormat::NUMBER, nullptr, rImport);
mpNumberList.reset();
}
if (mpTextList)
{
list<ScRange> aList;
mpTextList->getRangeList(aList);
SetStylesToRanges(aList, pStyleName, util::NumberFormat::TEXT, nullptr, rImport);
mpTextList->clear();
SetStylesToRanges(*mpTextList, pStyleName, util::NumberFormat::TEXT, nullptr, rImport);
mpTextList.reset();
}
if (mpTimeList)
{
list<ScRange> aList;
mpTimeList->getRangeList(aList);
SetStylesToRanges(aList, pStyleName, util::NumberFormat::TIME, nullptr, rImport);
mpTimeList->clear();
SetStylesToRanges(*mpTimeList, pStyleName, util::NumberFormat::TIME, nullptr, rImport);
mpTimeList.reset();
}
if (mpDateTimeList)
{
list<ScRange> aList;
mpDateTimeList->getRangeList(aList);
SetStylesToRanges(aList, pStyleName, util::NumberFormat::DATETIME, nullptr, rImport);
mpDateTimeList->clear();
SetStylesToRanges(*mpDateTimeList, pStyleName, util::NumberFormat::DATETIME, nullptr, rImport);
mpDateTimeList.reset();
}
if (mpPercentList)
{
list<ScRange> aList;
mpPercentList->getRangeList(aList);
SetStylesToRanges(aList, pStyleName, util::NumberFormat::PERCENT, nullptr, rImport);
mpPercentList->clear();
SetStylesToRanges(*mpPercentList, pStyleName, util::NumberFormat::PERCENT, nullptr, rImport);
mpPercentList.reset();
}
if (mpLogicalList)
{
list<ScRange> aList;
mpLogicalList->getRangeList(aList);
SetStylesToRanges(aList, pStyleName, util::NumberFormat::LOGICAL, nullptr, rImport);
mpLogicalList->clear();
SetStylesToRanges(*mpLogicalList, pStyleName, util::NumberFormat::LOGICAL, nullptr, rImport);
mpLogicalList.reset();
}
if (mpUndefinedList)
{
list<ScRange> aList;
mpUndefinedList->getRangeList(aList);
SetStylesToRanges(aList, pStyleName, util::NumberFormat::UNDEFINED, nullptr, rImport);
mpUndefinedList->clear();
SetStylesToRanges(*mpUndefinedList, pStyleName, util::NumberFormat::UNDEFINED, nullptr, rImport);
mpUndefinedList.reset();
}
if (pCurrencyList)
{
for (const auto& rCurrency : *pCurrencyList)
{
list<ScRange> aList;
rCurrency.mpRanges->getRangeList(aList);
SetStylesToRanges(aList, pStyleName, util::NumberFormat::CURRENCY, &rCurrency.sCurrency, rImport);
SetStylesToRanges(*rCurrency.mpRanges, pStyleName, util::NumberFormat::CURRENCY, &rCurrency.sCurrency, rImport);
}
}
}
diff --git a/sc/source/filter/xml/XMLStylesImportHelper.hxx b/sc/source/filter/xml/XMLStylesImportHelper.hxx
index 2d39097..e0d5bed 100644
--- a/sc/source/filter/xml/XMLStylesImportHelper.hxx
+++ b/sc/source/filter/xml/XMLStylesImportHelper.hxx
@@ -20,7 +20,7 @@
#ifndef INCLUDED_SC_SOURCE_FILTER_XML_XMLSTYLESIMPORTHELPER_HXX
#define INCLUDED_SC_SOURCE_FILTER_XML_XMLSTYLESIMPORTHELPER_HXX
#include <simplerangelist.hxx>
#include <rangelst.hxx>
#include <rtl/ustring.hxx>
#include <tools/ref.hxx>
@@ -66,10 +66,10 @@
struct ScMyCurrencyStyle
{
OUString sCurrency;
std::shared_ptr<ScSimpleRangeList> mpRanges;
std::shared_ptr<ScRangeList> mpRanges;
ScMyCurrencyStyle() :
mpRanges(std::make_shared<ScSimpleRangeList>())
mpRanges(std::make_shared<ScRangeList>())
{}
};
@@ -85,16 +85,16 @@
class ScMyStyleRanges
{
std::shared_ptr<ScSimpleRangeList> mpTextList;
std::shared_ptr<ScSimpleRangeList> mpNumberList;
std::shared_ptr<ScSimpleRangeList> mpTimeList;
std::shared_ptr<ScSimpleRangeList> mpDateTimeList;
std::shared_ptr<ScSimpleRangeList> mpPercentList;
std::shared_ptr<ScSimpleRangeList> mpLogicalList;
std::shared_ptr<ScSimpleRangeList> mpUndefinedList;
std::shared_ptr<ScRangeList> mpTextList;
std::shared_ptr<ScRangeList> mpNumberList;
std::shared_ptr<ScRangeList> mpTimeList;
std::shared_ptr<ScRangeList> mpDateTimeList;
std::shared_ptr<ScRangeList> mpPercentList;
std::shared_ptr<ScRangeList> mpLogicalList;
std::shared_ptr<ScRangeList> mpUndefinedList;
std::unique_ptr<ScMyCurrencyStylesSet> pCurrencyList;
static void SetStylesToRanges(const ::std::list<ScRange>& rList,
static void SetStylesToRanges(const ScRangeList& rList,
const OUString* pStyleName, const sal_Int16 nCellType,
const OUString* pCurrency, ScXMLImport& rImport);
public:
diff --git a/sc/source/filter/xml/xmlimprt.cxx b/sc/source/filter/xml/xmlimprt.cxx
index 02310a5..84931b6 100644
--- a/sc/source/filter/xml/xmlimprt.cxx
+++ b/sc/source/filter/xml/xmlimprt.cxx
@@ -95,6 +95,7 @@
#include <com/sun/star/io/XSeekable.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/sheet/XSheetCellRangeContainer.hpp>
#include <cellsuno.hxx>
#include <memory>
#include <utility>
@@ -1345,6 +1346,51 @@
AddStyleRange(aCellRange);
}
void ScXMLImport::SetStyleToRanges(const ScRangeList& rRanges, const OUString* pStyleName,
const sal_Int16 nCellType, const OUString* pCurrency)
{
if (!mbImportStyles)
return;
if (sPrevStyleName.isEmpty())
{
nPrevCellType = nCellType;
if (pStyleName)
sPrevStyleName = *pStyleName;
if (pCurrency)
sPrevCurrency = *pCurrency;
else if (!sPrevCurrency.isEmpty())
sPrevCurrency.clear();
}
else if ((nCellType != nPrevCellType) ||
((pStyleName && *pStyleName != sPrevStyleName) ||
(!pStyleName && !sPrevStyleName.isEmpty())) ||
((pCurrency && *pCurrency != sPrevCurrency) ||
(!pCurrency && !sPrevCurrency.isEmpty())))
{
SetStyleToRanges();
nPrevCellType = nCellType;
if (pStyleName)
sPrevStyleName = *pStyleName;
else if(!sPrevStyleName.isEmpty())
sPrevStyleName.clear();
if (pCurrency)
sPrevCurrency = *pCurrency;
else if(!sPrevCurrency.isEmpty())
sPrevCurrency.clear();
}
if (!xSheetCellRanges.is() && GetModel().is())
{
uno::Reference <lang::XMultiServiceFactory> xMultiServiceFactory(GetModel(), uno::UNO_QUERY);
if (xMultiServiceFactory.is())
xSheetCellRanges.set(uno::Reference <sheet::XSheetCellRangeContainer>(xMultiServiceFactory->createInstance("com.sun.star.sheet.SheetCellRanges"), uno::UNO_QUERY));
OSL_ENSURE(xSheetCellRanges.is(), "didn't get SheetCellRanges");
}
static_cast<ScCellRangesObj*>(xSheetCellRanges.get())->SetNewRanges(rRanges);
}
bool ScXMLImport::SetNullDateOnUnitConverter()
{
if (!bNullDateSetted)
diff --git a/sc/source/filter/xml/xmlimprt.hxx b/sc/source/filter/xml/xmlimprt.hxx
index 843a437..0523d43 100644
--- a/sc/source/filter/xml/xmlimprt.hxx
+++ b/sc/source/filter/xml/xmlimprt.hxx
@@ -371,6 +371,8 @@
public:
void SetStyleToRange(const ScRange& rRange, const OUString* pStyleName,
const sal_Int16 nCellType, const OUString* pCurrency);
void SetStyleToRanges(const ScRangeList& rRanges, const OUString* pStyleName,
const sal_Int16 nCellType, const OUString* pCurrency);
bool SetNullDateOnUnitConverter();
XMLNumberFormatAttributesExportHelper* GetNumberFormatAttributesExportHelper();
ScMyStyleNumberFormats* GetStyleNumberFormats();
