diff options
Diffstat (limited to 'sc/source/ui/vba/excelvbahelper.cxx')
| -rw-r--r-- | sc/source/ui/vba/excelvbahelper.cxx | 617 |
1 files changed, 617 insertions, 0 deletions
diff --git a/sc/source/ui/vba/excelvbahelper.cxx b/sc/source/ui/vba/excelvbahelper.cxx new file mode 100644 index 0000000000..3224171677 --- /dev/null +++ b/sc/source/ui/vba/excelvbahelper.cxx @@ -0,0 +1,617 @@ +/* -*- 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 "excelvbahelper.hxx" + +#include <basic/basmgr.hxx> +#include <comphelper/propertyvalue.hxx> +#include <comphelper/processfactory.hxx> +#include <comphelper/servicehelper.hxx> +#include <osl/file.hxx> +#include <tools/urlobj.hxx> +#include <vbahelper/vbahelper.hxx> +#include <com/sun/star/beans/PropertyAttribute.hpp> +#include <com/sun/star/beans/PropertyExistException.hpp> +#include <com/sun/star/frame/XModel.hpp> +#include <com/sun/star/sheet/XSheetCellRange.hpp> +#include <com/sun/star/sheet/GlobalSheetSettings.hpp> +#include <com/sun/star/sheet/XUnnamedDatabaseRanges.hpp> +#include <com/sun/star/sheet/XSpreadsheet.hpp> +#include <com/sun/star/sheet/XDatabaseRange.hpp> +#include <com/sun/star/system/SystemShellExecute.hpp> +#include <com/sun/star/system/SystemShellExecuteFlags.hpp> +#include <com/sun/star/util/XCloneable.hpp> + +#include <document.hxx> +#include <docuno.hxx> +#include <tabvwsh.hxx> +#include <transobj.hxx> +#include <cellsuno.hxx> +#include <gridwin.hxx> + +#include <com/sun/star/script/vba/VBAEventId.hpp> +#include <com/sun/star/script/vba/XVBACompatibility.hpp> +#include <com/sun/star/script/vba/XVBAEventProcessor.hpp> +#include <com/sun/star/script/vba/XVBAModuleInfo.hpp> +#include <com/sun/star/script/ModuleInfo.hpp> +#include <com/sun/star/script/ModuleType.hpp> + +using namespace ::com::sun::star; +using namespace ::ooo::vba; + +namespace ooo::vba::excel { + +uno::Reference< sheet::XUnnamedDatabaseRanges > +GetUnnamedDataBaseRanges( const ScDocShell* pShell ) +{ + uno::Reference< frame::XModel > xModel; + if ( pShell ) + xModel.set( pShell->GetModel(), uno::UNO_SET_THROW ); + uno::Reference< beans::XPropertySet > xModelProps( xModel, uno::UNO_QUERY_THROW ); + uno::Reference< sheet::XUnnamedDatabaseRanges > xUnnamedDBRanges( xModelProps->getPropertyValue("UnnamedDatabaseRanges"), uno::UNO_QUERY_THROW ); + return xUnnamedDBRanges; +} + +// returns the XDatabaseRange for the autofilter on sheet (nSheet) +// also populates sName with the name of range +uno::Reference< sheet::XDatabaseRange > +GetAutoFiltRange( const ScDocShell* pShell, sal_Int16 nSheet ) +{ + uno::Reference< sheet::XUnnamedDatabaseRanges > xUnnamedDBRanges( GetUnnamedDataBaseRanges( pShell ), uno::UNO_SET_THROW ); + uno::Reference< sheet::XDatabaseRange > xDataBaseRange; + if (xUnnamedDBRanges->hasByTable( nSheet ) ) + { + uno::Reference< sheet::XDatabaseRange > xDBRange( xUnnamedDBRanges->getByTable( nSheet ) , uno::UNO_QUERY_THROW ); + bool bHasAuto = false; + uno::Reference< beans::XPropertySet > xProps( xDBRange, uno::UNO_QUERY_THROW ); + xProps->getPropertyValue("AutoFilter") >>= bHasAuto; + if ( bHasAuto ) + { + xDataBaseRange=xDBRange; + } + } + return xDataBaseRange; +} + +ScDocShell* GetDocShellFromRange( const uno::Reference< uno::XInterface >& xRange ) +{ + ScCellRangesBase* pScCellRangesBase = dynamic_cast<ScCellRangesBase*>( xRange.get() ); + if ( !pScCellRangesBase ) + { + throw uno::RuntimeException("Failed to access underlying doc shell uno range object" ); + } + return pScCellRangesBase->GetDocShell(); +} + +uno::Reference< XHelperInterface > +getUnoSheetModuleObj( const uno::Reference< table::XCellRange >& xRange ) +{ + uno::Reference< sheet::XSheetCellRange > xSheetRange( xRange, uno::UNO_QUERY_THROW ); + uno::Reference< sheet::XSpreadsheet > xSheet( xSheetRange->getSpreadsheet(), uno::UNO_SET_THROW ); + return getUnoSheetModuleObj( xSheet ); +} + +void implSetZoom( const uno::Reference< frame::XModel >& xModel, sal_Int16 nZoom, std::vector< SCTAB >& nTabs ) +{ + ScTabViewShell* pViewSh = excel::getBestViewShell( xModel ); + Fraction aFract( nZoom, 100 ); + pViewSh->GetViewData().SetZoom( aFract, aFract, nTabs ); + pViewSh->RefreshZoom(); +} + +namespace { + +class PasteCellsWarningReseter +{ +private: + bool bInitialWarningState; + /// @throws uno::RuntimeException + static uno::Reference< sheet::XGlobalSheetSettings > const & getGlobalSheetSettings() + { + static uno::Reference< sheet::XGlobalSheetSettings > xProps = sheet::GlobalSheetSettings::create( comphelper::getProcessComponentContext() ); + return xProps; + } + + /// @throws uno::RuntimeException + static bool getReplaceCellsWarning() + { + return getGlobalSheetSettings()->getReplaceCellsWarning(); + } + + /// @throws uno::RuntimeException + static void setReplaceCellsWarning( bool bState ) + { + getGlobalSheetSettings()->setReplaceCellsWarning( bState ); + } +public: + /// @throws uno::RuntimeException + PasteCellsWarningReseter() + { + bInitialWarningState = getReplaceCellsWarning(); + if ( bInitialWarningState ) + setReplaceCellsWarning( false ); + } + ~PasteCellsWarningReseter() + { + if ( bInitialWarningState ) + { + // don't allow dtor to throw + try + { + setReplaceCellsWarning( true ); + } + catch ( uno::Exception& /*e*/ ){} + } + } +}; + +} + +void +implnPaste( const uno::Reference< frame::XModel>& xModel ) +{ + PasteCellsWarningReseter resetWarningBox; + ScTabViewShell* pViewShell = getBestViewShell( xModel ); + if ( pViewShell ) + { + pViewShell->PasteFromSystem(); + pViewShell->CellContentChanged(); + } +} + +void +implnCopy( const uno::Reference< frame::XModel>& xModel ) +{ + ScTabViewShell* pViewShell = getBestViewShell( xModel ); + ScDocShell* pDocShell = getDocShell( xModel ); + if ( !(pViewShell && pDocShell) ) + return; + + pViewShell->CopyToClip(nullptr,false,false,true); + + // mark the copied transfer object so it is used in ScVbaRange::Insert + uno::Reference<datatransfer::XTransferable2> xTransferable(ScTabViewShell::GetClipData(pViewShell->GetViewData().GetActiveWin())); + ScTransferObj* pClipObj = ScTransferObj::GetOwnClipboard(xTransferable); + if (pClipObj) + { + pClipObj->SetUseInApi( true ); + pDocShell->SetClipData(xTransferable); + } +} + +void +implnCut( const uno::Reference< frame::XModel>& xModel ) +{ + ScTabViewShell* pViewShell = getBestViewShell( xModel ); + ScDocShell* pDocShell = getDocShell( xModel ); + if ( !(pViewShell && pDocShell) ) + return; + + pViewShell->CutToClip(); + + // mark the copied transfer object so it is used in ScVbaRange::Insert + uno::Reference<datatransfer::XTransferable2> xTransferable(ScTabViewShell::GetClipData(pViewShell->GetViewData().GetActiveWin())); + ScTransferObj* pClipObj = ScTransferObj::GetOwnClipboard(xTransferable); + if (pClipObj) + { + pClipObj->SetUseInApi( true ); + pDocShell->SetClipData(xTransferable); + } +} + +void implnPasteSpecial( const uno::Reference< frame::XModel>& xModel, InsertDeleteFlags nFlags, ScPasteFunc nFunction, bool bSkipEmpty, bool bTranspose) +{ + PasteCellsWarningReseter resetWarningBox; + + ScTabViewShell* pTabViewShell = getBestViewShell(xModel); + if (!pTabViewShell) + return; + + ScDocShell* pDocShell = getDocShell(xModel); + if (!pDocShell) + return; + + ScViewData& rView = pTabViewShell->GetViewData(); + vcl::Window* pWin = rView.GetActiveWin(); + if (!pWin) + return; + + const ScTransferObj* pOwnClip = ScTransferObj::GetOwnClipboard(ScTabViewShell::GetClipData(pWin)); + if (pOwnClip) + { + pTabViewShell->PasteFromClip(nFlags, pOwnClip->GetDocument(), + nFunction, bSkipEmpty, bTranspose, false, + INS_NONE, InsertDeleteFlags::NONE, true); + + pTabViewShell->CellContentChanged(); + } +} + +ScDocShell* +getDocShell( const css::uno::Reference< css::frame::XModel>& xModel ) +{ + uno::Reference< uno::XInterface > xIf( xModel, uno::UNO_QUERY_THROW ); + ScModelObj* pModel = comphelper::getFromUnoTunnel< ScModelObj >( xIf ); + ScDocShell* pDocShell = nullptr; + if ( pModel ) + pDocShell = static_cast<ScDocShell*>(pModel->GetEmbeddedObject()); + return pDocShell; + +} + +ScTabViewShell* +getBestViewShell( const css::uno::Reference< css::frame::XModel>& xModel ) +{ + ScDocShell* pDocShell = getDocShell( xModel ); + if ( pDocShell ) + return pDocShell->GetBestViewShell(); + return nullptr; +} + +ScTabViewShell* +getCurrentBestViewShell( const uno::Reference< uno::XComponentContext >& xContext ) +{ + uno::Reference< frame::XModel > xModel = getCurrentExcelDoc( xContext ); + return getBestViewShell( xModel ); +} + +SfxViewFrame* +getViewFrame( const uno::Reference< frame::XModel >& xModel ) +{ + ScTabViewShell* pViewShell = getBestViewShell( xModel ); + if ( pViewShell ) + return &pViewShell->GetViewFrame(); + return nullptr; +} + +uno::Reference< XHelperInterface > +getUnoSheetModuleObj( const uno::Reference< sheet::XSpreadsheet >& xSheet ) +{ + uno::Reference< beans::XPropertySet > xProps( xSheet, uno::UNO_QUERY_THROW ); + OUString sCodeName; + xProps->getPropertyValue("CodeName") >>= sCodeName; + // #TODO #FIXME ideally we should 'throw' here if we don't get a valid parent, but... it is possible + // to create a module ( and use 'Option VBASupport 1' ) for a calc document, in this scenario there + // are *NO* special document module objects ( of course being able to switch between vba/non vba mode at + // the document in the future could fix this, especially IF the switching of the vba mode takes care to + // create the special document module objects if they don't exist. + return getUnoDocModule( sCodeName, GetDocShellFromRange( xSheet ) ); +} + +uno::Reference< XHelperInterface > +getUnoSheetModuleObj( const uno::Reference< sheet::XSheetCellRangeContainer >& xRanges ) +{ + uno::Reference< container::XEnumerationAccess > xEnumAccess( xRanges, uno::UNO_QUERY_THROW ); + uno::Reference< container::XEnumeration > xEnum = xEnumAccess->createEnumeration(); + uno::Reference< table::XCellRange > xRange( xEnum->nextElement(), uno::UNO_QUERY_THROW ); + return getUnoSheetModuleObj( xRange ); +} + +uno::Reference< XHelperInterface > +getUnoSheetModuleObj( const uno::Reference< table::XCell >& xCell ) +{ + uno::Reference< sheet::XSheetCellRange > xSheetRange( xCell, uno::UNO_QUERY_THROW ); + uno::Reference< sheet::XSpreadsheet > xSheet( xSheetRange->getSpreadsheet(), uno::UNO_SET_THROW ); + return getUnoSheetModuleObj( xSheet ); +} + +uno::Reference< XHelperInterface > +getUnoSheetModuleObj( const uno::Reference< frame::XModel >& xModel, SCTAB nTab ) +{ + uno::Reference< sheet::XSpreadsheetDocument > xDoc( xModel, uno::UNO_QUERY_THROW ); + uno::Reference< container::XIndexAccess > xSheets( xDoc->getSheets(), uno::UNO_QUERY_THROW ); + uno::Reference< sheet::XSpreadsheet > xSheet( xSheets->getByIndex( nTab ), uno::UNO_QUERY_THROW ); + return getUnoSheetModuleObj( xSheet ); +} + +void setUpDocumentModules( const uno::Reference< sheet::XSpreadsheetDocument >& xDoc ) +{ + uno::Reference< frame::XModel > xModel( xDoc, uno::UNO_QUERY ); + ScDocShell* pShell = excel::getDocShell( xModel ); + if ( !pShell ) + return; + + OUString aPrjName( "Standard" ); + pShell->GetBasicManager()->SetName( aPrjName ); + + /* Set library container to VBA compatibility mode. This will create + the VBA Globals object and store it in the Basic manager of the + document. */ + uno::Reference<script::XLibraryContainer> xLibContainer = pShell->GetBasicContainer(); + uno::Reference<script::vba::XVBACompatibility> xVBACompat( xLibContainer, uno::UNO_QUERY_THROW ); + xVBACompat->setVBACompatibilityMode( true ); + + if( xLibContainer.is() ) + { + if( !xLibContainer->hasByName( aPrjName ) ) + xLibContainer->createLibrary( aPrjName ); + uno::Any aLibAny = xLibContainer->getByName( aPrjName ); + uno::Reference< container::XNameContainer > xLib; + aLibAny >>= xLib; + if( xLib.is() ) + { + uno::Reference< script::vba::XVBAModuleInfo > xVBAModuleInfo( xLib, uno::UNO_QUERY_THROW ); + uno::Reference< container::XNameAccess > xVBACodeNamedObjectAccess( pShell->GetModel()->createInstance("ooo.vba.VBAObjectModuleObjectProvider"), uno::UNO_QUERY_THROW ); + // set up the module info for the workbook and sheets in the newly created + // spreadsheet + ScDocument& rDoc = pShell->GetDocument(); + OUString sCodeName = rDoc.GetCodeName(); + if ( sCodeName.isEmpty() ) + { + sCodeName = "ThisWorkbook"; + rDoc.SetCodeName( sCodeName ); + } + + std::vector< OUString > sDocModuleNames { sCodeName }; + + for ( SCTAB index = 0; index < rDoc.GetTableCount(); index++) + { + OUString aName; + rDoc.GetCodeName( index, aName ); + sDocModuleNames.push_back( aName ); + } + + for ( const auto& rName : sDocModuleNames ) + { + script::ModuleInfo sModuleInfo; + + uno::Any aName= xVBACodeNamedObjectAccess->getByName( rName ); + sModuleInfo.ModuleObject.set( aName, uno::UNO_QUERY ); + sModuleInfo.ModuleType = script::ModuleType::DOCUMENT; + xVBAModuleInfo->insertModuleInfo( rName, sModuleInfo ); + if( xLib->hasByName( rName ) ) + xLib->replaceByName( rName, uno::Any( OUString( "Option VBASupport 1\n") ) ); + else + xLib->insertByName( rName, uno::Any( OUString( "Option VBASupport 1\n" ) ) ); + } + } + } + + /* Trigger the Workbook_Open event, event processor will register + itself as listener for specific events. */ + try + { + uno::Reference< script::vba::XVBAEventProcessor > xVbaEvents( pShell->GetDocument().GetVbaEventProcessor(), uno::UNO_SET_THROW ); + uno::Sequence< uno::Any > aArgs; + xVbaEvents->processVbaEvent( script::vba::VBAEventId::WORKBOOK_OPEN, aArgs ); + } + catch( uno::Exception& ) + { + } +} + +void ExportAsFixedFormatHelper( + const uno::Reference< frame::XModel >& xModel, const css::uno::Reference< XApplication >& xApplication, + const css::uno::Any& Type, const css::uno::Any& FileName, const css::uno::Any& Quality, + const css::uno::Any& IncludeDocProperties, const css::uno::Any& From, + const css::uno::Any& To, const css::uno::Any& OpenAfterPublish) +{ + OUString sType; + if ((Type >>= sType) && (sType.equalsIgnoreAsciiCase(u"xlTypeXPS") || sType == "1")) + { + /* xlTypePDF 0 "PDF" - Portable Document Format file(.pdf) + xlTypeXPS 1 "XPS" - XPS Document(.xps) --> not supported in LibreOffice */ + return; + } + + OUString sFileName; + FileName >>= sFileName; + OUString sRelURL;; + osl::FileBase::getFileURLFromSystemPath(sFileName, sRelURL); + // detect if there is no path then we need + // to use the current folder + INetURLObject aURL(sRelURL); + OUString sURL; + sURL = aURL.GetMainURL(INetURLObject::DecodeMechanism::ToIUri); + if (sURL.isEmpty()) + { + // need to add cur dir ( of this workbook ) or else the 'Work' dir + sURL = xModel->getURL(); + + if (sURL.isEmpty()) + { + // not path available from 'this' document + // need to add the 'document'/work directory then + OUString sWorkPath = xApplication->getDefaultFilePath(); + OUString sWorkURL; + osl::FileBase::getFileURLFromSystemPath(sWorkPath, sWorkURL); + aURL.SetURL(sWorkURL); + } + else + { + if (!sFileName.isEmpty()) + { + aURL.SetURL(INetURLObject::GetAbsURL(sURL, sRelURL)); + } + else + { + aURL.SetURL(sURL); + if (aURL.removeExtension()) + aURL.setExtension(u"pdf"); + } + } + sURL = aURL.GetMainURL(INetURLObject::DecodeMechanism::ToIUri); + + } + + sal_Int32 nTo = 0; + sal_Int32 nFrom = 0; + From >>= nFrom; + To >>= nTo; + + OUString sRange("-"); + + css::uno::Sequence<css::beans::PropertyValue> aFilterData; + if (nFrom || nTo) + { + if (nFrom) + sRange = OUString::number(nFrom) + sRange; + if (nTo) + sRange += OUString::number(nTo); + + aFilterData.realloc(aFilterData.getLength() + 1); + aFilterData.getArray()[aFilterData.getLength() - 1] = comphelper::makePropertyValue("PageRange", sRange); + } + + OUString sQuality; + if (Quality >>= sQuality) + { + if (sQuality.equalsIgnoreAsciiCase(u"xlQualityMinimum") || sQuality == "1") + { + aFilterData.realloc(aFilterData.getLength() + 1); + aFilterData.getArray()[aFilterData.getLength() - 1] = comphelper::makePropertyValue("Quality", sal_Int32(70)); + } + else if (sQuality.equalsIgnoreAsciiCase(u"xlQualityStandard") || sQuality == "0") + { + aFilterData.realloc(aFilterData.getLength() + 1); + aFilterData.getArray()[aFilterData.getLength() - 1] = comphelper::makePropertyValue("UseLosslessCompression", true); + } + else + { + /* Name Value Description + xlQualityMinimum 1 Minimum quality + xlQualityStandard 0 Standard quality */ + } + } + + // init set of params for storeToURL() call + css::uno::Sequence<css::beans::PropertyValue> storeProps{ + comphelper::makePropertyValue("FilterData", aFilterData), + comphelper::makePropertyValue("FilterName", OUString("calc_pdf_Export")), + comphelper::makePropertyValue("URL", sURL) + }; + + bool bIncludeDocProperties = true; + if ((IncludeDocProperties >>= bIncludeDocProperties) && !bIncludeDocProperties) + { + uno::Reference<document::XDocumentPropertiesSupplier> xDPS(xModel, uno::UNO_QUERY); + if (xDPS.is()) + { + uno::Reference<document::XDocumentProperties> xDocProps = xDPS->getDocumentProperties(); + uno::Reference<util::XCloneable> xCloneable(xDocProps, uno::UNO_QUERY_THROW); + uno::Reference<document::XDocumentProperties> xOldDocProps(xCloneable->createClone(), uno::UNO_QUERY_THROW); + + // reset doc properties to default temporary + xDocProps->resetUserData(OUString()); + + uno::Reference< frame::XStorable > xStor(xModel, uno::UNO_QUERY_THROW); + try { + xStor->storeToURL(sURL, storeProps); + } + catch (const uno::Exception&) + { + SetDocInfoState(xModel, xOldDocProps); + throw; + } + + SetDocInfoState(xModel, xOldDocProps); + } + } + else + { + uno::Reference< frame::XStorable > xStor(xModel, uno::UNO_QUERY_THROW); + xStor->storeToURL(sURL, storeProps); + } + + bool bOpenAfterPublish = false; + if ((OpenAfterPublish >>= bOpenAfterPublish) && bOpenAfterPublish) + { + uno::Reference<css::system::XSystemShellExecute> xSystemShellExecute(css::system::SystemShellExecute::create(::comphelper::getProcessComponentContext())); + xSystemShellExecute->execute(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE), "", css::system::SystemShellExecuteFlags::URIS_ONLY); + } +} + +void SetDocInfoState( + const uno::Reference< frame::XModel >& xModel, + const uno::Reference< css::document::XDocumentProperties>& i_xOldDocProps) +{ + uno::Reference<document::XDocumentPropertiesSupplier> const + xModelDocPropsSupplier(xModel, uno::UNO_QUERY_THROW); + uno::Reference<document::XDocumentProperties> const xDocPropsToFill = + xModelDocPropsSupplier->getDocumentProperties(); + uno::Reference< beans::XPropertySet > const xPropSet( + i_xOldDocProps->getUserDefinedProperties(), uno::UNO_QUERY_THROW); + + uno::Reference< util::XModifiable > xModifiable(xModel, uno::UNO_QUERY); + if (!xModifiable.is()) + throw uno::RuntimeException(); + + bool bIsModified = xModifiable->isModified(); + + try + { + uno::Reference< beans::XPropertySet > const xSet( + xDocPropsToFill->getUserDefinedProperties(), uno::UNO_QUERY); + uno::Reference< beans::XPropertyContainer > xContainer(xSet, uno::UNO_QUERY); + uno::Reference< beans::XPropertySetInfo > xSetInfo = xSet->getPropertySetInfo(); + const uno::Sequence< beans::Property > lProps = xSetInfo->getProperties(); + for (const beans::Property& rProp : lProps) + { + uno::Any aValue = xPropSet->getPropertyValue(rProp.Name); + if (rProp.Attributes & css::beans::PropertyAttribute::REMOVABLE) + { + try + { + // QUESTION: DefaultValue?! + xContainer->addProperty(rProp.Name, rProp.Attributes, aValue); + } + catch (beans::PropertyExistException const&) {} + try + { + // it is possible that the propertysets from XML and binary files differ; we shouldn't break then + xSet->setPropertyValue(rProp.Name, aValue); + } + catch (const uno::Exception&) {} + } + } + + // sigh... have to set these manually I'm afraid... + xDocPropsToFill->setAuthor(i_xOldDocProps->getAuthor()); + xDocPropsToFill->setGenerator(i_xOldDocProps->getGenerator()); + xDocPropsToFill->setCreationDate(i_xOldDocProps->getCreationDate()); + xDocPropsToFill->setTitle(i_xOldDocProps->getTitle()); + xDocPropsToFill->setSubject(i_xOldDocProps->getSubject()); + xDocPropsToFill->setDescription(i_xOldDocProps->getDescription()); + xDocPropsToFill->setKeywords(i_xOldDocProps->getKeywords()); + xDocPropsToFill->setModifiedBy(i_xOldDocProps->getModifiedBy()); + xDocPropsToFill->setModificationDate(i_xOldDocProps->getModificationDate()); + xDocPropsToFill->setPrintedBy(i_xOldDocProps->getPrintedBy()); + xDocPropsToFill->setPrintDate(i_xOldDocProps->getPrintDate()); + xDocPropsToFill->setAutoloadURL(i_xOldDocProps->getAutoloadURL()); + xDocPropsToFill->setAutoloadSecs(i_xOldDocProps->getAutoloadSecs()); + xDocPropsToFill->setDefaultTarget(i_xOldDocProps->getDefaultTarget()); + xDocPropsToFill->setEditingCycles(i_xOldDocProps->getEditingCycles()); + xDocPropsToFill->setEditingDuration(i_xOldDocProps->getEditingDuration()); + } + catch (const uno::Exception&) {} + + // set the modified flag back if required + if (bIsModified != bool(xModifiable->isModified())) + xModifiable->setModified(bIsModified); +} + +SfxItemSet* +ScVbaCellRangeAccess::GetDataSet( ScCellRangesBase* pRangeObj ) +{ + return pRangeObj ? pRangeObj->GetCurrentDataSet( true ) : nullptr; +} + +} // namespace ooo::vba::excel + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |