| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sc.hxx" |
| |
| |
| |
| // INCLUDE --------------------------------------------------------------- |
| #include "XMLStylesImportHelper.hxx" |
| #include "xmlimprt.hxx" |
| #include <tools/debug.hxx> |
| #include <com/sun/star/util/NumberFormat.hpp> |
| |
| using namespace com::sun::star; |
| |
| void ScMyStyleNumberFormats::AddStyleNumberFormat(const rtl::OUString& rStyleName, const sal_Int32 nNumberFormat) |
| { |
| aSet.insert(ScMyStyleNumberFormat(rStyleName, nNumberFormat)); |
| } |
| |
| sal_Int32 ScMyStyleNumberFormats::GetStyleNumberFormat(const rtl::OUString& rStyleName) |
| { |
| ScMyStyleNumberFormat aStyleNumberFormat(rStyleName); |
| ScMyStyleNumberFormatSet::iterator aItr(aSet.find(aStyleNumberFormat)); |
| if (aItr == aSet.end()) |
| return -1; |
| else |
| return aItr->nNumberFormat; |
| } |
| |
| ScMyStyleRanges::ScMyStyleRanges() |
| : |
| pTextList(NULL), |
| pNumberList(NULL), |
| pTimeList(NULL), |
| pDateTimeList(NULL), |
| pPercentList(NULL), |
| pLogicalList(NULL), |
| pUndefinedList(NULL), |
| pCurrencyList(NULL) |
| { |
| } |
| |
| ScMyStyleRanges::~ScMyStyleRanges() |
| { |
| if (pTextList) |
| delete pTextList; |
| if (pNumberList) |
| delete pNumberList; |
| if (pTimeList) |
| delete pTimeList; |
| if (pDateTimeList) |
| delete pDateTimeList; |
| if (pPercentList) |
| delete pPercentList; |
| if (pLogicalList) |
| delete pLogicalList; |
| if (pUndefinedList) |
| delete pUndefinedList; |
| if (pCurrencyList) |
| delete pCurrencyList; |
| } |
| |
| void ScMyStyleRanges::AddRange(const ScRange& rRange, ScRangeList* pList, |
| const rtl::OUString* pStyleName, const sal_Int16 nType, |
| ScXMLImport& rImport, const sal_uInt32 nMaxRanges) |
| { |
| pList->Join(rRange); |
| DBG_ASSERT(nMaxRanges > 0, "MaxRanges to less"); |
| if (pList->Count() > nMaxRanges) |
| { |
| sal_Int32 nCount(pList->Count()); |
| ScRange* pRange(NULL); |
| for (sal_Int32 i = 0; i < nCount; ++i) |
| { |
| pRange = pList->GetObject(i); |
| if (pRange && (pRange->aEnd.Row() + 1 < rRange.aStart.Row())) |
| { |
| rImport.SetStyleToRange(*pRange, pStyleName, nType, NULL); |
| delete pRange; |
| pRange = NULL; |
| pList->Remove(i); |
| } |
| } |
| } |
| } |
| |
| void ScMyStyleRanges::AddCurrencyRange(const ScRange& rRange, ScRangeListRef xList, |
| const rtl::OUString* pStyleName, const rtl::OUString* pCurrency, |
| ScXMLImport& rImport, const sal_uInt32 nMaxRanges) |
| { |
| xList->Join(rRange); |
| DBG_ASSERT(nMaxRanges > 0, "MaxRanges to less"); |
| if (xList->Count() > nMaxRanges) |
| { |
| sal_Int32 nCount(xList->Count()); |
| ScRange* pRange(NULL); |
| for (sal_Int32 i = 0; i < nCount; ++i) |
| { |
| pRange = xList->GetObject(i); |
| if (pRange && (pRange->aEnd.Row() + 1 < rRange.aStart.Row())) |
| { |
| rImport.SetStyleToRange(*pRange, pStyleName, util::NumberFormat::CURRENCY, pCurrency); |
| delete pRange; |
| pRange = NULL; |
| xList->Remove(i); |
| } |
| } |
| } |
| } |
| |
| void ScMyStyleRanges::AddRange(const ScRange& rRange, |
| const rtl::OUString* pStyleName, const sal_Int16 nType, |
| ScXMLImport& rImport, const sal_uInt32 nMaxRanges) |
| { |
| switch (nType) |
| { |
| case util::NumberFormat::NUMBER: |
| { |
| if (!pNumberList) |
| pNumberList = new ScRangeList(); |
| AddRange(rRange, pNumberList, pStyleName, nType, rImport, nMaxRanges); |
| } |
| break; |
| case util::NumberFormat::TEXT: |
| { |
| if (!pTextList) |
| pTextList = new ScRangeList(); |
| AddRange(rRange, pTextList, pStyleName, nType, rImport, nMaxRanges); |
| } |
| break; |
| case util::NumberFormat::TIME: |
| { |
| if (!pTimeList) |
| pTimeList = new ScRangeList(); |
| AddRange(rRange, pTimeList, pStyleName, nType, rImport, nMaxRanges); |
| } |
| break; |
| case util::NumberFormat::DATETIME: |
| { |
| if (!pDateTimeList) |
| pDateTimeList = new ScRangeList(); |
| AddRange(rRange, pDateTimeList, pStyleName, nType, rImport, nMaxRanges); |
| } |
| break; |
| case util::NumberFormat::PERCENT: |
| { |
| if (!pPercentList) |
| pPercentList = new ScRangeList(); |
| AddRange(rRange, pPercentList, pStyleName, nType, rImport, nMaxRanges); |
| } |
| break; |
| case util::NumberFormat::LOGICAL: |
| { |
| if (!pLogicalList) |
| pLogicalList = new ScRangeList(); |
| AddRange(rRange, pLogicalList, pStyleName, nType, rImport, nMaxRanges); |
| } |
| break; |
| case util::NumberFormat::UNDEFINED: |
| { |
| if (!pUndefinedList) |
| pUndefinedList = new ScRangeList(); |
| AddRange(rRange, pUndefinedList, pStyleName, nType, rImport, nMaxRanges); |
| } |
| break; |
| default: |
| { |
| DBG_ERROR("wrong type"); |
| } |
| break; |
| } |
| } |
| |
| void ScMyStyleRanges::AddCurrencyRange(const ScRange& rRange, |
| const rtl::OUString* pStyleName, const rtl::OUString* pCurrency, |
| ScXMLImport& rImport, const sal_uInt32 nMaxRanges) |
| { |
| if (!pCurrencyList) |
| pCurrencyList = new ScMyCurrencyStylesSet(); |
| ScMyCurrencyStyle aStyle; |
| if (pCurrency) |
| aStyle.sCurrency = *pCurrency; |
| ScMyCurrencyStylesSet::iterator aItr(pCurrencyList->find(aStyle)); |
| if (aItr == pCurrencyList->end()) |
| { |
| std::pair<ScMyCurrencyStylesSet::iterator, bool> aPair(pCurrencyList->insert(aStyle)); |
| if (aPair.second) |
| { |
| aItr = aPair.first; |
| AddCurrencyRange(rRange, aItr->xRanges, pStyleName, pCurrency, rImport, nMaxRanges); |
| } |
| } |
| else |
| aItr->xRanges->Join(rRange); |
| } |
| |
| void ScMyStyleRanges::InsertColRow(const ScRange& rRange, const SCsCOL nDx, const SCsROW nDy, |
| const SCsTAB nDz, ScDocument* pDoc) |
| { |
| UpdateRefMode aRefMode(URM_INSDEL); |
| if (pNumberList) |
| pNumberList->UpdateReference(aRefMode, pDoc, rRange, nDx, nDy, nDz); |
| if (pTextList) |
| pTextList->UpdateReference(aRefMode, pDoc, rRange, nDx, nDy, nDz); |
| if (pTimeList) |
| pTimeList->UpdateReference(aRefMode, pDoc, rRange, nDx, nDy, nDz); |
| if (pDateTimeList) |
| pDateTimeList->UpdateReference(aRefMode, pDoc, rRange, nDx, nDy, nDz); |
| if (pPercentList) |
| pPercentList->UpdateReference(aRefMode, pDoc, rRange, nDx, nDy, nDz); |
| if (pLogicalList) |
| pLogicalList->UpdateReference(aRefMode, pDoc, rRange, nDx, nDy, nDz); |
| if (pUndefinedList) |
| pUndefinedList->UpdateReference(aRefMode, pDoc, rRange, nDx, nDy, nDz); |
| if (pCurrencyList) |
| { |
| ScMyCurrencyStylesSet::iterator aItr(pCurrencyList->begin()); |
| ScMyCurrencyStylesSet::iterator aEndItr(pCurrencyList->end()); |
| while (aItr != aEndItr) |
| { |
| aItr->xRanges->UpdateReference(aRefMode, pDoc, rRange, nDx, nDy, nDz); |
| ++aItr; |
| } |
| } |
| } |
| |
| void ScMyStyleRanges::InsertRow(const sal_Int32 nRow, const sal_Int32 nTab, ScDocument* pDoc) |
| { |
| InsertColRow(ScRange(0, static_cast<SCROW>(nRow), static_cast<SCTAB>(nTab), |
| MAXCOL, MAXROW, static_cast<SCTAB>(nTab)), 0, 1, 0, pDoc); |
| } |
| |
| void ScMyStyleRanges::InsertCol(const sal_Int32 nCol, const sal_Int32 nTab, ScDocument* pDoc) |
| { |
| InsertColRow(ScRange(static_cast<SCCOL>(nCol), 0, static_cast<SCTAB>(nTab), |
| MAXCOL, MAXROW, static_cast<SCTAB>(nTab)), 1, 0, 0, pDoc); |
| } |
| |
| void ScMyStyleRanges::SetStylesToRanges(ScRangeList* pList, |
| const rtl::OUString* pStyleName, const sal_Int16 nCellType, |
| const rtl::OUString* pCurrency, ScXMLImport& rImport) |
| { |
| sal_Int32 nCount(pList->Count()); |
| for (sal_Int32 i = 0; i < nCount; ++i) |
| rImport.SetStyleToRange(*pList->GetObject(i), pStyleName, nCellType, pCurrency); |
| } |
| |
| void ScMyStyleRanges::SetStylesToRanges(ScRangeListRef xList, |
| const rtl::OUString* pStyleName, const sal_Int16 nCellType, |
| const rtl::OUString* pCurrency, ScXMLImport& rImport) |
| { |
| sal_Int32 nCount(xList->Count()); |
| for (sal_Int32 i = 0; i < nCount; ++i) |
| rImport.SetStyleToRange(*xList->GetObject(i), pStyleName, nCellType, pCurrency); |
| } |
| |
| void ScMyStyleRanges::SetStylesToRanges(const rtl::OUString* pStyleName, ScXMLImport& rImport) |
| { |
| if (pNumberList) |
| SetStylesToRanges(pNumberList, pStyleName, util::NumberFormat::NUMBER, NULL, rImport); |
| if (pTextList) |
| SetStylesToRanges(pTextList, pStyleName, util::NumberFormat::TEXT, NULL, rImport); |
| if (pTimeList) |
| SetStylesToRanges(pTimeList, pStyleName, util::NumberFormat::TIME, NULL, rImport); |
| if (pDateTimeList) |
| SetStylesToRanges(pDateTimeList, pStyleName, util::NumberFormat::DATETIME, NULL, rImport); |
| if (pPercentList) |
| SetStylesToRanges(pPercentList, pStyleName, util::NumberFormat::PERCENT, NULL, rImport); |
| if (pLogicalList) |
| SetStylesToRanges(pLogicalList, pStyleName, util::NumberFormat::LOGICAL, NULL, rImport); |
| if (pUndefinedList) |
| SetStylesToRanges(pUndefinedList, pStyleName, util::NumberFormat::UNDEFINED, NULL, rImport); |
| if (pCurrencyList) |
| { |
| ScMyCurrencyStylesSet::iterator aItr(pCurrencyList->begin()); |
| ScMyCurrencyStylesSet::iterator aEndItr(pCurrencyList->end()); |
| while (aItr != aEndItr) |
| { |
| SetStylesToRanges(aItr->xRanges, pStyleName, util::NumberFormat::CURRENCY, &aItr->sCurrency, rImport); |
| ++aItr; |
| } |
| } |
| } |
| |
| //---------------------------------------------------------------------------- |
| |
| ScMyStylesImportHelper::ScMyStylesImportHelper(ScXMLImport& rTempImport) |
| : |
| aRowDefaultStyle(aCellStyles.end()), |
| rImport(rTempImport), |
| pStyleName(NULL), |
| pPrevStyleName(NULL), |
| pCurrency(NULL), |
| pPrevCurrency(NULL), |
| nMaxRanges(0), |
| bPrevRangeAdded(sal_True) |
| { |
| } |
| |
| ScMyStylesImportHelper::~ScMyStylesImportHelper() |
| { |
| if (pPrevStyleName) |
| delete pPrevStyleName; |
| if (pPrevCurrency) |
| delete pPrevCurrency; |
| if (pStyleName) |
| delete pStyleName; |
| if (pCurrency) |
| delete pCurrency; |
| } |
| |
| void ScMyStylesImportHelper::ResetAttributes() |
| { |
| if (pPrevStyleName) |
| delete pPrevStyleName; |
| if (pPrevCurrency) |
| delete pPrevCurrency; |
| pPrevStyleName = pStyleName; |
| pPrevCurrency = pCurrency; |
| nPrevCellType = nCellType; |
| pStyleName = NULL; |
| pCurrency = NULL; |
| nCellType = 0; |
| } |
| |
| ScMyStylesSet::iterator ScMyStylesImportHelper::GetIterator(const rtl::OUString* pStyleNameP) |
| { |
| ScMyStyle aStyle; |
| if (pStyleNameP) |
| aStyle.sStyleName = *pStyleNameP; |
| else |
| { |
| DBG_ERROR("here is no stylename given"); |
| } |
| ScMyStylesSet::iterator aItr(aCellStyles.find(aStyle)); |
| if (aItr == aCellStyles.end()) |
| { |
| std::pair<ScMyStylesSet::iterator, bool> aPair(aCellStyles.insert(aStyle)); |
| if (aPair.second) |
| aItr = aPair.first; |
| else |
| { |
| DBG_ERROR("not possible to insert style"); |
| return aCellStyles.end(); |
| } |
| } |
| return aItr; |
| } |
| |
| void ScMyStylesImportHelper::AddDefaultRange(const ScRange& rRange) |
| { |
| DBG_ASSERT(aRowDefaultStyle != aCellStyles.end(), "no row default style"); |
| if (!aRowDefaultStyle->sStyleName.getLength()) |
| { |
| SCCOL nStartCol(rRange.aStart.Col()); |
| SCCOL nEndCol(rRange.aEnd.Col()); |
| if (aColDefaultStyles.size() > sal::static_int_cast<sal_uInt32>(nStartCol)) |
| { |
| ScMyStylesSet::iterator aPrevItr(aColDefaultStyles[nStartCol]); |
| DBG_ASSERT(aColDefaultStyles.size() > sal::static_int_cast<sal_uInt32>(nEndCol), "to much columns"); |
| for (SCCOL i = nStartCol + 1; (i <= nEndCol) && (i < sal::static_int_cast<SCCOL>(aColDefaultStyles.size())); ++i) |
| { |
| if (aPrevItr != aColDefaultStyles[i]) |
| { |
| DBG_ASSERT(aPrevItr != aCellStyles.end(), "no column default style"); |
| ScRange aRange(rRange); |
| aRange.aStart.SetCol(nStartCol); |
| aRange.aEnd.SetCol(i - 1); |
| if (pPrevStyleName) |
| delete pPrevStyleName; |
| pPrevStyleName = new rtl::OUString(aPrevItr->sStyleName); |
| AddSingleRange(aRange); |
| nStartCol = i; |
| aPrevItr = aColDefaultStyles[i]; |
| } |
| } |
| if (aPrevItr != aCellStyles.end()) |
| { |
| ScRange aRange(rRange); |
| aRange.aStart.SetCol(nStartCol); |
| if (pPrevStyleName) |
| delete pPrevStyleName; |
| pPrevStyleName = new rtl::OUString(aPrevItr->sStyleName); |
| AddSingleRange(aRange); |
| } |
| else |
| { |
| DBG_ERRORFILE("no column default style"); |
| } |
| } |
| else |
| { |
| DBG_ERRORFILE("to much columns"); |
| } |
| } |
| else |
| { |
| if (pPrevStyleName) |
| delete pPrevStyleName; |
| pPrevStyleName = new rtl::OUString(aRowDefaultStyle->sStyleName); |
| AddSingleRange(rRange); |
| } |
| } |
| |
| void ScMyStylesImportHelper::AddSingleRange(const ScRange& rRange) |
| { |
| if (nMaxRanges == 0) |
| nMaxRanges = aColDefaultStyles.size(); |
| ScMyStylesSet::iterator aItr(GetIterator(pPrevStyleName)); |
| if (aItr != aCellStyles.end()) |
| { |
| if (nPrevCellType != util::NumberFormat::CURRENCY) |
| aItr->xRanges->AddRange(rRange, pPrevStyleName, nPrevCellType, |
| rImport, nMaxRanges); |
| else |
| aItr->xRanges->AddCurrencyRange(rRange, pPrevStyleName, pPrevCurrency, |
| rImport, nMaxRanges); |
| } |
| } |
| |
| void ScMyStylesImportHelper::AddRange() |
| { |
| if (pPrevStyleName && pPrevStyleName->getLength()) |
| AddSingleRange(aPrevRange); |
| else |
| AddDefaultRange(aPrevRange); |
| ResetAttributes(); |
| } |
| |
| void ScMyStylesImportHelper::AddColumnStyle(const rtl::OUString& sStyleName, const sal_Int32 nColumn, const sal_Int32 nRepeat) |
| { |
| (void)nColumn; // avoid warning in product version |
| DBG_ASSERT(static_cast<sal_uInt32>(nColumn) == aColDefaultStyles.size(), "some columns are absent"); |
| ScMyStylesSet::iterator aItr(GetIterator(&sStyleName)); |
| DBG_ASSERT(aItr != aCellStyles.end(), "no column default style"); |
| aColDefaultStyles.reserve(aColDefaultStyles.size() + nRepeat); |
| for (sal_Int32 i = 0; i < nRepeat; ++i) |
| aColDefaultStyles.push_back(aItr); |
| } |
| |
| void ScMyStylesImportHelper::SetRowStyle(const rtl::OUString& sStyleName) |
| { |
| aRowDefaultStyle = GetIterator(&sStyleName); |
| } |
| |
| void ScMyStylesImportHelper::SetAttributes(rtl::OUString* pStyleNameP, |
| rtl::OUString* pCurrencyP, const sal_Int16 nCellTypeP) |
| { |
| if (this->pStyleName) |
| delete this->pStyleName; |
| if (this->pCurrency) |
| delete this->pCurrency; |
| this->pStyleName = pStyleNameP; |
| this->pCurrency = pCurrencyP; |
| this->nCellType = nCellTypeP; |
| } |
| |
| void ScMyStylesImportHelper::AddRange(const ScRange& rRange) |
| { |
| if (!bPrevRangeAdded) |
| { |
| sal_Bool bAddRange(sal_False); |
| if (nCellType == nPrevCellType && |
| IsEqual(pStyleName, pPrevStyleName) && |
| IsEqual(pCurrency, pPrevCurrency)) |
| { |
| if (rRange.aStart.Row() == aPrevRange.aStart.Row()) |
| { |
| if (rRange.aEnd.Row() == aPrevRange.aEnd.Row()) |
| { |
| DBG_ASSERT(aPrevRange.aEnd.Col() + 1 == rRange.aStart.Col(), "something wents wrong"); |
| aPrevRange.aEnd.SetCol(rRange.aEnd.Col()); |
| } |
| else |
| bAddRange = sal_True; |
| } |
| else |
| { |
| if (rRange.aStart.Col() == aPrevRange.aStart.Col() && |
| rRange.aEnd.Col() == aPrevRange.aEnd.Col()) |
| { |
| DBG_ASSERT(aPrevRange.aEnd.Row() + 1 == rRange.aStart.Row(), "something wents wrong"); |
| aPrevRange.aEnd.SetRow(rRange.aEnd.Row()); |
| } |
| else |
| bAddRange = sal_True; |
| } |
| } |
| else |
| bAddRange = sal_True; |
| if (bAddRange) |
| { |
| AddRange(); |
| aPrevRange = rRange; |
| } |
| } |
| else |
| { |
| aPrevRange = rRange; |
| ResetAttributes(); |
| bPrevRangeAdded = sal_False; |
| } |
| } |
| |
| void ScMyStylesImportHelper::AddCell(const com::sun::star::table::CellAddress& rAddress) |
| { |
| ScAddress aScAddress( static_cast<SCCOL>(rAddress.Column), static_cast<SCROW>(rAddress.Row), rAddress.Sheet ); |
| ScRange aScRange( aScAddress, aScAddress ); |
| AddRange(aScRange); |
| } |
| |
| void ScMyStylesImportHelper::InsertRow(const sal_Int32 nRow, const sal_Int32 nTab, ScDocument* pDoc) |
| { |
| rImport.LockSolarMutex(); |
| ScMyStylesSet::iterator aItr(aCellStyles.begin()); |
| ScMyStylesSet::iterator aEndItr(aCellStyles.end()); |
| while (aItr != aEndItr) |
| { |
| aItr->xRanges->InsertRow(nRow, nTab, pDoc); |
| ++aItr; |
| } |
| rImport.UnlockSolarMutex(); |
| } |
| |
| void ScMyStylesImportHelper::InsertCol(const sal_Int32 nCol, const sal_Int32 nTab, ScDocument* pDoc) |
| { |
| rImport.LockSolarMutex(); |
| ScMyStylesSet::iterator aItr(aCellStyles.begin()); |
| ScMyStylesSet::iterator aEndItr(aCellStyles.end()); |
| while (aItr != aEndItr) |
| { |
| aItr->xRanges->InsertCol(nCol, nTab, pDoc); |
| ++aItr; |
| } |
| rImport.UnlockSolarMutex(); |
| } |
| |
| void ScMyStylesImportHelper::EndTable() |
| { |
| if (!bPrevRangeAdded) |
| { |
| AddRange(); |
| bPrevRangeAdded = sal_True; |
| } |
| nMaxRanges = 0; |
| } |
| |
| void ScMyStylesImportHelper::SetStylesToRanges() |
| { |
| ScMyStylesSet::iterator aItr(aCellStyles.begin()); |
| ScMyStylesSet::iterator aEndItr(aCellStyles.end()); |
| while (aItr != aEndItr) |
| { |
| aItr->xRanges->SetStylesToRanges(&aItr->sStyleName, rImport); |
| ++aItr; |
| } |
| aColDefaultStyles.clear(); |
| aCellStyles.clear(); |
| nMaxRanges = 0; |
| } |
| |
