/************************************************************** * * 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 "XMLExportDatabaseRanges.hxx" #include #include #include #include #include "xmlexprt.hxx" #include "XMLExportIterator.hxx" #include "XMLConverter.hxx" #include "unonames.hxx" #include "dbcolect.hxx" #include "document.hxx" #include "globstr.hrc" #include "XMLExportSharedData.hxx" #include "rangeutl.hxx" #include #include #include #include #include #include #include #include #include //! not found in unonames.hxx #define SC_USERLIST "UserList" #define SC_SORTASCENDING "SortAscending" #define SC_ENABLEUSERSORTLIST "EnableUserSortList" #define SC_USERSORTLISTINDEX "UserSortListIndex" using namespace com::sun::star; using namespace xmloff::token; ScXMLExportDatabaseRanges::ScXMLExportDatabaseRanges(ScXMLExport& rTempExport) : rExport(rTempExport), pDoc( NULL ) { } ScXMLExportDatabaseRanges::~ScXMLExportDatabaseRanges() { } ScMyEmptyDatabaseRangesContainer ScXMLExportDatabaseRanges::GetEmptyDatabaseRanges() { ScMyEmptyDatabaseRangesContainer aSkipRanges; if (rExport.GetModel().is()) { sal_Int32 nSkipRangesCount = 0; uno::Reference xPropertySet (rExport.GetModel(), uno::UNO_QUERY); if (xPropertySet.is()) { uno::Reference xDatabaseRanges(xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_DATABASERNG))), uno::UNO_QUERY); rExport.CheckAttrList(); if (xDatabaseRanges.is()) { uno::Sequence aRanges(xDatabaseRanges->getElementNames()); sal_Int32 nDatabaseRangesCount = aRanges.getLength(); for (sal_Int32 i = 0; i < nDatabaseRangesCount; ++i) { rtl::OUString sDatabaseRangeName(aRanges[i]); uno::Reference xDatabaseRange(xDatabaseRanges->getByName(sDatabaseRangeName), uno::UNO_QUERY); if (xDatabaseRange.is()) { uno::Reference xDatabaseRangePropertySet (xDatabaseRange, uno::UNO_QUERY); if (xDatabaseRangePropertySet.is() && ::cppu::any2bool(xDatabaseRangePropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_STRIPDAT))))) { uno::Sequence aImportProperties(xDatabaseRange->getImportDescriptor()); sal_Int32 nLength = aImportProperties.getLength(); sheet::DataImportMode nSourceType = sheet::DataImportMode_NONE; for (sal_Int32 j = 0; j < nLength; ++j) if (aImportProperties[j].Name == rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_SRCTYPE))) aImportProperties[j].Value >>= nSourceType; if (nSourceType != sheet::DataImportMode_NONE) { table::CellRangeAddress aArea = xDatabaseRange->getDataArea(); aSkipRanges.AddNewEmptyDatabaseRange(aArea); // #105276#; set last row/column so default styles are collected rExport.GetSharedData()->SetLastColumn(aArea.Sheet, aArea.EndColumn); rExport.GetSharedData()->SetLastRow(aArea.Sheet, aArea.EndRow); } } } } if (nSkipRangesCount > 1) aSkipRanges.Sort(); } } } return aSkipRanges; } void ScXMLExportDatabaseRanges::WriteImportDescriptor(const uno::Sequence aImportDescriptor) { sal_Int32 nProperties = aImportDescriptor.getLength(); rtl::OUString sDatabaseName; rtl::OUString sConRes; rtl::OUString sSourceObject; sheet::DataImportMode nSourceType = sheet::DataImportMode_NONE; sal_Bool bNative = sal_False; for (sal_Int16 i = 0; i < nProperties; ++i) { if (aImportDescriptor[i].Name == rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_DBNAME))) aImportDescriptor[i].Value >>= sDatabaseName; else if (aImportDescriptor[i].Name == rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_CONRES))) aImportDescriptor[i].Value >>= sConRes; else if (aImportDescriptor[i].Name == rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_SRCOBJ))) aImportDescriptor[i].Value >>= sSourceObject; else if (aImportDescriptor[i].Name == rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_SRCTYPE))) aImportDescriptor[i].Value >>= nSourceType; else if (aImportDescriptor[i].Name == rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_ISNATIVE))) bNative = ::cppu::any2bool(aImportDescriptor[i].Value); } switch (nSourceType) { case sheet::DataImportMode_NONE : break; case sheet::DataImportMode_QUERY : { if (sDatabaseName.getLength()) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_DATABASE_NAME, sDatabaseName); rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_QUERY_NAME, sSourceObject); SvXMLElementExport aElemID(rExport, XML_NAMESPACE_TABLE, XML_DATABASE_SOURCE_QUERY, sal_True, sal_True); if (sConRes.getLength()) { rExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, sConRes ); SvXMLElementExport aElemCR(rExport, XML_NAMESPACE_FORM, XML_CONNECTION_RESOURCE, sal_True, sal_True); } rExport.CheckAttrList(); } break; case sheet::DataImportMode_TABLE : { if (sDatabaseName.getLength()) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_DATABASE_NAME, sDatabaseName); rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_TABLE_NAME, sSourceObject); SvXMLElementExport aElemID(rExport, XML_NAMESPACE_TABLE, XML_DATABASE_SOURCE_TABLE, sal_True, sal_True); if (sConRes.getLength()) { rExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, sConRes ); SvXMLElementExport aElemCR(rExport, XML_NAMESPACE_FORM, XML_CONNECTION_RESOURCE, sal_True, sal_True); } rExport.CheckAttrList(); } break; case sheet::DataImportMode_SQL : { if (sDatabaseName.getLength()) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_DATABASE_NAME, sDatabaseName); rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_SQL_STATEMENT, sSourceObject); if (!bNative) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_PARSE_SQL_STATEMENT, XML_TRUE); SvXMLElementExport aElemID(rExport, XML_NAMESPACE_TABLE, XML_DATABASE_SOURCE_SQL, sal_True, sal_True); if (sConRes.getLength()) { rExport.AddAttribute( XML_NAMESPACE_XLINK, XML_HREF, sConRes ); SvXMLElementExport aElemCR(rExport, XML_NAMESPACE_FORM, XML_CONNECTION_RESOURCE, sal_True, sal_True); } rExport.CheckAttrList(); } break; default: { // added to avoid warnings } } } rtl::OUString ScXMLExportDatabaseRanges::getOperatorXML(const long aFilterOperator, const sal_Bool bUseRegularExpressions) const { switch (aFilterOperator) { case sheet::FilterOperator2::EQUAL : { if (bUseRegularExpressions) return GetXMLToken(XML_MATCH); else return rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("=")); } case sheet::FilterOperator2::NOT_EQUAL : { if (bUseRegularExpressions) return GetXMLToken(XML_NOMATCH); else return rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("!=")); } case sheet::FilterOperator2::BOTTOM_PERCENT : return GetXMLToken(XML_BOTTOM_PERCENT); case sheet::FilterOperator2::BOTTOM_VALUES : return GetXMLToken(XML_BOTTOM_VALUES); case sheet::FilterOperator2::EMPTY : return GetXMLToken(XML_EMPTY); case sheet::FilterOperator2::GREATER : return rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(">")); case sheet::FilterOperator2::GREATER_EQUAL : return rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(">=")); case sheet::FilterOperator2::LESS : return rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("<")); case sheet::FilterOperator2::LESS_EQUAL : return rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("<=")); case sheet::FilterOperator2::NOT_EMPTY : return GetXMLToken(XML_NOEMPTY); case sheet::FilterOperator2::TOP_PERCENT : return GetXMLToken(XML_TOP_PERCENT); case sheet::FilterOperator2::TOP_VALUES : return GetXMLToken(XML_TOP_VALUES); case sheet::FilterOperator2::CONTAINS : return GetXMLToken(XML_CONTAINS); case sheet::FilterOperator2::DOES_NOT_CONTAIN : return GetXMLToken(XML_DOES_NOT_CONTAIN); case sheet::FilterOperator2::BEGINS_WITH : return GetXMLToken(XML_BEGINS_WITH); case sheet::FilterOperator2::DOES_NOT_BEGIN_WITH : return GetXMLToken(XML_DOES_NOT_BEGIN_WITH); case sheet::FilterOperator2::ENDS_WITH : return GetXMLToken(XML_ENDS_WITH); case sheet::FilterOperator2::DOES_NOT_END_WITH : return GetXMLToken(XML_DOES_NOT_END_WITH); default: { // added to avoid warnings } } return rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("=")); } void ScXMLExportDatabaseRanges::WriteCondition(const sheet::TableFilterField2& aFilterField, sal_Bool bIsCaseSensitive, sal_Bool bUseRegularExpressions) { rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_FIELD_NUMBER, rtl::OUString::valueOf(aFilterField.Field)); if (bIsCaseSensitive) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_CASE_SENSITIVE, XML_TRUE); if (aFilterField.IsNumeric) { rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_DATA_TYPE, XML_NUMBER); rtl::OUStringBuffer sBuffer; rExport.GetMM100UnitConverter().convertDouble(sBuffer, aFilterField.NumericValue); rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_VALUE, sBuffer.makeStringAndClear()); } else rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_VALUE, aFilterField.StringValue); rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_OPERATOR, getOperatorXML(aFilterField.Operator, bUseRegularExpressions)); SvXMLElementExport aElemC(rExport, XML_NAMESPACE_TABLE, XML_FILTER_CONDITION, sal_True, sal_True); } void ScXMLExportDatabaseRanges::WriteFilterDescriptor(const uno::Reference & xSheetFilterDescriptor, const rtl::OUString sDatabaseRangeName) { uno::Sequence< sheet::TableFilterField2 > aTableFilterFields( xSheetFilterDescriptor->getFilterFields2() ); sal_Int32 nTableFilterFields = aTableFilterFields.getLength(); if (nTableFilterFields > 0) { uno::Reference xPropertySet (xSheetFilterDescriptor, uno::UNO_QUERY); if (xPropertySet.is()) { if (::cppu::any2bool(xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_COPYOUT))))) { table::CellAddress aOutputPosition; if (xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_OUTPOS))) >>= aOutputPosition) { rtl::OUString sOUCellAddress; ScRangeStringConverter::GetStringFromAddress( sOUCellAddress, aOutputPosition, pDoc, ::formula::FormulaGrammar::CONV_OOO ); rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_TARGET_RANGE_ADDRESS, sOUCellAddress); } } ScDBCollection* pDBCollection = pDoc->GetDBCollection(); sal_uInt16 nIndex; pDBCollection->SearchName(sDatabaseRangeName, nIndex); ScDBData* pDBData = (*pDBCollection)[nIndex]; ScRange aAdvSource; if (pDBData->GetAdvancedQuerySource(aAdvSource)) { rtl::OUString sOUCellAddress; ScRangeStringConverter::GetStringFromRange( sOUCellAddress, aAdvSource, pDoc, ::formula::FormulaGrammar::CONV_OOO ); rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_CONDITION_SOURCE_RANGE_ADDRESS, sOUCellAddress); } if (::cppu::any2bool(xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_SKIPDUP))))) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_DISPLAY_DUPLICATES, XML_FALSE); SvXMLElementExport aElemF(rExport, XML_NAMESPACE_TABLE, XML_FILTER, sal_True, sal_True); rExport.CheckAttrList(); sal_Bool bIsCaseSensitive = ::cppu::any2bool(xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_ISCASE)))); sal_Bool bUseRegularExpressions = ::cppu::any2bool(xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_USEREGEX)))); sal_Bool bAnd = sal_False; sal_Bool bOr = sal_False; for (sal_Int32 i = 1; i < nTableFilterFields; ++i) { if (aTableFilterFields[i].Connection == sheet::FilterConnection_AND) bAnd = sal_True; else bOr = sal_True; } if (bOr && !bAnd) { SvXMLElementExport aElemOr(rExport, XML_NAMESPACE_TABLE, XML_FILTER_OR, sal_True, sal_True); for (sal_Int32 i = 0; i < nTableFilterFields; ++i) { WriteCondition(aTableFilterFields[i], bIsCaseSensitive, bUseRegularExpressions); } } else if (bAnd && !bOr) { SvXMLElementExport aElemAnd(rExport, XML_NAMESPACE_TABLE, XML_FILTER_AND, sal_True, sal_True); for (sal_Int32 i = 0; i < nTableFilterFields; ++i) { WriteCondition(aTableFilterFields[i], bIsCaseSensitive, bUseRegularExpressions); } } else if (nTableFilterFields == 1) { WriteCondition(aTableFilterFields[0], bIsCaseSensitive, bUseRegularExpressions); } else { SvXMLElementExport aElemC(rExport, XML_NAMESPACE_TABLE, XML_FILTER_OR, sal_True, sal_True); sheet::TableFilterField2 aPrevFilterField = aTableFilterFields[0]; sheet::FilterConnection aConnection = aTableFilterFields[1].Connection; sal_Bool bOpenAndElement; rtl::OUString aName = rExport.GetNamespaceMap().GetQNameByKey(XML_NAMESPACE_TABLE, GetXMLToken(XML_FILTER_AND)); if (aConnection == sheet::FilterConnection_AND) { rExport.StartElement( aName, sal_True); bOpenAndElement = sal_True; } else bOpenAndElement = sal_False; for (sal_Int32 i = 1; i < nTableFilterFields; ++i) { if (aConnection != aTableFilterFields[i].Connection) { aConnection = aTableFilterFields[i].Connection; if (aTableFilterFields[i].Connection == sheet::FilterConnection_AND) { rExport.StartElement( aName, sal_True ); bOpenAndElement = sal_True; WriteCondition(aPrevFilterField, bIsCaseSensitive, bUseRegularExpressions); aPrevFilterField = aTableFilterFields[i]; if (i == nTableFilterFields - 1) { WriteCondition(aPrevFilterField, bIsCaseSensitive, bUseRegularExpressions); rExport.EndElement(aName, sal_True); bOpenAndElement = sal_False; } } else { WriteCondition(aPrevFilterField, bIsCaseSensitive, bUseRegularExpressions); aPrevFilterField = aTableFilterFields[i]; if (bOpenAndElement) { rExport.EndElement(aName, sal_True); bOpenAndElement = sal_False; } if (i == nTableFilterFields - 1) { WriteCondition(aPrevFilterField, bIsCaseSensitive, bUseRegularExpressions); } } } else { WriteCondition(aPrevFilterField, bIsCaseSensitive, bUseRegularExpressions); aPrevFilterField = aTableFilterFields[i]; if (i == nTableFilterFields - 1) WriteCondition(aPrevFilterField, bIsCaseSensitive, bUseRegularExpressions); } } if(bOpenAndElement) rExport.EndElement(aName, sal_True); } } } } void ScXMLExportDatabaseRanges::WriteSortDescriptor(const uno::Sequence aSortProperties) { uno::Sequence aSortFields; sal_Bool bBindFormatsToContent (sal_True); sal_Bool bCopyOutputData (sal_False); // sal_Bool bIsCaseSensitive (sal_False); sal_Bool bIsUserListEnabled (sal_False); table::CellAddress aOutputPosition; sal_Int32 nUserListIndex = 0; sal_Int32 nProperties = aSortProperties.getLength(); sal_Int32 i; for (i = 0; i < nProperties; ++i) { if (aSortProperties[i].Name.compareToAscii(SC_UNONAME_BINDFMT) == 0) bBindFormatsToContent = ::cppu::any2bool(aSortProperties[i].Value); else if (aSortProperties[i].Name.compareToAscii(SC_UNONAME_COPYOUT) == 0) bCopyOutputData = ::cppu::any2bool(aSortProperties[i].Value); // no longer supported /* else if (aSortProperties[i].Name.compareToAscii(SC_UNONAME_ISCASE) == 0) bIsCaseSensitive = ::cppu::any2bool(aSortProperties[i].Value);*/ else if (aSortProperties[i].Name.compareToAscii(SC_UNONAME_ISULIST) == 0) bIsUserListEnabled = ::cppu::any2bool(aSortProperties[i].Value); else if (aSortProperties[i].Name.compareToAscii(SC_UNONAME_OUTPOS) == 0) aSortProperties[i].Value >>= aOutputPosition; else if (aSortProperties[i].Name.compareToAscii(SC_UNONAME_UINDEX) == 0) aSortProperties[i].Value >>= nUserListIndex; else if (aSortProperties[i].Name.compareToAscii(SC_UNONAME_SORTFLD) == 0) aSortProperties[i].Value >>= aSortFields; // no longer supported /* else if (aSortProperties[i].Name.compareToAscii(SC_UNONAME_COLLLOC) == 0) aSortProperties[i].Value >>= aCollatorLocale; else if (aSortProperties[i].Name.compareToAscii(SC_UNONAME_COLLALG) == 0) aSortProperties[i].Value >>= sCollatorAlgorithm;*/ } sal_Int32 nSortFields = aSortFields.getLength(); if (nSortFields > 0) { if (!bBindFormatsToContent) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_BIND_STYLES_TO_CONTENT, XML_FALSE); if (bCopyOutputData) { rtl::OUString sOUCellAddress; ScRangeStringConverter::GetStringFromAddress( sOUCellAddress, aOutputPosition, pDoc, ::formula::FormulaGrammar::CONV_OOO ); rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_TARGET_RANGE_ADDRESS, sOUCellAddress); } // no longer supported // if (bIsCaseSensitive) // rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_CASE_SENSITIVE, XML_TRUE); if (aSortFields[0].IsCaseSensitive) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_CASE_SENSITIVE, XML_TRUE); #ifdef DBG_UTIL sal_Bool bCaseSensitive(aSortFields[0].IsCaseSensitive); for (i = 1; i < nSortFields; ++i) { DBG_ASSERT(bCaseSensitive == aSortFields[i].IsCaseSensitive, "seems that it is now possible to have every field case sensitive"); } #endif // no longer supported /* if (aCollatorLocale.Language.getLength()) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_LANGUAGE, aCollatorLocale.Language); if (aCollatorLocale.Country.getLength()) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_COUNTRY, aCollatorLocale.Country); if (sCollatorAlgorithm.getLength()) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_ALGORITHM, sCollatorAlgorithm);*/ if (aSortFields[0].CollatorLocale.Language.getLength()) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_LANGUAGE, aSortFields[0].CollatorLocale.Language); if (aSortFields[0].CollatorLocale.Country.getLength()) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_COUNTRY, aSortFields[0].CollatorLocale.Country); if (aSortFields[0].CollatorAlgorithm.getLength()) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_ALGORITHM, aSortFields[0].CollatorAlgorithm); #ifdef DBG_UTIL rtl::OUString sLanguage(aSortFields[0].CollatorLocale.Language); rtl::OUString sCountry(aSortFields[0].CollatorLocale.Country); rtl::OUString sAlgorithm(aSortFields[0].CollatorAlgorithm); for (i = 1; i < nSortFields; ++i) { DBG_ASSERT(sLanguage == aSortFields[i].CollatorLocale.Language, "seems that it is now possible to have every field localized"); DBG_ASSERT(sCountry == aSortFields[i].CollatorLocale.Country, "seems that it is now possible to have every field localized"); DBG_ASSERT(sAlgorithm == aSortFields[i].CollatorAlgorithm, "seems that it is now possible to have every field localized"); } #endif SvXMLElementExport aElemS(rExport, XML_NAMESPACE_TABLE, XML_SORT, sal_True, sal_True); rExport.CheckAttrList(); for (i = 0; i < nSortFields; ++i) { rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_FIELD_NUMBER, rtl::OUString::valueOf(aSortFields[i].Field)); if (!aSortFields[i].IsAscending) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_ORDER, XML_DESCENDING); if (!bIsUserListEnabled) { switch (aSortFields[i].FieldType) { case table::TableSortFieldType_ALPHANUMERIC : rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_DATA_TYPE, XML_TEXT); break; case table::TableSortFieldType_AUTOMATIC : rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_DATA_TYPE, XML_AUTOMATIC); break; case table::TableSortFieldType_NUMERIC : rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_DATA_TYPE, XML_NUMBER); break; default: { // added to avoid warnings } } } else rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_DATA_TYPE, rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_USERLIST)) + rtl::OUString::valueOf(nUserListIndex)); SvXMLElementExport aElemSb(rExport, XML_NAMESPACE_TABLE, XML_SORT_BY, sal_True, sal_True); rExport.CheckAttrList(); } } } void ScXMLExportDatabaseRanges::WriteSubTotalDescriptor(const com::sun::star::uno::Reference xSubTotalDescriptor, const rtl::OUString sDatabaseRangeName) { uno::Reference xIndexAccess (xSubTotalDescriptor, uno::UNO_QUERY); if (xIndexAccess.is()) { sal_Int32 nSubTotalFields = xIndexAccess->getCount(); if (nSubTotalFields > 0) { uno::Reference xPropertySet (xSubTotalDescriptor, uno::UNO_QUERY); // sal_Bool bEnableUserSortList = sal_False; // sal_Bool bSortAscending = sal_True; // sal_Int32 nUserSortListIndex = 0; if (xPropertySet.is()) { if (!::cppu::any2bool(xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_BINDFMT))))) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_BIND_STYLES_TO_CONTENT, XML_FALSE); if (::cppu::any2bool(xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_INSBRK))))) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_PAGE_BREAKS_ON_GROUP_CHANGE, XML_TRUE); if (::cppu::any2bool(xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_ISCASE))))) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_CASE_SENSITIVE, XML_TRUE); // bSortAscending = ::cppu::any2bool(xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_SORTASCENDING)))); // if (::cppu::any2bool(xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_ENABLEUSERSORTLIST))))) // xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_USERSORTLISTINDEX))) >>= nUserSortListIndex; } SvXMLElementExport aElemSTRs(rExport, XML_NAMESPACE_TABLE, XML_SUBTOTAL_RULES, sal_True, sal_True); rExport.CheckAttrList(); { ScDBCollection* pDBCollection = pDoc->GetDBCollection(); sal_uInt16 nIndex; pDBCollection->SearchName(sDatabaseRangeName, nIndex); ScDBData* pDBData = (*pDBCollection)[nIndex]; ScSubTotalParam aSubTotalParam; pDBData->GetSubTotalParam(aSubTotalParam); if (aSubTotalParam.bDoSort) { if (!aSubTotalParam.bAscending) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_ORDER, XML_DESCENDING); if (aSubTotalParam.bUserDef) { rtl::OUString sUserList(RTL_CONSTASCII_USTRINGPARAM(SC_USERLIST)); sUserList += rtl::OUString::valueOf(aSubTotalParam.nUserIndex); rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_DATA_TYPE, sUserList); } SvXMLElementExport aElemSGs(rExport, XML_NAMESPACE_TABLE, XML_SORT_GROUPS, sal_True, sal_True); rExport.CheckAttrList(); } } for (sal_Int32 i = 0; i < nSubTotalFields; ++i) { uno::Reference xSubTotalField(xIndexAccess->getByIndex(i), uno::UNO_QUERY); if (xSubTotalField.is()) { sal_Int32 nGroupColumn = xSubTotalField->getGroupColumn(); rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_GROUP_BY_FIELD_NUMBER, rtl::OUString::valueOf(nGroupColumn)); SvXMLElementExport aElemSTR(rExport, XML_NAMESPACE_TABLE, XML_SUBTOTAL_RULE, sal_True, sal_True); rExport.CheckAttrList(); uno::Sequence aSubTotalColumns = xSubTotalField->getSubTotalColumns(); sal_Int32 nSubTotalColumns = aSubTotalColumns.getLength(); for (sal_Int32 j = 0; j < nSubTotalColumns; ++j) { rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_FIELD_NUMBER, rtl::OUString::valueOf(aSubTotalColumns[j].Column)); rtl::OUString sFunction; ScXMLConverter::GetStringFromFunction( sFunction, aSubTotalColumns[j].Function ); rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_FUNCTION, sFunction); SvXMLElementExport aElemSTF(rExport, XML_NAMESPACE_TABLE, XML_SUBTOTAL_FIELD, sal_True, sal_True); rExport.CheckAttrList(); } } } } } } void ScXMLExportDatabaseRanges::WriteDatabaseRanges(const com::sun::star::uno::Reference & xSpreadDoc) { pDoc = rExport.GetDocument(); if (pDoc) { uno::Reference xPropertySet (xSpreadDoc, uno::UNO_QUERY); if (xPropertySet.is()) { uno::Reference xDatabaseRanges(xPropertySet->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNO_DATABASERNG))), uno::UNO_QUERY); rExport.CheckAttrList(); if (xDatabaseRanges.is()) { uno::Sequence aRanges(xDatabaseRanges->getElementNames()); sal_Int32 nDatabaseRangesCount = aRanges.getLength(); if (nDatabaseRangesCount > 0) { SvXMLElementExport aElemDRs(rExport, XML_NAMESPACE_TABLE, XML_DATABASE_RANGES, sal_True, sal_True); for (sal_Int32 i = 0; i < nDatabaseRangesCount; ++i) { rtl::OUString sDatabaseRangeName(aRanges[i]); uno::Reference xDatabaseRange(xDatabaseRanges->getByName(sDatabaseRangeName), uno::UNO_QUERY); if (xDatabaseRange.is()) { rtl::OUString sOUUnbenannt (ScGlobal::GetRscString(STR_DB_NONAME)); if (sOUUnbenannt != sDatabaseRangeName) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_NAME, sDatabaseRangeName); table::CellRangeAddress aRangeAddress(xDatabaseRange->getDataArea()); rtl::OUString sOUAddress; ScRangeStringConverter::GetStringFromRange( sOUAddress, aRangeAddress, pDoc, ::formula::FormulaGrammar::CONV_OOO ); rExport.AddAttribute (XML_NAMESPACE_TABLE, XML_TARGET_RANGE_ADDRESS, sOUAddress); ScDBCollection* pDBCollection = pDoc->GetDBCollection(); sal_uInt16 nIndex; pDBCollection->SearchName(sDatabaseRangeName, nIndex); ScDBData* pDBData = (*pDBCollection)[nIndex]; if (pDBData->HasImportSelection()) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_IS_SELECTION, XML_TRUE); if (pDBData->HasAutoFilter()) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_DISPLAY_FILTER_BUTTONS, XML_TRUE); uno::Reference xPropertySetDatabaseRange (xDatabaseRange, uno::UNO_QUERY); if (xPropertySetDatabaseRange.is()) { if (::cppu::any2bool(xPropertySetDatabaseRange->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_KEEPFORM))))) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_ON_UPDATE_KEEP_STYLES, XML_TRUE); if (::cppu::any2bool(xPropertySetDatabaseRange->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_MOVCELLS))))) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_ON_UPDATE_KEEP_SIZE, XML_FALSE); if (::cppu::any2bool(xPropertySetDatabaseRange->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_STRIPDAT))))) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_HAS_PERSISTENT_DATA, XML_FALSE); } uno::Reference< sheet::XSheetFilterDescriptor2 > xSheetFilterDescriptor( xDatabaseRange->getFilterDescriptor(), uno::UNO_QUERY ); uno::Sequence aSortProperties(xDatabaseRange->getSortDescriptor()); if (xSheetFilterDescriptor.is()) { uno::Reference xFilterProperties (xSheetFilterDescriptor, uno::UNO_QUERY); if (xFilterProperties.is()) { if (!::cppu::any2bool(xFilterProperties->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_CONTHDR))))) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_CONTAINS_HEADER, XML_FALSE); // #98317#; there is no orientation on the filter /* table::TableOrientation eFilterOrient(table::TableOrientation_ROWS); if (::cppu::any2bool(xFilterProperties->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(SC_UNONAME_ORIENT))))) eFilterOrient = table::TableOrientation_ROWS;*/ sal_Bool bSortColumns(sal_True); sal_Bool bFound(sal_False); sal_Int32 nProperty(0); while (!bFound && (nProperty < aSortProperties.getLength())) { if (aSortProperties[nProperty].Name.compareToAscii(SC_UNONAME_ISSORTCOLUMNS) == 0) { bSortColumns = ::cppu::any2bool(aSortProperties[nProperty].Value); bFound = sal_True; } else ++nProperty; } if (bSortColumns) rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_ORIENTATION, XML_COLUMN); } } sal_Int32 nRefresh( pDBData->GetRefreshDelay() ); if( nRefresh ) { rtl::OUStringBuffer sBuffer; SvXMLUnitConverter::convertTime( sBuffer, (double)nRefresh / 86400 ); rExport.AddAttribute( XML_NAMESPACE_TABLE, XML_REFRESH_DELAY, sBuffer.makeStringAndClear() ); } SvXMLElementExport aElemDR(rExport, XML_NAMESPACE_TABLE, XML_DATABASE_RANGE, sal_True, sal_True); rExport.CheckAttrList(); WriteImportDescriptor(xDatabaseRange->getImportDescriptor()); if (xSheetFilterDescriptor.is()) WriteFilterDescriptor(xSheetFilterDescriptor, sDatabaseRangeName); WriteSortDescriptor(aSortProperties); WriteSubTotalDescriptor(xDatabaseRange->getSubTotalDescriptor(), sDatabaseRangeName); } } } } } } }