| /************************************************************** |
| * |
| * 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 "XMLStylesExportHelper.hxx" |
| #include "global.hxx" |
| #include "unonames.hxx" |
| #include "XMLConverter.hxx" |
| #include "xmlexprt.hxx" |
| #include "document.hxx" |
| #include "rangeutl.hxx" |
| #include <xmloff/xmltoken.hxx> |
| #include <xmloff/xmlnmspe.hxx> |
| #include <xmloff/XMLEventExport.hxx> |
| #include <xmloff/nmspmap.hxx> |
| #include <tools/debug.hxx> |
| #include <com/sun/star/uno/Reference.h> |
| #include <com/sun/star/beans/XPropertySet.hpp> |
| #include <com/sun/star/sheet/XSheetCondition.hpp> |
| #include <com/sun/star/sheet/TableValidationVisibility.hpp> |
| #include <comphelper/extract.hxx> |
| #include <sfx2/app.hxx> |
| |
| #include <algorithm> |
| |
| using namespace com::sun::star; |
| using namespace xmloff::token; |
| |
| ScMyValidation::ScMyValidation() |
| : sName(), |
| sErrorMessage(), |
| sErrorTitle(), |
| sImputMessage(), |
| sImputTitle(), |
| sFormula1(), |
| sFormula2(), |
| bShowErrorMessage(sal_False), |
| bShowImputMessage(sal_False), |
| bIgnoreBlanks(sal_False) |
| { |
| } |
| |
| ScMyValidation::~ScMyValidation() |
| { |
| } |
| |
| sal_Bool ScMyValidation::IsEqual(const ScMyValidation& aVal) const |
| { |
| if (aVal.bIgnoreBlanks == bIgnoreBlanks && |
| aVal.bShowImputMessage == bShowImputMessage && |
| aVal.bShowErrorMessage == bShowErrorMessage && |
| aVal.aBaseCell.Sheet == aBaseCell.Sheet && |
| aVal.aBaseCell.Column == aBaseCell.Column && |
| aVal.aBaseCell.Row == aBaseCell.Row && |
| aVal.aAlertStyle == aAlertStyle && |
| aVal.aValidationType == aValidationType && |
| aVal.aOperator == aOperator && |
| aVal.sErrorTitle == sErrorTitle && |
| aVal.sImputTitle == sImputTitle && |
| aVal.sErrorMessage == sErrorMessage && |
| aVal.sImputMessage == sImputMessage && |
| aVal.sFormula1 == sFormula1 && |
| aVal.sFormula2 == sFormula2) |
| return sal_True; |
| else |
| return sal_False; |
| } |
| |
| ScMyValidationsContainer::ScMyValidationsContainer() |
| : aValidationVec(), |
| sEmptyString(), |
| sERRALSTY(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_ERRALSTY)), |
| sIGNOREBL(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_IGNOREBL)), |
| sSHOWLIST(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_SHOWLIST)), |
| sTYPE(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_TYPE)), |
| sSHOWINP(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_SHOWINP)), |
| sSHOWERR(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_SHOWERR)), |
| sINPTITLE(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_INPTITLE)), |
| sINPMESS(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_INPMESS)), |
| sERRTITLE(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_ERRTITLE)), |
| sERRMESS(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_ERRMESS)), |
| sOnError(RTL_CONSTASCII_USTRINGPARAM("OnError")), |
| sEventType(RTL_CONSTASCII_USTRINGPARAM("EventType")), |
| sStarBasic(RTL_CONSTASCII_USTRINGPARAM("StarBasic")), |
| sScript(RTL_CONSTASCII_USTRINGPARAM("Script")), |
| sLibrary(RTL_CONSTASCII_USTRINGPARAM("Library")), |
| sMacroName(RTL_CONSTASCII_USTRINGPARAM("MacroName")) |
| { |
| } |
| |
| ScMyValidationsContainer::~ScMyValidationsContainer() |
| { |
| } |
| |
| sal_Bool ScMyValidationsContainer::AddValidation(const uno::Any& aTempAny, |
| sal_Int32& nValidationIndex) |
| { |
| sal_Bool bAdded(sal_False); |
| uno::Reference<beans::XPropertySet> xPropertySet(aTempAny, uno::UNO_QUERY); |
| if (xPropertySet.is()) |
| { |
| rtl::OUString sErrorMessage; |
| xPropertySet->getPropertyValue(sERRMESS) >>= sErrorMessage; |
| rtl::OUString sErrorTitle; |
| xPropertySet->getPropertyValue(sERRTITLE) >>= sErrorTitle; |
| rtl::OUString sImputMessage; |
| xPropertySet->getPropertyValue(sINPMESS) >>= sImputMessage; |
| rtl::OUString sImputTitle; |
| xPropertySet->getPropertyValue(sINPTITLE) >>= sImputTitle; |
| sal_Bool bShowErrorMessage = ::cppu::any2bool(xPropertySet->getPropertyValue(sSHOWERR)); |
| sal_Bool bShowImputMessage = ::cppu::any2bool(xPropertySet->getPropertyValue(sSHOWINP)); |
| sheet::ValidationType aValidationType; |
| xPropertySet->getPropertyValue(sTYPE) >>= aValidationType; |
| if (bShowErrorMessage || bShowImputMessage || aValidationType != sheet::ValidationType_ANY || |
| sErrorMessage.getLength() || sErrorTitle.getLength() || sImputMessage.getLength() || sImputTitle.getLength()) |
| { |
| ScMyValidation aValidation; |
| aValidation.sErrorMessage = sErrorMessage; |
| aValidation.sErrorTitle = sErrorTitle; |
| aValidation.sImputMessage = sImputMessage; |
| aValidation.sImputTitle = sImputTitle; |
| aValidation.bShowErrorMessage = bShowErrorMessage; |
| aValidation.bShowImputMessage = bShowImputMessage; |
| aValidation.aValidationType = aValidationType; |
| aValidation.bIgnoreBlanks = ::cppu::any2bool(xPropertySet->getPropertyValue(sIGNOREBL)); |
| xPropertySet->getPropertyValue(sSHOWLIST) >>= aValidation.nShowList; |
| xPropertySet->getPropertyValue(sERRALSTY) >>= aValidation.aAlertStyle; |
| uno::Reference<sheet::XSheetCondition> xCondition(xPropertySet, uno::UNO_QUERY); |
| if (xCondition.is()) |
| { |
| aValidation.sFormula1 = xCondition->getFormula1(); |
| aValidation.sFormula2 = xCondition->getFormula2(); |
| aValidation.aOperator = xCondition->getOperator(); |
| aValidation.aBaseCell = xCondition->getSourcePosition(); |
| } |
| //ScMyValidationRange aValidationRange; |
| sal_Bool bEqualFound(sal_False); |
| sal_Int32 i(0); |
| sal_Int32 nCount(aValidationVec.size()); |
| while (i < nCount && !bEqualFound) |
| { |
| bEqualFound = aValidationVec[i].IsEqual(aValidation); |
| if (!bEqualFound) |
| ++i; |
| } |
| if (bEqualFound) |
| nValidationIndex = i; |
| else |
| { |
| sal_Int32 nNameIndex(nCount + 1); |
| rtl::OUString sCount(rtl::OUString::valueOf(nNameIndex)); |
| rtl::OUString sPrefix(RTL_CONSTASCII_USTRINGPARAM("val")); |
| aValidation.sName += sPrefix; |
| aValidation.sName += sCount; |
| aValidationVec.push_back(aValidation); |
| nValidationIndex = nCount; |
| bAdded = sal_True; |
| } |
| } |
| } |
| return bAdded; |
| } |
| |
| rtl::OUString ScMyValidationsContainer::GetCondition(ScXMLExport& rExport, const ScMyValidation& aValidation) |
| { |
| /* ATTENTION! Should the condition to not write sheet::ValidationType_ANY |
| * ever be changed, adapt the conditional call of |
| * MarkUsedExternalReferences() in |
| * ScTableValidationObj::ScTableValidationObj() accordingly! */ |
| rtl::OUString sCondition; |
| if (aValidation.aValidationType != sheet::ValidationType_ANY) |
| { |
| switch (aValidation.aValidationType) |
| { |
| //case sheet::ValidationType_CUSTOM |
| case sheet::ValidationType_DATE : |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("cell-content-is-date()")); |
| break; |
| case sheet::ValidationType_DECIMAL : |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("cell-content-is-decimal-number()")); |
| break; |
| case sheet::ValidationType_LIST : |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("cell-content-is-in-list(")); |
| sCondition += aValidation.sFormula1; |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(")")); |
| break; |
| case sheet::ValidationType_TEXT_LEN : |
| if (aValidation.aOperator != sheet::ConditionOperator_BETWEEN && |
| aValidation.aOperator != sheet::ConditionOperator_NOT_BETWEEN) |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("cell-content-text-length()")); |
| break; |
| case sheet::ValidationType_TIME : |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("cell-content-is-time()")); |
| break; |
| case sheet::ValidationType_WHOLE : |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("cell-content-is-whole-number()")); |
| break; |
| default: |
| { |
| // added to avoid warnings |
| } |
| } |
| if (aValidation.aValidationType != sheet::ValidationType_LIST && |
| (aValidation.sFormula1.getLength() || |
| (aValidation.aOperator == sheet::ConditionOperator_BETWEEN && |
| aValidation.aOperator == sheet::ConditionOperator_NOT_BETWEEN && |
| aValidation.sFormula2.getLength()))) |
| { |
| if (aValidation.aValidationType != sheet::ValidationType_TEXT_LEN) |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" and ")); |
| if (aValidation.aOperator != sheet::ConditionOperator_BETWEEN && |
| aValidation.aOperator != sheet::ConditionOperator_NOT_BETWEEN) |
| { |
| if (aValidation.aValidationType != sheet::ValidationType_TEXT_LEN) |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("cell-content()")); |
| switch (aValidation.aOperator) |
| { |
| case sheet::ConditionOperator_EQUAL : |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("=")); |
| break; |
| case sheet::ConditionOperator_GREATER : |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(">")); |
| break; |
| case sheet::ConditionOperator_GREATER_EQUAL : |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(">=")); |
| break; |
| case sheet::ConditionOperator_LESS : |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("<")); |
| break; |
| case sheet::ConditionOperator_LESS_EQUAL : |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("<=")); |
| break; |
| case sheet::ConditionOperator_NOT_EQUAL : |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("!=")); |
| break; |
| default: |
| { |
| // added to avoid warnings |
| } |
| } |
| sCondition += aValidation.sFormula1; |
| } |
| else |
| { |
| if (aValidation.aValidationType == sheet::ValidationType_TEXT_LEN) |
| { |
| if (aValidation.aOperator == sheet::ConditionOperator_BETWEEN) |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("cell-content-text-length-is-between(")); |
| else |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("cell-content-text-length-is-not-between(")); |
| } |
| else |
| { |
| if (aValidation.aOperator == sheet::ConditionOperator_BETWEEN) |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("cell-content-is-between(")); |
| else |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("cell-content-is-not-between(")); |
| } |
| sCondition += aValidation.sFormula1; |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(",")); |
| sCondition += aValidation.sFormula2; |
| sCondition += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(")")); |
| } |
| } |
| else |
| if (aValidation.aValidationType == sheet::ValidationType_TEXT_LEN) |
| sCondition = rtl::OUString(); |
| } |
| if (sCondition.getLength()) |
| { |
| const formula::FormulaGrammar::Grammar eGrammar = rExport.GetDocument()->GetStorageGrammar(); |
| sal_uInt16 nNamespacePrefix = (eGrammar == formula::FormulaGrammar::GRAM_ODFF ? XML_NAMESPACE_OF : XML_NAMESPACE_OOOC); |
| sCondition = rExport.GetNamespaceMap().GetQNameByKey( nNamespacePrefix, sCondition, sal_False ); |
| } |
| |
| return sCondition; |
| } |
| |
| rtl::OUString ScMyValidationsContainer::GetBaseCellAddress(ScDocument* pDoc, const table::CellAddress& aCell) |
| { |
| rtl::OUString sAddress; |
| ScRangeStringConverter::GetStringFromAddress( sAddress, aCell, pDoc, ::formula::FormulaGrammar::CONV_OOO ); |
| return sAddress; |
| } |
| |
| void ScMyValidationsContainer::WriteMessage(ScXMLExport& rExport, |
| const rtl::OUString& sTitle, const rtl::OUString& sOUMessage, |
| const sal_Bool bShowMessage, const sal_Bool bIsHelpMessage) |
| { |
| if (sTitle.getLength()) |
| rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_TITLE, sTitle); |
| if (bShowMessage) |
| rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_DISPLAY, XML_TRUE); |
| else |
| rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_DISPLAY, XML_FALSE); |
| SvXMLElementExport* pMessage(NULL); |
| if (bIsHelpMessage) |
| pMessage = new SvXMLElementExport(rExport, XML_NAMESPACE_TABLE, XML_HELP_MESSAGE, sal_True, sal_True); |
| else |
| pMessage = new SvXMLElementExport(rExport, XML_NAMESPACE_TABLE, XML_ERROR_MESSAGE, sal_True, sal_True); |
| if (sOUMessage.getLength()) |
| { |
| sal_Int32 i(0); |
| rtl::OUStringBuffer sTemp; |
| String sMessage(sOUMessage); |
| rtl::OUString sText (sMessage.ConvertLineEnd(LINEEND_LF)); |
| sal_Bool bPrevCharWasSpace(sal_True); |
| while(i < sText.getLength()) |
| { |
| if( sText[i] == '\n') |
| { |
| SvXMLElementExport aElemP(rExport, XML_NAMESPACE_TEXT, XML_P, sal_True, sal_False); |
| rExport.GetTextParagraphExport()->exportText(sTemp.makeStringAndClear(), bPrevCharWasSpace); |
| } |
| else |
| sTemp.append(sText[i]); |
| ++i; |
| } |
| if (sTemp.getLength()) |
| { |
| SvXMLElementExport aElemP(rExport, XML_NAMESPACE_TEXT, XML_P, sal_True, sal_False); |
| rExport.GetTextParagraphExport()->exportText(sTemp.makeStringAndClear(), bPrevCharWasSpace); |
| } |
| } |
| if (pMessage) |
| delete pMessage; |
| } |
| |
| void ScMyValidationsContainer::WriteValidations(ScXMLExport& rExport) |
| { |
| if (aValidationVec.size()) |
| { |
| SvXMLElementExport aElemVs(rExport, XML_NAMESPACE_TABLE, XML_CONTENT_VALIDATIONS, sal_True, sal_True); |
| ScMyValidationVec::iterator aItr(aValidationVec.begin()); |
| ScMyValidationVec::iterator aEndItr(aValidationVec.end()); |
| while (aItr != aEndItr) |
| { |
| rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_NAME, aItr->sName); |
| rtl::OUString sCondition(GetCondition(rExport, *aItr)); |
| if (sCondition.getLength()) |
| { |
| rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_CONDITION, sCondition); |
| if (aItr->bIgnoreBlanks) |
| rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_ALLOW_EMPTY_CELL, XML_TRUE); |
| else |
| rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_ALLOW_EMPTY_CELL, XML_FALSE); |
| if (aItr->aValidationType == sheet::ValidationType_LIST) |
| { |
| switch (aItr->nShowList) |
| { |
| case sheet::TableValidationVisibility::INVISIBLE: |
| rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_DISPLAY_LIST, XML_NO); |
| break; |
| case sheet::TableValidationVisibility::UNSORTED: |
| rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_DISPLAY_LIST, XML_UNSORTED); |
| break; |
| case sheet::TableValidationVisibility::SORTEDASCENDING: |
| rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_DISPLAY_LIST, XML_SORTED_ASCENDING); |
| break; |
| default: |
| DBG_ERROR("unknown ListType"); |
| } |
| } |
| } |
| rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_BASE_CELL_ADDRESS, GetBaseCellAddress(rExport.GetDocument(), aItr->aBaseCell)); |
| SvXMLElementExport aElemV(rExport, XML_NAMESPACE_TABLE, XML_CONTENT_VALIDATION, sal_True, sal_True); |
| if (aItr->bShowImputMessage || aItr->sImputMessage.getLength() || aItr->sImputTitle.getLength()) |
| { |
| WriteMessage(rExport, aItr->sImputTitle, aItr->sImputMessage, aItr->bShowImputMessage, sal_True); |
| } |
| if (aItr->bShowErrorMessage || aItr->sErrorMessage.getLength() || aItr->sErrorTitle.getLength()) |
| { |
| switch (aItr->aAlertStyle) |
| { |
| case sheet::ValidationAlertStyle_INFO : |
| { |
| rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_MESSAGE_TYPE, XML_INFORMATION); |
| WriteMessage(rExport, aItr->sErrorTitle, aItr->sErrorMessage, aItr->bShowErrorMessage, sal_False); |
| } |
| break; |
| case sheet::ValidationAlertStyle_WARNING : |
| { |
| rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_MESSAGE_TYPE, XML_WARNING); |
| WriteMessage(rExport, aItr->sErrorTitle, aItr->sErrorMessage, aItr->bShowErrorMessage, sal_False); |
| } |
| break; |
| case sheet::ValidationAlertStyle_STOP : |
| { |
| rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_MESSAGE_TYPE, XML_STOP); |
| WriteMessage(rExport, aItr->sErrorTitle, aItr->sErrorMessage, aItr->bShowErrorMessage, sal_False); |
| } |
| break; |
| case sheet::ValidationAlertStyle_MACRO : |
| { |
| { |
| //rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_NAME, aItr->sErrorTitle); |
| if (aItr->bShowErrorMessage) |
| rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_EXECUTE, XML_TRUE); |
| else |
| rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_EXECUTE, XML_FALSE); |
| SvXMLElementExport aEMElem(rExport, XML_NAMESPACE_TABLE, XML_ERROR_MACRO, sal_True, sal_True); |
| } |
| { |
| // #i47525# for a script URL the type and the property name for the URL |
| // are both "Script", for a simple macro name the type is "StarBasic" |
| // and the property name is "MacroName". |
| bool bScriptURL = SfxApplication::IsXScriptURL( aItr->sErrorTitle ); |
| |
| uno::Sequence<beans::PropertyValue> aSeq(3); |
| beans::PropertyValue* pArr(aSeq.getArray()); |
| pArr[0].Name = sEventType; |
| pArr[0].Value <<= bScriptURL ? sScript : sStarBasic; |
| pArr[1].Name = sLibrary; |
| pArr[1].Value <<= sEmptyString; |
| pArr[2].Name = bScriptURL ? sScript : sMacroName; |
| pArr[2].Value <<= aItr->sErrorTitle; |
| |
| // 2) export the sequence |
| rExport.GetEventExport().ExportSingleEvent( aSeq, sOnError); |
| } |
| } |
| break; |
| default: |
| { |
| // added to avoid warnings |
| } |
| } |
| } |
| ++aItr; |
| } |
| } |
| } |
| |
| const rtl::OUString& ScMyValidationsContainer::GetValidationName(const sal_Int32 nIndex) |
| { |
| DBG_ASSERT( static_cast<size_t>(nIndex) < aValidationVec.size(), "out of range" ); |
| return aValidationVec[nIndex].sName; |
| } |
| |
| //============================================================================== |
| |
| sal_Int32 ScMyDefaultStyles::GetStyleNameIndex(const ScFormatRangeStyles* pCellStyles, |
| const sal_Int32 nTable, const sal_Int32 nPos, |
| const sal_Int32 i, const sal_Bool bRow, sal_Bool& bIsAutoStyle) |
| { |
| if (bRow) |
| return pCellStyles->GetStyleNameIndex(nTable, nPos, i, |
| bIsAutoStyle); |
| else |
| return pCellStyles->GetStyleNameIndex(nTable, i, nPos, |
| bIsAutoStyle); |
| } |
| |
| void ScMyDefaultStyles::FillDefaultStyles(const sal_Int32 nTable, |
| const sal_Int32 nLastRow, const sal_Int32 nLastCol, |
| const ScFormatRangeStyles* pCellStyles, ScDocument* pDoc, |
| const sal_Bool bRow) |
| { |
| if (pDoc) |
| { |
| SCTAB nTab = static_cast<SCTAB>(nTable); |
| sal_Int32 nPos; |
| sal_Int32 nLast; |
| ScMyDefaultStyleList* pDefaults; |
| if (bRow) |
| { |
| pDefaults = pRowDefaults; |
| nLast = nLastRow; |
| } |
| else |
| { |
| pDefaults = pColDefaults; |
| nLast = nLastCol; |
| } |
| sal_Bool bPrevAutoStyle(sal_False); |
| sal_Bool bIsAutoStyle; |
| sal_Bool bResult; |
| sal_Int32 nPrevIndex(0); |
| sal_Int32 nIndex; |
| sal_Int32 nRepeat(0); |
| sal_Int32 nEmptyRepeat(0); |
| for (sal_Int32 i = nLast; i >= 0; --i) |
| { |
| if (bRow) |
| { |
| SCCOL nCol; |
| bResult = pDoc->GetRowDefault(nTab, |
| static_cast<SCROW>(i), static_cast<SCCOL>(nLastCol), nCol); |
| nPos = static_cast<sal_Int32>(nCol); |
| } |
| else |
| { |
| SCROW nRow; |
| bResult = pDoc->GetColDefault(nTab, |
| static_cast<SCCOL>(i), static_cast<SCROW>(nLastRow), nRow); |
| nPos = static_cast<sal_Int32>(nRow); |
| } |
| if (bResult) |
| { |
| nEmptyRepeat = 0; |
| if (!nRepeat) |
| { |
| nPrevIndex = GetStyleNameIndex(pCellStyles, nTab, nPos, i, |
| bRow, bPrevAutoStyle); |
| (*pDefaults)[i].nIndex = nPrevIndex; |
| (*pDefaults)[i].bIsAutoStyle = bPrevAutoStyle; |
| nRepeat = 1; |
| } |
| else |
| { |
| nIndex = GetStyleNameIndex(pCellStyles, nTab, nPos, i, |
| bRow, bIsAutoStyle); |
| if ((nIndex != nPrevIndex) || (bIsAutoStyle != bPrevAutoStyle)) |
| { |
| nRepeat = 1; |
| nPrevIndex = GetStyleNameIndex(pCellStyles, nTab, nPos, i, |
| bRow, bPrevAutoStyle); |
| (*pDefaults)[i].nIndex = nPrevIndex; |
| (*pDefaults)[i].bIsAutoStyle = bPrevAutoStyle; |
| } |
| else |
| { |
| (*pDefaults)[i].nIndex = nPrevIndex; |
| (*pDefaults)[i].bIsAutoStyle = bPrevAutoStyle; |
| ++nRepeat; |
| if (nRepeat > 1) |
| (*pDefaults)[i].nRepeat = nRepeat; |
| } |
| } |
| } |
| else |
| { |
| nRepeat = 0; |
| if (!nEmptyRepeat) |
| nEmptyRepeat = 1; |
| else |
| { |
| ++nEmptyRepeat; |
| if (nEmptyRepeat > 1) |
| (*pDefaults)[i].nRepeat = nEmptyRepeat; |
| } |
| } |
| } |
| } |
| } |
| |
| void ScMyDefaultStyles::FillDefaultStyles(const sal_Int32 nTable, |
| const sal_Int32 nLastRow, const sal_Int32 nLastCol, |
| const ScFormatRangeStyles* pCellStyles, ScDocument* pDoc) |
| { |
| if (pRowDefaults) |
| delete pRowDefaults; |
| pRowDefaults = new ScMyDefaultStyleList(nLastRow + 1); |
| FillDefaultStyles(nTable, nLastRow, nLastCol, pCellStyles, pDoc, sal_True); |
| if (pColDefaults) |
| delete pColDefaults; |
| pColDefaults = new ScMyDefaultStyleList(nLastCol + 1); |
| FillDefaultStyles(nTable, nLastRow, nLastCol, pCellStyles, pDoc, sal_False); |
| } |
| |
| ScMyDefaultStyles::~ScMyDefaultStyles() |
| { |
| if (pRowDefaults) |
| delete pRowDefaults; |
| if (pColDefaults) |
| delete pColDefaults; |
| } |
| |
| ScMyRowFormatRange::ScMyRowFormatRange() |
| : nStartColumn(0), |
| nRepeatColumns(0), |
| nRepeatRows(0), |
| nIndex(-1), |
| nValidationIndex(-1), |
| bIsAutoStyle(sal_True) |
| { |
| } |
| |
| sal_Bool ScMyRowFormatRange::operator< (const ScMyRowFormatRange& rRange) const |
| { |
| return (nStartColumn < rRange.nStartColumn); |
| } |
| |
| ScRowFormatRanges::ScRowFormatRanges() |
| : aRowFormatRanges(), |
| pRowDefaults(NULL), |
| pColDefaults(NULL), |
| nSize(0) |
| { |
| } |
| |
| ScRowFormatRanges::ScRowFormatRanges(const ScRowFormatRanges* pRanges) |
| : aRowFormatRanges(pRanges->aRowFormatRanges), |
| pRowDefaults(pRanges->pRowDefaults), |
| pColDefaults(pRanges->pColDefaults), |
| nSize(pRanges->nSize) |
| { |
| } |
| |
| ScRowFormatRanges::~ScRowFormatRanges() |
| { |
| } |
| |
| void ScRowFormatRanges::Clear() |
| { |
| aRowFormatRanges.clear(); |
| nSize = 0; |
| } |
| |
| void ScRowFormatRanges::AddRange(const sal_Int32 nPrevStartCol, const sal_Int32 nRepeat, const sal_Int32 nPrevIndex, |
| const sal_Bool bPrevAutoStyle, const ScMyRowFormatRange& rFormatRange) |
| { |
| sal_Int32 nIndex(-1); |
| if ((nPrevIndex != rFormatRange.nIndex) || |
| (bPrevAutoStyle != rFormatRange.bIsAutoStyle)) |
| nIndex = rFormatRange.nIndex; |
| |
| sal_Bool bInserted(sal_False); |
| if (!aRowFormatRanges.empty()) |
| { |
| ScMyRowFormatRange* pRange(&aRowFormatRanges.back()); |
| if (pRange) |
| { |
| if ((nPrevStartCol == (pRange->nStartColumn + pRange->nRepeatColumns)) && |
| (pRange->bIsAutoStyle == rFormatRange.bIsAutoStyle) && |
| (pRange->nIndex == nIndex) && |
| (pRange->nValidationIndex == rFormatRange.nValidationIndex)) |
| { |
| if (rFormatRange.nRepeatRows < pRange->nRepeatRows) |
| pRange->nRepeatRows = rFormatRange.nRepeatRows; |
| pRange->nRepeatColumns += nRepeat; |
| bInserted = sal_True; |
| } |
| } |
| } |
| if (!bInserted) |
| { |
| ScMyRowFormatRange aRange; |
| aRange.nStartColumn = nPrevStartCol; |
| aRange.nRepeatColumns = nRepeat; |
| aRange.nRepeatRows = rFormatRange.nRepeatRows; |
| aRange.nValidationIndex = rFormatRange.nValidationIndex; |
| aRange.bIsAutoStyle = rFormatRange.bIsAutoStyle; |
| aRange.nIndex = nIndex; |
| aRowFormatRanges.push_back(aRange); |
| ++nSize; |
| } |
| } |
| |
| void ScRowFormatRanges::AddRange(ScMyRowFormatRange& rFormatRange, |
| const sal_Int32 nRow) |
| { |
| DBG_ASSERT(pRowDefaults, "no row defaults"); |
| DBG_ASSERT(pColDefaults, "no column defaults"); |
| sal_uInt32 nEnd (rFormatRange.nRepeatRows + nRow - 1); |
| sal_Int32 nPrevIndex((*pRowDefaults)[nRow].nIndex); |
| sal_Bool bPrevAutoStyle((*pRowDefaults)[nRow].bIsAutoStyle); |
| sal_uInt32 i(nRow + 1); |
| sal_Bool bReady(sal_False); |
| while ((i < nEnd) && !bReady && (i < pRowDefaults->size())) |
| { |
| if ((nPrevIndex != (*pRowDefaults)[i].nIndex) || |
| (bPrevAutoStyle != (*pRowDefaults)[i].bIsAutoStyle)) |
| bReady = sal_True; |
| else |
| i += (*pRowDefaults)[i].nRepeat; |
| } |
| if (i > nEnd) |
| i = nEnd; |
| if (bReady) |
| rFormatRange.nRepeatRows = i - nRow + 1; |
| if (nPrevIndex == -1) |
| { |
| nPrevIndex = (*pColDefaults)[rFormatRange.nStartColumn].nIndex; |
| bPrevAutoStyle = (*pColDefaults)[rFormatRange.nStartColumn].bIsAutoStyle; |
| sal_uInt32 nPrevStartCol(rFormatRange.nStartColumn); |
| sal_uInt32 nRepeat((*pColDefaults)[rFormatRange.nStartColumn].nRepeat); |
| nEnd = rFormatRange.nStartColumn + rFormatRange.nRepeatColumns; |
| for(i = nPrevStartCol + nRepeat; i < nEnd; i += (*pColDefaults)[i].nRepeat) |
| { |
| DBG_ASSERT(sal_uInt32(nPrevStartCol + nRepeat) <= nEnd, "something wents wrong"); |
| if ((nPrevIndex != (*pColDefaults)[i].nIndex) || |
| (bPrevAutoStyle != (*pColDefaults)[i].bIsAutoStyle)) |
| { |
| AddRange(nPrevStartCol, nRepeat, nPrevIndex, bPrevAutoStyle, rFormatRange); |
| nPrevStartCol = i; |
| nRepeat = (*pColDefaults)[i].nRepeat; |
| nPrevIndex = (*pColDefaults)[i].nIndex; |
| bPrevAutoStyle = (*pColDefaults)[i].bIsAutoStyle; |
| } |
| else |
| nRepeat += (*pColDefaults)[i].nRepeat; |
| } |
| if (sal_uInt32(nPrevStartCol + nRepeat) > nEnd) |
| nRepeat = nEnd - nPrevStartCol; |
| AddRange(nPrevStartCol, nRepeat, nPrevIndex, bPrevAutoStyle, rFormatRange); |
| } |
| else if ((nPrevIndex == rFormatRange.nIndex) && |
| (bPrevAutoStyle == rFormatRange.bIsAutoStyle)) |
| { |
| rFormatRange.nIndex = -1; |
| aRowFormatRanges.push_back(rFormatRange); |
| ++nSize; |
| } |
| } |
| |
| sal_Bool ScRowFormatRanges::GetNext(ScMyRowFormatRange& aFormatRange) |
| { |
| ScMyRowFormatRangesList::iterator aItr(aRowFormatRanges.begin()); |
| if (aItr != aRowFormatRanges.end()) |
| { |
| aFormatRange = (*aItr); |
| aRowFormatRanges.erase(aItr); |
| --nSize; |
| return sal_True; |
| } |
| return sal_False; |
| } |
| |
| sal_Int32 ScRowFormatRanges::GetMaxRows() |
| { |
| ScMyRowFormatRangesList::iterator aItr(aRowFormatRanges.begin()); |
| ScMyRowFormatRangesList::iterator aEndItr(aRowFormatRanges.end()); |
| sal_Int32 nMaxRows = MAXROW + 1; |
| if (aItr != aEndItr) |
| while (aItr != aEndItr) |
| { |
| if ((*aItr).nRepeatRows < nMaxRows) |
| nMaxRows = (*aItr).nRepeatRows; |
| ++aItr; |
| } |
| else |
| { |
| DBG_ERROR("no ranges found"); |
| } |
| return nMaxRows; |
| } |
| |
| sal_Int32 ScRowFormatRanges::GetSize() |
| { |
| return nSize; |
| } |
| |
| void ScRowFormatRanges::Sort() |
| { |
| aRowFormatRanges.sort(); |
| } |
| |
| // ============================================================================ |
| ScMyFormatRange::ScMyFormatRange() |
| : nStyleNameIndex(-1), |
| nValidationIndex(-1), |
| bIsAutoStyle(sal_True) |
| { |
| } |
| |
| sal_Bool ScMyFormatRange::operator<(const ScMyFormatRange& rRange) const |
| { |
| if (aRangeAddress.StartRow < rRange.aRangeAddress.StartRow) |
| return sal_True; |
| else |
| if (aRangeAddress.StartRow == rRange.aRangeAddress.StartRow) |
| return (aRangeAddress.StartColumn < rRange.aRangeAddress.StartColumn); |
| else |
| return sal_False; |
| } |
| |
| ScFormatRangeStyles::ScFormatRangeStyles() |
| : aTables(), |
| aStyleNames(), |
| aAutoStyleNames() |
| { |
| } |
| |
| ScFormatRangeStyles::~ScFormatRangeStyles() |
| { |
| ScMyOUStringVec::iterator i(aStyleNames.begin()); |
| ScMyOUStringVec::iterator endi(aStyleNames.end()); |
| while (i != endi) |
| { |
| delete *i; |
| ++i; |
| } |
| i = aAutoStyleNames.begin(); |
| endi = aAutoStyleNames.end(); |
| while (i != endi) |
| { |
| delete *i; |
| ++i; |
| } |
| ScMyFormatRangeListVec::iterator j(aTables.begin()); |
| ScMyFormatRangeListVec::iterator endj(aTables.end()); |
| while (j != endj) |
| { |
| delete *j; |
| ++j; |
| } |
| } |
| |
| void ScFormatRangeStyles::AddNewTable(const sal_Int32 nTable) |
| { |
| sal_Int32 nSize = aTables.size() - 1; |
| if (nTable > nSize) |
| for (sal_Int32 i = nSize; i < nTable; ++i) |
| { |
| ScMyFormatRangeAddresses* aRangeAddresses(new ScMyFormatRangeAddresses); |
| aTables.push_back(aRangeAddresses); |
| } |
| } |
| |
| sal_Bool ScFormatRangeStyles::AddStyleName(rtl::OUString* rpString, sal_Int32& rIndex, const sal_Bool bIsAutoStyle) |
| { |
| if (bIsAutoStyle) |
| { |
| aAutoStyleNames.push_back(rpString); |
| rIndex = aAutoStyleNames.size() - 1; |
| return sal_True; |
| } |
| else |
| { |
| sal_Int32 nCount(aStyleNames.size()); |
| sal_Bool bFound(sal_False); |
| sal_Int32 i(nCount - 1); |
| while ((i >= 0) && (!bFound)) |
| { |
| if (aStyleNames.at(i)->equals(*rpString)) |
| bFound = sal_True; |
| else |
| i--; |
| } |
| if (bFound) |
| { |
| rIndex = i; |
| return sal_False; |
| } |
| else |
| { |
| aStyleNames.push_back(rpString); |
| rIndex = aStyleNames.size() - 1; |
| return sal_True; |
| } |
| } |
| } |
| |
| sal_Int32 ScFormatRangeStyles::GetIndexOfStyleName(const rtl::OUString& rString, const rtl::OUString& rPrefix, sal_Bool& bIsAutoStyle) |
| { |
| sal_Int32 nPrefixLength(rPrefix.getLength()); |
| rtl::OUString sTemp(rString.copy(nPrefixLength)); |
| sal_Int32 nIndex(sTemp.toInt32()); |
| if (nIndex > 0 && static_cast<size_t>(nIndex-1) < aAutoStyleNames.size() && aAutoStyleNames.at(nIndex - 1)->equals(rString)) |
| { |
| bIsAutoStyle = sal_True; |
| return nIndex - 1; |
| } |
| else |
| { |
| sal_Int32 i(0); |
| sal_Bool bFound(sal_False); |
| while (!bFound && static_cast<size_t>(i) < aStyleNames.size()) |
| { |
| if (aStyleNames[i]->equals(rString)) |
| bFound = sal_True; |
| else |
| ++i; |
| } |
| if (bFound) |
| { |
| bIsAutoStyle = sal_False; |
| return i; |
| } |
| else |
| { |
| i = 0; |
| while (!bFound && static_cast<size_t>(i) < aAutoStyleNames.size()) |
| { |
| if (aAutoStyleNames[i]->equals(rString)) |
| bFound = sal_True; |
| else |
| ++i; |
| } |
| if (bFound) |
| { |
| bIsAutoStyle = sal_True; |
| return i; |
| } |
| else |
| return -1; |
| } |
| } |
| } |
| |
| sal_Int32 ScFormatRangeStyles::GetStyleNameIndex(const sal_Int32 nTable, |
| const sal_Int32 nColumn, const sal_Int32 nRow, sal_Bool& bIsAutoStyle) const |
| { |
| DBG_ASSERT(static_cast<size_t>(nTable) < aTables.size(), "wrong table"); |
| ScMyFormatRangeAddresses* pFormatRanges(aTables[nTable]); |
| ScMyFormatRangeAddresses::iterator aItr(pFormatRanges->begin()); |
| ScMyFormatRangeAddresses::iterator aEndItr(pFormatRanges->end()); |
| while (aItr != aEndItr) |
| { |
| if (((*aItr).aRangeAddress.StartColumn <= nColumn) && |
| ((*aItr).aRangeAddress.EndColumn >= nColumn) && |
| ((*aItr).aRangeAddress.StartRow <= nRow) && |
| ((*aItr).aRangeAddress.EndRow >= nRow)) |
| { |
| bIsAutoStyle = aItr->bIsAutoStyle; |
| return (*aItr).nStyleNameIndex; |
| } |
| else |
| ++aItr; |
| } |
| return -1; |
| } |
| |
| sal_Int32 ScFormatRangeStyles::GetStyleNameIndex(const sal_Int32 nTable, const sal_Int32 nColumn, const sal_Int32 nRow, |
| sal_Bool& bIsAutoStyle, sal_Int32& nValidationIndex, sal_Int32& nNumberFormat, const sal_Int32 nRemoveBeforeRow) |
| { |
| DBG_ASSERT(static_cast<size_t>(nTable) < aTables.size(), "wrong table"); |
| ScMyFormatRangeAddresses* pFormatRanges(aTables[nTable]); |
| ScMyFormatRangeAddresses::iterator aItr(pFormatRanges->begin()); |
| ScMyFormatRangeAddresses::iterator aEndItr(pFormatRanges->end()); |
| while (aItr != aEndItr) |
| { |
| if (((*aItr).aRangeAddress.StartColumn <= nColumn) && |
| ((*aItr).aRangeAddress.EndColumn >= nColumn) && |
| ((*aItr).aRangeAddress.StartRow <= nRow) && |
| ((*aItr).aRangeAddress.EndRow >= nRow)) |
| { |
| bIsAutoStyle = aItr->bIsAutoStyle; |
| nValidationIndex = aItr->nValidationIndex; |
| nNumberFormat = aItr->nNumberFormat; |
| if (((*pRowDefaults)[nRow].nIndex != -1)) |
| { |
| if (((*pRowDefaults)[nRow].nIndex == (*aItr).nStyleNameIndex) && |
| ((*pRowDefaults)[nRow].bIsAutoStyle == (*aItr).bIsAutoStyle)) |
| return -1; |
| else |
| return (*aItr).nStyleNameIndex; |
| } |
| else if (((*pColDefaults)[nColumn].nIndex != -1) && |
| ((*pColDefaults)[nColumn].nIndex == (*aItr).nStyleNameIndex) && |
| ((*pColDefaults)[nColumn].bIsAutoStyle == (*aItr).bIsAutoStyle)) |
| return -1; |
| else |
| return (*aItr).nStyleNameIndex; |
| } |
| else |
| { |
| if ((*aItr).aRangeAddress.EndRow < nRemoveBeforeRow) |
| aItr = pFormatRanges->erase(aItr); |
| else |
| ++aItr; |
| } |
| } |
| return -1; |
| } |
| |
| void ScFormatRangeStyles::GetFormatRanges(const sal_Int32 nStartColumn, const sal_Int32 nEndColumn, const sal_Int32 nRow, |
| const sal_Int32 nTable, ScRowFormatRanges* pRowFormatRanges) |
| { |
| sal_Int32 nTotalColumns(nEndColumn - nStartColumn + 1); |
| DBG_ASSERT(static_cast<size_t>(nTable) < aTables.size(), "wrong table"); |
| ScMyFormatRangeAddresses* pFormatRanges(aTables[nTable]); |
| ScMyFormatRangeAddresses::iterator aItr(pFormatRanges->begin()); |
| ScMyFormatRangeAddresses::iterator aEndItr(pFormatRanges->end()); |
| sal_Int32 nColumns = 0; |
| while (aItr != aEndItr && nColumns < nTotalColumns) |
| { |
| #if OSL_DEBUG_LEVEL > 1 |
| table::CellRangeAddress aTempRangeAddress((*aItr).aRangeAddress); |
| #endif |
| if (((*aItr).aRangeAddress.StartRow <= nRow) && |
| ((*aItr).aRangeAddress.EndRow >= nRow)) |
| { |
| if ((((*aItr).aRangeAddress.StartColumn <= nStartColumn) && |
| ((*aItr).aRangeAddress.EndColumn >= nStartColumn)) || |
| (((*aItr).aRangeAddress.StartColumn <= nEndColumn) && |
| ((*aItr).aRangeAddress.EndColumn >= nEndColumn)) || |
| (((*aItr).aRangeAddress.StartColumn >= nStartColumn) && |
| ((*aItr).aRangeAddress.EndColumn <= nEndColumn))) |
| { |
| ScMyRowFormatRange aRange; |
| aRange.nIndex = aItr->nStyleNameIndex; |
| aRange.nValidationIndex = aItr->nValidationIndex; |
| aRange.bIsAutoStyle = aItr->bIsAutoStyle; |
| if ((aItr->aRangeAddress.StartColumn < nStartColumn) && |
| (aItr->aRangeAddress.EndColumn >= nStartColumn)) |
| { |
| if (aItr->aRangeAddress.EndColumn >= nEndColumn) |
| aRange.nRepeatColumns = nTotalColumns; |
| else |
| aRange.nRepeatColumns = aItr->aRangeAddress.EndColumn - nStartColumn + 1; |
| aRange.nStartColumn = nStartColumn; |
| } |
| else if ((aItr->aRangeAddress.StartColumn >= nStartColumn) && |
| (aItr->aRangeAddress.EndColumn <= nEndColumn)) |
| { |
| aRange.nRepeatColumns = aItr->aRangeAddress.EndColumn - aItr->aRangeAddress.StartColumn + 1; |
| aRange.nStartColumn = aItr->aRangeAddress.StartColumn; |
| } |
| else if ((aItr->aRangeAddress.StartColumn >= nStartColumn) && |
| (aItr->aRangeAddress.StartColumn <= nEndColumn) && |
| (aItr->aRangeAddress.EndColumn > nEndColumn)) |
| { |
| aRange.nRepeatColumns = nEndColumn - aItr->aRangeAddress.StartColumn + 1; |
| aRange.nStartColumn = aItr->aRangeAddress.StartColumn; |
| } |
| aRange.nRepeatRows = aItr->aRangeAddress.EndRow - nRow + 1; |
| pRowFormatRanges->AddRange(aRange, nRow); |
| nColumns += aRange.nRepeatColumns; |
| } |
| ++aItr; |
| } |
| else |
| if(aItr->aRangeAddress.EndRow < nRow) |
| aItr = pFormatRanges->erase(aItr); |
| else |
| ++aItr; |
| } |
| pRowFormatRanges->Sort(); |
| } |
| |
| void ScFormatRangeStyles::AddRangeStyleName(const table::CellRangeAddress aCellRangeAddress, |
| const sal_Int32 nStringIndex, const sal_Bool bIsAutoStyle, const sal_Int32 nValidationIndex, |
| const sal_Int32 nNumberFormat) |
| { |
| ScMyFormatRange aFormatRange; |
| aFormatRange.aRangeAddress = aCellRangeAddress; |
| aFormatRange.nStyleNameIndex = nStringIndex; |
| aFormatRange.nValidationIndex = nValidationIndex; |
| aFormatRange.nNumberFormat = nNumberFormat; |
| aFormatRange.bIsAutoStyle = bIsAutoStyle; |
| DBG_ASSERT(static_cast<size_t>(aCellRangeAddress.Sheet) < aTables.size(), "wrong table"); |
| ScMyFormatRangeAddresses* pFormatRanges(aTables[aCellRangeAddress.Sheet]); |
| pFormatRanges->push_back(aFormatRange); |
| } |
| |
| rtl::OUString* ScFormatRangeStyles::GetStyleNameByIndex(const sal_Int32 nIndex, const sal_Bool bIsAutoStyle) |
| { |
| if (bIsAutoStyle) |
| return aAutoStyleNames[nIndex]; |
| else |
| return aStyleNames[nIndex]; |
| } |
| |
| void ScFormatRangeStyles::Sort() |
| { |
| sal_Int32 nTables = aTables.size(); |
| for (sal_Int16 i = 0; i < nTables; ++i) |
| if (!aTables[i]->empty()) |
| aTables[i]->sort(); |
| } |
| |
| //=========================================================================== |
| |
| ScColumnRowStylesBase::ScColumnRowStylesBase() |
| : aStyleNames() |
| { |
| } |
| |
| ScColumnRowStylesBase::~ScColumnRowStylesBase() |
| { |
| ScMyOUStringVec::iterator i(aStyleNames.begin()); |
| ScMyOUStringVec::iterator endi(aStyleNames.end()); |
| while (i != endi) |
| { |
| delete *i; |
| ++i; |
| } |
| } |
| |
| sal_Int32 ScColumnRowStylesBase::AddStyleName(rtl::OUString* pString) |
| { |
| aStyleNames.push_back(pString); |
| return aStyleNames.size() - 1; |
| } |
| |
| sal_Int32 ScColumnRowStylesBase::GetIndexOfStyleName(const rtl::OUString& rString, const rtl::OUString& rPrefix) |
| { |
| sal_Int32 nPrefixLength(rPrefix.getLength()); |
| rtl::OUString sTemp(rString.copy(nPrefixLength)); |
| sal_Int32 nIndex(sTemp.toInt32()); |
| if (nIndex > 0 && static_cast<size_t>(nIndex-1) < aStyleNames.size() && aStyleNames.at(nIndex - 1)->equals(rString)) |
| return nIndex - 1; |
| else |
| { |
| sal_Int32 i(0); |
| sal_Bool bFound(sal_False); |
| while (!bFound && static_cast<size_t>(i) < aStyleNames.size()) |
| { |
| if (aStyleNames.at(i)->equals(rString)) |
| bFound = sal_True; |
| else |
| ++i; |
| } |
| if (bFound) |
| return i; |
| else |
| return -1; |
| } |
| } |
| |
| rtl::OUString* ScColumnRowStylesBase::GetStyleNameByIndex(const sal_Int32 nIndex) |
| { |
| if ( nIndex < 0 || nIndex >= sal::static_int_cast<sal_Int32>( aStyleNames.size() ) ) |
| { |
| // #123981# should no longer happen, use first style then |
| DBG_ERRORFILE("GetStyleNameByIndex: invalid index"); |
| return aStyleNames[0]; |
| } |
| |
| return aStyleNames[nIndex]; |
| } |
| |
| //=========================================================================== |
| |
| ScColumnStyles::ScColumnStyles() |
| : ScColumnRowStylesBase(), |
| aTables() |
| { |
| } |
| |
| ScColumnStyles::~ScColumnStyles() |
| { |
| } |
| |
| void ScColumnStyles::AddNewTable(const sal_Int32 nTable, const sal_Int32 nFields) |
| { |
| sal_Int32 nSize(aTables.size() - 1); |
| if (nTable > nSize) |
| for (sal_Int32 i = nSize; i < nTable; ++i) |
| { |
| ScMyColumnStyleVec aFieldsVec(nFields + 1, ScColumnStyle()); |
| aTables.push_back(aFieldsVec); |
| } |
| } |
| |
| sal_Int32 ScColumnStyles::GetStyleNameIndex(const sal_Int32 nTable, const sal_Int32 nField, |
| sal_Bool& bIsVisible) |
| { |
| DBG_ASSERT(static_cast<size_t>(nTable) < aTables.size(), "wrong table"); |
| if (static_cast<size_t>(nField) < aTables[nTable].size()) |
| { |
| bIsVisible = aTables[nTable][nField].bIsVisible; |
| return aTables[nTable][nField].nIndex; |
| } |
| else |
| { |
| bIsVisible = aTables[nTable][aTables[nTable].size() - 1].bIsVisible; |
| return aTables[nTable][aTables[nTable].size() - 1].nIndex; |
| } |
| } |
| |
| void ScColumnStyles::AddFieldStyleName(const sal_Int32 nTable, const sal_Int32 nField, |
| const sal_Int32 nStringIndex, const sal_Bool bIsVisible) |
| { |
| DBG_ASSERT(static_cast<size_t>(nTable) < aTables.size(), "wrong table"); |
| DBG_ASSERT(aTables[nTable].size() >= static_cast<sal_uInt32>(nField), "wrong field"); |
| ScColumnStyle aStyle; |
| aStyle.nIndex = nStringIndex; |
| aStyle.bIsVisible = bIsVisible; |
| if (aTables[nTable].size() == static_cast<sal_uInt32>(nField)) |
| aTables[nTable].push_back(aStyle); |
| aTables[nTable][nField] = aStyle; |
| } |
| |
| rtl::OUString* ScColumnStyles::GetStyleName(const sal_Int32 nTable, const sal_Int32 nField) |
| { |
| sal_Bool bTemp; |
| return GetStyleNameByIndex(GetStyleNameIndex(nTable, nField, bTemp)); |
| } |
| |
| //=========================================================================== |
| |
| ScRowStyles::ScRowStyles() |
| : ScColumnRowStylesBase(), |
| aTables() |
| { |
| } |
| |
| ScRowStyles::~ScRowStyles() |
| { |
| } |
| |
| void ScRowStyles::AddNewTable(const sal_Int32 nTable, const sal_Int32 nFields) |
| { |
| sal_Int32 nSize(aTables.size() - 1); |
| if (nTable > nSize) |
| for (sal_Int32 i = nSize; i < nTable; ++i) |
| { |
| ScMysalInt32Vec aFieldsVec(nFields + 1, -1); |
| aTables.push_back(aFieldsVec); |
| } |
| } |
| |
| sal_Int32 ScRowStyles::GetStyleNameIndex(const sal_Int32 nTable, const sal_Int32 nField) |
| { |
| DBG_ASSERT(static_cast<size_t>(nTable) < aTables.size(), "wrong table"); |
| if (static_cast<size_t>(nField) < aTables[nTable].size()) |
| return aTables[nTable][nField]; |
| else |
| return aTables[nTable][aTables[nTable].size() - 1]; |
| } |
| |
| void ScRowStyles::AddFieldStyleName(const sal_Int32 nTable, const sal_Int32 nField, |
| const sal_Int32 nStringIndex) |
| { |
| DBG_ASSERT(static_cast<size_t>(nTable) < aTables.size(), "wrong table"); |
| DBG_ASSERT(aTables[nTable].size() >= static_cast<size_t>(nField), "wrong field"); |
| if (aTables[nTable].size() == static_cast<size_t>(nField)) |
| aTables[nTable].push_back(nStringIndex); |
| else |
| aTables[nTable][nField] = nStringIndex; |
| } |
| |
| void ScRowStyles::AddFieldStyleName(const sal_Int32 nTable, const sal_Int32 nStartField, |
| const sal_Int32 nStringIndex, const sal_Int32 nEndField) |
| { |
| DBG_ASSERT( nStartField <= nEndField, "bad field range"); |
| DBG_ASSERT(static_cast<size_t>(nTable) < aTables.size(), "wrong table"); |
| DBG_ASSERT(aTables[nTable].size() >= static_cast<size_t>(nStartField), "wrong field"); |
| ScMysalInt32Vec& rTable = aTables[nTable]; |
| size_t nSize = rTable.size(); |
| if (nSize == static_cast<size_t>(nStartField)) |
| rTable.insert( rTable.end(), static_cast<size_t>(nEndField - nStartField + 1), nStringIndex); |
| else |
| { |
| size_t nField = static_cast<size_t>(nStartField); |
| for ( ; nField < nSize && nField <= static_cast<size_t>(nEndField); ++nField) |
| rTable[nField] = nStringIndex; |
| if (nField <= static_cast<size_t>(nEndField)) |
| rTable.insert( rTable.end(), static_cast<size_t>(nEndField - nField + 1), nStringIndex); |
| } |
| } |
| |
| rtl::OUString* ScRowStyles::GetStyleName(const sal_Int32 nTable, const sal_Int32 nField) |
| { |
| return GetStyleNameByIndex(GetStyleNameIndex(nTable, nField)); |
| } |