diff options
Diffstat (limited to 'sfx2/source/doc')
51 files changed, 40791 insertions, 0 deletions
diff --git a/sfx2/source/doc/DocumentMetadataAccess.cxx b/sfx2/source/doc/DocumentMetadataAccess.cxx new file mode 100644 index 000000000..3bb670c7b --- /dev/null +++ b/sfx2/source/doc/DocumentMetadataAccess.cxx @@ -0,0 +1,1381 @@ +/* -*- 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 <sfx2/DocumentMetadataAccess.hxx> + +#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/embed/ElementModes.hpp> +#include <com/sun/star/embed/XStorage.hpp> +#include <com/sun/star/embed/XTransactedObject.hpp> +#include <com/sun/star/frame/XTransientDocumentsDocumentContentIdentifierFactory.hpp> +#include <com/sun/star/task/ErrorCodeIOException.hpp> +#include <com/sun/star/ucb/InteractiveAugmentedIOException.hpp> +#include <com/sun/star/rdf/FileFormat.hpp> +#include <com/sun/star/rdf/ParseException.hpp> +#include <com/sun/star/rdf/RepositoryException.hpp> +#include <com/sun/star/rdf/URIs.hpp> +#include <com/sun/star/rdf/Statement.hpp> +#include <com/sun/star/rdf/URI.hpp> +#include <com/sun/star/rdf/Repository.hpp> + +#include <rtl/ustrbuf.hxx> +#include <rtl/uri.hxx> +#include <rtl/bootstrap.hxx> +#include <sal/log.hxx> + +#include <comphelper/interaction.hxx> +#include <unotools/mediadescriptor.hxx> +#include <comphelper/sequence.hxx> +#include <comphelper/storagehelper.hxx> +#include <cppuhelper/exc_hlp.hxx> +#include <o3tl/string_view.hxx> + +#include <sfx2/docfile.hxx> +#include <sfx2/XmlIdRegistry.hxx> +#include <sfx2/objsh.hxx> +#include <tools/diagnose_ex.h> + +#include <libxml/tree.h> + +#include <vector> +#include <set> +#include <string_view> + +#include <com/sun/star/uri/XUriReference.hpp> +#include <com/sun/star/uri/UriReferenceFactory.hpp> + + +/* + Note: in the context of this implementation, all rdf.QueryExceptions and + rdf.RepositoryExceptions are RuntimeExceptions, and will be reported as such. + + This implementation assumes that it is only used with ODF documents, not mere + ODF packages. In other words, we enforce that metadata files must not be + called reserved names. + */ + +using namespace ::com::sun::star; + +namespace sfx2 { + + +bool isValidNCName(std::u16string_view i_rIdref) +{ + const OString id( + OUStringToOString(i_rIdref, RTL_TEXTENCODING_UTF8) ); + return !(xmlValidateNCName( + reinterpret_cast<const unsigned char*>(id.getStr()), 0)); +} + + +constexpr OUStringLiteral s_content = u"content.xml"; +constexpr OUStringLiteral s_styles = u"styles.xml"; +constexpr OUStringLiteral s_manifest = u"manifest.rdf"; +const char s_odfmime [] = "application/vnd.oasis.opendocument."; + + +static bool isContentFile(std::u16string_view i_rPath) +{ + return i_rPath == s_content; +} + +static bool isStylesFile (std::u16string_view i_rPath) +{ + return i_rPath == s_styles; +} + +bool isValidXmlId(std::u16string_view i_rStreamName, + std::u16string_view i_rIdref) +{ + return isValidNCName(i_rIdref) + && (isContentFile(i_rStreamName) || isStylesFile(i_rStreamName)); +} + +static bool isReservedFile(std::u16string_view i_rPath) +{ + return isContentFile(i_rPath) || isStylesFile(i_rPath) || i_rPath == u"meta.xml" || i_rPath == u"settings.xml"; +} + + +uno::Reference<rdf::XURI> createBaseURI( + uno::Reference<uno::XComponentContext> const & i_xContext, + uno::Reference<frame::XModel> const & i_xModel, + OUString const & i_rPkgURI, std::u16string_view i_rSubDocument) +{ + if (!i_xContext.is() || (!i_xModel.is() && i_rPkgURI.isEmpty())) { + throw uno::RuntimeException(); + } + + OUString pkgURI(i_rPkgURI); + + // tdf#123293 chicken/egg problem when loading from stream: there is no URI, + // and also the model doesn't have a storage yet, so we need to get the + // tdoc URI without a storage... + if (pkgURI.isEmpty()) + { + assert(i_xModel.is()); + uno::Reference<frame::XTransientDocumentsDocumentContentIdentifierFactory> + const xTDDCIF( + i_xContext->getServiceManager()->createInstanceWithContext( + "com.sun.star.ucb.TransientDocumentsContentProvider", + i_xContext), + uno::UNO_QUERY_THROW); + uno::Reference<ucb::XContentIdentifier> const xContentId( + xTDDCIF->createDocumentContentIdentifier(i_xModel)); + SAL_WARN_IF(!xContentId.is(), "sfx", "createBaseURI: cannot create ContentIdentifier"); + if (!xContentId.is()) + { + throw uno::RuntimeException("createBaseURI: cannot create ContentIdentifier"); + } + pkgURI = xContentId->getContentIdentifier(); + assert(!pkgURI.isEmpty()); + if (!pkgURI.isEmpty() && !pkgURI.endsWith("/")) + { + pkgURI += "/"; + } + } + + // #i108078# workaround non-hierarchical vnd.sun.star.expand URIs + // this really should be done somewhere else, not here. + if (pkgURI.matchIgnoreAsciiCase("vnd.sun.star.expand:")) + { + // expand it here (makeAbsolute requires hierarchical URI) + pkgURI = pkgURI.copy( RTL_CONSTASCII_LENGTH("vnd.sun.star.expand:") ); + if (!pkgURI.isEmpty()) { + pkgURI = ::rtl::Uri::decode( + pkgURI, rtl_UriDecodeStrict, RTL_TEXTENCODING_UTF8); + if (pkgURI.isEmpty()) { + throw uno::RuntimeException(); + } + ::rtl::Bootstrap::expandMacros(pkgURI); + } + } + + const uno::Reference<uri::XUriReferenceFactory> xUriFactory = + uri::UriReferenceFactory::create( i_xContext); + uno::Reference< uri::XUriReference > xBaseURI; + + const uno::Reference< uri::XUriReference > xPkgURI( + xUriFactory->parse(pkgURI), uno::UNO_SET_THROW ); + xPkgURI->clearFragment(); + + // need to know whether the storage is a FileSystemStorage + // XServiceInfo would be better, but it is not implemented +// if ( pkgURI.getLength() && ::utl::UCBContentHelper::IsFolder(pkgURI) ) + if (true) { + xBaseURI.set( xPkgURI, uno::UNO_SET_THROW ); + } + OUStringBuffer buf(64); + if (!xBaseURI->getUriReference().endsWith("/")) + { + const sal_Int32 count( xBaseURI->getPathSegmentCount() ); + if (count > 0) + { + buf.append(xBaseURI->getPathSegment(count - 1)); + } + buf.append('/'); + } + if (!i_rSubDocument.empty()) + { + buf.append(i_rSubDocument); + buf.append('/'); + } + if (!buf.isEmpty()) + { + const uno::Reference< uri::XUriReference > xPathURI( + xUriFactory->parse(buf.makeStringAndClear()), uno::UNO_SET_THROW ); + xBaseURI.set( + xUriFactory->makeAbsolute(xBaseURI, xPathURI, + true, uri::RelativeUriExcessParentSegments_ERROR), + uno::UNO_SET_THROW); + } + + return rdf::URI::create(i_xContext, xBaseURI->getUriReference()); +} + + +struct DocumentMetadataAccess_Impl +{ + // note: these are all initialized in constructor, and loadFromStorage + const uno::Reference<uno::XComponentContext> m_xContext; + const SfxObjectShell & m_rXmlIdRegistrySupplier; + uno::Reference<rdf::XURI> m_xBaseURI; + uno::Reference<rdf::XRepository> m_xRepository; + uno::Reference<rdf::XNamedGraph> m_xManifest; + DocumentMetadataAccess_Impl( + uno::Reference<uno::XComponentContext> const& i_xContext, + SfxObjectShell const & i_rRegistrySupplier) + : m_xContext(i_xContext) + , m_rXmlIdRegistrySupplier(i_rRegistrySupplier) + { + OSL_ENSURE(m_xContext.is(), "context null"); + } +}; + +// this is... a hack. +template<sal_Int16 Constant> +static uno::Reference<rdf::XURI> const & +getURI(uno::Reference< uno::XComponentContext > const & i_xContext) +{ + static uno::Reference< rdf::XURI > xURI( + rdf::URI::createKnown(i_xContext, Constant), uno::UNO_SET_THROW); + return xURI; +} + + +/** would storing the file to a XStorage succeed? */ +static bool isFileNameValid(std::u16string_view i_rFileName) +{ + if (i_rFileName.empty()) return false; + if (i_rFileName[0] == '/') return false; // no absolute paths! + sal_Int32 idx(0); + do { + const OUString segment( + o3tl::getToken(i_rFileName, 0, u'/', idx) ); + if (segment.isEmpty() || // no empty segments + segment == "." || // no . segments + segment == ".." || // no .. segments + !::comphelper::OStorageHelper::IsValidZipEntryFileName( + segment, false)) // no invalid characters + return false; + } while (idx >= 0); + return true; +} + +/** split a uri hierarchy into first segment and rest */ +static bool +splitPath(OUString const & i_rPath, + OUString & o_rDir, OUString& o_rRest) +{ + const sal_Int32 idx(i_rPath.indexOf(u'/')); + if (idx < 0 || idx >= i_rPath.getLength()) { + o_rDir.clear(); + o_rRest = i_rPath; + return true; + } else if (idx == 0 || idx == i_rPath.getLength() - 1) { + // input must not start or end with '/' + return false; + } else { + o_rDir = i_rPath.copy(0, idx); + o_rRest = i_rPath.copy(idx+1); + return true; + } +} + +static bool +splitXmlId(OUString const & i_XmlId, + OUString & o_StreamName, OUString& o_Idref ) +{ + const sal_Int32 idx(i_XmlId.indexOf(u'#')); + if ((idx <= 0) || (idx >= i_XmlId.getLength() - 1)) { + return false; + } else { + o_StreamName = i_XmlId.copy(0, idx); + o_Idref = i_XmlId.copy(idx+1); + return isValidXmlId(o_StreamName, o_Idref); + } +} + + +static uno::Reference<rdf::XURI> +getURIForStream(struct DocumentMetadataAccess_Impl const & i_rImpl, + OUString const& i_rPath) +{ + const uno::Reference<rdf::XURI> xURI( + rdf::URI::createNS( i_rImpl.m_xContext, + i_rImpl.m_xBaseURI->getStringValue(), i_rPath), + uno::UNO_SET_THROW); + return xURI; +} + +/** add statements declaring i_xResource to be a file of type i_xType with + path i_rPath to manifest, with optional additional types i_pTypes */ +static void +addFile(struct DocumentMetadataAccess_Impl const & i_rImpl, + uno::Reference<rdf::XURI> const& i_xType, + OUString const & i_rPath, + const uno::Sequence < uno::Reference< rdf::XURI > > * i_pTypes) +{ + try { + const uno::Reference<rdf::XURI> xURI( getURIForStream( + i_rImpl, i_rPath) ); + + i_rImpl.m_xManifest->addStatement(i_rImpl.m_xBaseURI, + getURI<rdf::URIs::PKG_HASPART>(i_rImpl.m_xContext), + xURI); + i_rImpl.m_xManifest->addStatement(xURI, + getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext), + i_xType); + if (i_pTypes) { + for (const auto& rType : *i_pTypes) { + i_rImpl.m_xManifest->addStatement(xURI, + getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext), + rType); + } + } + } catch (const uno::RuntimeException &) { + throw; + } catch (const uno::Exception &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetRuntimeException( + "addFile: exception", /*this*/nullptr, anyEx); + } +} + +/** add content.xml or styles.xml to manifest */ +static bool +addContentOrStylesFileImpl(struct DocumentMetadataAccess_Impl const & i_rImpl, + const OUString & i_rPath) +{ + uno::Reference<rdf::XURI> xType; + if (isContentFile(i_rPath)) { + xType.set(getURI<rdf::URIs::ODF_CONTENTFILE>(i_rImpl.m_xContext)); + } else if (isStylesFile(i_rPath)) { + xType.set(getURI<rdf::URIs::ODF_STYLESFILE>(i_rImpl.m_xContext)); + } else { + return false; + } + addFile(i_rImpl, xType, i_rPath, nullptr); + return true; +} + +/** add metadata file to manifest */ +static void +addMetadataFileImpl(struct DocumentMetadataAccess_Impl const & i_rImpl, + const OUString & i_rPath, + const uno::Sequence < uno::Reference< rdf::XURI > > & i_rTypes) +{ + addFile(i_rImpl, + getURI<rdf::URIs::PKG_METADATAFILE>(i_rImpl.m_xContext), + i_rPath, &i_rTypes); +} + +/** remove a file from the manifest */ +static void +removeFile(struct DocumentMetadataAccess_Impl const & i_rImpl, + uno::Reference<rdf::XURI> const& i_xPart) +{ + if (!i_xPart.is()) throw uno::RuntimeException(); + try { + i_rImpl.m_xManifest->removeStatements(i_rImpl.m_xBaseURI, + getURI<rdf::URIs::PKG_HASPART>(i_rImpl.m_xContext), + i_xPart); + i_rImpl.m_xManifest->removeStatements(i_xPart, + getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext), nullptr); + } catch (const uno::RuntimeException &) { + throw; + } catch (const uno::Exception &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetRuntimeException( + "removeFile: exception", + nullptr, anyEx); + } +} + +static ::std::vector< uno::Reference< rdf::XURI > > +getAllParts(struct DocumentMetadataAccess_Impl const & i_rImpl) +{ + ::std::vector< uno::Reference< rdf::XURI > > ret; + try { + const uno::Reference<container::XEnumeration> xEnum( + i_rImpl.m_xManifest->getStatements( i_rImpl.m_xBaseURI, + getURI<rdf::URIs::PKG_HASPART>(i_rImpl.m_xContext), nullptr), + uno::UNO_SET_THROW); + while (xEnum->hasMoreElements()) { + rdf::Statement stmt; + if (!(xEnum->nextElement() >>= stmt)) { + throw uno::RuntimeException(); + } + const uno::Reference<rdf::XURI> xPart(stmt.Object, + uno::UNO_QUERY); + if (!xPart.is()) continue; + ret.push_back(xPart); + } + return ret; + } catch (const uno::RuntimeException &) { + throw; + } catch (const uno::Exception &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetRuntimeException( + "getAllParts: exception", + nullptr, anyEx); + } +} + +static bool +isPartOfType(struct DocumentMetadataAccess_Impl const & i_rImpl, + uno::Reference<rdf::XURI> const & i_xPart, + uno::Reference<rdf::XURI> const & i_xType) +{ + if (!i_xPart.is() || !i_xType.is()) throw uno::RuntimeException(); + try { + const uno::Reference<container::XEnumeration> xEnum( + i_rImpl.m_xManifest->getStatements(i_xPart, + getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext), + i_xType), + uno::UNO_SET_THROW); + return xEnum->hasMoreElements(); + } catch (const uno::RuntimeException &) { + throw; + } catch (const uno::Exception &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetRuntimeException( + "isPartOfType: exception", + nullptr, anyEx); + } +} + +static ::std::vector<uno::Reference<rdf::XURI>> +getAllParts(struct DocumentMetadataAccess_Impl const& i_rImpl, + const uno::Reference<rdf::XURI>& i_xType) +{ + ::std::vector<uno::Reference<rdf::XURI>> ret; + try + { + const uno::Reference<container::XEnumeration> xEnum( + i_rImpl.m_xManifest->getStatements(i_rImpl.m_xBaseURI, + getURI<rdf::URIs::PKG_HASPART>(i_rImpl.m_xContext), + nullptr), + uno::UNO_SET_THROW); + while (xEnum->hasMoreElements()) + { + rdf::Statement stmt; + if (!(xEnum->nextElement() >>= stmt)) + { + throw uno::RuntimeException(); + } + const uno::Reference<rdf::XURI> xPart(stmt.Object, uno::UNO_QUERY); + if (!xPart.is()) + continue; + + const uno::Reference<container::XEnumeration> xEnum2( + i_rImpl.m_xManifest->getStatements( + xPart, getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext), i_xType), + uno::UNO_SET_THROW); + if (xEnum2->hasMoreElements()) + ret.emplace_back(xPart); + } + return ret; + } + catch (const uno::RuntimeException&) + { + throw; + } + catch (const uno::Exception& e) + { + throw lang::WrappedTargetRuntimeException("getAllParts: exception", nullptr, + uno::Any(e)); + } +} + +static ucb::InteractiveAugmentedIOException +mkException( OUString const & i_rMessage, + ucb::IOErrorCode const i_ErrorCode, + OUString const & i_rUri, OUString const & i_rResource) +{ + ucb::InteractiveAugmentedIOException iaioe; + iaioe.Message = i_rMessage; + iaioe.Classification = task::InteractionClassification_ERROR; + iaioe.Code = i_ErrorCode; + + const beans::PropertyValue uriProp("Uri", + -1, uno::Any(i_rUri), static_cast<beans::PropertyState>(0)); + const beans::PropertyValue rnProp( + "ResourceName", + -1, uno::Any(i_rResource), static_cast<beans::PropertyState>(0)); + iaioe.Arguments = { uno::Any(uriProp), uno::Any(rnProp) }; + return iaioe; +} + +/** error handling policy. + <p>If a handler is given, ask it how to proceed: + <ul><li>(default:) cancel import, raise exception</li> + <li>ignore the error and continue</li> + <li>retry the action that led to the error</li></ul></p> + N.B.: must not be called before DMA is fully initialized! + @returns true iff caller should retry + */ +static bool +handleError( ucb::InteractiveAugmentedIOException const & i_rException, + const uno::Reference<task::XInteractionHandler> & i_xHandler) +{ + if (!i_xHandler.is()) { + throw lang::WrappedTargetException( + "DocumentMetadataAccess::loadMetadataFromStorage: exception", + /* *this*/ nullptr, uno::Any(i_rException)); + } + + ::rtl::Reference< ::comphelper::OInteractionRequest > pRequest( + new ::comphelper::OInteractionRequest(uno::Any(i_rException)) ); + ::rtl::Reference< ::comphelper::OInteractionRetry > pRetry( + new ::comphelper::OInteractionRetry ); + ::rtl::Reference< ::comphelper::OInteractionApprove > pApprove( + new ::comphelper::OInteractionApprove ); + ::rtl::Reference< ::comphelper::OInteractionAbort > pAbort( + new ::comphelper::OInteractionAbort ); + + pRequest->addContinuation( pApprove ); + pRequest->addContinuation( pAbort ); + // actually call the handler + i_xHandler->handle( pRequest ); + if (pRetry->wasSelected()) { + return true; + } else if (pApprove->wasSelected()) { + return false; + } else { + OSL_ENSURE(pAbort->wasSelected(), "no continuation selected?"); + throw lang::WrappedTargetException( + "DocumentMetadataAccess::loadMetadataFromStorage: exception", + /* *this*/ nullptr, uno::Any(i_rException)); + } +} + +/** check if storage has content.xml/styles.xml; + e.g. ODB files seem to only have content.xml */ +static void +collectFilesFromStorage(uno::Reference<embed::XStorage> const& i_xStorage, + std::set< OUString > & o_rFiles) +{ + try { + if (i_xStorage->hasByName(s_content) && + i_xStorage->isStreamElement(s_content)) + { + o_rFiles.insert(s_content); + } + if (i_xStorage->hasByName(s_styles) && + i_xStorage->isStreamElement(s_styles)) + { + o_rFiles.insert(s_styles); + } + } catch (const uno::Exception &) { + TOOLS_WARN_EXCEPTION("sfx", "collectFilesFromStorage"); + } +} + +/** import a metadata file into repository */ +static void +readStream(struct DocumentMetadataAccess_Impl & i_rImpl, + uno::Reference< embed::XStorage > const & i_xStorage, + OUString const & i_rPath, + OUString const & i_rBaseURI) +{ + try { + OUString dir; + OUString rest; + if (!splitPath(i_rPath, dir, rest)) throw uno::RuntimeException(); + if (dir.isEmpty()) { + if (!i_xStorage->isStreamElement(i_rPath)) { + throw mkException( + "readStream: is not a stream", + ucb::IOErrorCode_NO_FILE, i_rBaseURI + i_rPath, i_rPath); + } + const uno::Reference<io::XStream> xStream( + i_xStorage->openStreamElement(i_rPath, + embed::ElementModes::READ), uno::UNO_SET_THROW); + const uno::Reference<io::XInputStream> xInStream( + xStream->getInputStream(), uno::UNO_SET_THROW ); + const uno::Reference<rdf::XURI> xBaseURI( + rdf::URI::create(i_rImpl.m_xContext, i_rBaseURI)); + const uno::Reference<rdf::XURI> xURI( + rdf::URI::createNS(i_rImpl.m_xContext, + i_rBaseURI, i_rPath)); + i_rImpl.m_xRepository->importGraph(rdf::FileFormat::RDF_XML, + xInStream, xURI, xBaseURI); + } else { + if (!i_xStorage->isStorageElement(dir)) { + throw mkException( + "readStream: is not a directory", + ucb::IOErrorCode_NO_DIRECTORY, i_rBaseURI + dir, dir); + } + const uno::Reference<embed::XStorage> xDir( + i_xStorage->openStorageElement(dir, + embed::ElementModes::READ)); + const uno::Reference< beans::XPropertySet > xDirProps(xDir, + uno::UNO_QUERY_THROW); + try { + OUString mimeType; + xDirProps->getPropertyValue( + utl::MediaDescriptor::PROP_MEDIATYPE ) + >>= mimeType; + if (mimeType.startsWith(s_odfmime)) { + SAL_WARN("sfx", "readStream: refusing to recurse into embedded document"); + return; + } + } catch (const uno::Exception &) { } + readStream(i_rImpl, xDir, rest, i_rBaseURI+dir+"/" ); + } + } catch (const container::NoSuchElementException & e) { + throw mkException(e.Message, ucb::IOErrorCode_NOT_EXISTING_PATH, + i_rBaseURI + i_rPath, i_rPath); + } catch (const io::IOException & e) { + throw mkException(e.Message, ucb::IOErrorCode_CANT_READ, + i_rBaseURI + i_rPath, i_rPath); + } catch (const rdf::ParseException & e) { + throw mkException(e.Message, ucb::IOErrorCode_WRONG_FORMAT, + i_rBaseURI + i_rPath, i_rPath); + } +} + +/** import a metadata file into repository */ +static void +importFile(struct DocumentMetadataAccess_Impl & i_rImpl, + uno::Reference<embed::XStorage> const & i_xStorage, + OUString const & i_rBaseURI, + uno::Reference<task::XInteractionHandler> const & i_xHandler, + const OUString& i_rPath) +{ +retry: + try { + readStream(i_rImpl, i_xStorage, i_rPath, i_rBaseURI); + } catch (const ucb::InteractiveAugmentedIOException & e) { + if (handleError(e, i_xHandler)) goto retry; + } catch (const uno::RuntimeException &) { + throw; + } catch (const uno::Exception &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetRuntimeException( + "importFile: exception", + nullptr, anyEx); + } +} + +/** actually write a metadata file to the storage */ +static void +exportStream(struct DocumentMetadataAccess_Impl const & i_rImpl, + uno::Reference< embed::XStorage > const & i_xStorage, + uno::Reference<rdf::XURI> const & i_xGraphName, + OUString const & i_rFileName, + OUString const & i_rBaseURI) +{ + const uno::Reference<io::XStream> xStream( + i_xStorage->openStreamElement(i_rFileName, + embed::ElementModes::WRITE | embed::ElementModes::TRUNCATE), + uno::UNO_SET_THROW); + const uno::Reference< beans::XPropertySet > xStreamProps(xStream, + uno::UNO_QUERY); + if (xStreamProps.is()) { // this is NOT supported in FileSystemStorage + xStreamProps->setPropertyValue( + "MediaType", + uno::Any(OUString("application/rdf+xml"))); + } + const uno::Reference<io::XOutputStream> xOutStream( + xStream->getOutputStream(), uno::UNO_SET_THROW ); + const uno::Reference<rdf::XURI> xBaseURI( + rdf::URI::create(i_rImpl.m_xContext, i_rBaseURI)); + i_rImpl.m_xRepository->exportGraph(rdf::FileFormat::RDF_XML, + xOutStream, i_xGraphName, xBaseURI); +} + +/** write a metadata file to the storage */ +static void +writeStream(struct DocumentMetadataAccess_Impl & i_rImpl, + uno::Reference< embed::XStorage > const & i_xStorage, + uno::Reference<rdf::XURI> const & i_xGraphName, + OUString const & i_rPath, + OUString const & i_rBaseURI) +{ + OUString dir; + OUString rest; + if (!splitPath(i_rPath, dir, rest)) throw uno::RuntimeException(); + try { + if (dir.isEmpty()) { + exportStream(i_rImpl, i_xStorage, i_xGraphName, i_rPath, + i_rBaseURI); + } else { + const uno::Reference<embed::XStorage> xDir( + i_xStorage->openStorageElement(dir, + embed::ElementModes::WRITE)); + const uno::Reference< beans::XPropertySet > xDirProps(xDir, + uno::UNO_QUERY_THROW); + try { + OUString mimeType; + xDirProps->getPropertyValue( + utl::MediaDescriptor::PROP_MEDIATYPE ) + >>= mimeType; + if (mimeType.startsWith(s_odfmime)) { + SAL_WARN("sfx", "writeStream: refusing to recurse into embedded document"); + return; + } + } catch (const uno::Exception &) { } + writeStream(i_rImpl, xDir, i_xGraphName, rest, i_rBaseURI+dir+"/"); + uno::Reference<embed::XTransactedObject> const xTransaction( + xDir, uno::UNO_QUERY); + if (xTransaction.is()) { + xTransaction->commit(); + } + } + } catch (const uno::RuntimeException &) { + throw; + } catch (const io::IOException &) { + throw; + } +} + +static void +initLoading(struct DocumentMetadataAccess_Impl & i_rImpl, + const uno::Reference< embed::XStorage > & i_xStorage, + const uno::Reference<rdf::XURI> & i_xBaseURI, + const uno::Reference<task::XInteractionHandler> & i_xHandler) +{ +retry: + // clear old data + i_rImpl.m_xManifest.clear(); + // init BaseURI + i_rImpl.m_xBaseURI = i_xBaseURI; + + // create repository + i_rImpl.m_xRepository.clear(); + i_rImpl.m_xRepository.set(rdf::Repository::create(i_rImpl.m_xContext), + uno::UNO_SET_THROW); + + // try to delay raising errors until after initialization is done + uno::Any rterr; + ucb::InteractiveAugmentedIOException iaioe; + bool err(false); + + const uno::Reference <rdf::XURI> xManifest( + getURIForStream(i_rImpl, s_manifest)); + try { + readStream(i_rImpl, i_xStorage, s_manifest, i_xBaseURI->getStringValue()); + } catch (const ucb::InteractiveAugmentedIOException & e) { + // no manifest.rdf: this is not an error in ODF < 1.2 + if (ucb::IOErrorCode_NOT_EXISTING_PATH != e.Code) { + iaioe = e; + err = true; + } + } catch (const uno::Exception & e) { + rterr <<= e; + } + + // init manifest graph + const uno::Reference<rdf::XNamedGraph> xManifestGraph( + i_rImpl.m_xRepository->getGraph(xManifest)); + i_rImpl.m_xManifest.set(xManifestGraph.is() ? xManifestGraph : + i_rImpl.m_xRepository->createGraph(xManifest), uno::UNO_SET_THROW); + + // document statement + i_rImpl.m_xManifest->addStatement(i_rImpl.m_xBaseURI, + getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext), + getURI<rdf::URIs::PKG_DOCUMENT>(i_rImpl.m_xContext)); + + OSL_ENSURE(i_rImpl.m_xBaseURI.is(), "base URI is null"); + OSL_ENSURE(i_rImpl.m_xRepository.is(), "repository is null"); + OSL_ENSURE(i_rImpl.m_xManifest.is(), "manifest is null"); + + if (rterr.hasValue()) { + throw lang::WrappedTargetRuntimeException( + "DocumentMetadataAccess::loadMetadataFromStorage: " + "exception", nullptr, rterr); + } + + if (err && handleError(iaioe, i_xHandler)) + goto retry; +} + +/** init Impl struct */ +static void init(struct DocumentMetadataAccess_Impl & i_rImpl) +{ + try { + + i_rImpl.m_xManifest.set(i_rImpl.m_xRepository->createGraph( + getURIForStream(i_rImpl, s_manifest)), + uno::UNO_SET_THROW); + + // insert the document statement + i_rImpl.m_xManifest->addStatement(i_rImpl.m_xBaseURI, + getURI<rdf::URIs::RDF_TYPE>(i_rImpl.m_xContext), + getURI<rdf::URIs::PKG_DOCUMENT>(i_rImpl.m_xContext)); + } catch (const uno::Exception &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetRuntimeException( + "init: unexpected exception", nullptr, + anyEx); + } + + // add top-level content files + if (!addContentOrStylesFileImpl(i_rImpl, s_content)) { + throw uno::RuntimeException(); + } + if (!addContentOrStylesFileImpl(i_rImpl, s_styles)) { + throw uno::RuntimeException(); + } +} + + +DocumentMetadataAccess::DocumentMetadataAccess( + uno::Reference< uno::XComponentContext > const & i_xContext, + const SfxObjectShell & i_rRegistrySupplier) + : m_pImpl(new DocumentMetadataAccess_Impl(i_xContext, i_rRegistrySupplier)) +{ + // no initialization: must call loadFrom... +} + +DocumentMetadataAccess::DocumentMetadataAccess( + uno::Reference< uno::XComponentContext > const & i_xContext, + const SfxObjectShell & i_rRegistrySupplier, + OUString const & i_rURI) + : m_pImpl(new DocumentMetadataAccess_Impl(i_xContext, i_rRegistrySupplier)) +{ + OSL_ENSURE(!i_rURI.isEmpty(), "DMA::DMA: no URI given!"); + OSL_ENSURE(i_rURI.endsWith("/"), "DMA::DMA: URI without / given!"); + if (!i_rURI.endsWith("/")) throw uno::RuntimeException(); + m_pImpl->m_xBaseURI.set(rdf::URI::create(m_pImpl->m_xContext, i_rURI)); + m_pImpl->m_xRepository.set(rdf::Repository::create(m_pImpl->m_xContext), + uno::UNO_SET_THROW); + + // init repository + init(*m_pImpl); + + OSL_ENSURE(m_pImpl->m_xBaseURI.is(), "base URI is null"); + OSL_ENSURE(m_pImpl->m_xRepository.is(), "repository is null"); + OSL_ENSURE(m_pImpl->m_xManifest.is(), "manifest is null"); +} + +DocumentMetadataAccess::~DocumentMetadataAccess() +{ +} + +// css::rdf::XRepositorySupplier: +uno::Reference< rdf::XRepository > SAL_CALL +DocumentMetadataAccess::getRDFRepository() +{ + OSL_ENSURE(m_pImpl->m_xRepository.is(), "repository not initialized"); + return m_pImpl->m_xRepository; +} + +// css::rdf::XNode: +OUString SAL_CALL +DocumentMetadataAccess::getStringValue() +{ + return m_pImpl->m_xBaseURI->getStringValue(); +} + +// css::rdf::XURI: +OUString SAL_CALL +DocumentMetadataAccess::getNamespace() +{ + return m_pImpl->m_xBaseURI->getNamespace(); +} + +OUString SAL_CALL +DocumentMetadataAccess::getLocalName() +{ + return m_pImpl->m_xBaseURI->getLocalName(); +} + +// css::rdf::XDocumentMetadataAccess: +uno::Reference< rdf::XMetadatable > SAL_CALL +DocumentMetadataAccess::getElementByMetadataReference( + const css::beans::StringPair & i_rReference) +{ + const IXmlIdRegistry * pReg( + m_pImpl->m_rXmlIdRegistrySupplier.GetXmlIdRegistry() ); + if (!pReg) { + throw uno::RuntimeException( + "DocumentMetadataAccess::getElementByXmlId: no registry", *this); + } + return pReg->GetElementByMetadataReference(i_rReference); +} + +uno::Reference< rdf::XMetadatable > SAL_CALL +DocumentMetadataAccess::getElementByURI( + const uno::Reference< rdf::XURI > & i_xURI ) +{ + if (!i_xURI.is()) { + throw lang::IllegalArgumentException( + "DocumentMetadataAccess::getElementByURI: URI is null", *this, 0); + } + + const OUString baseURI( m_pImpl->m_xBaseURI->getStringValue() ); + const OUString name( i_xURI->getStringValue() ); + if (!name.match(baseURI)) { + return nullptr; + } + OUString path; + OUString idref; + if (!splitXmlId(name.copy(baseURI.getLength()), path, idref)) { + return nullptr; + } + + return getElementByMetadataReference( beans::StringPair(path, idref) ); +} + +uno::Sequence<uno::Reference<rdf::XURI>> SAL_CALL +DocumentMetadataAccess::getMetadataGraphsWithType(const uno::Reference<rdf::XURI>& i_xType) +{ + if (!i_xType.is()) + { + throw lang::IllegalArgumentException("DocumentMetadataAccess::getMetadataGraphsWithType: " + "type is null", + *this, 0); + } + + return ::comphelper::containerToSequence(getAllParts(*m_pImpl, i_xType)); +} + +uno::Reference<rdf::XURI> SAL_CALL +DocumentMetadataAccess::addMetadataFile(const OUString & i_rFileName, + const uno::Sequence < uno::Reference< rdf::XURI > > & i_rTypes) +{ + if (!isFileNameValid(i_rFileName)) { + throw lang::IllegalArgumentException( + "DocumentMetadataAccess::addMetadataFile: invalid FileName", + *this, 0); + } + if (isReservedFile(i_rFileName)) { + throw lang::IllegalArgumentException( + "DocumentMetadataAccess::addMetadataFile:" + "invalid FileName: reserved", *this, 0); + } + if (std::any_of(i_rTypes.begin(), i_rTypes.end(), + [](const uno::Reference< rdf::XURI >& rType) { return !rType.is(); })) { + throw lang::IllegalArgumentException( + "DocumentMetadataAccess::addMetadataFile: " + "null type", *this, 2); + } + + const uno::Reference<rdf::XURI> xGraphName( + getURIForStream(*m_pImpl, i_rFileName) ); + + try { + m_pImpl->m_xRepository->createGraph(xGraphName); + } catch (const rdf::RepositoryException &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetRuntimeException( + "DocumentMetadataAccess::addMetadataFile: exception", + *this, anyEx); + // note: all other exceptions are propagated + } + + addMetadataFileImpl(*m_pImpl, i_rFileName, i_rTypes); + return xGraphName; +} + +uno::Reference<rdf::XURI> SAL_CALL +DocumentMetadataAccess::importMetadataFile(::sal_Int16 i_Format, + const uno::Reference< io::XInputStream > & i_xInStream, + const OUString & i_rFileName, + const uno::Reference< rdf::XURI > & i_xBaseURI, + const uno::Sequence < uno::Reference< rdf::XURI > > & i_rTypes) +{ + if (!isFileNameValid(i_rFileName)) { + throw lang::IllegalArgumentException( + "DocumentMetadataAccess::importMetadataFile: invalid FileName", + *this, 0); + } + if (isReservedFile(i_rFileName)) { + throw lang::IllegalArgumentException( + "DocumentMetadataAccess::importMetadataFile:" + "invalid FileName: reserved", *this, 0); + } + if (std::any_of(i_rTypes.begin(), i_rTypes.end(), + [](const uno::Reference< rdf::XURI >& rType) { return !rType.is(); })) { + throw lang::IllegalArgumentException( + "DocumentMetadataAccess::importMetadataFile: null type", + *this, 5); + } + + const uno::Reference<rdf::XURI> xGraphName( + getURIForStream(*m_pImpl, i_rFileName) ); + + try { + m_pImpl->m_xRepository->importGraph( + i_Format, i_xInStream, xGraphName, i_xBaseURI); + } catch (const rdf::RepositoryException &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetRuntimeException( + "DocumentMetadataAccess::importMetadataFile: " + "RepositoryException", *this, anyEx); + // note: all other exceptions are propagated + } + + // add to manifest + addMetadataFileImpl(*m_pImpl, i_rFileName, i_rTypes); + return xGraphName; +} + +void SAL_CALL +DocumentMetadataAccess::removeMetadataFile( + const uno::Reference< rdf::XURI > & i_xGraphName) +{ + try { + m_pImpl->m_xRepository->destroyGraph(i_xGraphName); + } catch (const rdf::RepositoryException &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetRuntimeException( + "DocumentMetadataAccess::removeMetadataFile: " + "RepositoryException", *this, anyEx); + // note: all other exceptions are propagated + } + + // remove file from manifest + removeFile(*m_pImpl, i_xGraphName); +} + +void SAL_CALL +DocumentMetadataAccess::addContentOrStylesFile( + const OUString & i_rFileName) +{ + if (!isFileNameValid(i_rFileName)) { + throw lang::IllegalArgumentException( + "DocumentMetadataAccess::addContentOrStylesFile: " + "invalid FileName", *this, 0); + } + + if (!addContentOrStylesFileImpl(*m_pImpl, i_rFileName)) { + throw lang::IllegalArgumentException( + "DocumentMetadataAccess::addContentOrStylesFile: " + "invalid FileName: must end with content.xml or styles.xml", + *this, 0); + } +} + +void SAL_CALL +DocumentMetadataAccess::removeContentOrStylesFile( + const OUString & i_rFileName) +{ + if (!isFileNameValid(i_rFileName)) { + throw lang::IllegalArgumentException( + "DocumentMetadataAccess::removeContentOrStylesFile: " + "invalid FileName", *this, 0); + } + + try { + const uno::Reference<rdf::XURI> xPart( + getURIForStream(*m_pImpl, i_rFileName) ); + const uno::Reference<container::XEnumeration> xEnum( + m_pImpl->m_xManifest->getStatements( m_pImpl->m_xBaseURI, + getURI<rdf::URIs::PKG_HASPART>(m_pImpl->m_xContext), + xPart), + uno::UNO_SET_THROW); + if (!xEnum->hasMoreElements()) { + throw container::NoSuchElementException( + "DocumentMetadataAccess::removeContentOrStylesFile: " + "cannot find stream in manifest graph: " + i_rFileName, + *this); + } + + // remove file from manifest + removeFile(*m_pImpl, xPart); + + } catch (const uno::RuntimeException &) { + throw; + } catch (const uno::Exception &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetRuntimeException( + "DocumentMetadataAccess::removeContentOrStylesFile: exception", + *this, anyEx); + } +} + +void SAL_CALL DocumentMetadataAccess::loadMetadataFromStorage( + const uno::Reference< embed::XStorage > & i_xStorage, + const uno::Reference<rdf::XURI> & i_xBaseURI, + const uno::Reference<task::XInteractionHandler> & i_xHandler) +{ + if (!i_xStorage.is()) { + throw lang::IllegalArgumentException( + "DocumentMetadataAccess::loadMetadataFromStorage: " + "storage is null", *this, 0); + } + if (!i_xBaseURI.is()) { + throw lang::IllegalArgumentException( + "DocumentMetadataAccess::loadMetadataFromStorage: " + "base URI is null", *this, 1); + } + const OUString baseURI( i_xBaseURI->getStringValue()); + if (baseURI.indexOf('#') >= 0) { + throw lang::IllegalArgumentException( + "DocumentMetadataAccess::loadMetadataFromStorage: " + "base URI not absolute", *this, 1); + } + if (!baseURI.endsWith("/")) { + throw lang::IllegalArgumentException( + "DocumentMetadataAccess::loadMetadataFromStorage: " + "base URI does not end with slash", *this, 1); + } + + initLoading(*m_pImpl, i_xStorage, i_xBaseURI, i_xHandler); + + std::set< OUString > StgFiles; + collectFilesFromStorage(i_xStorage, StgFiles); + + std::vector< OUString > MfstMetadataFiles; + + try { + const ::std::vector< uno::Reference< rdf::XURI > > parts( + getAllParts(*m_pImpl) ); + const uno::Reference<rdf::XURI>& xContentFile( + getURI<rdf::URIs::ODF_CONTENTFILE>(m_pImpl->m_xContext)); + const uno::Reference<rdf::XURI>& xStylesFile( + getURI<rdf::URIs::ODF_STYLESFILE>(m_pImpl->m_xContext)); + const uno::Reference<rdf::XURI>& xMetadataFile( + getURI<rdf::URIs::PKG_METADATAFILE>(m_pImpl->m_xContext)); + const sal_Int32 len( baseURI.getLength() ); + for (const auto& rxPart : parts) { + const OUString name(rxPart->getStringValue()); + if (!name.match(baseURI)) { + SAL_WARN("sfx", "loadMetadataFromStorage: graph not in document: " << name); + continue; + } + const OUString relName( name.copy(len) ); + if (relName == s_manifest) { + SAL_WARN("sfx", "loadMetadataFromStorage: found ourselves a recursive manifest!"); + continue; + } + // remove found items from StgFiles + StgFiles.erase(relName); + if (isContentFile(relName)) { + if (!isPartOfType(*m_pImpl, rxPart, xContentFile)) { + const uno::Reference <rdf::XURI> xName( + getURIForStream(*m_pImpl, relName) ); + // add missing type statement + m_pImpl->m_xManifest->addStatement(xName, + getURI<rdf::URIs::RDF_TYPE>(m_pImpl->m_xContext), + xContentFile); + } + } else if (isStylesFile(relName)) { + if (!isPartOfType(*m_pImpl, rxPart, xStylesFile)) { + const uno::Reference <rdf::XURI> xName( + getURIForStream(*m_pImpl, relName) ); + // add missing type statement + m_pImpl->m_xManifest->addStatement(xName, + getURI<rdf::URIs::RDF_TYPE>(m_pImpl->m_xContext), + xStylesFile); + } + } else if (isReservedFile(relName)) { + SAL_WARN("sfx", "loadMetadataFromStorage: reserved file name in manifest"); + } else { + if (isPartOfType(*m_pImpl, rxPart, xMetadataFile)) { + MfstMetadataFiles.push_back(relName); + } + // do not add statement for MetadataFile; it could be + // something else! just ignore it... + } + } + } catch (const uno::RuntimeException &) { + throw; + } catch (const uno::Exception &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetRuntimeException( + "DocumentMetadataAccess::loadMetadataFromStorage: " + "exception", *this, anyEx); + } + + for (const auto& aStgFile : StgFiles) + addContentOrStylesFileImpl(*m_pImpl, aStgFile); + + for (const auto& aMfstMetadataFile : MfstMetadataFiles) + importFile(*m_pImpl, i_xStorage, baseURI, i_xHandler, aMfstMetadataFile); +} + +void SAL_CALL DocumentMetadataAccess::storeMetadataToStorage( + const uno::Reference< embed::XStorage > & i_xStorage) +{ + if (!i_xStorage.is()) { + throw lang::IllegalArgumentException( + "DocumentMetadataAccess::storeMetadataToStorage: " + "storage is null", *this, 0); + } + + // export manifest + const uno::Reference <rdf::XURI> xManifest( + getURIForStream(*m_pImpl, s_manifest) ); + const OUString baseURI( m_pImpl->m_xBaseURI->getStringValue() ); + try { + writeStream(*m_pImpl, i_xStorage, xManifest, s_manifest, baseURI); + } catch (const uno::RuntimeException &) { + throw; + } catch (const io::IOException &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetException( + "storeMetadataToStorage: IO exception", *this, anyEx); + } catch (const uno::Exception &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetRuntimeException( + "storeMetadataToStorage: exception", *this, anyEx); + } + + // export metadata streams + try { + const uno::Sequence<uno::Reference<rdf::XURI> > graphs( + m_pImpl->m_xRepository->getGraphNames()); + const sal_Int32 len( baseURI.getLength() ); + for (const uno::Reference<rdf::XURI>& xName : graphs) { + const OUString name(xName->getStringValue()); + if (!name.match(baseURI)) { + SAL_WARN("sfx", "storeMetadataToStorage: graph not in document: " << name); + continue; + } + const OUString relName( name.copy(len) ); + if (relName == s_manifest) { + continue; + } + if (!isFileNameValid(relName) || isReservedFile(relName)) { + SAL_WARN("sfx", "storeMetadataToStorage: invalid file name: " << relName); + continue; + } + try { + writeStream(*m_pImpl, i_xStorage, xName, relName, baseURI); + } catch (const uno::RuntimeException &) { + throw; + } catch (const io::IOException &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetException( + "storeMetadataToStorage: IO exception", + *this, anyEx); + } catch (const uno::Exception &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetRuntimeException( + "storeMetadataToStorage: exception", + *this, anyEx); + } + } + } catch (const rdf::RepositoryException &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetRuntimeException( + "storeMetadataToStorage: exception", *this, anyEx); + } +} + +void SAL_CALL +DocumentMetadataAccess::loadMetadataFromMedium( + const uno::Sequence< beans::PropertyValue > & i_rMedium) +{ + uno::Reference<io::XInputStream> xIn; + utl::MediaDescriptor md(i_rMedium); + OUString URL; + md[ utl::MediaDescriptor::PROP_URL ] >>= URL; + OUString BaseURL; + md[ utl::MediaDescriptor::PROP_DOCUMENTBASEURL ] >>= BaseURL; + if (md.addInputStream()) { + md[ utl::MediaDescriptor::PROP_INPUTSTREAM ] >>= xIn; + } + if (!xIn.is() && URL.isEmpty()) { + throw lang::IllegalArgumentException( + "DocumentMetadataAccess::loadMetadataFromMedium: " + "invalid medium: no URL, no input stream", *this, 0); + } + uno::Reference<embed::XStorage> xStorage; + try { + if (xIn.is()) { + xStorage = ::comphelper::OStorageHelper::GetStorageFromInputStream( + xIn, m_pImpl->m_xContext); + } else { // fallback to url + xStorage = ::comphelper::OStorageHelper::GetStorageFromURL2( + URL, embed::ElementModes::READ, m_pImpl->m_xContext); + } + } catch (const uno::RuntimeException &) { + throw; + } catch (const io::IOException &) { + throw; + } catch (const uno::Exception &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetException( + "DocumentMetadataAccess::loadMetadataFromMedium: " + "exception", *this, anyEx); + } + if (!xStorage.is()) { + throw uno::RuntimeException( + "DocumentMetadataAccess::loadMetadataFromMedium: " + "cannot get Storage", *this); + } + uno::Reference<rdf::XURI> xBaseURI; + try { + xBaseURI = createBaseURI(m_pImpl->m_xContext, nullptr, BaseURL); + } catch (const uno::Exception &) { + // fall back to URL + try { + xBaseURI = createBaseURI(m_pImpl->m_xContext, nullptr, URL); + } catch (const uno::Exception &) { + OSL_FAIL("cannot create base URI"); + } + } + uno::Reference<task::XInteractionHandler> xIH; + md[ utl::MediaDescriptor::PROP_INTERACTIONHANDLER ] >>= xIH; + loadMetadataFromStorage(xStorage, xBaseURI, xIH); +} + +void SAL_CALL +DocumentMetadataAccess::storeMetadataToMedium( + const uno::Sequence< beans::PropertyValue > & i_rMedium) +{ + utl::MediaDescriptor md(i_rMedium); + OUString URL; + md[ utl::MediaDescriptor::PROP_URL ] >>= URL; + if (URL.isEmpty()) { + throw lang::IllegalArgumentException( + "DocumentMetadataAccess::storeMetadataToMedium: " + "invalid medium: no URL", *this, 0); + } + + SfxMedium aMedium(i_rMedium); + uno::Reference<embed::XStorage> xStorage(aMedium.GetOutputStorage()); + + bool sfx(false); + if (xStorage.is()) { + sfx = true; + } else { + xStorage = ::comphelper::OStorageHelper::GetStorageFromURL2( + URL, embed::ElementModes::WRITE, m_pImpl->m_xContext); + } + + if (!xStorage.is()) { + throw uno::RuntimeException( + "DocumentMetadataAccess::storeMetadataToMedium: " + "cannot get Storage", *this); + } + // set MIME type of the storage + utl::MediaDescriptor::const_iterator iter + = md.find(utl::MediaDescriptor::PROP_MEDIATYPE); + if (iter != md.end()) { + uno::Reference< beans::XPropertySet > xProps(xStorage, + uno::UNO_QUERY_THROW); + try { + // this is NOT supported in FileSystemStorage + xProps->setPropertyValue( + utl::MediaDescriptor::PROP_MEDIATYPE, + iter->second); + } catch (const uno::Exception &) { } + } + storeMetadataToStorage(xStorage); + + if (!sfx) + return; + + const bool bOk = aMedium.Commit(); + aMedium.Close(); + if ( !bOk ) { + ErrCode nError = aMedium.GetError(); + if ( nError == ERRCODE_NONE ) { + nError = ERRCODE_IO_GENERAL; + } + task::ErrorCodeIOException ex( + "DocumentMetadataAccess::storeMetadataToMedium Commit failed: " + nError.toHexString(), + uno::Reference< uno::XInterface >(), sal_uInt32(nError)); + throw lang::WrappedTargetException(OUString(), *this, + uno::Any(ex)); + } +} + +} // namespace sfx2 + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/DocumentSigner.cxx b/sfx2/source/doc/DocumentSigner.cxx new file mode 100644 index 000000000..0106a6477 --- /dev/null +++ b/sfx2/source/doc/DocumentSigner.cxx @@ -0,0 +1,121 @@ +/* -*- 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/. + * + */ + +#include <sfx2/DocumentSigner.hxx> + +#include <tools/stream.hxx> +#include <unotools/ucbstreamhelper.hxx> +#include <unotools/streamwrap.hxx> + +#include <comphelper/storagehelper.hxx> +#include <comphelper/processfactory.hxx> + +#include <com/sun/star/embed/XStorage.hpp> +#include <com/sun/star/embed/XTransactedObject.hpp> +#include <com/sun/star/security/DocumentDigitalSignatures.hpp> +#include <com/sun/star/io/IOException.hpp> +#include <com/sun/star/io/XStream.hpp> + +using namespace css; + +namespace sfx2 +{ +bool DocumentSigner::signDocument(uno::Reference<security::XCertificate> const& rxCertificate) +{ + std::unique_ptr<SvStream> pStream( + utl::UcbStreamHelper::CreateStream(m_aUrl, StreamMode::READ | StreamMode::WRITE)); + uno::Reference<io::XStream> xInputStream(new utl::OStreamWrapper(std::move(pStream))); + + bool bResult = false; + uno::Reference<embed::XStorage> xWriteableZipStore; + try + { + xWriteableZipStore = comphelper::OStorageHelper::GetStorageOfFormatFromStream( + ZIP_STORAGE_FORMAT_STRING, xInputStream); + } + catch (const io::IOException&) + { + } + + OUString aODFVersion(comphelper::OStorageHelper::GetODFVersionFromStorage(xWriteableZipStore)); + + uno::Reference<security::XDocumentDigitalSignatures> xSigner( + security::DocumentDigitalSignatures::createWithVersionAndValidSignature( + comphelper::getProcessComponentContext(), aODFVersion, + /*bHasValidDocumentSignature*/ true)); + + try + { + uno::Reference<embed::XStorage> xMetaInf; + if (xWriteableZipStore.is() && xWriteableZipStore->hasByName("META-INF")) + { + xMetaInf = xWriteableZipStore->openStorageElement("META-INF", + embed::ElementModes::READWRITE); + if (!xMetaInf.is()) + throw uno::RuntimeException(); + } + if (xMetaInf.is()) + { + uno::Reference<embed::XStorage> xStorage + = comphelper::OStorageHelper::GetStorageOfFormatFromStream( + ZIP_STORAGE_FORMAT_STRING, xInputStream); + + // ODF. + uno::Reference<io::XStream> xStream; + xStream.set( + xMetaInf->openStreamElement(xSigner->getDocumentContentSignatureDefaultStreamName(), + embed::ElementModes::READWRITE), + uno::UNO_SET_THROW); + bool bSuccess = xSigner->signDocumentWithCertificate(rxCertificate, xStorage, xStream); + if (bSuccess) + { + uno::Reference<embed::XTransactedObject> xTransact(xMetaInf, uno::UNO_QUERY_THROW); + xTransact->commit(); + xTransact.set(xWriteableZipStore, uno::UNO_QUERY_THROW); + xTransact->commit(); + bResult = true; + } + } + else if (xWriteableZipStore.is()) + { + uno::Reference<embed::XStorage> xStorage + = comphelper::OStorageHelper::GetStorageOfFormatFromStream( + ZIP_STORAGE_FORMAT_STRING, xInputStream); + + // OOXML. + uno::Reference<io::XStream> xStream; + + // We need read-write to be able to add the signature relation. + bool bSuccess = xSigner->signDocumentWithCertificate(rxCertificate, xStorage, xStream); + + if (bSuccess) + { + uno::Reference<embed::XTransactedObject> xTransact(xWriteableZipStore, + uno::UNO_QUERY_THROW); + xTransact->commit(); + bResult = true; + } + } + else + { + // Something not ZIP based: e.g. PDF. + bResult = xSigner->signDocumentWithCertificate( + rxCertificate, uno::Reference<embed::XStorage>(), xInputStream); + } + } + catch (const uno::Exception&) + { + } + return bResult; +} + +} // namespace sfx2 + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/Metadatable.cxx b/sfx2/source/doc/Metadatable.cxx new file mode 100644 index 000000000..1906967ca --- /dev/null +++ b/sfx2/source/doc/Metadatable.cxx @@ -0,0 +1,1602 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <sal/config.h> +#include <sal/log.hxx> + +#include <osl/diagnose.h> +#include <sfx2/Metadatable.hxx> +#include <sfx2/XmlIdRegistry.hxx> + +#include <vcl/svapp.hxx> +#include <com/sun/star/frame/XModel.hpp> +#include <com/sun/star/lang/IllegalArgumentException.hpp> +#include <comphelper/random.hxx> +#include <tools/diagnose_ex.h> + +#include <algorithm> +#include <memory> +#include <string_view> +#include <unordered_map> +#if OSL_DEBUG_LEVEL > 0 +#include <typeinfo> +#endif + + +/** XML ID handling. + + There is an abstract base class <type>XmlIdRegistry</type>, with + 2 subclasses <type>XmlIdRegistryDocument</type> for "normal" documents, + and <type>XmlIdRegistryClipboard</type> for clipboard documents. + These classes are responsible for managing XML IDs for all elements + of the model. Only the implementation of the <type>Metadatable</type> + base class needs to know the registries, so they are not in the header. + + The handling of XML IDs differs between clipboard and non-clipboard + documents in several aspects. Most importantly, non-clipboard documents + can have several elements associated with one XML ID. + This is necessary because of the weird undo implementation: + deleting a text node moves the deleted node to the undo array, but + executing undo will then create a <em>copy</em> of that node in the + document array. These 2 nodes must have the same XML ID, because + we cannot know whether the user will do a redo next, or something else. + + Because we need to have a mechanism for several objects per XML ID anyway, + we use that also to enable some usability features: + The document registry has a list of Metadatables per XML ID. + This list is sorted by priority, i.e., the first element has highest + priority. When inserting copies, care must be taken that they are inserted + at the right position: either before or after the source. + This is done by <method>Metadatable::RegisterAsCopyOf</method>. + When a text node is split, then both resulting text nodes are inserted + into the list. If the user then deletes one text node, the other one + will have the XML ID. + Also, when a Metadatable is copied to the clipboard and then pasted, + the copy is inserted into the list. If the user then deletes the source, + the XML ID is not lost. + The goal is that it should be hard to lose an XML ID by accident, which + is especially important as long as we do not have an UI that displays them. + + There are two subclasses of <type>Metadatable</type>: + <ul><li><type>MetadatableClipboard</type>: for copies in the clipboard</li> + <li><type>MetadatableUndo</type>: for undo, because a Metadatable + may be destroyed on delete and a new one created on undo.</li></ul> + These serve only to track the position in an XML ID list in a document + registry, so that future actions can insert objects at the right position. + Unfortunately, inserting dummy objects seems to be necessary: + <ul><li>it is not sufficient to just remember the saved id, because then + the relative priorities might change when executing the undo</li> + <li>it is not sufficient to record the position as an integer, because + if we delete a text node and then undo, the node will be copied(!), + and we will have one more node in the list.<li> + <li>it is not sufficient to record the pointer of the previous/next + Metadatable, because if we delete a text node, undo, and then + do something to clear the redo array, the original text node is + destroyed, and is replaced by the copy created by undo</li></ul> + + If content from a non-clipboard document is copied into a clipboard + document, a dummy <type>MetadatableClipboard</type> is inserted into the + non-clipboard document registry in order to track the position of the + source element. When the clipboard content is pasted back into the source + document, this dummy object is used to associate the pasted element with + that same XML ID. + + If a <type>Metadatable</type> is deleted or merged, + <method>Metadatable::CreateUndo</method> is called, and returns a + <type>MetadatableUndo<type> instance, which can be used to undo the action + by passing it to <method>Metadatable::RestoreMetadata</method>. + + */ + + +using namespace ::com::sun::star; + +using ::sfx2::isValidXmlId; + + +namespace sfx2 { + +constexpr OUStringLiteral s_content = u"content.xml"; +constexpr OUStringLiteral s_styles = u"styles.xml"; + +static bool isContentFile(std::u16string_view i_rPath) +{ + return i_rPath == s_content; +} + +static bool isStylesFile (std::u16string_view i_rPath) +{ + return i_rPath == s_styles; +} + + +// XML ID handling --------------------------------------------------- + +/** handles registration of XMetadatable. + + This class is responsible for guaranteeing that XMetadatable objects + always have XML IDs that are unique within a stream. + + This is an abstract base class; see subclasses XmlIdRegistryDocument and + XmlIdRegistryClipboard. + + @see SwDoc::GetXmlIdRegistry + @see SwDocShell::GetXmlIdRegistry + */ +class XmlIdRegistry : public sfx2::IXmlIdRegistry +{ + +public: + XmlIdRegistry(); + + /** get the ODF element with the given metadata reference. */ + virtual css::uno::Reference< css::rdf::XMetadatable > + GetElementByMetadataReference( + const css::beans::StringPair & i_rReference) const + override; + + /** register an ODF element at a newly generated, unique metadata reference. + + <p> + Find a fresh XML ID, and register it for the element. + The generated ID does not occur in any stream of the document. + </p> + */ + virtual void RegisterMetadatableAndCreateID(Metadatable& i_xObject) = 0; + + /** try to register an ODF element at a given XML ID, or update its + registration to a different XML ID. + + <p> + If the given new metadata reference is not already occupied in the + document, unregister the element at its old metadata reference if + it has one, and register the new metadata reference for the element. + Note that this method only ensures that XML IDs are unique per stream, + so using the same XML ID in both content.xml and styles.xml is allowed. + </p> + + @returns + true iff the element has successfully been registered + */ + virtual bool TryRegisterMetadatable(Metadatable& i_xObject, + OUString const& i_rStreamName, OUString const& i_rIdref) + = 0; + + /** unregister an ODF element. + + <p> + Unregister the element at its metadata reference. + Does not remove the metadata reference from the element. + </p> + + @see RemoveXmlIdForElement + */ + virtual void UnregisterMetadatable(Metadatable const&) = 0; + + /** get the metadata reference for the given element. */ + css::beans::StringPair + GetXmlIdForElement(Metadatable const&) const; + + /** remove the metadata reference for the given element. */ + virtual void RemoveXmlIdForElement(Metadatable const&) = 0; + +protected: + + virtual bool LookupXmlId(const Metadatable& i_xObject, + OUString & o_rStream, OUString & o_rIdref) const = 0; + + virtual Metadatable* LookupElement(const OUString & i_rStreamName, + const OUString & i_rIdref) const = 0; +}; + +// XmlIdRegistryDocument --------------------------------------------- + +namespace { + +/** non-clipboard documents */ +class XmlIdRegistryDocument : public XmlIdRegistry +{ + +public: + XmlIdRegistryDocument(); + + virtual ~XmlIdRegistryDocument() override; + + virtual void RegisterMetadatableAndCreateID(Metadatable& i_xObject) override; + + virtual bool TryRegisterMetadatable(Metadatable& i_xObject, + OUString const& i_rStreamName, OUString const& i_rIdref) override; + + virtual void UnregisterMetadatable(Metadatable const&) override; + + virtual void RemoveXmlIdForElement(Metadatable const&) override; + + /** register i_rCopy as a copy of i_rSource, + with precedence iff i_bCopyPrecedesSource is true */ + void RegisterCopy(Metadatable const& i_rSource, Metadatable & i_rCopy, + const bool i_bCopyPrecedesSource); + + /** create a Undo Metadatable for i_rObject. */ + static std::shared_ptr<MetadatableUndo> CreateUndo( + Metadatable const& i_rObject); + + /** merge i_rMerged and i_rOther into i_rMerged. */ + void JoinMetadatables(Metadatable & i_rMerged, Metadatable const& i_rOther); + + // unfortunately public, Metadatable::RegisterAsCopyOf needs this + virtual bool LookupXmlId(const Metadatable& i_xObject, + OUString & o_rStream, OUString & o_rIdref) const override; + +private: + + virtual Metadatable* LookupElement(const OUString & i_rStreamName, + const OUString & i_rIdref) const override; + + struct XmlIdRegistry_Impl; + ::std::unique_ptr<XmlIdRegistry_Impl> m_pImpl; +}; + +} + +// MetadatableUndo --------------------------------------------------- + +/** the horrible Undo Metadatable: is inserted into lists to track position */ +class MetadatableUndo : public Metadatable +{ + /// as determined by the stream of the source in original document + const bool m_isInContent; +public: + explicit MetadatableUndo(const bool i_isInContent) + : m_isInContent(i_isInContent) { } + virtual ::sfx2::XmlIdRegistry& GetRegistry() override + { + // N.B. for Undo, m_pReg is initialized by registering this as copy in + // CreateUndo; it is never cleared + OSL_ENSURE(m_pReg, "no m_pReg in MetadatableUndo ?"); + return *m_pReg; + } + virtual bool IsInClipboard() const override { return false; } + virtual bool IsInUndo() const override { return true; } + virtual bool IsInContent() const override { return m_isInContent; } + virtual css::uno::Reference< css::rdf::XMetadatable > MakeUnoObject() override + { OSL_FAIL("MetadatableUndo::MakeUnoObject"); throw; } +}; + +// MetadatableClipboard ---------------------------------------------- + +/** the horrible Clipboard Metadatable: inserted into lists to track position */ +class MetadatableClipboard : public Metadatable +{ + /// as determined by the stream of the source in original document + const bool m_isInContent; +public: + explicit MetadatableClipboard(const bool i_isInContent) + : m_isInContent(i_isInContent) { } + virtual ::sfx2::XmlIdRegistry& GetRegistry() override + { + // N.B. for Clipboard, m_pReg is initialized by registering this as copy in + // RegisterAsCopyOf; it is only cleared by OriginNoLongerInBusinessAnymore + assert(m_pReg && "no m_pReg in MetadatableClipboard ?"); + return *m_pReg; + } + virtual bool IsInClipboard() const override { return true; } + virtual bool IsInUndo() const override { return false; } + virtual bool IsInContent() const override { return m_isInContent; } + virtual css::uno::Reference< css::rdf::XMetadatable > MakeUnoObject() override + { OSL_FAIL("MetadatableClipboard::MakeUnoObject"); throw; } + void OriginNoLongerInBusinessAnymore() { m_pReg = nullptr; } +}; + +// XmlIdRegistryClipboard -------------------------------------------- + +namespace { + +class XmlIdRegistryClipboard : public XmlIdRegistry +{ + +public: + XmlIdRegistryClipboard(); + + virtual void RegisterMetadatableAndCreateID(Metadatable& i_xObject) override; + + virtual bool TryRegisterMetadatable(Metadatable& i_xObject, + OUString const& i_rStreamName, OUString const& i_rIdref) override; + + virtual void UnregisterMetadatable(Metadatable const&) override; + + virtual void RemoveXmlIdForElement(Metadatable const&) override; + + /** register i_rCopy as a copy of i_rSource */ + MetadatableClipboard & RegisterCopyClipboard(Metadatable & i_rCopy, + beans::StringPair const & i_rReference, + const bool i_isLatent); + + /** get the Metadatable that links i_rObject to its origin registry */ + MetadatableClipboard const* SourceLink(Metadatable const& i_rObject); + +private: + virtual bool LookupXmlId(const Metadatable& i_xObject, + OUString & o_rStream, OUString & o_rIdref) const override; + + virtual Metadatable* LookupElement(const OUString & i_rStreamName, + const OUString & i_rIdref) const override; + + /** create a Clipboard Metadatable for i_rObject. */ + static std::shared_ptr<MetadatableClipboard> CreateClipboard( + const bool i_isInContent); + + struct XmlIdRegistry_Impl; + ::std::unique_ptr<XmlIdRegistry_Impl> m_pImpl; +}; + +} + +// XmlIdRegistry + +::sfx2::IXmlIdRegistry * createXmlIdRegistry(const bool i_DocIsClipboard) +{ + return i_DocIsClipboard + ? static_cast<XmlIdRegistry*>( new XmlIdRegistryClipboard ) + : static_cast<XmlIdRegistry*>( new XmlIdRegistryDocument ); +} + +XmlIdRegistry::XmlIdRegistry() +{ +} + +css::uno::Reference< css::rdf::XMetadatable > +XmlIdRegistry::GetElementByMetadataReference( + const beans::StringPair & i_rReference) const +{ + Metadatable* pObject( LookupElement(i_rReference.First, + i_rReference.Second) ); + return pObject ? pObject->MakeUnoObject() : nullptr; +} + +beans::StringPair +XmlIdRegistry::GetXmlIdForElement(const Metadatable& i_rObject) const +{ + OUString path; + OUString idref; + if (LookupXmlId(i_rObject, path, idref)) + { + if (LookupElement(path, idref) == &i_rObject) + { + return beans::StringPair(path, idref); + } + } + return beans::StringPair(); +} + + +/// generate unique xml:id +template< typename T > +static OUString create_id(const + std::unordered_map< OUString, T > & i_rXmlIdMap) +{ + static bool bHack = (getenv("LIBO_ONEWAY_STABLE_ODF_EXPORT") != nullptr); + static const char prefix[] = "id"; // prefix for generated xml:id + typename std::unordered_map< OUString, T > + ::const_iterator iter; + OUString id; + + if (bHack) + { + static sal_Int64 nIdCounter = SAL_CONST_INT64(4000000000); + do + { + id = prefix + OUString::number(nIdCounter++); + iter = i_rXmlIdMap.find(id); + } + while (iter != i_rXmlIdMap.end()); + } + else + { + do + { + unsigned int const n(comphelper::rng::uniform_uint_distribution(0, + std::numeric_limits<unsigned int>::max())); + id = prefix + OUString::number(n); + iter = i_rXmlIdMap.find(id); + } + while (iter != i_rXmlIdMap.end()); + } + return id; +} + + +// Document XML ID Registry (_Impl) + +/// element list +typedef ::std::vector< Metadatable* > XmlIdVector_t; + +/// Idref -> (content.xml element list, styles.xml element list) +typedef std::unordered_map< OUString, + ::std::pair< XmlIdVector_t, XmlIdVector_t > > XmlIdMap_t; + +namespace { + +/// pointer hash template +template<typename T> struct PtrHash +{ + size_t operator() (T const * i_pT) const + { + return reinterpret_cast<size_t>(i_pT); + } +}; + +} + +/// element -> (stream name, idref) +typedef std::unordered_map< const Metadatable*, + ::std::pair< OUString, OUString>, PtrHash<Metadatable> > + XmlIdReverseMap_t; + +struct XmlIdRegistryDocument::XmlIdRegistry_Impl +{ + XmlIdRegistry_Impl() {} + + bool TryInsertMetadatable(Metadatable& i_xObject, + std::u16string_view i_rStream, const OUString & i_rIdref); + + bool LookupXmlId(const Metadatable& i_xObject, + OUString & o_rStream, OUString & o_rIdref) const; + + Metadatable* LookupElement(std::u16string_view i_rStreamName, + const OUString & i_rIdref) const; + + const XmlIdVector_t * LookupElementVector( + std::u16string_view i_rStreamName, + const OUString & i_rIdref) const; + + XmlIdVector_t * LookupElementVector( + std::u16string_view i_rStreamName, + const OUString & i_rIdref) + { + return const_cast<XmlIdVector_t*>( + const_cast<const XmlIdRegistry_Impl*>(this) + ->LookupElementVector(i_rStreamName, i_rIdref)); + } + + XmlIdMap_t m_XmlIdMap; + XmlIdReverseMap_t m_XmlIdReverseMap; +}; + + +static void +rmIter(XmlIdMap_t & i_rXmlIdMap, XmlIdMap_t::iterator const& i_rIter, + std::u16string_view i_rStream, Metadatable const& i_rObject) +{ + if (i_rIter != i_rXmlIdMap.end()) + { + XmlIdVector_t & rVector( isContentFile(i_rStream) + ? i_rIter->second.first : i_rIter->second.second ); + rVector.erase(std::remove(rVector.begin(), rVector.end(), &const_cast<Metadatable&>(i_rObject))); + if (i_rIter->second.first.empty() && i_rIter->second.second.empty()) + { + i_rXmlIdMap.erase(i_rIter); + } + } +} + + +const XmlIdVector_t * +XmlIdRegistryDocument::XmlIdRegistry_Impl::LookupElementVector( + std::u16string_view i_rStreamName, + const OUString & i_rIdref) const +{ + const XmlIdMap_t::const_iterator iter( m_XmlIdMap.find(i_rIdref) ); + if (iter != m_XmlIdMap.end()) + { + OSL_ENSURE(!iter->second.first.empty() || !iter->second.second.empty(), + "null entry in m_XmlIdMap"); + return (isContentFile(i_rStreamName)) + ? &iter->second.first + : &iter->second.second; + } + else + { + return nullptr; + } +} + +Metadatable* +XmlIdRegistryDocument::XmlIdRegistry_Impl::LookupElement( + std::u16string_view i_rStreamName, + const OUString & i_rIdref) const +{ + if (!isValidXmlId(i_rStreamName, i_rIdref)) + { + throw lang::IllegalArgumentException("illegal XmlId", nullptr, 0); + } + + const XmlIdVector_t * pList( LookupElementVector(i_rStreamName, i_rIdref) ); + if (pList) + { + const XmlIdVector_t::const_iterator iter( + ::std::find_if(pList->begin(), pList->end(), + [](Metadatable* item)->bool { + return !(item->IsInUndo() || item->IsInClipboard()); + } ) ) ; + if (iter != pList->end()) + { + return *iter; + } + } + return nullptr; +} + +bool +XmlIdRegistryDocument::XmlIdRegistry_Impl::LookupXmlId( + const Metadatable& i_rObject, + OUString & o_rStream, OUString & o_rIdref) const +{ + const XmlIdReverseMap_t::const_iterator iter( + m_XmlIdReverseMap.find(&i_rObject) ); + if (iter != m_XmlIdReverseMap.end()) + { + OSL_ENSURE(!iter->second.first.isEmpty(), + "null stream in m_XmlIdReverseMap"); + OSL_ENSURE(!iter->second.second.isEmpty(), + "null id in m_XmlIdReverseMap"); + o_rStream = iter->second.first; + o_rIdref = iter->second.second; + return true; + } + else + { + return false; + } +} + +bool +XmlIdRegistryDocument::XmlIdRegistry_Impl::TryInsertMetadatable( + Metadatable & i_rObject, + std::u16string_view i_rStreamName, const OUString & i_rIdref) +{ + const bool bContent( isContentFile(i_rStreamName) ); + OSL_ENSURE(isContentFile(i_rStreamName) || isStylesFile(i_rStreamName), + "invalid stream"); + + XmlIdVector_t * pList( LookupElementVector(i_rStreamName, i_rIdref) ); + if (pList) + { + if (pList->empty()) + { + pList->push_back( &i_rObject ); + return true; + } + else + { + // this is only called from TryRegister now, so check + // if all elements in the list are deleted (in undo) or + // placeholders, then "steal" the id from them + if ( std::none_of(pList->begin(), pList->end(), + [](Metadatable* item)->bool { + return !(item->IsInUndo() || item->IsInClipboard()); + } ) ) + { + pList->insert(pList->begin(), &i_rObject ); + return true; + } + else + { + return false; + } + } + } + else + { + m_XmlIdMap.insert(::std::make_pair(i_rIdref, bContent + ? ::std::make_pair( XmlIdVector_t( 1, &i_rObject ), XmlIdVector_t() ) + : ::std::make_pair( XmlIdVector_t(), XmlIdVector_t( 1, &i_rObject ) ))); + return true; + } +} + + +// Document XML ID Registry + + +XmlIdRegistryDocument::XmlIdRegistryDocument() + : m_pImpl( new XmlIdRegistry_Impl ) +{ +} + +static void +removeLink(Metadatable* i_pObject) +{ + OSL_ENSURE(i_pObject, "null in list ???"); + if (!i_pObject) return; + if (i_pObject->IsInClipboard()) + { + MetadatableClipboard* pLink( + dynamic_cast<MetadatableClipboard*>( i_pObject ) ); + OSL_ENSURE(pLink, "IsInClipboard, but no MetadatableClipboard ?"); + if (pLink) + { + pLink->OriginNoLongerInBusinessAnymore(); + } + } +} + +XmlIdRegistryDocument::~XmlIdRegistryDocument() +{ + // notify all list elements that are actually in the clipboard + for (const auto& aXmlId : m_pImpl->m_XmlIdMap) { + for (auto aLink : aXmlId.second.first) + removeLink(aLink); + for (auto aLink : aXmlId.second.second) + removeLink(aLink); + } +} + +bool +XmlIdRegistryDocument::LookupXmlId( + const Metadatable& i_rObject, + OUString & o_rStream, OUString & o_rIdref) const +{ + return m_pImpl->LookupXmlId(i_rObject, o_rStream, o_rIdref); +} + +Metadatable* +XmlIdRegistryDocument::LookupElement( + const OUString & i_rStreamName, + const OUString & i_rIdref) const +{ + return m_pImpl->LookupElement(i_rStreamName, i_rIdref); +} + +bool +XmlIdRegistryDocument::TryRegisterMetadatable(Metadatable & i_rObject, + OUString const& i_rStreamName, OUString const& i_rIdref) +{ + SAL_INFO("sfx", "TryRegisterMetadatable: " << &i_rObject << " (" << i_rStreamName << "#" << i_rIdref << ")"); + + OSL_ENSURE(!dynamic_cast<MetadatableUndo*>(&i_rObject), + "TryRegisterMetadatable called for MetadatableUndo?"); + OSL_ENSURE(!dynamic_cast<MetadatableClipboard*>(&i_rObject), + "TryRegisterMetadatable called for MetadatableClipboard?"); + + if (!isValidXmlId(i_rStreamName, i_rIdref)) + { + throw lang::IllegalArgumentException("illegal XmlId", nullptr, 0); + } + if (i_rObject.IsInContent() + ? !isContentFile(i_rStreamName) + : !isStylesFile(i_rStreamName)) + { + throw lang::IllegalArgumentException("illegal XmlId: wrong stream", nullptr, 0); + } + + OUString old_path; + OUString old_idref; + m_pImpl->LookupXmlId(i_rObject, old_path, old_idref); + if (old_path == i_rStreamName && old_idref == i_rIdref) + { + return (m_pImpl->LookupElement(old_path, old_idref) == &i_rObject); + } + XmlIdMap_t::iterator old_id( m_pImpl->m_XmlIdMap.end() ); + if (!old_idref.isEmpty()) + { + old_id = m_pImpl->m_XmlIdMap.find(old_idref); + OSL_ENSURE(old_id != m_pImpl->m_XmlIdMap.end(), "old id not found"); + } + if (m_pImpl->TryInsertMetadatable(i_rObject, i_rStreamName, i_rIdref)) + { + rmIter(m_pImpl->m_XmlIdMap, old_id, old_path, i_rObject); + m_pImpl->m_XmlIdReverseMap[&i_rObject] = + ::std::make_pair(i_rStreamName, i_rIdref); + return true; + } + else + { + return false; + } +} + +void +XmlIdRegistryDocument::RegisterMetadatableAndCreateID(Metadatable & i_rObject) +{ + SAL_INFO("sfx", "RegisterMetadatableAndCreateID: " << &i_rObject); + + OSL_ENSURE(!dynamic_cast<MetadatableUndo*>(&i_rObject), + "RegisterMetadatableAndCreateID called for MetadatableUndo?"); + OSL_ENSURE(!dynamic_cast<MetadatableClipboard*>(&i_rObject), + "RegisterMetadatableAndCreateID called for MetadatableClipboard?"); + + const bool isInContent( i_rObject.IsInContent() ); + const OUString stream( + isInContent ? OUString(s_content) : OUString(s_styles) ); + // check if we have a latent xmlid, and if yes, remove it + OUString old_path; + OUString old_idref; + m_pImpl->LookupXmlId(i_rObject, old_path, old_idref); + + XmlIdMap_t::iterator old_id( m_pImpl->m_XmlIdMap.end() ); + if (!old_idref.isEmpty()) + { + old_id = m_pImpl->m_XmlIdMap.find(old_idref); + OSL_ENSURE(old_id != m_pImpl->m_XmlIdMap.end(), "old id not found"); + if (m_pImpl->LookupElement(old_path, old_idref) == &i_rObject) + { + return; + } + else + { + // remove latent xmlid + rmIter(m_pImpl->m_XmlIdMap, old_id, old_path, i_rObject); + } + } + + // create id + const OUString id( create_id(m_pImpl->m_XmlIdMap) ); + OSL_ENSURE(m_pImpl->m_XmlIdMap.find(id) == m_pImpl->m_XmlIdMap.end(), + "created id is in use"); + m_pImpl->m_XmlIdMap.insert(::std::make_pair(id, isInContent + ? ::std::make_pair( XmlIdVector_t( 1, &i_rObject ), XmlIdVector_t() ) + : ::std::make_pair( XmlIdVector_t(), XmlIdVector_t( 1, &i_rObject ) ))); + m_pImpl->m_XmlIdReverseMap[&i_rObject] = ::std::make_pair(stream, id); +} + +void XmlIdRegistryDocument::UnregisterMetadatable(const Metadatable& i_rObject) +{ + SAL_INFO("sfx", "UnregisterMetadatable: " << &i_rObject); + + OUString path; + OUString idref; + if (!m_pImpl->LookupXmlId(i_rObject, path, idref)) + { + OSL_FAIL("unregister: no xml id?"); + return; + } + const XmlIdMap_t::iterator iter( m_pImpl->m_XmlIdMap.find(idref) ); + if (iter != m_pImpl->m_XmlIdMap.end()) + { + rmIter(m_pImpl->m_XmlIdMap, iter, path, i_rObject); + } +} + +void XmlIdRegistryDocument::RemoveXmlIdForElement(const Metadatable& i_rObject) +{ + SAL_INFO("sfx", "RemoveXmlIdForElement: " << &i_rObject); + + const XmlIdReverseMap_t::iterator iter( + m_pImpl->m_XmlIdReverseMap.find(&i_rObject) ); + if (iter != m_pImpl->m_XmlIdReverseMap.end()) + { + OSL_ENSURE(!iter->second.second.isEmpty(), + "null id in m_XmlIdReverseMap"); + m_pImpl->m_XmlIdReverseMap.erase(iter); + } +} + + +void XmlIdRegistryDocument::RegisterCopy(Metadatable const& i_rSource, + Metadatable & i_rCopy, const bool i_bCopyPrecedesSource) +{ + SAL_INFO("sfx", "RegisterCopy: " << &i_rSource << " -> " << &i_rCopy << " (" << i_bCopyPrecedesSource << ")"); + + // potential sources: clipboard, undo array, splitNode + // assumption: stream change can only happen via clipboard, and is handled + // by Metadatable::RegisterAsCopyOf + OSL_ENSURE(i_rSource.IsInUndo() || i_rCopy.IsInUndo() || + (i_rSource.IsInContent() == i_rCopy.IsInContent()), + "RegisterCopy: not in same stream?"); + + OUString path; + OUString idref; + if (!m_pImpl->LookupXmlId( i_rSource, path, idref )) + { + OSL_FAIL("no xml id?"); + return; + } + XmlIdVector_t * pList ( m_pImpl->LookupElementVector(path, idref) ); + OSL_ENSURE( ::std::find( pList->begin(), pList->end(), &i_rCopy ) + == pList->end(), "copy already registered???"); + XmlIdVector_t::iterator srcpos( + ::std::find( pList->begin(), pList->end(), &i_rSource ) ); + OSL_ENSURE(srcpos != pList->end(), "source not in list???"); + if (srcpos == pList->end()) + { + return; + } + if (i_bCopyPrecedesSource) + { + pList->insert( srcpos, &i_rCopy ); + } + else + { + // for undo push_back does not work! must insert right after source + pList->insert( ++srcpos, &i_rCopy ); + } + m_pImpl->m_XmlIdReverseMap.insert(::std::make_pair(&i_rCopy, + ::std::make_pair(path, idref))); +} + +std::shared_ptr<MetadatableUndo> +XmlIdRegistryDocument::CreateUndo(Metadatable const& i_rObject) +{ + SAL_INFO("sfx", "CreateUndo: " << &i_rObject); + + return std::make_shared<MetadatableUndo>( + i_rObject.IsInContent() ); +} + +/* +i_rMerged is both a source and the target node of the merge +i_rOther is the other source, and will be deleted after the merge + +dimensions: none|latent|actual empty|nonempty +i_rMerged(1) i_rOther(2) result + *|empty *|empty => 1|2 (arbitrary) + *|empty *|nonempty => 2 + *|nonempty *|empty => 1 + none|nonempty none|nonempty => none + none|nonempty latent|nonempty => 2 +latent|nonempty none|nonempty => 1 +latent|nonempty latent|nonempty => 1|2 + *|nonempty actual|nonempty => 2 +actual|nonempty *|nonempty => 1 +actual|nonempty actual|nonempty => 1|2 +*/ +void +XmlIdRegistryDocument::JoinMetadatables( + Metadatable & i_rMerged, Metadatable const & i_rOther) +{ + SAL_INFO("sfx", "JoinMetadatables: " << &i_rMerged << " <- " << &i_rOther); + + bool mergedOwnsRef; + OUString path; + OUString idref; + if (m_pImpl->LookupXmlId(i_rMerged, path, idref)) + { + mergedOwnsRef = (m_pImpl->LookupElement(path, idref) == &i_rMerged); + } + else + { + OSL_FAIL("JoinMetadatables: no xmlid?"); + return; + } + if (!mergedOwnsRef) + { + i_rMerged.RemoveMetadataReference(); + i_rMerged.RegisterAsCopyOf(i_rOther, true); + return; + } + // other cases: merged has actual ref and is nonempty, + // other has latent/actual ref and is nonempty: other loses => nothing to do +} + + +// Clipboard XML ID Registry (_Impl) + +namespace { + +struct RMapEntry +{ + RMapEntry() {} + RMapEntry(OUString const& i_rStream, + OUString const& i_rXmlId, + std::shared_ptr<MetadatableClipboard> const& i_pLink + = std::shared_ptr<MetadatableClipboard>()) + : m_Stream(i_rStream), m_XmlId(i_rXmlId), m_xLink(i_pLink) + {} + OUString m_Stream; + OUString m_XmlId; + // this would have been an auto_ptr, if only that would have compiled... + std::shared_ptr<MetadatableClipboard> m_xLink; +}; + +} + +/// element -> (stream name, idref, source) +typedef std::unordered_map< const Metadatable*, + struct RMapEntry, + PtrHash<Metadatable> > + ClipboardXmlIdReverseMap_t; + +/// Idref -> (content.xml element, styles.xml element) +typedef std::unordered_map< OUString, + ::std::pair< Metadatable*, Metadatable* > > + ClipboardXmlIdMap_t; + +struct XmlIdRegistryClipboard::XmlIdRegistry_Impl +{ + XmlIdRegistry_Impl() {} + + bool TryInsertMetadatable(Metadatable& i_xObject, + std::u16string_view i_rStream, const OUString & i_rIdref); + + bool LookupXmlId(const Metadatable& i_xObject, + OUString & o_rStream, OUString & o_rIdref, + MetadatableClipboard const* &o_rpLink) const; + + Metadatable* LookupElement(std::u16string_view i_rStreamName, + const OUString & i_rIdref) const; + + Metadatable* const* LookupEntry(std::u16string_view i_rStreamName, + const OUString & i_rIdref) const; + + ClipboardXmlIdMap_t m_XmlIdMap; + ClipboardXmlIdReverseMap_t m_XmlIdReverseMap; +}; + + +static void +rmIter(ClipboardXmlIdMap_t & i_rXmlIdMap, + ClipboardXmlIdMap_t::iterator const& i_rIter, + std::u16string_view i_rStream, Metadatable const& i_rObject) +{ + if (i_rIter == i_rXmlIdMap.end()) + return; + + Metadatable *& rMeta = isContentFile(i_rStream) + ? i_rIter->second.first : i_rIter->second.second; + if (rMeta == &i_rObject) + { + rMeta = nullptr; + } + if (!i_rIter->second.first && !i_rIter->second.second) + { + i_rXmlIdMap.erase(i_rIter); + } +} + + +Metadatable* const* +XmlIdRegistryClipboard::XmlIdRegistry_Impl::LookupEntry( + std::u16string_view i_rStreamName, + const OUString & i_rIdref) const +{ + if (!isValidXmlId(i_rStreamName, i_rIdref)) + { + throw lang::IllegalArgumentException("illegal XmlId", nullptr, 0); + } + + const ClipboardXmlIdMap_t::const_iterator iter( m_XmlIdMap.find(i_rIdref) ); + if (iter != m_XmlIdMap.end()) + { + OSL_ENSURE(iter->second.first || iter->second.second, + "null entry in m_XmlIdMap"); + return (isContentFile(i_rStreamName)) + ? &iter->second.first + : &iter->second.second; + } + else + { + return nullptr; + } +} + +Metadatable* +XmlIdRegistryClipboard::XmlIdRegistry_Impl::LookupElement( + std::u16string_view i_rStreamName, + const OUString & i_rIdref) const +{ + Metadatable * const * ppEntry = LookupEntry(i_rStreamName, i_rIdref); + return ppEntry ? *ppEntry : nullptr; +} + +bool +XmlIdRegistryClipboard::XmlIdRegistry_Impl::LookupXmlId( + const Metadatable& i_rObject, + OUString & o_rStream, OUString & o_rIdref, + MetadatableClipboard const* &o_rpLink) const +{ + const ClipboardXmlIdReverseMap_t::const_iterator iter( + m_XmlIdReverseMap.find(&i_rObject) ); + if (iter != m_XmlIdReverseMap.end()) + { + OSL_ENSURE(!iter->second.m_Stream.isEmpty(), + "null stream in m_XmlIdReverseMap"); + OSL_ENSURE(!iter->second.m_XmlId.isEmpty(), + "null id in m_XmlIdReverseMap"); + o_rStream = iter->second.m_Stream; + o_rIdref = iter->second.m_XmlId; + o_rpLink = iter->second.m_xLink.get(); + return true; + } + else + { + return false; + } +} + +bool +XmlIdRegistryClipboard::XmlIdRegistry_Impl::TryInsertMetadatable( + Metadatable & i_rObject, + std::u16string_view i_rStreamName, const OUString & i_rIdref) +{ + bool bContent( isContentFile(i_rStreamName) ); + OSL_ENSURE(isContentFile(i_rStreamName) || isStylesFile(i_rStreamName), + "invalid stream"); + + Metadatable ** ppEntry = const_cast<Metadatable**>(LookupEntry(i_rStreamName, i_rIdref)); + if (ppEntry) + { + if (*ppEntry) + { + return false; + } + else + { + *ppEntry = &i_rObject; + return true; + } + } + else + { + m_XmlIdMap.insert(::std::make_pair(i_rIdref, bContent + ? ::std::make_pair( &i_rObject, static_cast<Metadatable*>(nullptr) ) + : ::std::make_pair( static_cast<Metadatable*>(nullptr), &i_rObject ))); + return true; + } +} + + +// Clipboard XML ID Registry + + +XmlIdRegistryClipboard::XmlIdRegistryClipboard() + : m_pImpl( new XmlIdRegistry_Impl ) +{ +} + +bool +XmlIdRegistryClipboard::LookupXmlId( + const Metadatable& i_rObject, + OUString & o_rStream, OUString & o_rIdref) const +{ + const MetadatableClipboard * pLink; + return m_pImpl->LookupXmlId(i_rObject, o_rStream, o_rIdref, pLink); +} + +Metadatable* +XmlIdRegistryClipboard::LookupElement( + const OUString & i_rStreamName, + const OUString & i_rIdref) const +{ + return m_pImpl->LookupElement(i_rStreamName, i_rIdref); +} + +bool +XmlIdRegistryClipboard::TryRegisterMetadatable(Metadatable & i_rObject, + OUString const& i_rStreamName, OUString const& i_rIdref) +{ + SAL_INFO("sfx", "TryRegisterMetadatable: " << &i_rObject << " (" << i_rStreamName << "#" << i_rIdref <<")"); + + OSL_ENSURE(!dynamic_cast<MetadatableUndo*>(&i_rObject), + "TryRegisterMetadatable called for MetadatableUndo?"); + OSL_ENSURE(!dynamic_cast<MetadatableClipboard*>(&i_rObject), + "TryRegisterMetadatable called for MetadatableClipboard?"); + + if (!isValidXmlId(i_rStreamName, i_rIdref)) + { + throw lang::IllegalArgumentException("illegal XmlId", nullptr, 0); + } + if (i_rObject.IsInContent() + ? !isContentFile(i_rStreamName) + : !isStylesFile(i_rStreamName)) + { + throw lang::IllegalArgumentException("illegal XmlId: wrong stream", nullptr, 0); + } + + OUString old_path; + OUString old_idref; + const MetadatableClipboard * pLink; + m_pImpl->LookupXmlId(i_rObject, old_path, old_idref, pLink); + if (old_path == i_rStreamName && old_idref == i_rIdref) + { + return (m_pImpl->LookupElement(old_path, old_idref) == &i_rObject); + } + ClipboardXmlIdMap_t::iterator old_id( m_pImpl->m_XmlIdMap.end() ); + if (!old_idref.isEmpty()) + { + old_id = m_pImpl->m_XmlIdMap.find(old_idref); + OSL_ENSURE(old_id != m_pImpl->m_XmlIdMap.end(), "old id not found"); + } + if (m_pImpl->TryInsertMetadatable(i_rObject, i_rStreamName, i_rIdref)) + { + rmIter(m_pImpl->m_XmlIdMap, old_id, old_path, i_rObject); + m_pImpl->m_XmlIdReverseMap[&i_rObject] = + RMapEntry(i_rStreamName, i_rIdref); + return true; + } + else + { + return false; + } +} + +void +XmlIdRegistryClipboard::RegisterMetadatableAndCreateID(Metadatable & i_rObject) +{ + SAL_INFO("sfx", "RegisterMetadatableAndCreateID: " << &i_rObject); + + OSL_ENSURE(!dynamic_cast<MetadatableUndo*>(&i_rObject), + "RegisterMetadatableAndCreateID called for MetadatableUndo?"); + OSL_ENSURE(!dynamic_cast<MetadatableClipboard*>(&i_rObject), + "RegisterMetadatableAndCreateID called for MetadatableClipboard?"); + + bool isInContent( i_rObject.IsInContent() ); + OUString stream( + isInContent ? OUString(s_content) : OUString(s_styles) ); + + OUString old_path; + OUString old_idref; + LookupXmlId(i_rObject, old_path, old_idref); + if (!old_idref.isEmpty() && + (m_pImpl->LookupElement(old_path, old_idref) == &i_rObject)) + { + return; + } + + // create id + const OUString id( create_id(m_pImpl->m_XmlIdMap) ); + OSL_ENSURE(m_pImpl->m_XmlIdMap.find(id) == m_pImpl->m_XmlIdMap.end(), + "created id is in use"); + m_pImpl->m_XmlIdMap.insert(::std::make_pair(id, isInContent + ? ::std::make_pair( &i_rObject, static_cast<Metadatable*>(nullptr) ) + : ::std::make_pair( static_cast<Metadatable*>(nullptr), &i_rObject ))); + // N.B.: if i_rObject had a latent XmlId, then we implicitly delete the + // MetadatableClipboard and thus the latent XmlId here + m_pImpl->m_XmlIdReverseMap[&i_rObject] = RMapEntry(stream, id); +} + +void XmlIdRegistryClipboard::UnregisterMetadatable(const Metadatable& i_rObject) +{ + SAL_INFO("sfx", "UnregisterMetadatable: " << &i_rObject); + + OUString path; + OUString idref; + const MetadatableClipboard * pLink; + if (!m_pImpl->LookupXmlId(i_rObject, path, idref, pLink)) + { + OSL_FAIL("unregister: no xml id?"); + return; + } + const ClipboardXmlIdMap_t::iterator iter( m_pImpl->m_XmlIdMap.find(idref) ); + if (iter != m_pImpl->m_XmlIdMap.end()) + { + rmIter(m_pImpl->m_XmlIdMap, iter, path, i_rObject); + } +} + + +void XmlIdRegistryClipboard::RemoveXmlIdForElement(const Metadatable& i_rObject) +{ + SAL_INFO("sfx", "RemoveXmlIdForElement: " << &i_rObject); + + ClipboardXmlIdReverseMap_t::iterator iter( + m_pImpl->m_XmlIdReverseMap.find(&i_rObject) ); + if (iter != m_pImpl->m_XmlIdReverseMap.end()) + { + OSL_ENSURE(!iter->second.m_XmlId.isEmpty(), + "null id in m_XmlIdReverseMap"); + m_pImpl->m_XmlIdReverseMap.erase(iter); + } +} + + +std::shared_ptr<MetadatableClipboard> +XmlIdRegistryClipboard::CreateClipboard(const bool i_isInContent) +{ + SAL_INFO("sfx", "CreateClipboard:"); + + return std::make_shared<MetadatableClipboard>( + i_isInContent ); +} + +MetadatableClipboard & +XmlIdRegistryClipboard::RegisterCopyClipboard(Metadatable & i_rCopy, + beans::StringPair const & i_rReference, + const bool i_isLatent) +{ + SAL_INFO("sfx", "RegisterCopyClipboard: " << &i_rCopy + << " -> (" << i_rReference.First << "#" << i_rReference.Second << ") (" << i_isLatent << ")"); + + // N.B.: when copying to the clipboard, the selection is always inserted + // into the body, even if the source is a header/footer! + // so we do not check whether the stream is right in this function + + if (!isValidXmlId(i_rReference.First, i_rReference.Second)) + { + throw lang::IllegalArgumentException("illegal XmlId", nullptr, 0); + } + + if (!i_isLatent) + { + // this should succeed assuming clipboard has a single source document + const bool success( m_pImpl->TryInsertMetadatable(i_rCopy, + i_rReference.First, i_rReference.Second) ); + OSL_ENSURE(success, "RegisterCopyClipboard: TryInsert failed?"); + } + const std::shared_ptr<MetadatableClipboard> xLink( + CreateClipboard( isContentFile(i_rReference.First)) ); + m_pImpl->m_XmlIdReverseMap.insert(::std::make_pair(&i_rCopy, + RMapEntry(i_rReference.First, i_rReference.Second, xLink))); + return *xLink; +} + +MetadatableClipboard const* +XmlIdRegistryClipboard::SourceLink(Metadatable const& i_rObject) +{ + OUString path; + OUString idref; + const MetadatableClipboard * pLink( nullptr ); + m_pImpl->LookupXmlId(i_rObject, path, idref, pLink); + return pLink; +} + + +// Metadatable mixin + + +Metadatable::~Metadatable() +{ + RemoveMetadataReference(); +} + +void Metadatable::RemoveMetadataReference() +{ + try + { + if (m_pReg) + { + m_pReg->UnregisterMetadatable( *this ); + m_pReg->RemoveXmlIdForElement( *this ); + m_pReg = nullptr; + } + } + catch (const uno::Exception &) + { + TOOLS_WARN_EXCEPTION( "sfx.doc", "Metadatable::RemoveMetadataReference"); + } +} + +// css::rdf::XMetadatable: +beans::StringPair +Metadatable::GetMetadataReference() const +{ + if (m_pReg) + { + return m_pReg->GetXmlIdForElement(*this); + } + return beans::StringPair(); +} + +void Metadatable::SetMetadataReference( const css::beans::StringPair & i_rReference) +{ + if (i_rReference.Second.isEmpty()) + { + RemoveMetadataReference(); + } + else + { + OUString streamName( i_rReference.First ); + if (streamName.isEmpty()) + { + // handle empty stream name as auto-detect. + // necessary for importing flat file format. + streamName = IsInContent() ? OUString(s_content) : OUString(s_styles); + } + XmlIdRegistry & rReg( dynamic_cast<XmlIdRegistry&>( GetRegistry() ) ); + if (!rReg.TryRegisterMetadatable(*this, streamName, i_rReference.Second)) + { + throw lang::IllegalArgumentException( + "Metadatable::SetMetadataReference: argument is invalid", /*this*/nullptr, 0); + } + + m_pReg = &rReg; + } +} + +void Metadatable::EnsureMetadataReference() +{ + XmlIdRegistry& rReg( + m_pReg ? *m_pReg : dynamic_cast<XmlIdRegistry&>( GetRegistry() ) ); + rReg.RegisterMetadatableAndCreateID( *this ); + m_pReg = &rReg; +} + +static const ::sfx2::IXmlIdRegistry& GetRegistryConst(Metadatable const& i_rObject) +{ + return const_cast< Metadatable& >( i_rObject ).GetRegistry(); +} + +void +Metadatable::RegisterAsCopyOf(Metadatable const & i_rSource, + const bool i_bCopyPrecedesSource) +{ + OSL_ENSURE(typeid(*this) == typeid(i_rSource) + || typeid(i_rSource) == typeid(MetadatableUndo) + || typeid(*this) == typeid(MetadatableUndo) + || typeid(i_rSource) == typeid(MetadatableClipboard) + || typeid(*this) == typeid(MetadatableClipboard), + "RegisterAsCopyOf element with different class?"); + OSL_ENSURE(!m_pReg, "RegisterAsCopyOf called on element with XmlId?"); + + if (m_pReg) + { + RemoveMetadataReference(); + } + + try + { + if (i_rSource.m_pReg) + { + XmlIdRegistry & rReg( + dynamic_cast<XmlIdRegistry&>( GetRegistry() ) ); + if (i_rSource.m_pReg == &rReg) + { + OSL_ENSURE(!IsInClipboard(), + "RegisterAsCopy: both in clipboard?"); + if (!IsInClipboard()) + { + XmlIdRegistryDocument & rRegDoc( + dynamic_cast<XmlIdRegistryDocument&>( rReg ) ); + rRegDoc.RegisterCopy(i_rSource, *this, + i_bCopyPrecedesSource); + m_pReg = &rRegDoc; + } + return; + } + // source is in different document + XmlIdRegistryDocument * pRegDoc( + dynamic_cast<XmlIdRegistryDocument *>(&rReg) ); + XmlIdRegistryClipboard * pRegClp( + dynamic_cast<XmlIdRegistryClipboard*>(&rReg) ); + + if (pRegClp) + { + beans::StringPair SourceRef( + i_rSource.m_pReg->GetXmlIdForElement(i_rSource) ); + bool isLatent( SourceRef.Second.isEmpty() ); + XmlIdRegistryDocument * pSourceRegDoc( + dynamic_cast<XmlIdRegistryDocument*>(i_rSource.m_pReg) ); + OSL_ENSURE(pSourceRegDoc, "RegisterAsCopyOf: 2 clipboards?"); + if (!pSourceRegDoc) return; + // this is a copy _to_ the clipboard + if (isLatent) + { + pSourceRegDoc->LookupXmlId(i_rSource, + SourceRef.First, SourceRef.Second); + } + Metadatable & rLink( + pRegClp->RegisterCopyClipboard(*this, SourceRef, isLatent)); + m_pReg = pRegClp; + // register as copy in the non-clipboard registry + pSourceRegDoc->RegisterCopy(i_rSource, rLink, + false); // i_bCopyPrecedesSource); + rLink.m_pReg = pSourceRegDoc; + } + else if (pRegDoc) + { + XmlIdRegistryClipboard * pSourceRegClp( + dynamic_cast<XmlIdRegistryClipboard*>(i_rSource.m_pReg) ); + OSL_ENSURE(pSourceRegClp, + "RegisterAsCopyOf: 2 non-clipboards?"); + if (!pSourceRegClp) return; + const MetadatableClipboard * pLink( + pSourceRegClp->SourceLink(i_rSource) ); + // may happen if src got its id via UNO call + if (!pLink) return; + // only register copy if clipboard content is from this SwDoc! + if (&GetRegistryConst(*pLink) == pRegDoc) + { + // this is a copy _from_ the clipboard; check if the + // element is still in the same stream + // N.B.: we check the stream of pLink, not of i_rSource! + bool srcInContent( pLink->IsInContent() ); + bool tgtInContent( IsInContent() ); + if (srcInContent == tgtInContent) + { + pRegDoc->RegisterCopy(*pLink, *this, + true); // i_bCopyPrecedesSource); + m_pReg = pRegDoc; + } + // otherwise: stream change! do not register! + } + } + else + { + OSL_FAIL("neither RegDoc nor RegClp cannot happen"); + } + } + } + catch (const uno::Exception &) + { + TOOLS_WARN_EXCEPTION( "sfx.doc", "Metadatable::RegisterAsCopyOf"); + } +} + +std::shared_ptr<MetadatableUndo> Metadatable::CreateUndo() const +{ + OSL_ENSURE(!IsInUndo(), "CreateUndo called for object in undo?"); + OSL_ENSURE(!IsInClipboard(), "CreateUndo called for object in clipboard?"); + try + { + if (!IsInClipboard() && !IsInUndo() && m_pReg) + { + XmlIdRegistryDocument * pRegDoc( + dynamic_cast<XmlIdRegistryDocument*>( m_pReg ) ); + assert(pRegDoc); + std::shared_ptr<MetadatableUndo> xUndo( + sfx2::XmlIdRegistryDocument::CreateUndo(*this) ); + pRegDoc->RegisterCopy(*this, *xUndo, false); + xUndo->m_pReg = pRegDoc; + return xUndo; + } + } + catch (const uno::Exception &) + { + TOOLS_WARN_EXCEPTION( "sfx.doc", "Metadatable::CreateUndo"); + } + return std::shared_ptr<MetadatableUndo>(); +} + +std::shared_ptr<MetadatableUndo> Metadatable::CreateUndoForDelete() +{ + std::shared_ptr<MetadatableUndo> const xUndo( CreateUndo() ); + RemoveMetadataReference(); + return xUndo; +} + +void Metadatable::RestoreMetadata( + std::shared_ptr<MetadatableUndo> const& i_pUndo) +{ + OSL_ENSURE(!IsInUndo(), "RestoreMetadata called for object in undo?"); + OSL_ENSURE(!IsInClipboard(), + "RestoreMetadata called for object in clipboard?"); + if (IsInClipboard() || IsInUndo()) return; + RemoveMetadataReference(); + if (i_pUndo) + { + RegisterAsCopyOf(*i_pUndo, true); + } +} + +void +Metadatable::JoinMetadatable(Metadatable const & i_rOther, + const bool i_isMergedEmpty, const bool i_isOtherEmpty) +{ + OSL_ENSURE(!IsInUndo(), "JoinMetadatables called for object in undo?"); + OSL_ENSURE(!IsInClipboard(), + "JoinMetadatables called for object in clipboard?"); + if (IsInClipboard() || IsInUndo()) return; + + if (i_isOtherEmpty && !i_isMergedEmpty) + { + // other is empty, thus loses => nothing to do + return; + } + if (i_isMergedEmpty && !i_isOtherEmpty) + { + RemoveMetadataReference(); + RegisterAsCopyOf(i_rOther, true); + return; + } + + if (!i_rOther.m_pReg) + { + // other doesn't have xmlid, thus loses => nothing to do + return; + } + if (!m_pReg) + { + RegisterAsCopyOf(i_rOther, true); + // assumption: i_rOther will be deleted, so don't unregister it here + return; + } + try + { + XmlIdRegistryDocument * pRegDoc( + dynamic_cast<XmlIdRegistryDocument*>( m_pReg ) ); + OSL_ENSURE(pRegDoc, "JoinMetadatable: no pRegDoc?"); + if (pRegDoc) + { + pRegDoc->JoinMetadatables(*this, i_rOther); + } + } + catch (const uno::Exception &) + { + TOOLS_WARN_EXCEPTION( "sfx.doc", "Metadatable::JoinMetadatable"); + } +} + + +// XMetadatable mixin + +// css::rdf::XNode: +OUString SAL_CALL MetadatableMixin::getStringValue() +{ + return getNamespace() + getLocalName(); +} + +// css::rdf::XURI: +OUString SAL_CALL MetadatableMixin::getLocalName() +{ + SolarMutexGuard aGuard; + beans::StringPair mdref( getMetadataReference() ); + if (mdref.Second.isEmpty()) + { + ensureMetadataReference(); // N.B.: side effect! + mdref = getMetadataReference(); + } + return mdref.First + "#" + mdref.Second; +} + +OUString SAL_CALL MetadatableMixin::getNamespace() +{ + SolarMutexGuard aGuard; + const uno::Reference< frame::XModel > xModel( GetModel() ); + const uno::Reference< rdf::XURI > xDMA( xModel, uno::UNO_QUERY_THROW ); + return xDMA->getStringValue(); +} + +// css::rdf::XMetadatable: +beans::StringPair SAL_CALL +MetadatableMixin::getMetadataReference() +{ + SolarMutexGuard aGuard; + + Metadatable *const pObject( GetCoreObject() ); + if (!pObject) + { + throw uno::RuntimeException( + "MetadatableMixin: cannot get core object; not inserted?", + *this); + } + return pObject->GetMetadataReference(); +} + +void SAL_CALL +MetadatableMixin::setMetadataReference( + const beans::StringPair & i_rReference) +{ + SolarMutexGuard aGuard; + + Metadatable *const pObject( GetCoreObject() ); + if (!pObject) + { + throw uno::RuntimeException( + "MetadatableMixin: cannot get core object; not inserted?", + *this); + } + return pObject->SetMetadataReference(i_rReference); +} + +void SAL_CALL MetadatableMixin::ensureMetadataReference() +{ + SolarMutexGuard aGuard; + + Metadatable *const pObject( GetCoreObject() ); + if (!pObject) + { + throw uno::RuntimeException( + "MetadatableMixin: cannot get core object; not inserted?", + *this); + } + return pObject->EnsureMetadataReference(); +} + +} // namespace sfx2 + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/QuerySaveDocument.cxx b/sfx2/source/doc/QuerySaveDocument.cxx new file mode 100644 index 000000000..4abc612dc --- /dev/null +++ b/sfx2/source/doc/QuerySaveDocument.cxx @@ -0,0 +1,39 @@ +/* -*- 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 <sfx2/QuerySaveDocument.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> + +short ExecuteQuerySaveDocument(weld::Widget* _pParent, std::u16string_view _rTitle) +{ + if (Application::IsHeadlessModeEnabled() || getenv("SAL_NO_QUERYSAVE")) + { + // don't block Desktop::terminate() if there's no user to ask + return RET_NO; + } + + std::unique_ptr<weld::Builder> xBuilder( + Application::CreateBuilder(_pParent, "sfx/ui/querysavedialog.ui")); + std::unique_ptr<weld::MessageDialog> xQBox(xBuilder->weld_message_dialog("QuerySaveDialog")); + xQBox->set_primary_text(xQBox->get_primary_text().replaceFirst("$(DOC)", _rTitle)); + return xQBox->run(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/SfxDocumentMetaData.cxx b/sfx2/source/doc/SfxDocumentMetaData.cxx new file mode 100644 index 000000000..6392bd4aa --- /dev/null +++ b/sfx2/source/doc/SfxDocumentMetaData.cxx @@ -0,0 +1,2214 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <sal/config.h> +#include <sal/log.hxx> + +#include <cppuhelper/compbase.hxx> +#include <cppuhelper/exc_hlp.hxx> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/document/XDocumentProperties.hpp> +#include <com/sun/star/lang/XInitialization.hpp> +#include <com/sun/star/util/XCloneable.hpp> +#include <com/sun/star/util/XModifiable.hpp> +#include <com/sun/star/xml/sax/SAXException.hpp> +#include <com/sun/star/xml/sax/XSAXSerializable.hpp> + +#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp> +#include <com/sun/star/lang/EventObject.hpp> +#include <com/sun/star/beans/IllegalTypeException.hpp> +#include <com/sun/star/beans/PropertyExistException.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/beans/XPropertySetInfo.hpp> +#include <com/sun/star/beans/PropertyAttribute.hpp> +#include <com/sun/star/task/ErrorCodeIOException.hpp> +#include <com/sun/star/embed/XStorage.hpp> +#include <com/sun/star/embed/XTransactedObject.hpp> +#include <com/sun/star/embed/ElementModes.hpp> +#include <com/sun/star/io/WrongFormatException.hpp> +#include <com/sun/star/io/XStream.hpp> +#include <com/sun/star/document/XImporter.hpp> +#include <com/sun/star/document/XExporter.hpp> +#include <com/sun/star/document/XFilter.hpp> +#include <com/sun/star/xml/sax/Writer.hpp> +#include <com/sun/star/xml/sax/Parser.hpp> +#include <com/sun/star/xml/sax/XFastParser.hpp> +#include <com/sun/star/xml/dom/DOMException.hpp> +#include <com/sun/star/xml/dom/XDocument.hpp> +#include <com/sun/star/xml/dom/XElement.hpp> +#include <com/sun/star/xml/dom/DocumentBuilder.hpp> +#include <com/sun/star/xml/dom/NodeType.hpp> +#include <com/sun/star/xml/xpath/XPathAPI.hpp> +#include <com/sun/star/util/Date.hpp> +#include <com/sun/star/util/Time.hpp> +#include <com/sun/star/util/DateWithTimezone.hpp> +#include <com/sun/star/util/DateTimeWithTimezone.hpp> +#include <com/sun/star/util/Duration.hpp> + +#include <rtl/ustrbuf.hxx> +#include <tools/datetime.hxx> +#include <tools/diagnose_ex.h> +#include <osl/mutex.hxx> +#include <comphelper/fileformat.h> +#include <cppuhelper/basemutex.hxx> +#include <comphelper/interfacecontainer3.hxx> +#include <comphelper/storagehelper.hxx> +#include <unotools/mediadescriptor.hxx> +#include <comphelper/sequence.hxx> +#include <sot/storage.hxx> +#include <sfx2/docfile.hxx> +#include <sax/tools/converter.hxx> +#include <i18nlangtag/languagetag.hxx> +#include <optional> + +#include <algorithm> +#include <utility> +#include <vector> +#include <map> +#include <cstring> +#include <limits> + + +#include <cppuhelper/implbase.hxx> +#include <cppuhelper/supportsservice.hxx> +#include <com/sun/star/document/XCompatWriterDocProperties.hpp> +#include <com/sun/star/beans/PropertyBag.hpp> + +/** + * This file contains the implementation of the service + * com.sun.star.document.DocumentProperties. + * This service enables access to the meta-data stored in documents. + * Currently, this service only handles documents in ODF format. + * + * The implementation uses an XML DOM to store the properties. + * This approach was taken because it allows for preserving arbitrary XML data + * in loaded documents, which will be stored unmodified when saving the + * document again. + * + * Upon access, some properties are directly read from and updated in the DOM. + * Exception: it seems impossible to get notified upon addition of a property + * to a com.sun.star.beans.PropertyBag, which is used for storing user-defined + * properties; because of this, user-defined properties are updated in the + * XML DOM only when storing the document. + * Exception 2: when setting certain properties which correspond to attributes + * in the XML DOM, we want to remove the corresponding XML element. Detecting + * this condition can get messy, so we store all such properties as members, + * and update the DOM tree only when storing the document (in + * <method>updateUserDefinedAndAttributes</method>). + * + */ + +/// anonymous implementation namespace +namespace { + +/// a list of attribute-lists, where attribute means name and content +typedef std::vector<std::vector<std::pair<OUString, OUString> > > + AttrVector; + +typedef ::cppu::WeakComponentImplHelper< + css::lang::XServiceInfo, + css::document::XDocumentProperties, + css::lang::XInitialization, + css::util::XCloneable, + css::util::XModifiable, + css::xml::sax::XSAXSerializable> + SfxDocumentMetaData_Base; + +class SfxDocumentMetaData: + private ::cppu::BaseMutex, + public SfxDocumentMetaData_Base +{ +public: + explicit SfxDocumentMetaData( + css::uno::Reference< css::uno::XComponentContext > const & context); + SfxDocumentMetaData(const SfxDocumentMetaData&) = delete; + SfxDocumentMetaData& operator=(const SfxDocumentMetaData&) = delete; + + // css::lang::XServiceInfo: + virtual OUString SAL_CALL getImplementationName() override; + virtual sal_Bool SAL_CALL supportsService( + const OUString & ServiceName) override; + virtual css::uno::Sequence< OUString > SAL_CALL + getSupportedServiceNames() override; + + // css::lang::XComponent: + virtual void SAL_CALL dispose() override; + + // css::document::XDocumentProperties: + virtual OUString SAL_CALL getAuthor() override; + virtual void SAL_CALL setAuthor(const OUString & the_value) override; + virtual OUString SAL_CALL getGenerator() override; + virtual void SAL_CALL setGenerator(const OUString & the_value) override; + virtual css::util::DateTime SAL_CALL getCreationDate() override; + virtual void SAL_CALL setCreationDate(const css::util::DateTime & the_value) override; + virtual OUString SAL_CALL getTitle() override; + virtual void SAL_CALL setTitle(const OUString & the_value) override; + virtual OUString SAL_CALL getSubject() override; + virtual void SAL_CALL setSubject(const OUString & the_value) override; + virtual OUString SAL_CALL getDescription() override; + virtual void SAL_CALL setDescription(const OUString & the_value) override; + virtual css::uno::Sequence< OUString > SAL_CALL getKeywords() override; + virtual void SAL_CALL setKeywords( + const css::uno::Sequence< OUString > & the_value) override; + virtual css::lang::Locale SAL_CALL getLanguage() override; + virtual void SAL_CALL setLanguage(const css::lang::Locale & the_value) override; + virtual OUString SAL_CALL getModifiedBy() override; + virtual void SAL_CALL setModifiedBy(const OUString & the_value) override; + virtual css::util::DateTime SAL_CALL getModificationDate() override; + virtual void SAL_CALL setModificationDate( + const css::util::DateTime & the_value) override; + virtual OUString SAL_CALL getPrintedBy() override; + virtual void SAL_CALL setPrintedBy(const OUString & the_value) override; + virtual css::util::DateTime SAL_CALL getPrintDate() override; + virtual void SAL_CALL setPrintDate(const css::util::DateTime & the_value) override; + virtual OUString SAL_CALL getTemplateName() override; + virtual void SAL_CALL setTemplateName(const OUString & the_value) override; + virtual OUString SAL_CALL getTemplateURL() override; + virtual void SAL_CALL setTemplateURL(const OUString & the_value) override; + virtual css::util::DateTime SAL_CALL getTemplateDate() override; + virtual void SAL_CALL setTemplateDate(const css::util::DateTime & the_value) override; + virtual OUString SAL_CALL getAutoloadURL() override; + virtual void SAL_CALL setAutoloadURL(const OUString & the_value) override; + virtual ::sal_Int32 SAL_CALL getAutoloadSecs() override; + virtual void SAL_CALL setAutoloadSecs(::sal_Int32 the_value) override; + virtual OUString SAL_CALL getDefaultTarget() override; + virtual void SAL_CALL setDefaultTarget(const OUString & the_value) override; + virtual css::uno::Sequence< css::beans::NamedValue > SAL_CALL + getDocumentStatistics() override; + virtual void SAL_CALL setDocumentStatistics( + const css::uno::Sequence< css::beans::NamedValue > & the_value) override; + virtual ::sal_Int16 SAL_CALL getEditingCycles() override; + virtual void SAL_CALL setEditingCycles(::sal_Int16 the_value) override; + virtual ::sal_Int32 SAL_CALL getEditingDuration() override; + virtual void SAL_CALL setEditingDuration(::sal_Int32 the_value) override; + virtual void SAL_CALL resetUserData(const OUString & the_value) override; + virtual css::uno::Reference< css::beans::XPropertyContainer > SAL_CALL + getUserDefinedProperties() override; + virtual void SAL_CALL loadFromStorage( + const css::uno::Reference< css::embed::XStorage > & Storage, + const css::uno::Sequence< css::beans::PropertyValue > & Medium) override; + virtual void SAL_CALL loadFromMedium(const OUString & URL, + const css::uno::Sequence< css::beans::PropertyValue > & Medium) override; + virtual void SAL_CALL storeToStorage( + const css::uno::Reference< css::embed::XStorage > & Storage, + const css::uno::Sequence< css::beans::PropertyValue > & Medium) override; + virtual void SAL_CALL storeToMedium(const OUString & URL, + const css::uno::Sequence< css::beans::PropertyValue > & Medium) override; + + // css::lang::XInitialization: + virtual void SAL_CALL initialize( + const css::uno::Sequence< css::uno::Any > & aArguments) override; + + // css::util::XCloneable: + virtual css::uno::Reference<css::util::XCloneable> SAL_CALL createClone() override; + + // css::util::XModifiable: + virtual sal_Bool SAL_CALL isModified( ) override; + virtual void SAL_CALL setModified( sal_Bool bModified ) override; + + // css::util::XModifyBroadcaster: + virtual void SAL_CALL addModifyListener( + const css::uno::Reference< css::util::XModifyListener > & xListener) override; + virtual void SAL_CALL removeModifyListener( + const css::uno::Reference< css::util::XModifyListener > & xListener) override; + + // css::xml::sax::XSAXSerializable + virtual void SAL_CALL serialize( + const css::uno::Reference<css::xml::sax::XDocumentHandler>& i_xHandler, + const css::uno::Sequence< css::beans::StringPair >& i_rNamespaces) override; + +protected: + virtual ~SfxDocumentMetaData() override {} + virtual rtl::Reference<SfxDocumentMetaData> createMe( css::uno::Reference< css::uno::XComponentContext > const & context ) { return new SfxDocumentMetaData( context ); }; + const css::uno::Reference< css::uno::XComponentContext > m_xContext; + + /// for notification + ::comphelper::OInterfaceContainerHelper3<css::util::XModifyListener> m_NotifyListeners; + /// flag: false means not initialized yet, or disposed + bool m_isInitialized; + /// flag + bool m_isModified; + /// meta-data DOM tree + css::uno::Reference< css::xml::dom::XDocument > m_xDoc; + /// meta-data super node in the meta-data DOM tree + css::uno::Reference< css::xml::dom::XNode> m_xParent; + /// standard meta data (single occurrence) + std::map< OUString, css::uno::Reference<css::xml::dom::XNode> > + m_meta; + /// standard meta data (multiple occurrences) + std::map< OUString, + std::vector<css::uno::Reference<css::xml::dom::XNode> > > m_metaList; + /// user-defined meta data (meta:user-defined) @ATTENTION may be null! + css::uno::Reference<css::beans::XPropertyContainer> m_xUserDefined; + // now for some meta-data attributes; these are not updated directly in the + // DOM because updates (detecting "empty" elements) would be quite messy + OUString m_TemplateName; + OUString m_TemplateURL; + css::util::DateTime m_TemplateDate; + OUString m_AutoloadURL; + sal_Int32 m_AutoloadSecs; + OUString m_DefaultTarget; + + /// check if we are initialized properly + void checkInit() const; + /// initialize state from given DOM tree + void init(const css::uno::Reference<css::xml::dom::XDocument>& i_xDom); + /// update element in DOM tree + void updateElement(const OUString & i_name, + std::vector<std::pair<OUString, OUString> >* i_pAttrs = nullptr); + /// update user-defined meta data and attributes in DOM tree + void updateUserDefinedAndAttributes(); + /// create empty DOM tree (XDocument) + css::uno::Reference<css::xml::dom::XDocument> createDOM() const; + /// extract base URL (necessary for converting relative links) + css::uno::Reference<css::beans::XPropertySet> getURLProperties( + const css::uno::Sequence<css::beans::PropertyValue> & i_rMedium) const; + /// get text of standard meta data element + OUString getMetaText(const char* i_name) const; + /// set text of standard meta data element iff not equal to existing text + bool setMetaText(const OUString& i_name, + const OUString & i_rValue); + /// set text of standard meta data element iff not equal to existing text + void setMetaTextAndNotify(const OUString& i_name, + const OUString & i_rValue); + /// get text of standard meta data element's attribute + OUString getMetaAttr(const OUString& i_name, + const OUString& i_attr) const; + /// get text of a list of standard meta data elements (multiple occ.) + css::uno::Sequence< OUString > getMetaList( + const char* i_name) const; + /// set text of a list of standard meta data elements (multiple occ.) + bool setMetaList(const OUString& i_name, + const css::uno::Sequence< OUString > & i_rValue, + AttrVector const*); + void createUserDefined(); +}; + +typedef ::cppu::ImplInheritanceHelper< SfxDocumentMetaData, css::document::XCompatWriterDocProperties > CompatWriterDocPropsImpl_BASE; + +class CompatWriterDocPropsImpl : public CompatWriterDocPropsImpl_BASE +{ + OUString msManager; + OUString msCategory; + OUString msCompany; +protected: + virtual rtl::Reference<SfxDocumentMetaData> createMe( css::uno::Reference< css::uno::XComponentContext > const & context ) override { return new CompatWriterDocPropsImpl( context ); }; +public: + explicit CompatWriterDocPropsImpl( css::uno::Reference< css::uno::XComponentContext > const & context) : CompatWriterDocPropsImpl_BASE( context ) {} + +// XCompatWriterDocPropsImpl + virtual OUString SAL_CALL getManager() override { return msManager; } + virtual void SAL_CALL setManager( const OUString& _manager ) override { msManager = _manager; } + virtual OUString SAL_CALL getCategory() override { return msCategory; } + virtual void SAL_CALL setCategory( const OUString& _category ) override { msCategory = _category; } + virtual OUString SAL_CALL getCompany() override { return msCompany; } + virtual void SAL_CALL setCompany( const OUString& _company ) override { msCompany = _company; } + +// XServiceInfo + virtual OUString SAL_CALL getImplementationName( ) override + { + return "CompatWriterDocPropsImpl"; + } + + virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override + { + return cppu::supportsService(this, ServiceName); + } + + virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames( ) override + { + css::uno::Sequence<OUString> aServiceNames { "com.sun.star.writer.DocumentProperties" }; + return aServiceNames; + } +}; + +constexpr OUStringLiteral sMetaPageCount = u"meta:page-count"; +constexpr OUStringLiteral sMetaTableCount = u"meta:table-count"; +constexpr OUStringLiteral sMetaDrawCount = u"meta:draw-count"; +constexpr OUStringLiteral sMetaImageCount = u"meta:image-count"; +constexpr OUStringLiteral sMetaObjectCount = u"meta:object-count"; +constexpr OUStringLiteral sMetaOleObjectCount = u"meta:ole-object-count"; +constexpr OUStringLiteral sMetaParagraphCount = u"meta:paragraph-count"; +constexpr OUStringLiteral sMetaWordCount = u"meta:word-count"; +constexpr OUStringLiteral sMetaCharacterCount = u"meta:character-count"; +constexpr OUStringLiteral sMetaRowCount = u"meta:row-count"; +constexpr OUStringLiteral sMetaFrameCount = u"meta:frame-count"; +constexpr OUStringLiteral sMetaSentenceCount = u"meta:sentence-count"; +constexpr OUStringLiteral sMetaSyllableCount = u"meta:syllable-count"; +constexpr OUStringLiteral sMetaNonWhitespaceCharacterCount = u"meta:non-whitespace-character-count"; +constexpr OUStringLiteral sMetaCellCount = u"meta:cell-count"; + +// NB: keep these two arrays in sync! +constexpr rtl::OUStringConstExpr s_stdStatAttrs[] = { + sMetaPageCount, + sMetaTableCount, + sMetaDrawCount, + sMetaImageCount, + sMetaObjectCount, + sMetaOleObjectCount, + sMetaParagraphCount, + sMetaWordCount, + sMetaCharacterCount, + sMetaRowCount, + sMetaFrameCount, + sMetaSentenceCount, + sMetaSyllableCount, + sMetaNonWhitespaceCharacterCount, + sMetaCellCount +}; + +// NB: keep these two arrays in sync! +const char* s_stdStats[] = { + "PageCount", + "TableCount", + "DrawCount", + "ImageCount", + "ObjectCount", + "OLEObjectCount", + "ParagraphCount", + "WordCount", + "CharacterCount", + "RowCount", + "FrameCount", + "SentenceCount", + "SyllableCount", + "NonWhitespaceCharacterCount", + "CellCount", + nullptr +}; + +const char* s_stdMeta[] = { + "meta:generator", // string + "dc:title", // string + "dc:description", // string + "dc:subject", // string + "meta:initial-creator", // string + "dc:creator", // string + "meta:printed-by", // string + "meta:creation-date", // dateTime + "dc:date", // dateTime + "meta:print-date", // dateTime + "meta:template", // XLink + "meta:auto-reload", + "meta:hyperlink-behaviour", + "dc:language", // language + "meta:editing-cycles", // nonNegativeInteger + "meta:editing-duration", // duration + "meta:document-statistic", // ... // note: statistic is singular, no s! + nullptr +}; + +constexpr OUStringLiteral sMetaKeyword = u"meta:keyword"; +constexpr OUStringLiteral sMetaUserDefined = u"meta:user-defined"; +constexpr rtl::OUStringConstExpr s_stdMetaList[] { + sMetaKeyword, // string* + sMetaUserDefined, // ...* +}; + +constexpr OUStringLiteral s_nsXLink = u"http://www.w3.org/1999/xlink"; +constexpr OUStringLiteral s_nsDC = u"http://purl.org/dc/elements/1.1/"; +constexpr OUStringLiteral s_nsODF = u"urn:oasis:names:tc:opendocument:xmlns:office:1.0"; +constexpr OUStringLiteral s_nsODFMeta = u"urn:oasis:names:tc:opendocument:xmlns:meta:1.0"; +// constexpr OUStringLiteral s_nsOOo = "http://openoffice.org/2004/office"; // not used (yet?) + +constexpr OUStringLiteral s_meta = u"meta.xml"; + +bool isValidDate(const css::util::Date & i_rDate) +{ + return i_rDate.Month > 0; +} + +bool isValidDateTime(const css::util::DateTime & i_rDateTime) +{ + return i_rDateTime.Month > 0; +} + +std::pair< OUString, OUString > +getQualifier(const OUString& nm) { + sal_Int32 ix = nm.indexOf(u':'); + if (ix == -1) { + return std::make_pair(OUString(), nm); + } else { + return std::make_pair(nm.copy(0,ix), nm.copy(ix+1)); + } +} + +// get namespace for standard qualified names +// NB: only call this with statically known strings! +OUString getNameSpace(const OUString& i_qname) noexcept +{ + OUString ns; + OUString n = getQualifier(i_qname).first; + if ( n == "xlink" ) ns = s_nsXLink; + if ( n == "dc" ) ns = s_nsDC; + if ( n == "office" ) ns = s_nsODF; + if ( n == "meta" ) ns = s_nsODFMeta; + assert(!ns.isEmpty()); + return ns; +} + +bool +textToDateOrDateTime(css::util::Date & io_rd, css::util::DateTime & io_rdt, + bool & o_rIsDateTime, std::optional<sal_Int16> & o_rTimeZone, + const OUString& i_text) noexcept +{ + if (::sax::Converter::parseDateOrDateTime( + &io_rd, io_rdt, o_rIsDateTime, &o_rTimeZone, i_text)) { + return true; + } else { + SAL_WARN_IF(!i_text.isEmpty(), "sfx.doc", "Invalid date: " << i_text); + return false; + } +} + +// convert string to date/time +bool +textToDateTime(css::util::DateTime & io_rdt, const OUString& i_text) noexcept +{ + if (::sax::Converter::parseDateTime(io_rdt, i_text)) { + return true; + } else { + SAL_WARN_IF(!i_text.isEmpty(), "sfx.doc", "Invalid date: " << i_text); + return false; + } +} + +// convert string to date/time with default return value +css::util::DateTime +textToDateTimeDefault(const OUString& i_text) noexcept +{ + css::util::DateTime dt; + static_cast<void> (textToDateTime(dt, i_text)); + // on conversion error: return default value (unchanged) + return dt; +} + +// convert date to string +OUString +dateToText(css::util::Date const& i_rd, + sal_Int16 const*const pTimeZone) noexcept +{ + if (isValidDate(i_rd)) { + OUStringBuffer buf; + ::sax::Converter::convertDate(buf, i_rd, pTimeZone); + return buf.makeStringAndClear(); + } else { + return OUString(); + } +} + + +// convert date/time to string +OUString +dateTimeToText(css::util::DateTime const& i_rdt, + sal_Int16 const*const pTimeZone = nullptr) noexcept +{ + if (isValidDateTime(i_rdt)) { + OUStringBuffer buf(32); + ::sax::Converter::convertDateTime(buf, i_rdt, pTimeZone, true); + return buf.makeStringAndClear(); + } else { + return OUString(); + } +} + +// convert string to duration +bool +textToDuration(css::util::Duration& io_rDur, OUString const& i_rText) +noexcept +{ + if (::sax::Converter::convertDuration(io_rDur, i_rText)) { + return true; + } else { + SAL_WARN_IF(!i_rText.isEmpty(), "sfx.doc", "Invalid duration: " << i_rText); + return false; + } +} + +sal_Int32 textToDuration(OUString const& i_rText) noexcept +{ + css::util::Duration d; + if (textToDuration(d, i_rText)) { + // #i107372#: approximate years/months + const sal_Int32 days( (d.Years * 365) + (d.Months * 30) + d.Days ); + return (days * (24*3600)) + + (d.Hours * 3600) + (d.Minutes * 60) + d.Seconds; + } else { + return 0; // default + } +} + +// convert duration to string +OUString durationToText(css::util::Duration const& i_rDur) noexcept +{ + OUStringBuffer buf; + ::sax::Converter::convertDuration(buf, i_rDur); + return buf.makeStringAndClear(); +} + +// convert duration to string +OUString durationToText(sal_Int32 i_value) noexcept +{ + css::util::Duration ud; + ud.Days = static_cast<sal_Int16>(i_value / (24 * 3600)); + ud.Hours = static_cast<sal_Int16>((i_value % (24 * 3600)) / 3600); + ud.Minutes = static_cast<sal_Int16>((i_value % 3600) / 60); + ud.Seconds = static_cast<sal_Int16>(i_value % 60); + ud.NanoSeconds = 0; + return durationToText(ud); +} + +// extract base URL (necessary for converting relative links) +css::uno::Reference< css::beans::XPropertySet > +SfxDocumentMetaData::getURLProperties( + const css::uno::Sequence< css::beans::PropertyValue > & i_rMedium) const +{ + css::uno::Reference< css::beans::XPropertyBag> xPropArg = css::beans::PropertyBag::createDefault( m_xContext ); + try { + css::uno::Any baseUri; + for (const auto& rProp : i_rMedium) { + if (rProp.Name == "DocumentBaseURL") { + baseUri = rProp.Value; + } else if (rProp.Name == "URL") { + if (!baseUri.hasValue()) { + baseUri = rProp.Value; + } + } else if (rProp.Name == "HierarchicalDocumentName") { + xPropArg->addProperty( + "StreamRelPath", + css::beans::PropertyAttribute::MAYBEVOID, + rProp.Value); + } + } + if (baseUri.hasValue()) { + xPropArg->addProperty( + "BaseURI", css::beans::PropertyAttribute::MAYBEVOID, + baseUri); + } + xPropArg->addProperty("StreamName", + css::beans::PropertyAttribute::MAYBEVOID, + css::uno::Any(OUString(s_meta))); + } catch (const css::uno::Exception &) { + // ignore + } + return css::uno::Reference< css::beans::XPropertySet>(xPropArg, + css::uno::UNO_QUERY_THROW); +} + +// return the text of the (hopefully unique, i.e., normalize first!) text +// node _below_ the given node +/// @throws css::uno::RuntimeException +OUString +getNodeText(const css::uno::Reference<css::xml::dom::XNode>& i_xNode) +{ + if (!i_xNode.is()) + throw css::uno::RuntimeException("SfxDocumentMetaData::getNodeText: argument is null", i_xNode); + for (css::uno::Reference<css::xml::dom::XNode> c = i_xNode->getFirstChild(); + c.is(); + c = c->getNextSibling()) { + if (c->getNodeType() == css::xml::dom::NodeType_TEXT_NODE) { + try { + return c->getNodeValue(); + } catch (const css::xml::dom::DOMException &) { // too big? + return OUString(); + } + } + } + return OUString(); +} + +OUString +SfxDocumentMetaData::getMetaText(const char* i_name) const +// throw (css::uno::RuntimeException) +{ + checkInit(); + + const OUString name( OUString::createFromAscii(i_name) ); + assert(m_meta.find(name) != m_meta.end()); + css::uno::Reference<css::xml::dom::XNode> xNode = m_meta.find(name)->second; + return (xNode.is()) ? getNodeText(xNode) : OUString(); +} + +bool +SfxDocumentMetaData::setMetaText(const OUString& name, + const OUString & i_rValue) + // throw (css::uno::RuntimeException) +{ + checkInit(); + + assert(m_meta.find(name) != m_meta.end()); + css::uno::Reference<css::xml::dom::XNode> xNode = m_meta.find(name)->second; + + try { + if (i_rValue.isEmpty()) { + if (xNode.is()) { // delete + m_xParent->removeChild(xNode); + xNode.clear(); + m_meta[name] = xNode; + return true; + } else { + return false; + } + } else { + if (xNode.is()) { // update + for (css::uno::Reference<css::xml::dom::XNode> c = + xNode->getFirstChild(); + c.is(); + c = c->getNextSibling()) { + if (c->getNodeType() == css::xml::dom::NodeType_TEXT_NODE) { + if (c->getNodeValue() != i_rValue) { + c->setNodeValue(i_rValue); + return true; + } else { + return false; + } + } + } + } else { // insert + xNode.set(m_xDoc->createElementNS(getNameSpace(name), name), + css::uno::UNO_QUERY_THROW); + m_xParent->appendChild(xNode); + m_meta[name] = xNode; + } + css::uno::Reference<css::xml::dom::XNode> xTextNode( + m_xDoc->createTextNode(i_rValue), css::uno::UNO_QUERY_THROW); + xNode->appendChild(xTextNode); + return true; + } + } catch (const css::xml::dom::DOMException &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw css::lang::WrappedTargetRuntimeException( + "SfxDocumentMetaData::setMetaText: DOM exception", + css::uno::Reference<css::uno::XInterface>(*this), anyEx); + } +} + +void +SfxDocumentMetaData::setMetaTextAndNotify(const OUString & i_name, + const OUString & i_rValue) + // throw (css::uno::RuntimeException) +{ + ::osl::ClearableMutexGuard g(m_aMutex); + if (setMetaText(i_name, i_rValue)) { + g.clear(); + setModified(true); + } +} + +OUString +SfxDocumentMetaData::getMetaAttr(const OUString& name, const OUString& i_attr) const +// throw (css::uno::RuntimeException) +{ + assert(m_meta.find(name) != m_meta.end()); + css::uno::Reference<css::xml::dom::XNode> xNode = m_meta.find(name)->second; + if (xNode.is()) { + css::uno::Reference<css::xml::dom::XElement> xElem(xNode, + css::uno::UNO_QUERY_THROW); + return xElem->getAttributeNS(getNameSpace(i_attr), + getQualifier(i_attr).second); + } else { + return OUString(); + } +} + +css::uno::Sequence< OUString> +SfxDocumentMetaData::getMetaList(const char* i_name) const +// throw (css::uno::RuntimeException) +{ + checkInit(); + OUString name = OUString::createFromAscii(i_name); + assert(m_metaList.find(name) != m_metaList.end()); + std::vector<css::uno::Reference<css::xml::dom::XNode> > const & vec = + m_metaList.find(name)->second; + css::uno::Sequence< OUString> ret(vec.size()); + std::transform(vec.begin(), vec.end(), ret.getArray(), + [](const auto& node) { return getNodeText(node); }); + return ret; +} + +bool +SfxDocumentMetaData::setMetaList(const OUString& name, + const css::uno::Sequence<OUString> & i_rValue, + AttrVector const* i_pAttrs) + // throw (css::uno::RuntimeException) +{ + checkInit(); + assert((i_pAttrs == nullptr) || + (static_cast<size_t>(i_rValue.getLength()) == i_pAttrs->size())); + + try { + assert(m_metaList.find(name) != m_metaList.end()); + std::vector<css::uno::Reference<css::xml::dom::XNode> > & vec = + m_metaList[name]; + + // if nothing changed, do nothing + // alas, this does not check for permutations, or attributes... + if (nullptr == i_pAttrs) { + if (static_cast<size_t>(i_rValue.getLength()) == vec.size()) { + bool isEqual(true); + for (sal_Int32 i = 0; i < i_rValue.getLength(); ++i) { + css::uno::Reference<css::xml::dom::XNode> xNode(vec.at(i)); + if (xNode.is()) { + OUString val = getNodeText(xNode); + if (val != i_rValue[i]) { + isEqual = false; + break; + } + } + } + if (isEqual) return false; + } + } + + // remove old meta data nodes + { + std::vector<css::uno::Reference<css::xml::dom::XNode> > + ::reverse_iterator it(vec.rbegin()); + try { + for ( ;it != vec.rend(); ++it) + { + m_xParent->removeChild(*it); + } + } + catch (...) + { + // Clean up already removed nodes + vec.erase(it.base(), vec.end()); + throw; + } + vec.clear(); + } + + // insert new meta data nodes into DOM tree + for (sal_Int32 i = 0; i < i_rValue.getLength(); ++i) { + css::uno::Reference<css::xml::dom::XElement> xElem( + m_xDoc->createElementNS(getNameSpace(name), name), + css::uno::UNO_SET_THROW); + css::uno::Reference<css::xml::dom::XNode> xNode(xElem, + css::uno::UNO_QUERY_THROW); + css::uno::Reference<css::xml::dom::XNode> xTextNode( + m_xDoc->createTextNode(i_rValue[i]), css::uno::UNO_QUERY_THROW); + // set attributes + if (i_pAttrs != nullptr) { + for (auto const& elem : (*i_pAttrs)[i]) + { + xElem->setAttributeNS(getNameSpace(elem.first), + elem.first, elem.second); + } + } + xNode->appendChild(xTextNode); + m_xParent->appendChild(xNode); + vec.push_back(xNode); + } + + return true; + } catch (const css::xml::dom::DOMException &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw css::lang::WrappedTargetRuntimeException( + "SfxDocumentMetaData::setMetaList: DOM exception", + css::uno::Reference<css::uno::XInterface>(*this), anyEx); + } +} + +// convert property list to string list and attribute list +std::pair<css::uno::Sequence< OUString>, AttrVector> +propsToStrings(css::uno::Reference<css::beans::XPropertySet> const & i_xPropSet) +{ + ::std::vector< OUString > values; + AttrVector attrs; + + css::uno::Reference<css::beans::XPropertySetInfo> xSetInfo + = i_xPropSet->getPropertySetInfo(); + css::uno::Sequence<css::beans::Property> props = xSetInfo->getProperties(); + + for (sal_Int32 i = 0; i < props.getLength(); ++i) { + if (props[i].Attributes & css::beans::PropertyAttribute::TRANSIENT) { + continue; + } + const OUString name = props[i].Name; + css::uno::Any any; + try { + any = i_xPropSet->getPropertyValue(name); + } catch (const css::uno::Exception &) { + // ignore + } + const css::uno::Type & type = any.getValueType(); + std::vector<std::pair<OUString, OUString> > as; + as.emplace_back("meta:name", name); + static constexpr OUStringLiteral vt = u"meta:value-type"; + + // convert according to type + if (type == ::cppu::UnoType<bool>::get()) { + bool b = false; + any >>= b; + OUStringBuffer buf; + ::sax::Converter::convertBool(buf, b); + values.push_back(buf.makeStringAndClear()); + as.emplace_back(vt, OUString("boolean")); + } else if (type == ::cppu::UnoType< OUString>::get()) { + OUString s; + any >>= s; + values.push_back(s); +// #i90847# OOo 2.x does stupid things if value-type="string"; +// fortunately string is default anyway, so we can just omit it +// #i107502#: however, OOo 2.x only reads 4 user-defined without @value-type +// => best backward compatibility: first 4 without @value-type, rest with + if (4 <= i) + { + as.emplace_back(vt, OUString("string")); + } + } else if (type == ::cppu::UnoType<css::util::DateTime>::get()) { + css::util::DateTime dt; + any >>= dt; + values.push_back(dateTimeToText(dt)); + as.emplace_back(vt, OUString("date")); + } else if (type == ::cppu::UnoType<css::util::Date>::get()) { + css::util::Date d; + any >>= d; + values.push_back(dateToText(d, nullptr)); + as.emplace_back(vt,OUString("date")); + } else if (type == ::cppu::UnoType<css::util::DateTimeWithTimezone>::get()) { + css::util::DateTimeWithTimezone dttz; + any >>= dttz; + values.push_back(dateTimeToText(dttz.DateTimeInTZ, &dttz.Timezone)); + as.emplace_back(vt, OUString("date")); + } else if (type == ::cppu::UnoType<css::util::DateWithTimezone>::get()) { + css::util::DateWithTimezone dtz; + any >>= dtz; + values.push_back(dateToText(dtz.DateInTZ, &dtz.Timezone)); + as.emplace_back(vt, OUString("date")); + } else if (type == ::cppu::UnoType<css::util::Time>::get()) { + // #i97029#: replaced by Duration + // Time is supported for backward compatibility with OOo 3.x, x<=2 + css::util::Time ut; + any >>= ut; + css::util::Duration ud; + ud.Hours = ut.Hours; + ud.Minutes = ut.Minutes; + ud.Seconds = ut.Seconds; + ud.NanoSeconds = ut.NanoSeconds; + values.push_back(durationToText(ud)); + as.emplace_back(vt, OUString("time")); + } else if (type == ::cppu::UnoType<css::util::Duration>::get()) { + css::util::Duration ud; + any >>= ud; + values.push_back(durationToText(ud)); + as.emplace_back(vt, OUString("time")); + } else if (::cppu::UnoType<double>::get().isAssignableFrom(type)) { + // support not just double, but anything that can be converted + double d = 0; + any >>= d; + OUStringBuffer buf; + ::sax::Converter::convertDouble(buf, d); + values.push_back(buf.makeStringAndClear()); + as.emplace_back(vt, OUString("float")); + } else { + SAL_WARN("sfx.doc", "Unsupported property type: " << any.getValueTypeName() ); + continue; + } + attrs.push_back(as); + } + + return std::make_pair(comphelper::containerToSequence(values), attrs); +} + +// remove the given element from the DOM, and iff i_pAttrs != 0 insert new one +void +SfxDocumentMetaData::updateElement(const OUString& name, + std::vector<std::pair<OUString, OUString> >* i_pAttrs) +{ + try { + // remove old element + css::uno::Reference<css::xml::dom::XNode> xNode = + m_meta.find(name)->second; + if (xNode.is()) { + m_xParent->removeChild(xNode); + xNode.clear(); + } + // add new element + if (nullptr != i_pAttrs) { + css::uno::Reference<css::xml::dom::XElement> xElem( + m_xDoc->createElementNS(getNameSpace(name), name), + css::uno::UNO_SET_THROW); + xNode.set(xElem, css::uno::UNO_QUERY_THROW); + // set attributes + for (auto const& elem : *i_pAttrs) + { + xElem->setAttributeNS(getNameSpace(elem.first), + elem.first, elem.second); + } + m_xParent->appendChild(xNode); + } + m_meta[name] = xNode; + } catch (const css::xml::dom::DOMException &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw css::lang::WrappedTargetRuntimeException( + "SfxDocumentMetaData::updateElement: DOM exception", + css::uno::Reference<css::uno::XInterface>(*this), anyEx); + } +} + +// update user-defined meta data in DOM tree +void SfxDocumentMetaData::updateUserDefinedAndAttributes() +{ + createUserDefined(); + const css::uno::Reference<css::beans::XPropertySet> xPSet(m_xUserDefined, + css::uno::UNO_QUERY_THROW); + const std::pair<css::uno::Sequence< OUString>, AttrVector> + udStringsAttrs( propsToStrings(xPSet) ); + (void) setMetaList("meta:user-defined", udStringsAttrs.first, + &udStringsAttrs.second); + + // update elements with attributes + std::vector<std::pair<OUString, OUString> > attributes; + if (!m_TemplateName.isEmpty() || !m_TemplateURL.isEmpty() + || isValidDateTime(m_TemplateDate)) { + attributes.emplace_back("xlink:type", OUString("simple")); + attributes.emplace_back("xlink:actuate", OUString("onRequest")); + attributes.emplace_back("xlink:title", m_TemplateName); + attributes.emplace_back("xlink:href", m_TemplateURL ); + if (isValidDateTime(m_TemplateDate)) { + attributes.emplace_back( + "meta:date", dateTimeToText(m_TemplateDate)); + } + updateElement("meta:template", &attributes); + } else { + updateElement("meta:template"); + } + attributes.clear(); + + if (!m_AutoloadURL.isEmpty() || (0 != m_AutoloadSecs)) { + attributes.emplace_back("xlink:href", m_AutoloadURL ); + attributes.emplace_back("meta:delay", + durationToText(m_AutoloadSecs)); + updateElement("meta:auto-reload", &attributes); + } else { + updateElement("meta:auto-reload"); + } + attributes.clear(); + + if (!m_DefaultTarget.isEmpty()) { + attributes.emplace_back( + "office:target-frame-name", + m_DefaultTarget); + // xlink:show: _blank -> new, any other value -> replace + const char* show = m_DefaultTarget == "_blank" ? "new" : "replace"; + attributes.emplace_back( + "xlink:show", + OUString::createFromAscii(show)); + updateElement("meta:hyperlink-behaviour", &attributes); + } else { + updateElement("meta:hyperlink-behaviour"); + } + attributes.clear(); +} + +// create empty DOM tree (XDocument) +css::uno::Reference<css::xml::dom::XDocument> +SfxDocumentMetaData::createDOM() const // throw (css::uno::RuntimeException) +{ + css::uno::Reference<css::xml::dom::XDocumentBuilder> xBuilder( css::xml::dom::DocumentBuilder::create(m_xContext) ); + css::uno::Reference<css::xml::dom::XDocument> xDoc = xBuilder->newDocument(); + if (!xDoc.is()) + throw css::uno::RuntimeException( + "SfxDocumentMetaData::createDOM: cannot create new document", + *const_cast<SfxDocumentMetaData*>(this)); + return xDoc; +} + +void +SfxDocumentMetaData::checkInit() const // throw (css::uno::RuntimeException) +{ + if (!m_isInitialized) { + throw css::uno::RuntimeException( + "SfxDocumentMetaData::checkInit: not initialized", + *const_cast<SfxDocumentMetaData*>(this)); + } + assert(m_xDoc.is() && m_xParent.is()); +} + +void extractTagAndNamespaceUri(std::u16string_view aChildNodeName, + std::u16string_view& rTagName, std::u16string_view& rNamespaceURI) +{ + size_t idx = aChildNodeName.find(':'); + assert(idx != std::u16string_view::npos); + std::u16string_view aPrefix = aChildNodeName.substr(0, idx); + rTagName = aChildNodeName.substr(idx + 1); + if (aPrefix == u"dc") + rNamespaceURI = s_nsDC; + else if (aPrefix == u"meta") + rNamespaceURI = s_nsODFMeta; + else if (aPrefix == u"office") + rNamespaceURI = s_nsODF; + else + assert(false); +} + + +css::uno::Reference<css::xml::dom::XElement> getChildNodeByName( + const css::uno::Reference<css::xml::dom::XNode>& xNode, + std::u16string_view aChildNodeName) +{ + css::uno::Reference< css::xml::dom::XNodeList > xList = xNode->getChildNodes(); + if (!xList) + return nullptr; + std::u16string_view aTagName, aNamespaceURI; + extractTagAndNamespaceUri(aChildNodeName, aTagName, aNamespaceURI); + + const sal_Int32 nLength(xList->getLength()); + for (sal_Int32 a(0); a < nLength; a++) + { + const css::uno::Reference< css::xml::dom::XElement > xChild(xList->item(a), css::uno::UNO_QUERY); + if (xChild && xChild->getNodeName() == aTagName && aNamespaceURI == xChild->getNamespaceURI()) + return xChild; + } + return nullptr; +} + + +std::vector<css::uno::Reference<css::xml::dom::XNode> > getChildNodeListByName( + const css::uno::Reference<css::xml::dom::XNode>& xNode, + std::u16string_view aChildNodeName) +{ + css::uno::Reference< css::xml::dom::XNodeList > xList = xNode->getChildNodes(); + if (!xList) + return {}; + std::u16string_view aTagName, aNamespaceURI; + extractTagAndNamespaceUri(aChildNodeName, aTagName, aNamespaceURI); + std::vector<css::uno::Reference<css::xml::dom::XNode>> aList; + const sal_Int32 nLength(xList->getLength()); + for (sal_Int32 a(0); a < nLength; a++) + { + const css::uno::Reference< css::xml::dom::XElement > xChild(xList->item(a), css::uno::UNO_QUERY); + if (xChild && xChild->getNodeName() == aTagName && aNamespaceURI == xChild->getNamespaceURI()) + aList.push_back(xChild); + } + return aList; +} + +// initialize state from DOM tree +void SfxDocumentMetaData::init( + const css::uno::Reference<css::xml::dom::XDocument>& i_xDoc) +{ + if (!i_xDoc.is()) + throw css::uno::RuntimeException("SfxDocumentMetaData::init: no DOM tree given", *this); + + m_isInitialized = false; + m_xDoc = i_xDoc; + + // select nodes for standard meta data stuff + // NB: we do not handle the single-XML-file ODF variant, which would + // have the root element office:document. + // The root of such documents must be converted in the importer! + css::uno::Reference<css::xml::dom::XNode> xDocNode( + m_xDoc, css::uno::UNO_QUERY_THROW); + m_xParent.clear(); + try { + css::uno::Reference<css::xml::dom::XNode> xChild = getChildNodeByName(xDocNode, u"office:document-meta"); + if (xChild) + m_xParent = getChildNodeByName(xChild, u"office:meta"); + } catch (const css::uno::Exception &) { + } + + if (!m_xParent.is()) { + // all this create/append stuff may throw DOMException + try { + css::uno::Reference<css::xml::dom::XElement> xRElem; + css::uno::Reference<css::xml::dom::XNode> xNode( + i_xDoc->getFirstChild()); + while (xNode.is()) { + if (css::xml::dom::NodeType_ELEMENT_NODE ==xNode->getNodeType()) + { + if ( xNode->getNamespaceURI() == s_nsODF && xNode->getLocalName() == "document-meta" ) + { + xRElem.set(xNode, css::uno::UNO_QUERY_THROW); + break; + } + else + { + SAL_INFO("sfx.doc", "SfxDocumentMetaData::init(): " + "deleting unexpected root element: " + << xNode->getLocalName()); + i_xDoc->removeChild(xNode); + xNode = i_xDoc->getFirstChild(); // start over + } + } else { + xNode = xNode->getNextSibling(); + } + } + if (!xRElem.is()) { + static constexpr OUStringLiteral sOfficeDocumentMeta = u"office:document-meta"; + xRElem = i_xDoc->createElementNS( + s_nsODF, sOfficeDocumentMeta); + css::uno::Reference<css::xml::dom::XNode> xRNode(xRElem, + css::uno::UNO_QUERY_THROW); + i_xDoc->appendChild(xRNode); + } + static constexpr OUStringLiteral sOfficeVersion = u"office:version"; + xRElem->setAttributeNS(s_nsODF, sOfficeVersion, "1.0"); + // does not exist, otherwise m_xParent would not be null + static constexpr OUStringLiteral sOfficeMeta = u"office:meta"; + css::uno::Reference<css::xml::dom::XNode> xParent ( + i_xDoc->createElementNS(s_nsODF, sOfficeMeta), + css::uno::UNO_QUERY_THROW); + xRElem->appendChild(xParent); + m_xParent = xParent; + } catch (const css::xml::dom::DOMException &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw css::lang::WrappedTargetRuntimeException( + "SfxDocumentMetaData::init: DOM exception", + css::uno::Reference<css::uno::XInterface>(*this), anyEx); + } + } + + + // select nodes for elements of which we only handle one occurrence + for (const char **pName = s_stdMeta; *pName != nullptr; ++pName) { + OUString name = OUString::createFromAscii(*pName); + // NB: If a document contains more than one occurrence of a + // meta-data element, we arbitrarily pick one of them here. + // We do not remove the others, i.e., when we write the + // document, it will contain the duplicates unchanged. + // The ODF spec says that handling multiple occurrences is + // application-specific. + css::uno::Reference<css::xml::dom::XNode> xNode = + getChildNodeByName(m_xParent, name); + // Do not create an empty element if it is missing; + // for certain elements, such as dateTime, this would be invalid + m_meta[name] = xNode; + } + + // select nodes for elements of which we handle all occurrences + for (const auto & name : s_stdMetaList) { + std::vector<css::uno::Reference<css::xml::dom::XNode> > nodes = + getChildNodeListByName(m_xParent, OUString(name)); + m_metaList[name] = nodes; + } + + // initialize members corresponding to attributes from DOM nodes + static constexpr OUStringLiteral sMetaTemplate = u"meta:template"; + static constexpr OUStringLiteral sMetaAutoReload = u"meta:auto-reload"; + static constexpr OUStringLiteral sMetaHyperlinkBehaviour = u"meta:hyperlink-behaviour"; + m_TemplateName = getMetaAttr(sMetaTemplate, "xlink:title"); + m_TemplateURL = getMetaAttr(sMetaTemplate, "xlink:href"); + m_TemplateDate = + textToDateTimeDefault(getMetaAttr(sMetaTemplate, "meta:date")); + m_AutoloadURL = getMetaAttr(sMetaAutoReload, "xlink:href"); + m_AutoloadSecs = + textToDuration(getMetaAttr(sMetaAutoReload, "meta:delay")); + m_DefaultTarget = + getMetaAttr(sMetaHyperlinkBehaviour, "office:target-frame-name"); + + + std::vector<css::uno::Reference<css::xml::dom::XNode> > & vec = + m_metaList[OUString("meta:user-defined")]; + m_xUserDefined.clear(); // #i105826#: reset (may be re-initialization) + if ( !vec.empty() ) + { + createUserDefined(); + } + + // user-defined meta data: initialize PropertySet from DOM nodes + for (auto const& elem : vec) + { + css::uno::Reference<css::xml::dom::XElement> xElem(elem, + css::uno::UNO_QUERY_THROW); + css::uno::Any any; + OUString name = xElem->getAttributeNS(s_nsODFMeta, "name"); + OUString type = xElem->getAttributeNS(s_nsODFMeta, "value-type"); + OUString text = getNodeText(elem); + if ( type == "float" ) { + double d; + if (::sax::Converter::convertDouble(d, text)) { + any <<= d; + } else { + SAL_WARN("sfx.doc", "Invalid float: " << text); + continue; + } + } else if ( type == "date" ) { + bool isDateTime; + css::util::Date d; + css::util::DateTime dt; + std::optional<sal_Int16> nTimeZone; + if (textToDateOrDateTime(d, dt, isDateTime, nTimeZone, text)) { + if (isDateTime) { + if (nTimeZone) { + any <<= css::util::DateTimeWithTimezone(dt, + *nTimeZone); + } else { + any <<= dt; + } + } else { + if (nTimeZone) { + any <<= css::util::DateWithTimezone(d, *nTimeZone); + } else { + any <<= d; + } + } + } else { + SAL_WARN("sfx.doc", "Invalid date: " << text); + continue; + } + } else if ( type == "time" ) { + css::util::Duration ud; + if (textToDuration(ud, text)) { + any <<= ud; + } else { + SAL_WARN("sfx.doc", "Invalid time: " << text); + continue; + } + } else if ( type == "boolean" ) { + bool b; + if (::sax::Converter::convertBool(b, text)) { + any <<= b; + } else { + SAL_WARN("sfx.doc", "Invalid boolean: " << text); + continue; + } + } else { // default + any <<= text; + } + try { + m_xUserDefined->addProperty(name, + css::beans::PropertyAttribute::REMOVABLE, any); + } catch (const css::beans::PropertyExistException &) { + SAL_WARN("sfx.doc", "Duplicate: " << name); + // ignore; duplicate + } catch (const css::beans::IllegalTypeException &) { + SAL_INFO("sfx.doc", "SfxDocumentMetaData: illegal type: " << name); + } catch (const css::lang::IllegalArgumentException &) { + SAL_INFO("sfx.doc", "SfxDocumentMetaData: illegal arg: " << name); + } + } + + m_isModified = false; + m_isInitialized = true; +} + + +SfxDocumentMetaData::SfxDocumentMetaData( + css::uno::Reference< css::uno::XComponentContext > const & context) + : BaseMutex() + , SfxDocumentMetaData_Base(m_aMutex) + , m_xContext(context) + , m_NotifyListeners(m_aMutex) + , m_isInitialized(false) + , m_isModified(false) + , m_AutoloadSecs(0) +{ + assert(context.is()); + assert(context->getServiceManager().is()); + init(createDOM()); +} + +// com.sun.star.uno.XServiceInfo: +OUString SAL_CALL +SfxDocumentMetaData::getImplementationName() +{ + return "SfxDocumentMetaData"; +} + +sal_Bool SAL_CALL +SfxDocumentMetaData::supportsService(OUString const & serviceName) +{ + return cppu::supportsService(this, serviceName); +} + +css::uno::Sequence< OUString > SAL_CALL +SfxDocumentMetaData::getSupportedServiceNames() +{ + css::uno::Sequence< OUString > s { "com.sun.star.document.DocumentProperties" }; + return s; +} + + +// css::lang::XComponent: +void SAL_CALL SfxDocumentMetaData::dispose() +{ + ::osl::MutexGuard g(m_aMutex); + if (!m_isInitialized) { + return; + } + WeakComponentImplHelperBase::dispose(); // superclass + m_NotifyListeners.disposeAndClear(css::lang::EventObject( + static_cast< ::cppu::OWeakObject* >(this))); + m_isInitialized = false; + m_meta.clear(); + m_metaList.clear(); + m_xParent.clear(); + m_xDoc.clear(); + m_xUserDefined.clear(); +} + + +// css::document::XDocumentProperties: +OUString SAL_CALL +SfxDocumentMetaData::getAuthor() +{ + ::osl::MutexGuard g(m_aMutex); + return getMetaText("meta:initial-creator"); +} + +void SAL_CALL SfxDocumentMetaData::setAuthor(const OUString & the_value) +{ + setMetaTextAndNotify("meta:initial-creator", the_value); +} + + +OUString SAL_CALL +SfxDocumentMetaData::getGenerator() +{ + ::osl::MutexGuard g(m_aMutex); + return getMetaText("meta:generator"); +} + +void SAL_CALL +SfxDocumentMetaData::setGenerator(const OUString & the_value) +{ + setMetaTextAndNotify("meta:generator", the_value); +} + +css::util::DateTime SAL_CALL +SfxDocumentMetaData::getCreationDate() +{ + ::osl::MutexGuard g(m_aMutex); + return textToDateTimeDefault(getMetaText("meta:creation-date")); +} + +void SAL_CALL +SfxDocumentMetaData::setCreationDate(const css::util::DateTime & the_value) +{ + setMetaTextAndNotify("meta:creation-date", dateTimeToText(the_value)); +} + +OUString SAL_CALL +SfxDocumentMetaData::getTitle() +{ + ::osl::MutexGuard g(m_aMutex); + return getMetaText("dc:title"); +} + +void SAL_CALL SfxDocumentMetaData::setTitle(const OUString & the_value) +{ + setMetaTextAndNotify("dc:title", the_value); +} + +OUString SAL_CALL +SfxDocumentMetaData::getSubject() +{ + ::osl::MutexGuard g(m_aMutex); + return getMetaText("dc:subject"); +} + +void SAL_CALL +SfxDocumentMetaData::setSubject(const OUString & the_value) +{ + setMetaTextAndNotify("dc:subject", the_value); +} + +OUString SAL_CALL +SfxDocumentMetaData::getDescription() +{ + ::osl::MutexGuard g(m_aMutex); + return getMetaText("dc:description"); +} + +void SAL_CALL +SfxDocumentMetaData::setDescription(const OUString & the_value) +{ + setMetaTextAndNotify("dc:description", the_value); +} + +css::uno::Sequence< OUString > +SAL_CALL SfxDocumentMetaData::getKeywords() +{ + ::osl::MutexGuard g(m_aMutex); + return getMetaList("meta:keyword"); +} + +void SAL_CALL +SfxDocumentMetaData::setKeywords( + const css::uno::Sequence< OUString > & the_value) +{ + ::osl::ClearableMutexGuard g(m_aMutex); + if (setMetaList("meta:keyword", the_value, nullptr)) { + g.clear(); + setModified(true); + } +} + +css::lang::Locale SAL_CALL + SfxDocumentMetaData::getLanguage() +{ + ::osl::MutexGuard g(m_aMutex); + css::lang::Locale loc( LanguageTag::convertToLocale( getMetaText("dc:language"), false)); + return loc; +} + +void SAL_CALL +SfxDocumentMetaData::setLanguage(const css::lang::Locale & the_value) +{ + OUString text( LanguageTag::convertToBcp47( the_value, false)); + setMetaTextAndNotify("dc:language", text); +} + +OUString SAL_CALL +SfxDocumentMetaData::getModifiedBy() +{ + ::osl::MutexGuard g(m_aMutex); + return getMetaText("dc:creator"); +} + +void SAL_CALL +SfxDocumentMetaData::setModifiedBy(const OUString & the_value) +{ + setMetaTextAndNotify("dc:creator", the_value); +} + +css::util::DateTime SAL_CALL +SfxDocumentMetaData::getModificationDate() +{ + ::osl::MutexGuard g(m_aMutex); + return textToDateTimeDefault(getMetaText("dc:date")); +} + +void SAL_CALL +SfxDocumentMetaData::setModificationDate(const css::util::DateTime & the_value) +{ + setMetaTextAndNotify("dc:date", dateTimeToText(the_value)); +} + +OUString SAL_CALL +SfxDocumentMetaData::getPrintedBy() +{ + ::osl::MutexGuard g(m_aMutex); + return getMetaText("meta:printed-by"); +} + +void SAL_CALL +SfxDocumentMetaData::setPrintedBy(const OUString & the_value) +{ + setMetaTextAndNotify("meta:printed-by", the_value); +} + +css::util::DateTime SAL_CALL +SfxDocumentMetaData::getPrintDate() +{ + ::osl::MutexGuard g(m_aMutex); + return textToDateTimeDefault(getMetaText("meta:print-date")); +} + +void SAL_CALL +SfxDocumentMetaData::setPrintDate(const css::util::DateTime & the_value) +{ + setMetaTextAndNotify("meta:print-date", dateTimeToText(the_value)); +} + +OUString SAL_CALL +SfxDocumentMetaData::getTemplateName() +{ + ::osl::MutexGuard g(m_aMutex); + checkInit(); + return m_TemplateName; +} + +void SAL_CALL +SfxDocumentMetaData::setTemplateName(const OUString & the_value) +{ + ::osl::ClearableMutexGuard g(m_aMutex); + checkInit(); + if (m_TemplateName != the_value) { + m_TemplateName = the_value; + g.clear(); + setModified(true); + } +} + +OUString SAL_CALL +SfxDocumentMetaData::getTemplateURL() +{ + ::osl::MutexGuard g(m_aMutex); + checkInit(); + return m_TemplateURL; +} + +void SAL_CALL +SfxDocumentMetaData::setTemplateURL(const OUString & the_value) +{ + ::osl::ClearableMutexGuard g(m_aMutex); + checkInit(); + if (m_TemplateURL != the_value) { + m_TemplateURL = the_value; + g.clear(); + setModified(true); + } +} + +css::util::DateTime SAL_CALL +SfxDocumentMetaData::getTemplateDate() +{ + ::osl::MutexGuard g(m_aMutex); + checkInit(); + return m_TemplateDate; +} + +void SAL_CALL +SfxDocumentMetaData::setTemplateDate(const css::util::DateTime & the_value) +{ + ::osl::ClearableMutexGuard g(m_aMutex); + checkInit(); + if (m_TemplateDate != the_value) { + m_TemplateDate = the_value; + g.clear(); + setModified(true); + } +} + +OUString SAL_CALL +SfxDocumentMetaData::getAutoloadURL() +{ + ::osl::MutexGuard g(m_aMutex); + checkInit(); + return m_AutoloadURL; +} + +void SAL_CALL +SfxDocumentMetaData::setAutoloadURL(const OUString & the_value) +{ + ::osl::ClearableMutexGuard g(m_aMutex); + checkInit(); + if (m_AutoloadURL != the_value) { + m_AutoloadURL = the_value; + g.clear(); + setModified(true); + } +} + +::sal_Int32 SAL_CALL +SfxDocumentMetaData::getAutoloadSecs() +{ + ::osl::MutexGuard g(m_aMutex); + checkInit(); + return m_AutoloadSecs; +} + +void SAL_CALL +SfxDocumentMetaData::setAutoloadSecs(::sal_Int32 the_value) +{ + if (the_value < 0) + throw css::lang::IllegalArgumentException( + "SfxDocumentMetaData::setAutoloadSecs: argument is negative", + *this, 0); + ::osl::ClearableMutexGuard g(m_aMutex); + checkInit(); + if (m_AutoloadSecs != the_value) { + m_AutoloadSecs = the_value; + g.clear(); + setModified(true); + } +} + +OUString SAL_CALL +SfxDocumentMetaData::getDefaultTarget() +{ + ::osl::MutexGuard g(m_aMutex); + checkInit(); + return m_DefaultTarget; +} + +void SAL_CALL +SfxDocumentMetaData::setDefaultTarget(const OUString & the_value) +{ + ::osl::ClearableMutexGuard g(m_aMutex); + checkInit(); + if (m_DefaultTarget != the_value) { + m_DefaultTarget = the_value; + g.clear(); + setModified(true); + } +} + +css::uno::Sequence< css::beans::NamedValue > SAL_CALL +SfxDocumentMetaData::getDocumentStatistics() +{ + ::osl::MutexGuard g(m_aMutex); + checkInit(); + ::std::vector<css::beans::NamedValue> stats; + for (size_t i = 0; s_stdStats[i] != nullptr; ++i) { + OUString text = getMetaAttr("meta:document-statistic", s_stdStatAttrs[i]); + if (text.isEmpty()) continue; + css::beans::NamedValue stat; + stat.Name = OUString::createFromAscii(s_stdStats[i]); + sal_Int32 val; + css::uno::Any any; + if (!::sax::Converter::convertNumber(val, text, 0) || (val < 0)) { + val = 0; + SAL_WARN("sfx.doc", "Invalid number: " << text); + } + any <<= val; + stat.Value = any; + stats.push_back(stat); + } + + return ::comphelper::containerToSequence(stats); +} + +void SAL_CALL +SfxDocumentMetaData::setDocumentStatistics( + const css::uno::Sequence< css::beans::NamedValue > & the_value) +{ + { + osl::MutexGuard g(m_aMutex); + checkInit(); + std::vector<std::pair<OUString, OUString> > attributes; + for (const auto& rValue : the_value) { + const OUString name = rValue.Name; + // inefficiently search for matching attribute + for (size_t j = 0; s_stdStats[j] != nullptr; ++j) { + if (name.equalsAscii(s_stdStats[j])) { + const css::uno::Any any = rValue.Value; + sal_Int32 val = 0; + if (any >>= val) { + attributes.emplace_back(s_stdStatAttrs[j], + OUString::number(val)); + } + else { + SAL_WARN("sfx.doc", "Invalid statistic: " << name); + } + break; + } + } + } + updateElement("meta:document-statistic", &attributes); + } + setModified(true); +} + +::sal_Int16 SAL_CALL +SfxDocumentMetaData::getEditingCycles() +{ + ::osl::MutexGuard g(m_aMutex); + OUString text = getMetaText("meta:editing-cycles"); + sal_Int32 ret; + if (::sax::Converter::convertNumber(ret, text, + 0, std::numeric_limits<sal_Int16>::max())) { + return static_cast<sal_Int16>(ret); + } else { + return 0; + } +} + +void SAL_CALL +SfxDocumentMetaData::setEditingCycles(::sal_Int16 the_value) +{ + if (the_value < 0) + throw css::lang::IllegalArgumentException( + "SfxDocumentMetaData::setEditingCycles: argument is negative", + *this, 0); + setMetaTextAndNotify("meta:editing-cycles", OUString::number(the_value)); +} + +::sal_Int32 SAL_CALL +SfxDocumentMetaData::getEditingDuration() +{ + ::osl::MutexGuard g(m_aMutex); + return textToDuration(getMetaText("meta:editing-duration")); +} + +void SAL_CALL +SfxDocumentMetaData::setEditingDuration(::sal_Int32 the_value) +{ + if (the_value < 0) + throw css::lang::IllegalArgumentException( + "SfxDocumentMetaData::setEditingDuration: argument is negative", + *this, 0); + setMetaTextAndNotify("meta:editing-duration", durationToText(the_value)); +} + +void SAL_CALL +SfxDocumentMetaData::resetUserData(const OUString & the_value) +{ + ::osl::ClearableMutexGuard g(m_aMutex); + + bool bModified( false ); + bModified |= setMetaText("meta:initial-creator", the_value); + ::DateTime now( ::DateTime::SYSTEM ); + css::util::DateTime uDT(now.GetUNODateTime()); + bModified |= setMetaText("meta:creation-date", dateTimeToText(uDT)); + bModified |= setMetaText("dc:creator", OUString()); + bModified |= setMetaText("meta:printed-by", OUString()); + bModified |= setMetaText("dc:date", dateTimeToText(css::util::DateTime())); + bModified |= setMetaText("meta:print-date", + dateTimeToText(css::util::DateTime())); + bModified |= setMetaText("meta:editing-duration", durationToText(0)); + bModified |= setMetaText("meta:editing-cycles", + "1"); + + if (bModified) { + g.clear(); + setModified(true); + } +} + + +css::uno::Reference< css::beans::XPropertyContainer > SAL_CALL +SfxDocumentMetaData::getUserDefinedProperties() +{ + ::osl::MutexGuard g(m_aMutex); + checkInit(); + createUserDefined(); + return m_xUserDefined; +} + + +void SAL_CALL +SfxDocumentMetaData::loadFromStorage( + const css::uno::Reference< css::embed::XStorage > & xStorage, + const css::uno::Sequence< css::beans::PropertyValue > & Medium) +{ + if (!xStorage.is()) + throw css::lang::IllegalArgumentException("SfxDocumentMetaData::loadFromStorage: argument is null", *this, 0); + ::osl::MutexGuard g(m_aMutex); + + // open meta data file + css::uno::Reference<css::io::XStream> xStream( + xStorage->openStreamElement( + s_meta, + css::embed::ElementModes::READ) ); + if (!xStream.is()) throw css::uno::RuntimeException(); + css::uno::Reference<css::io::XInputStream> xInStream = + xStream->getInputStream(); + if (!xInStream.is()) throw css::uno::RuntimeException(); + + // create DOM parser service + css::uno::Reference<css::lang::XMultiComponentFactory> xMsf ( + m_xContext->getServiceManager()); + css::xml::sax::InputSource input; + input.aInputStream = xInStream; + + sal_uInt64 version = SotStorage::GetVersion( xStorage ); + // Oasis is also the default (0) + bool bOasis = ( version > SOFFICE_FILEFORMAT_60 || version == 0 ); + const char *pServiceName = bOasis + ? "com.sun.star.document.XMLOasisMetaImporter" + : "com.sun.star.document.XMLMetaImporter"; + + // set base URL + css::uno::Reference<css::beans::XPropertySet> xPropArg = + getURLProperties(Medium); + try { + xPropArg->getPropertyValue("BaseURI") + >>= input.sSystemId; + input.sSystemId += OUString::Concat("/") + s_meta; + } catch (const css::uno::Exception &) { + input.sSystemId = s_meta; + } + css::uno::Sequence< css::uno::Any > args{ css::uno::Any(xPropArg) }; + + // the underlying SvXMLImport implements XFastParser, XImporter, XFastDocumentHandler + css::uno::Reference<XInterface> xFilter = + xMsf->createInstanceWithArgumentsAndContext( + OUString::createFromAscii(pServiceName), args, m_xContext); + assert(xFilter); + css::uno::Reference<css::xml::sax::XFastParser> xFastParser(xFilter, css::uno::UNO_QUERY); + css::uno::Reference<css::document::XImporter> xImp(xFilter, css::uno::UNO_QUERY_THROW); + xImp->setTargetDocument(css::uno::Reference<css::lang::XComponent>(this)); + try { + if (xFastParser) + xFastParser->parseStream(input); + else + { + css::uno::Reference<css::xml::sax::XDocumentHandler> xDocHandler(xFilter, css::uno::UNO_QUERY_THROW); + css::uno::Reference<css::xml::sax::XParser> xParser = css::xml::sax::Parser::create(m_xContext); + xParser->setDocumentHandler(xDocHandler); + xParser->parseStream(input); + } + } catch (const css::xml::sax::SAXException &) { + throw css::io::WrongFormatException( + "SfxDocumentMetaData::loadFromStorage:" + " XML parsing exception", *this); + } + // NB: the implementation of XMLOasisMetaImporter calls initialize + checkInit(); +} + +void SAL_CALL +SfxDocumentMetaData::storeToStorage( + const css::uno::Reference< css::embed::XStorage > & xStorage, + const css::uno::Sequence< css::beans::PropertyValue > & Medium) +{ + if (!xStorage.is()) + throw css::lang::IllegalArgumentException( + "SfxDocumentMetaData::storeToStorage: argument is null", *this, 0); + ::osl::MutexGuard g(m_aMutex); + checkInit(); + + // update user-defined meta data in DOM tree +// updateUserDefinedAndAttributes(); // this will be done in serialize! + + // write into storage + css::uno::Reference<css::io::XStream> xStream = + xStorage->openStreamElement(s_meta, + css::embed::ElementModes::WRITE + | css::embed::ElementModes::TRUNCATE); + if (!xStream.is()) throw css::uno::RuntimeException(); + css::uno::Reference< css::beans::XPropertySet > xStreamProps(xStream, + css::uno::UNO_QUERY_THROW); + xStreamProps->setPropertyValue( + "MediaType", + css::uno::Any(OUString("text/xml"))); + xStreamProps->setPropertyValue( + "Compressed", + css::uno::Any(false)); + xStreamProps->setPropertyValue( + "UseCommonStoragePasswordEncryption", + css::uno::Any(false)); + css::uno::Reference<css::io::XOutputStream> xOutStream = + xStream->getOutputStream(); + if (!xOutStream.is()) throw css::uno::RuntimeException(); + css::uno::Reference<css::lang::XMultiComponentFactory> xMsf ( + m_xContext->getServiceManager()); + css::uno::Reference<css::xml::sax::XWriter> xSaxWriter( + css::xml::sax::Writer::create(m_xContext)); + xSaxWriter->setOutputStream(xOutStream); + + const sal_uInt64 version = SotStorage::GetVersion( xStorage ); + // Oasis is also the default (0) + const bool bOasis = ( version > SOFFICE_FILEFORMAT_60 || version == 0 ); + const char *pServiceName = bOasis + ? "com.sun.star.document.XMLOasisMetaExporter" + : "com.sun.star.document.XMLMetaExporter"; + + // set base URL + css::uno::Reference<css::beans::XPropertySet> xPropArg = + getURLProperties(Medium); + css::uno::Sequence< css::uno::Any > args{ css::uno::Any(xSaxWriter), css::uno::Any(xPropArg) }; + + css::uno::Reference<css::document::XExporter> xExp( + xMsf->createInstanceWithArgumentsAndContext( + OUString::createFromAscii(pServiceName), args, m_xContext), + css::uno::UNO_QUERY_THROW); + xExp->setSourceDocument(css::uno::Reference<css::lang::XComponent>(this)); + css::uno::Reference<css::document::XFilter> xFilter(xExp, + css::uno::UNO_QUERY_THROW); + if (!xFilter->filter(css::uno::Sequence< css::beans::PropertyValue >())) { + throw css::io::IOException( + "SfxDocumentMetaData::storeToStorage: cannot filter", *this); + } + css::uno::Reference<css::embed::XTransactedObject> xTransaction( + xStorage, css::uno::UNO_QUERY); + if (xTransaction.is()) { + xTransaction->commit(); + } +} + +void SAL_CALL +SfxDocumentMetaData::loadFromMedium(const OUString & URL, + const css::uno::Sequence< css::beans::PropertyValue > & Medium) +{ + css::uno::Reference<css::io::XInputStream> xIn; + utl::MediaDescriptor md(Medium); + // if we have a URL parameter, it replaces the one in the media descriptor + if (!URL.isEmpty()) { + md[ utl::MediaDescriptor::PROP_URL ] <<= URL; + md[ utl::MediaDescriptor::PROP_READONLY ] <<= true; + } + if (md.addInputStream()) { + md[ utl::MediaDescriptor::PROP_INPUTSTREAM ] >>= xIn; + } + css::uno::Reference<css::embed::XStorage> xStorage; + try { + if (xIn.is()) { + xStorage = ::comphelper::OStorageHelper::GetStorageFromInputStream( + xIn, m_xContext); + } else { // fallback to url parameter + xStorage = ::comphelper::OStorageHelper::GetStorageFromURL( + URL, css::embed::ElementModes::READ, m_xContext); + } + } catch (const css::uno::RuntimeException &) { + throw; + } catch (const css::io::IOException &) { + throw; + } catch (const css::uno::Exception &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw css::lang::WrappedTargetException( + "SfxDocumentMetaData::loadFromMedium: exception", + css::uno::Reference<css::uno::XInterface>(*this), + anyEx); + } + if (!xStorage.is()) { + throw css::uno::RuntimeException( + "SfxDocumentMetaData::loadFromMedium: cannot get Storage", + *this); + } + loadFromStorage(xStorage, md.getAsConstPropertyValueList()); +} + +void SAL_CALL +SfxDocumentMetaData::storeToMedium(const OUString & URL, + const css::uno::Sequence< css::beans::PropertyValue > & Medium) +{ + utl::MediaDescriptor md(Medium); + if (!URL.isEmpty()) { + md[ utl::MediaDescriptor::PROP_URL ] <<= URL; + } + SfxMedium aMedium(md.getAsConstPropertyValueList()); + css::uno::Reference<css::embed::XStorage> xStorage + = aMedium.GetOutputStorage(); + + + if (!xStorage.is()) { + throw css::uno::RuntimeException( + "SfxDocumentMetaData::storeToMedium: cannot get Storage", + *this); + } + // set MIME type of the storage + utl::MediaDescriptor::const_iterator iter + = md.find(utl::MediaDescriptor::PROP_MEDIATYPE); + if (iter != md.end()) { + css::uno::Reference< css::beans::XPropertySet > xProps(xStorage, + css::uno::UNO_QUERY_THROW); + xProps->setPropertyValue( + utl::MediaDescriptor::PROP_MEDIATYPE, + iter->second); + } + storeToStorage(xStorage, md.getAsConstPropertyValueList()); + + + const bool bOk = aMedium.Commit(); + aMedium.Close(); + if ( !bOk ) { + ErrCode nError = aMedium.GetError(); + if ( nError == ERRCODE_NONE ) { + nError = ERRCODE_IO_GENERAL; + } + + throw css::task::ErrorCodeIOException( + "SfxDocumentMetaData::storeToMedium <" + URL + "> Commit failed: " + nError.toHexString(), + css::uno::Reference< css::uno::XInterface >(), sal_uInt32(nError)); + + } +} + +// css::lang::XInitialization: +void SAL_CALL SfxDocumentMetaData::initialize( const css::uno::Sequence< css::uno::Any > & aArguments) +{ + // possible arguments: + // - no argument: default initialization (empty DOM) + // - 1 argument, XDocument: initialize with given DOM and empty base URL + // NB: links in document must be absolute + + ::osl::MutexGuard g(m_aMutex); + css::uno::Reference<css::xml::dom::XDocument> xDoc; + + for (sal_Int32 i = 0; i < aArguments.getLength(); ++i) { + const css::uno::Any any = aArguments[i]; + if (!(any >>= xDoc)) { + throw css::lang::IllegalArgumentException( + "SfxDocumentMetaData::initialize: argument must be XDocument", + *this, static_cast<sal_Int16>(i)); + } + if (!xDoc.is()) { + throw css::lang::IllegalArgumentException( + "SfxDocumentMetaData::initialize: argument is null", + *this, static_cast<sal_Int16>(i)); + } + } + + if (!xDoc.is()) { + // For a new document, we create a new DOM tree here. + xDoc = createDOM(); + } + + init(xDoc); +} + +// css::util::XCloneable: +css::uno::Reference<css::util::XCloneable> SAL_CALL +SfxDocumentMetaData::createClone() +{ + ::osl::MutexGuard g(m_aMutex); + checkInit(); + + rtl::Reference<SfxDocumentMetaData> pNew = createMe(m_xContext); + + // NB: do not copy the modification listeners, only DOM + css::uno::Reference<css::xml::dom::XDocument> xDoc = createDOM(); + try { + updateUserDefinedAndAttributes(); + // deep copy of root node + css::uno::Reference<css::xml::dom::XNode> xRoot( + m_xDoc->getDocumentElement(), css::uno::UNO_QUERY_THROW); + css::uno::Reference<css::xml::dom::XNode> xRootNew( + xDoc->importNode(xRoot, true)); + xDoc->appendChild(xRootNew); + pNew->init(xDoc); + } catch (const css::uno::RuntimeException &) { + throw; + } catch (const css::uno::Exception &) { + css::uno::Any anyEx = cppu::getCaughtException(); + throw css::lang::WrappedTargetRuntimeException( + "SfxDocumentMetaData::createClone: exception", + css::uno::Reference<css::uno::XInterface>(*this), anyEx); + } + return css::uno::Reference<css::util::XCloneable> (pNew); +} + +// css::util::XModifiable: +sal_Bool SAL_CALL SfxDocumentMetaData::isModified( ) +{ + ::osl::MutexGuard g(m_aMutex); + checkInit(); + css::uno::Reference<css::util::XModifiable> xMB(m_xUserDefined, + css::uno::UNO_QUERY); + return m_isModified || (xMB.is() && xMB->isModified()); +} + +void SAL_CALL SfxDocumentMetaData::setModified( sal_Bool bModified ) +{ + css::uno::Reference<css::util::XModifiable> xMB; + { // do not lock mutex while notifying (#i93514#) to prevent deadlock + ::osl::MutexGuard g(m_aMutex); + checkInit(); + m_isModified = bModified; + if ( !bModified && m_xUserDefined.is() ) + { + xMB.set(m_xUserDefined, css::uno::UNO_QUERY); + assert(xMB.is() && + "SfxDocumentMetaData::setModified: PropertyBag not Modifiable?"); + } + } + if (bModified) { + try { + css::uno::Reference<css::uno::XInterface> xThis(*this); + css::lang::EventObject event(xThis); + m_NotifyListeners.notifyEach(&css::util::XModifyListener::modified, + event); + } catch (const css::uno::RuntimeException &) { + throw; + } catch (const css::uno::Exception &) { + // ignore + TOOLS_WARN_EXCEPTION("sfx.doc", "setModified"); + } + } else { + if (xMB.is()) { + xMB->setModified(false); + } + } +} + +// css::util::XModifyBroadcaster: +void SAL_CALL SfxDocumentMetaData::addModifyListener( + const css::uno::Reference< css::util::XModifyListener > & xListener) +{ + ::osl::MutexGuard g(m_aMutex); + checkInit(); + m_NotifyListeners.addInterface(xListener); + css::uno::Reference<css::util::XModifyBroadcaster> xMB(m_xUserDefined, + css::uno::UNO_QUERY); + if (xMB.is()) { + xMB->addModifyListener(xListener); + } +} + +void SAL_CALL SfxDocumentMetaData::removeModifyListener( + const css::uno::Reference< css::util::XModifyListener > & xListener) +{ + ::osl::MutexGuard g(m_aMutex); + checkInit(); + m_NotifyListeners.removeInterface(xListener); + css::uno::Reference<css::util::XModifyBroadcaster> xMB(m_xUserDefined, + css::uno::UNO_QUERY); + if (xMB.is()) { + xMB->removeModifyListener(xListener); + } +} + +// css::xml::sax::XSAXSerializable +void SAL_CALL SfxDocumentMetaData::serialize( + const css::uno::Reference<css::xml::sax::XDocumentHandler>& i_xHandler, + const css::uno::Sequence< css::beans::StringPair >& i_rNamespaces) +{ + ::osl::MutexGuard g(m_aMutex); + checkInit(); + updateUserDefinedAndAttributes(); + css::uno::Reference<css::xml::sax::XSAXSerializable> xSAXable(m_xDoc, + css::uno::UNO_QUERY_THROW); + xSAXable->serialize(i_xHandler, i_rNamespaces); +} + +void SfxDocumentMetaData::createUserDefined() +{ + // user-defined meta data: create PropertyBag which only accepts property + // values of allowed types + if ( m_xUserDefined.is() ) + return; + + css::uno::Sequence<css::uno::Type> types{ + ::cppu::UnoType<bool>::get(), + ::cppu::UnoType< OUString>::get(), + ::cppu::UnoType<css::util::DateTime>::get(), + ::cppu::UnoType<css::util::Date>::get(), + ::cppu::UnoType<css::util::DateTimeWithTimezone>::get(), + ::cppu::UnoType<css::util::DateWithTimezone>::get(), + ::cppu::UnoType<css::util::Duration>::get(), + ::cppu::UnoType<float>::get(), + ::cppu::UnoType<double>::get(), + ::cppu::UnoType<sal_Int16>::get(), + ::cppu::UnoType<sal_Int32>::get(), + ::cppu::UnoType<sal_Int64>::get(), + // Time is supported for backward compatibility with OOo 3.x, x<=2 + ::cppu::UnoType<css::util::Time>::get() + }; + // #i94175#: ODF allows empty user-defined property names! + m_xUserDefined.set( + css::beans::PropertyBag::createWithTypes( m_xContext, types, true/*AllowEmptyPropertyName*/, false/*AutomaticAddition*/ ), + css::uno::UNO_QUERY_THROW); + + const css::uno::Reference<css::util::XModifyBroadcaster> xMB( + m_xUserDefined, css::uno::UNO_QUERY); + if (xMB.is()) + { + const std::vector<css::uno::Reference<css::util::XModifyListener> > + listeners(m_NotifyListeners.getElements()); + for (const auto& l : listeners) { + xMB->addModifyListener(l); + } + } +} + +} // closing anonymous implementation namespace + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * +CompatWriterDocPropsImpl_get_implementation( + css::uno::XComponentContext *context, + css::uno::Sequence<css::uno::Any> const &) +{ + return cppu::acquire(new CompatWriterDocPropsImpl(context)); +} + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * +SfxDocumentMetaData_get_implementation( + css::uno::XComponentContext *context, + css::uno::Sequence<css::uno::Any> const &) +{ + return cppu::acquire(new SfxDocumentMetaData(context)); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/SfxRedactionHelper.cxx b/sfx2/source/doc/SfxRedactionHelper.cxx new file mode 100644 index 000000000..beb96b55d --- /dev/null +++ b/sfx2/source/doc/SfxRedactionHelper.cxx @@ -0,0 +1,562 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/. + */ + +#include <SfxRedactionHelper.hxx> +#include <autoredactdialog.hxx> + +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/drawing/XDrawPagesSupplier.hpp> +#include <com/sun/star/drawing/LineStyle.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/graphic/XGraphic.hpp> +#include <com/sun/star/frame/XLayoutManager.hpp> + +// For page margin related methods +#include <com/sun/star/style/XStyle.hpp> +#include <com/sun/star/style/XStyleFamiliesSupplier.hpp> +#include <com/sun/star/text/XPageCursor.hpp> +#include <com/sun/star/text/XTextViewCursorSupplier.hpp> +#include <com/sun/star/sheet/XSpreadsheetView.hpp> + +// Search util +#include <i18nutil/searchopt.hxx> +#include <com/sun/star/util/SearchAlgorithms.hpp> +#include <com/sun/star/util/SearchAlgorithms2.hpp> +#include <com/sun/star/util/SearchFlags.hpp> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> +#include <i18nlangtag/languagetag.hxx> +#include <unotools/textsearch.hxx> + +#include <sfx2/request.hxx> +#include <sfx2/sfxsids.hrc> +#include <sfx2/viewfrm.hxx> + +#include <svl/eitem.hxx> +#include <svl/stritem.hxx> + +#include <svtools/DocumentToGraphicRenderer.hxx> + +#include <tools/gen.hxx> +#include <tools/stream.hxx> +#include <tools/diagnose_ex.h> + +#include <vcl/gdimtf.hxx> +#include <vcl/graph.hxx> +#include <sal/log.hxx> + +#include <vcl/wmf.hxx> +#include <vcl/metaact.hxx> +#include <vcl/outdev.hxx> +#include <vcl/vcllayout.hxx> +#include <o3tl/string_view.hxx> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::uno; + +bool SfxRedactionHelper::isRedactMode(const SfxRequest& rReq) +{ + const SfxItemSet* pArgs = rReq.GetArgs(); + if (pArgs) + { + const SfxBoolItem* pIsRedactMode = rReq.GetArg<SfxBoolItem>(SID_IS_REDACT_MODE); + if (pIsRedactMode && pIsRedactMode->GetValue()) + return true; + } + + return false; +} + +OUString SfxRedactionHelper::getStringParam(const SfxRequest& rReq, sal_uInt16 nParamId) +{ + OUString sStringParam; + + const SfxItemSet* pArgs = rReq.GetArgs(); + if (!pArgs) + return sStringParam; + + const SfxStringItem* pStringArg = rReq.GetArg<SfxStringItem>(nParamId); + if (!pStringArg) + return sStringParam; + + sStringParam = pStringArg->GetValue(); + return sStringParam; +} + +namespace +{ +/* + * Roundtrip the gdimetafile to and from WMF + * to get rid of the position and size irregularities + * We better check the conversion method to see what it + * actually does to correct these issues, and do it ourselves. + * */ +void fixMetaFile(GDIMetaFile& tmpMtf) +{ + SvMemoryStream aDestStrm(65535, 65535); + ConvertGDIMetaFileToWMF(tmpMtf, aDestStrm, nullptr, false); + aDestStrm.Seek(0); + + tmpMtf.Clear(); + + ReadWindowMetafile(aDestStrm, tmpMtf); +} + +/* + * Sets page margins for a Draw page. Negative values are considered erroneous + * */ +void setPageMargins(const uno::Reference<beans::XPropertySet>& xPageProperySet, + const PageMargins& aPageMargins) +{ + if (aPageMargins.nTop < 0 || aPageMargins.nBottom < 0 || aPageMargins.nLeft < 0 + || aPageMargins.nRight < 0) + return; + + xPageProperySet->setPropertyValue("BorderTop", css::uno::Any(aPageMargins.nTop)); + xPageProperySet->setPropertyValue("BorderBottom", css::uno::Any(aPageMargins.nBottom)); + xPageProperySet->setPropertyValue("BorderLeft", css::uno::Any(aPageMargins.nLeft)); + xPageProperySet->setPropertyValue("BorderRight", css::uno::Any(aPageMargins.nRight)); +} + +// #i10613# Extracted from ImplCheckRect::ImplCreate +tools::Rectangle ImplCalcActionBounds(const MetaAction& rAct, const OutputDevice& rOut, + sal_Int32 nStrStartPos, sal_Int32 nStrEndPos) +{ + tools::Rectangle aActionBounds; + + switch (rAct.GetType()) + { + case MetaActionType::TEXTARRAY: + { + const MetaTextArrayAction& rTextAct = static_cast<const MetaTextArrayAction&>(rAct); + const OUString aString(rTextAct.GetText().copy(rTextAct.GetIndex(), rTextAct.GetLen())); + + if (!aString.isEmpty()) + { + // #105987# ImplLayout takes everything in logical coordinates + std::unique_ptr<SalLayout> pSalLayout1 = rOut.ImplLayout( + aString, 0, nStrStartPos, rTextAct.GetPoint(), 0, rTextAct.GetDXArray()); + std::unique_ptr<SalLayout> pSalLayout2 = rOut.ImplLayout( + aString, 0, nStrEndPos, rTextAct.GetPoint(), 0, rTextAct.GetDXArray()); + if (pSalLayout2) + { + tools::Rectangle aBoundRect2(rOut.ImplGetTextBoundRect(*pSalLayout2)); + aActionBounds = rOut.PixelToLogic(aBoundRect2); + } + if (pSalLayout1 && nStrStartPos > 0) + { + tools::Rectangle aBoundRect1(rOut.ImplGetTextBoundRect(*pSalLayout1)); + aActionBounds.SetLeft(rOut.PixelToLogic(aBoundRect1).Right()); + } + } + } + break; + + default: + break; + } + + if (!aActionBounds.IsEmpty()) + { + // fdo#40421 limit current action's output to clipped area + if (rOut.IsClipRegion()) + return rOut.GetClipRegion().GetBoundRect().Intersection(aActionBounds); + else + return aActionBounds; + } + else + return aActionBounds; +} + +} // End of anon namespace + +void SfxRedactionHelper::getPageMetaFilesFromDoc(std::vector<GDIMetaFile>& aMetaFiles, + std::vector<::Size>& aPageSizes, sal_Int32 nPages, + DocumentToGraphicRenderer& aRenderer) +{ + for (sal_Int32 nPage = 1; nPage <= nPages; ++nPage) + { + ::Size aDocumentSizePixel = aRenderer.getDocumentSizeInPixels(nPage); + ::Point aLogicPos; + ::Point aCalcPageLogicPos; + ::Size aCalcPageContentSize; + ::Size aLogic = aRenderer.getDocumentSizeIn100mm(nPage, &aLogicPos, &aCalcPageLogicPos, + &aCalcPageContentSize); + + aPageSizes.push_back(aLogic); + + Graphic aGraphic = aRenderer.renderToGraphic(nPage, aDocumentSizePixel, aDocumentSizePixel, + COL_TRANSPARENT, true); + auto& rGDIMetaFile = const_cast<GDIMetaFile&>(aGraphic.GetGDIMetaFile()); + + // Set preferred map unit and size on the metafile, so the Shape size + // will be correct in MM. + MapMode aMapMode; + aMapMode.SetMapUnit(MapUnit::Map100thMM); + + rGDIMetaFile.SetPrefMapMode(aMapMode); + rGDIMetaFile.SetPrefSize(aLogic); + + fixMetaFile(rGDIMetaFile); + + aMetaFiles.push_back(rGDIMetaFile); + } +} + +void SfxRedactionHelper::addPagesToDraw( + const uno::Reference<XComponent>& xComponent, sal_Int32 nPages, + const std::vector<GDIMetaFile>& aMetaFiles, const std::vector<::Size>& aPageSizes, + const PageMargins& aPageMargins, + const std::vector<std::pair<RedactionTarget, OUString>>& r_aTableTargets, bool bIsAutoRedact) +{ + // Access the draw pages + uno::Reference<drawing::XDrawPagesSupplier> xDrawPagesSupplier(xComponent, uno::UNO_QUERY); + uno::Reference<drawing::XDrawPages> xDrawPages = xDrawPagesSupplier->getDrawPages(); + + uno::Reference<css::lang::XMultiServiceFactory> xFactory(xComponent, uno::UNO_QUERY); + + for (sal_Int32 nPage = 0; nPage < nPages; ++nPage) + { + GDIMetaFile rGDIMetaFile = aMetaFiles[nPage]; + Graphic aGraphic(rGDIMetaFile); + + sal_Int32 nPageHeight(aPageSizes[nPage].Height()); + sal_Int32 nPageWidth(aPageSizes[nPage].Width()); + + uno::Reference<graphic::XGraphic> xGraph = aGraphic.GetXGraphic(); + uno::Reference<drawing::XDrawPage> xPage = xDrawPages->insertNewByIndex(nPage); + + // Set page size & margins + uno::Reference<beans::XPropertySet> xPageProperySet(xPage, uno::UNO_QUERY); + xPageProperySet->setPropertyValue("Height", css::uno::Any(nPageHeight)); + xPageProperySet->setPropertyValue("Width", css::uno::Any(nPageWidth)); + + setPageMargins(xPageProperySet, aPageMargins); + + // Create and insert the shape + uno::Reference<drawing::XShape> xShape( + xFactory->createInstance("com.sun.star.drawing.GraphicObjectShape"), uno::UNO_QUERY); + uno::Reference<beans::XPropertySet> xShapeProperySet(xShape, uno::UNO_QUERY); + xShapeProperySet->setPropertyValue("Graphic", uno::Any(xGraph)); + xShapeProperySet->setPropertyValue("MoveProtect", uno::Any(true)); + xShapeProperySet->setPropertyValue("SizeProtect", uno::Any(true)); + + // Set size + xShape->setSize( + awt::Size(rGDIMetaFile.GetPrefSize().Width(), rGDIMetaFile.GetPrefSize().Height())); + + xPage->add(xShape); + + if (bIsAutoRedact && !r_aTableTargets.empty()) + { + for (const auto& targetPair : r_aTableTargets) + { + autoRedactPage(targetPair.first, rGDIMetaFile, xPage, xComponent); + } + } + } + + // Remove the extra page at the beginning + uno::Reference<drawing::XDrawPage> xPage(xDrawPages->getByIndex(0), uno::UNO_QUERY_THROW); + xDrawPages->remove(xPage); +} + +void SfxRedactionHelper::showRedactionToolbar(const SfxViewFrame* pViewFrame) +{ + if (!pViewFrame) + return; + + Reference<frame::XFrame> xFrame = pViewFrame->GetFrame().GetFrameInterface(); + Reference<css::beans::XPropertySet> xPropSet(xFrame, UNO_QUERY); + Reference<css::frame::XLayoutManager> xLayoutManager; + + if (!xPropSet.is()) + return; + + try + { + Any aValue = xPropSet->getPropertyValue("LayoutManager"); + aValue >>= xLayoutManager; + xLayoutManager->createElement("private:resource/toolbar/redactionbar"); + xLayoutManager->showElement("private:resource/toolbar/redactionbar"); + } + catch (const css::uno::RuntimeException&) + { + throw; + } + catch (css::uno::Exception&) + { + TOOLS_WARN_EXCEPTION("sfx.doc", "Exception while trying to show the Redaction Toolbar!"); + } +} + +PageMargins +SfxRedactionHelper::getPageMarginsForWriter(const css::uno::Reference<css::frame::XModel>& xModel) +{ + PageMargins aPageMargins = { -1, -1, -1, -1 }; + + Reference<text::XTextViewCursorSupplier> xTextViewCursorSupplier(xModel->getCurrentController(), + UNO_QUERY); + if (!xTextViewCursorSupplier.is()) + { + SAL_WARN("sfx.doc", "Ref to xTextViewCursorSupplier is null in setPageMargins()."); + return aPageMargins; + } + + Reference<text::XPageCursor> xCursor(xTextViewCursorSupplier->getViewCursor(), UNO_QUERY); + + uno::Reference<beans::XPropertySet> xPageProperySet(xCursor, UNO_QUERY); + OUString sPageStyleName; + Any aValue = xPageProperySet->getPropertyValue("PageStyleName"); + aValue >>= sPageStyleName; + + Reference<css::style::XStyleFamiliesSupplier> xStyleFamiliesSupplier(xModel, UNO_QUERY); + if (!xStyleFamiliesSupplier.is()) + { + SAL_WARN("sfx.doc", "Ref to xStyleFamiliesSupplier is null in setPageMargins()."); + return aPageMargins; + } + uno::Reference<container::XNameAccess> xStyleFamilies + = xStyleFamiliesSupplier->getStyleFamilies(); + + if (!xStyleFamilies.is()) + return aPageMargins; + + uno::Reference<container::XNameAccess> xPageStyles(xStyleFamilies->getByName("PageStyles"), + UNO_QUERY); + + if (!xPageStyles.is()) + return aPageMargins; + + uno::Reference<css::style::XStyle> xPageStyle(xPageStyles->getByName(sPageStyleName), + UNO_QUERY); + + if (!xPageStyle.is()) + return aPageMargins; + + uno::Reference<beans::XPropertySet> xPageProperties(xPageStyle, uno::UNO_QUERY); + + if (!xPageProperties.is()) + return aPageMargins; + + xPageProperties->getPropertyValue("LeftMargin") >>= aPageMargins.nLeft; + xPageProperties->getPropertyValue("RightMargin") >>= aPageMargins.nRight; + xPageProperties->getPropertyValue("TopMargin") >>= aPageMargins.nTop; + xPageProperties->getPropertyValue("BottomMargin") >>= aPageMargins.nBottom; + + return aPageMargins; +} + +PageMargins +SfxRedactionHelper::getPageMarginsForCalc(const css::uno::Reference<css::frame::XModel>& xModel) +{ + PageMargins aPageMargins = { -1, -1, -1, -1 }; + OUString sPageStyleName("Default"); + + css::uno::Reference<css::sheet::XSpreadsheetView> xSpreadsheetView( + xModel->getCurrentController(), UNO_QUERY); + + if (!xSpreadsheetView.is()) + { + SAL_WARN("sfx.doc", "Ref to xSpreadsheetView is null in getPageMarginsForCalc()."); + return aPageMargins; + } + + uno::Reference<beans::XPropertySet> xSheetProperties(xSpreadsheetView->getActiveSheet(), + UNO_QUERY); + + xSheetProperties->getPropertyValue("PageStyle") >>= sPageStyleName; + + Reference<css::style::XStyleFamiliesSupplier> xStyleFamiliesSupplier(xModel, UNO_QUERY); + if (!xStyleFamiliesSupplier.is()) + { + SAL_WARN("sfx.doc", "Ref to xStyleFamiliesSupplier is null in getPageMarginsForCalc()."); + return aPageMargins; + } + uno::Reference<container::XNameAccess> xStyleFamilies + = xStyleFamiliesSupplier->getStyleFamilies(); + + if (!xStyleFamilies.is()) + return aPageMargins; + + uno::Reference<container::XNameAccess> xPageStyles(xStyleFamilies->getByName("PageStyles"), + UNO_QUERY); + + if (!xPageStyles.is()) + return aPageMargins; + + uno::Reference<css::style::XStyle> xPageStyle(xPageStyles->getByName(sPageStyleName), + UNO_QUERY); + + if (!xPageStyle.is()) + return aPageMargins; + + uno::Reference<beans::XPropertySet> xPageProperties(xPageStyle, uno::UNO_QUERY); + + if (!xPageProperties.is()) + return aPageMargins; + + xPageProperties->getPropertyValue("LeftMargin") >>= aPageMargins.nLeft; + xPageProperties->getPropertyValue("RightMargin") >>= aPageMargins.nRight; + xPageProperties->getPropertyValue("TopMargin") >>= aPageMargins.nTop; + xPageProperties->getPropertyValue("BottomMargin") >>= aPageMargins.nBottom; + + return aPageMargins; +} + +void SfxRedactionHelper::searchInMetaFile(const RedactionTarget& rRedactionTarget, + const GDIMetaFile& rMtf, + std::vector<::tools::Rectangle>& aRedactionRectangles, + const uno::Reference<XComponent>& xComponent) +{ + // Initialize search + i18nutil::SearchOptions2 aSearchOptions; + fillSearchOptions(aSearchOptions, rRedactionTarget); + + utl::TextSearch textSearch(aSearchOptions); + static tools::Long aLastFontHeight = 0; + + MetaAction* pCurrAct; + + for (pCurrAct = const_cast<GDIMetaFile&>(rMtf).FirstAction(); pCurrAct; + pCurrAct = const_cast<GDIMetaFile&>(rMtf).NextAction()) + { + // Watch for TEXTARRAY actions. + // They contain the text of paragraphs. + if (pCurrAct->GetType() == MetaActionType::TEXTARRAY) + { + MetaTextArrayAction* pMetaTextArrayAction = static_cast<MetaTextArrayAction*>(pCurrAct); + + // Search operation takes place here + OUString sText = pMetaTextArrayAction->GetText(); + sal_Int32 nStart = 0; + sal_Int32 nEnd = sText.getLength(); + + bool bFound = textSearch.SearchForward(sText, &nStart, &nEnd); + + // If found the string, add the corresponding rectangle to the collection + while (bFound) + { + OutputDevice* pOutputDevice + = SfxObjectShell::GetShellFromComponent(xComponent)->GetDocumentRefDev(); + tools::Rectangle aNewRect( + ImplCalcActionBounds(*pMetaTextArrayAction, *pOutputDevice, nStart, nEnd)); + + if (!aNewRect.IsEmpty()) + { + // Calculate the difference between current wrong value and value should it be. + // Add the difference to current value. + // Then increase 10% of the new value to make it look better. + aNewRect.SetTop(aNewRect.Bottom() - aLastFontHeight - aLastFontHeight / 10); + aRedactionRectangles.push_back(aNewRect); + } + + // Search for the next occurrence + nStart = nEnd; + nEnd = sText.getLength(); + bFound = textSearch.SearchForward(sText, &nStart, &nEnd); + } + } + else if (pCurrAct->GetType() == MetaActionType::FONT) + { + const MetaFontAction* pFontAct = static_cast<const MetaFontAction*>(pCurrAct); + aLastFontHeight = pFontAct->GetFont().GetFontSize().getHeight(); + } + } +} + +void SfxRedactionHelper::addRedactionRectToPage( + const uno::Reference<XComponent>& xComponent, const uno::Reference<drawing::XDrawPage>& xPage, + const std::vector<::tools::Rectangle>& aNewRectangles) +{ + if (!xComponent.is() || !xPage.is()) + return; + + if (aNewRectangles.empty()) + return; + + uno::Reference<css::lang::XMultiServiceFactory> xFactory(xComponent, uno::UNO_QUERY); + + for (auto const& aNewRectangle : aNewRectangles) + { + uno::Reference<drawing::XShape> xRectShape( + xFactory->createInstance("com.sun.star.drawing.RectangleShape"), uno::UNO_QUERY); + uno::Reference<beans::XPropertySet> xRectShapeProperySet(xRectShape, uno::UNO_QUERY); + + xRectShapeProperySet->setPropertyValue("Name", + uno::Any(OUString("RectangleRedactionShape"))); + xRectShapeProperySet->setPropertyValue("FillTransparence", + css::uno::Any(static_cast<sal_Int16>(50))); + xRectShapeProperySet->setPropertyValue("FillColor", css::uno::Any(COL_GRAY7)); + xRectShapeProperySet->setPropertyValue( + "LineStyle", css::uno::Any(css::drawing::LineStyle::LineStyle_NONE)); + + xRectShape->setSize(awt::Size(aNewRectangle.GetWidth(), aNewRectangle.GetHeight())); + xRectShape->setPosition(awt::Point(aNewRectangle.Left(), aNewRectangle.Top())); + + xPage->add(xRectShape); + } +} + +void SfxRedactionHelper::autoRedactPage(const RedactionTarget& rRedactionTarget, + const GDIMetaFile& rGDIMetaFile, + const uno::Reference<drawing::XDrawPage>& xPage, + const uno::Reference<XComponent>& xComponent) +{ + if (rRedactionTarget.sContent.isEmpty()) + return; + + // Search for the redaction strings, and get the rectangle coordinates + std::vector<::tools::Rectangle> aRedactionRectangles; + searchInMetaFile(rRedactionTarget, rGDIMetaFile, aRedactionRectangles, xComponent); + + // Add the redaction rectangles to the page + addRedactionRectToPage(xComponent, xPage, aRedactionRectangles); +} + +namespace +{ +const LanguageTag& GetAppLanguageTag() { return Application::GetSettings().GetLanguageTag(); } +} + +void SfxRedactionHelper::fillSearchOptions(i18nutil::SearchOptions2& rSearchOpt, + const RedactionTarget& rTarget) +{ + if (rTarget.sType == RedactionTargetType::REDACTION_TARGET_REGEX + || rTarget.sType == RedactionTargetType::REDACTION_TARGET_PREDEFINED) + { + rSearchOpt.algorithmType = util::SearchAlgorithms_REGEXP; + rSearchOpt.AlgorithmType2 = util::SearchAlgorithms2::REGEXP; + } + else + { + rSearchOpt.algorithmType = util::SearchAlgorithms_ABSOLUTE; + rSearchOpt.AlgorithmType2 = util::SearchAlgorithms2::ABSOLUTE; + } + + rSearchOpt.Locale = GetAppLanguageTag().getLocale(); + if (rTarget.sType == RedactionTargetType::REDACTION_TARGET_PREDEFINED) + { + auto nPredefIndex = o3tl::toUInt32(o3tl::getToken(rTarget.sContent, 0, ';')); + rSearchOpt.searchString = m_aPredefinedTargets[nPredefIndex]; + } + else + rSearchOpt.searchString = rTarget.sContent; + + rSearchOpt.replaceString.clear(); + + if (!rTarget.bCaseSensitive && rTarget.sType != RedactionTargetType::REDACTION_TARGET_REGEX + && rTarget.sType != RedactionTargetType::REDACTION_TARGET_PREDEFINED) + rSearchOpt.transliterateFlags |= TransliterationFlags::IGNORE_CASE; + if (rTarget.bWholeWords) + rSearchOpt.searchFlag |= util::SearchFlags::NORM_WORD_ONLY; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/sfx2/source/doc/autoredactdialog.cxx b/sfx2/source/doc/autoredactdialog.cxx new file mode 100644 index 000000000..6509f8c47 --- /dev/null +++ b/sfx2/source/doc/autoredactdialog.cxx @@ -0,0 +1,770 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/. + */ + +#include <autoredactdialog.hxx> + +#include <sfx2/filedlghelper.hxx> +#include <sfx2/sfxresid.hxx> +#include <sfx2/strings.hrc> + +#include <osl/file.hxx> +#include <sal/log.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> +#include <unotools/viewoptions.hxx> +#include <o3tl/string_view.hxx> + +#include <com/sun/star/ui/dialogs/TemplateDescription.hpp> + +#include <boost/property_tree/json_parser.hpp> + +constexpr OUStringLiteral FILEDIALOG_FILTER_JSON = u"*.json"; + +int TargetsTable::GetRowByTargetName(std::u16string_view sName) +{ + for (int i = 0, nCount = m_xControl->n_children(); i < nCount; ++i) + { + RedactionTarget* pTarget = weld::fromId<RedactionTarget*>(m_xControl->get_id(i)); + if (pTarget->sName == sName) + { + return i; + } + } + return -1; +} + +TargetsTable::TargetsTable(std::unique_ptr<weld::TreeView> xControl) + : m_xControl(std::move(xControl)) +{ + m_xControl->set_size_request(555, 250); + std::vector<int> aWidths{ 100, 50, 200, 105, 105 }; + m_xControl->set_column_fixed_widths(aWidths); + m_xControl->set_selection_mode(SelectionMode::Multiple); +} + +namespace +{ +OUString getTypeName(RedactionTargetType nType) +{ + OUString sTypeName(SfxResId(STR_REDACTION_TARGET_TYPE_UNKNOWN)); + + switch (nType) + { + case RedactionTargetType::REDACTION_TARGET_TEXT: + sTypeName = SfxResId(STR_REDACTION_TARGET_TYPE_TEXT); + break; + case RedactionTargetType::REDACTION_TARGET_REGEX: + sTypeName = SfxResId(STR_REDACTION_TARGET_TYPE_REGEX); + break; + case RedactionTargetType::REDACTION_TARGET_PREDEFINED: + sTypeName = SfxResId(STR_REDACTION_TARGET_TYPE_PREDEF); + break; + case RedactionTargetType::REDACTION_TARGET_UNKNOWN: + sTypeName = SfxResId(STR_REDACTION_TARGET_TYPE_UNKNOWN); + break; + } + + return sTypeName; +} + +/// Returns TypeID to be used in the add/edit target dialog +OUString getTypeID(RedactionTargetType nType) +{ + OUString sTypeID("unknown"); + + switch (nType) + { + case RedactionTargetType::REDACTION_TARGET_TEXT: + sTypeID = "text"; + break; + case RedactionTargetType::REDACTION_TARGET_REGEX: + sTypeID = "regex"; + break; + case RedactionTargetType::REDACTION_TARGET_PREDEFINED: + sTypeID = "predefined"; + break; + case RedactionTargetType::REDACTION_TARGET_UNKNOWN: + sTypeID = "unknown"; + break; + } + + return sTypeID; +} +} + +void TargetsTable::InsertTarget(RedactionTarget* pTarget) +{ + if (!pTarget) + { + SAL_WARN("sfx.doc", "pTarget is null in TargetsTable::InsertTarget()"); + return; + } + + // Check if the name is empty or invalid (clashing with another entry's name) + if (pTarget->sName.isEmpty() || GetRowByTargetName(pTarget->sName) != -1) + { + pTarget->sName = GetNameProposal(); + } + + OUString sContent = pTarget->sContent; + + if (pTarget->sType == RedactionTargetType::REDACTION_TARGET_PREDEFINED) + { + //selection_num;selection_name + sContent = sContent.getToken(1, ';'); + } + + // Add to the end + int nRow = m_xControl->n_children(); + m_xControl->append(weld::toId(pTarget), pTarget->sName); + m_xControl->set_text(nRow, getTypeName(pTarget->sType), 1); + m_xControl->set_text(nRow, sContent, 2); + m_xControl->set_text( + nRow, pTarget->bCaseSensitive ? SfxResId(STR_REDACTION_YES) : SfxResId(STR_REDACTION_NO), + 3); + m_xControl->set_text( + nRow, pTarget->bWholeWords ? SfxResId(STR_REDACTION_YES) : SfxResId(STR_REDACTION_NO), 4); +} + +RedactionTarget* TargetsTable::GetTargetByName(std::u16string_view sName) +{ + int nEntry = GetRowByTargetName(sName); + if (nEntry == -1) + return nullptr; + + return weld::fromId<RedactionTarget*>(m_xControl->get_id(nEntry)); +} + +OUString TargetsTable::GetNameProposal() const +{ + OUString sDefaultTargetName(SfxResId(STR_REDACTION_TARGET)); + sal_Int32 nHighestTargetId = 0; + for (int i = 0, nCount = m_xControl->n_children(); i < nCount; ++i) + { + RedactionTarget* pTarget = weld::fromId<RedactionTarget*>(m_xControl->get_id(i)); + const OUString& sName = pTarget->sName; + sal_Int32 nIndex = 0; + if (o3tl::getToken(sName, 0, ' ', nIndex) == sDefaultTargetName) + { + sal_Int32 nCurrTargetId = o3tl::toInt32(o3tl::getToken(sName, 0, ' ', nIndex)); + nHighestTargetId = std::max<sal_Int32>(nHighestTargetId, nCurrTargetId); + } + } + return sDefaultTargetName + " " + OUString::number(nHighestTargetId + 1); +} + +void TargetsTable::setRowData(int nRowIndex, const RedactionTarget* pTarget) +{ + OUString sContent = pTarget->sContent; + + if (pTarget->sType == RedactionTargetType::REDACTION_TARGET_PREDEFINED) + { + //selection_num;selection_name + sContent = sContent.getToken(1, ';'); + } + + m_xControl->set_text(nRowIndex, pTarget->sName, 0); + m_xControl->set_text(nRowIndex, getTypeName(pTarget->sType), 1); + m_xControl->set_text(nRowIndex, sContent, 2); + m_xControl->set_text( + nRowIndex, + pTarget->bCaseSensitive ? SfxResId(STR_REDACTION_YES) : SfxResId(STR_REDACTION_NO), 3); + m_xControl->set_text( + nRowIndex, pTarget->bWholeWords ? SfxResId(STR_REDACTION_YES) : SfxResId(STR_REDACTION_NO), + 4); +} + +IMPL_LINK_NOARG(SfxAutoRedactDialog, Load, weld::Button&, void) +{ + //Load a targets list from a previously saved file (a json file?) + // ask for filename, where we should load the new config data from + StartFileDialog(StartFileDialogType::Open, SfxResId(STR_REDACTION_LOAD_TARGETS)); +} + +IMPL_LINK_NOARG(SfxAutoRedactDialog, Save, weld::Button&, void) +{ + //Allow saving the targets into a file + StartFileDialog(StartFileDialogType::SaveAs, SfxResId(STR_REDACTION_SAVE_TARGETS)); +} + +IMPL_LINK_NOARG(SfxAutoRedactDialog, AddHdl, weld::Button&, void) +{ + // Open the Add Target dialog, create a new target and insert into the targets vector and the listbox + SfxAddTargetDialog aAddTargetDialog(getDialog(), m_xTargetsBox->GetNameProposal()); + + bool bIncomplete; + do + { + bIncomplete = false; + + if (aAddTargetDialog.run() != RET_OK) + return; + + if (aAddTargetDialog.getName().isEmpty() + || aAddTargetDialog.getType() == RedactionTargetType::REDACTION_TARGET_UNKNOWN + || aAddTargetDialog.getContent().isEmpty()) + { + bIncomplete = true; + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog( + getDialog(), VclMessageType::Warning, VclButtonsType::Ok, + SfxResId(STR_REDACTION_FIELDS_REQUIRED))); + xBox->run(); + } + else if (m_xTargetsBox->GetTargetByName(aAddTargetDialog.getName())) + { + bIncomplete = true; + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog( + getDialog(), VclMessageType::Warning, VclButtonsType::Ok, + SfxResId(STR_REDACTION_TARGET_NAME_CLASH))); + xBox->run(); + } + + } while (bIncomplete); + + //Alright, we now have everything we need to construct a new target + RedactionTarget* redactiontarget = new RedactionTarget( + { aAddTargetDialog.getName(), aAddTargetDialog.getType(), aAddTargetDialog.getContent(), + aAddTargetDialog.isCaseSensitive(), aAddTargetDialog.isWholeWords(), 0 }); + + // Only the visual/display part + m_xTargetsBox->InsertTarget(redactiontarget); + + // Actually add to the targets vector + if (m_xTargetsBox->GetTargetByName(redactiontarget->sName)) + m_aTableTargets.emplace_back(redactiontarget, redactiontarget->sName); + else + { + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog( + getDialog(), VclMessageType::Warning, VclButtonsType::Ok, + SfxResId(STR_REDACTION_TARGET_ADD_ERROR))); + xBox->run(); + delete redactiontarget; + } +} + +IMPL_LINK_NOARG(SfxAutoRedactDialog, EditHdl, weld::Button&, void) +{ + sal_Int32 nSelectedRow = m_xTargetsBox->get_selected_index(); + + // No selection, nothing to edit + if (nSelectedRow < 0) + return; + + // Only one entry should be selected for editing + if (m_xTargetsBox->get_selected_rows().size() > 1) + { + //Warn the user about multiple selections + std::unique_ptr<weld::MessageDialog> xBox( + Application::CreateMessageDialog(getDialog(), VclMessageType::Error, VclButtonsType::Ok, + SfxResId(STR_REDACTION_MULTI_EDIT))); + xBox->run(); + return; + } + + // Get the redaction target to be edited + RedactionTarget* pTarget = weld::fromId<RedactionTarget*>(m_xTargetsBox->get_id(nSelectedRow)); + + // Construct and run the edit target dialog + SfxAddTargetDialog aEditTargetDialog(getDialog(), pTarget->sName, pTarget->sType, + pTarget->sContent, pTarget->bCaseSensitive, + pTarget->bWholeWords); + + bool bIncomplete; + do + { + bIncomplete = false; + + if (aEditTargetDialog.run() != RET_OK) + return; + + if (aEditTargetDialog.getName().isEmpty() + || aEditTargetDialog.getType() == RedactionTargetType::REDACTION_TARGET_UNKNOWN + || aEditTargetDialog.getContent().isEmpty()) + { + bIncomplete = true; + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog( + getDialog(), VclMessageType::Warning, VclButtonsType::Ok, + SfxResId(STR_REDACTION_FIELDS_REQUIRED))); + xBox->run(); + } + else if (aEditTargetDialog.getName() != pTarget->sName + && m_xTargetsBox->GetTargetByName(aEditTargetDialog.getName())) + { + bIncomplete = true; + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog( + getDialog(), VclMessageType::Warning, VclButtonsType::Ok, + SfxResId(STR_REDACTION_TARGET_NAME_CLASH))); + xBox->run(); + } + + } while (bIncomplete); + + // Update the redaction target + pTarget->sName = aEditTargetDialog.getName(); + pTarget->sType = aEditTargetDialog.getType(); + pTarget->sContent = aEditTargetDialog.getContent(); + pTarget->bCaseSensitive = aEditTargetDialog.isCaseSensitive(); + pTarget->bWholeWords = aEditTargetDialog.isWholeWords(); + + // And sync the targets box row with the actual target data + m_xTargetsBox->setRowData(nSelectedRow, pTarget); +} +IMPL_LINK_NOARG(SfxAutoRedactDialog, DoubleClickEditHdl, weld::TreeView&, bool) +{ + if (m_xEditBtn->get_sensitive()) + m_xEditBtn->clicked(); + return true; +} +IMPL_LINK_NOARG(SfxAutoRedactDialog, DeleteHdl, weld::Button&, void) +{ + std::vector<int> aSelectedRows = m_xTargetsBox->get_selected_rows(); + + //No selection, so nothing to delete + if (aSelectedRows.empty()) + return; + + if (aSelectedRows.size() > 1) + { + OUString sMsg(SfxResId(STR_REDACTION_MULTI_DELETE) + .replaceFirst("$(TARGETSCOUNT)", OUString::number(aSelectedRows.size()))); + //Warn the user about multiple deletions + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog( + getDialog(), VclMessageType::Question, VclButtonsType::OkCancel, sMsg)); + if (xBox->run() == RET_CANCEL) + return; + } + + // After each delete, the indexes of the following items decrease by one. + int delta = 0; + for (const auto& i : aSelectedRows) + { + m_aTableTargets.erase(m_aTableTargets.begin() + (i - delta)); + m_xTargetsBox->remove(i - delta++); + } +} + +namespace +{ +boost::property_tree::ptree redactionTargetToJSON(const RedactionTarget* pTarget) +{ + boost::property_tree::ptree aNode; + aNode.put("sName", pTarget->sName.toUtf8().getStr()); + aNode.put("eType", pTarget->sType); + aNode.put("sContent", pTarget->sContent.toUtf8().getStr()); + aNode.put("bWholeWords", pTarget->bWholeWords); + aNode.put("bCaseSensitive", pTarget->bCaseSensitive); + aNode.put("nID", pTarget->nID); + + return aNode; +} + +std::unique_ptr<RedactionTarget> +JSONtoRedactionTarget(const boost::property_tree::ptree::value_type& rValue) +{ + OUString sName = OUString::fromUtf8(rValue.second.get<std::string>("sName").c_str()); + RedactionTargetType eType + = static_cast<RedactionTargetType>(atoi(rValue.second.get<std::string>("eType").c_str())); + OUString sContent = OUString::fromUtf8(rValue.second.get<std::string>("sContent").c_str()); + bool bCaseSensitive + = OUString::fromUtf8(rValue.second.get<std::string>("bCaseSensitive").c_str()).toBoolean(); + bool bWholeWords + = OUString::fromUtf8(rValue.second.get<std::string>("bWholeWords").c_str()).toBoolean(); + sal_uInt32 nID = atoi(rValue.second.get<std::string>("nID").c_str()); + + return std::unique_ptr<RedactionTarget>( + new RedactionTarget{ sName, eType, sContent, bCaseSensitive, bWholeWords, nID }); +} +} + +IMPL_LINK_NOARG(SfxAutoRedactDialog, LoadHdl, sfx2::FileDialogHelper*, void) +{ + assert(m_pFileDlg); + + OUString sTargetsFile; + if (ERRCODE_NONE == m_pFileDlg->GetError()) + sTargetsFile = m_pFileDlg->GetPath(); + + if (sTargetsFile.isEmpty()) + return; + + OUString sSysPath; + osl::File::getSystemPathFromFileURL(sTargetsFile, sSysPath); + sTargetsFile = sSysPath; + + weld::WaitObject aWaitObject(getDialog()); + + try + { + // Create path string, and read JSON from file + std::string sPathStr(OUStringToOString(sTargetsFile, RTL_TEXTENCODING_UTF8).getStr()); + + boost::property_tree::ptree aTargetsJSON; + + boost::property_tree::read_json(sPathStr, aTargetsJSON); + + // Clear the dialog + clearTargets(); + + // Recreate & add the targets to the dialog + for (const boost::property_tree::ptree::value_type& rValue : + aTargetsJSON.get_child("RedactionTargets")) + { + addTarget(JSONtoRedactionTarget(rValue)); + } + } + catch (css::uno::Exception& e) + { + SAL_WARN("sfx.doc", + "Exception caught while trying to load the targets JSON from file: " << e.Message); + return; + //TODO: Warn the user with a message box + } +} + +IMPL_LINK_NOARG(SfxAutoRedactDialog, SaveHdl, sfx2::FileDialogHelper*, void) +{ + assert(m_pFileDlg); + + OUString sTargetsFile; + if (ERRCODE_NONE == m_pFileDlg->GetError()) + sTargetsFile = m_pFileDlg->GetPath(); + + if (sTargetsFile.isEmpty()) + return; + + OUString sSysPath; + osl::File::getSystemPathFromFileURL(sTargetsFile, sSysPath); + sTargetsFile = sSysPath; + + weld::WaitObject aWaitObject(getDialog()); + + try + { + // Put the targets into a JSON array + boost::property_tree::ptree aTargetsArray; + for (const auto& targetPair : m_aTableTargets) + { + aTargetsArray.push_back( + std::make_pair("", redactionTargetToJSON(targetPair.first.get()))); + } + + // Build the JSON tree + boost::property_tree::ptree aTargetsTree; + aTargetsTree.add_child("RedactionTargets", aTargetsArray); + + // Create path string, and write JSON to file + std::string sPathStr(OUStringToOString(sTargetsFile, RTL_TEXTENCODING_UTF8).getStr()); + + boost::property_tree::write_json(sPathStr, aTargetsTree); + } + catch (css::uno::Exception& e) + { + SAL_WARN("sfx.doc", + "Exception caught while trying to save the targets JSON to file: " << e.Message); + return; + //TODO: Warn the user with a message box + } +} + +void SfxAutoRedactDialog::StartFileDialog(StartFileDialogType nType, const OUString& rTitle) +{ + OUString aFilterAllStr(SfxResId(STR_SFX_FILTERNAME_ALL)); + OUString aFilterJsonStr(SfxResId(STR_REDACTION_JSON_FILE_FILTER)); + + bool bSave = nType == StartFileDialogType::SaveAs; + short nDialogType = bSave ? css::ui::dialogs::TemplateDescription::FILESAVE_AUTOEXTENSION + : css::ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE; + m_pFileDlg.reset(new sfx2::FileDialogHelper(nDialogType, FileDialogFlags::NONE, getDialog())); + + m_pFileDlg->SetTitle(rTitle); + m_pFileDlg->AddFilter(aFilterAllStr, FILEDIALOG_FILTER_ALL); + m_pFileDlg->AddFilter(aFilterJsonStr, FILEDIALOG_FILTER_JSON); + m_pFileDlg->SetCurrentFilter(aFilterJsonStr); + + Link<sfx2::FileDialogHelper*, void> aDlgClosedLink + = bSave ? LINK(this, SfxAutoRedactDialog, SaveHdl) + : LINK(this, SfxAutoRedactDialog, LoadHdl); + m_pFileDlg->SetContext(sfx2::FileDialogHelper::AutoRedact); + m_pFileDlg->StartExecuteModal(aDlgClosedLink); +} + +void SfxAutoRedactDialog::addTarget(std::unique_ptr<RedactionTarget> pTarget) +{ + // Only the visual/display part + m_xTargetsBox->InsertTarget(pTarget.get()); + + // Actually add to the targets vector + auto name = pTarget->sName; + if (m_xTargetsBox->GetTargetByName(name)) + m_aTableTargets.emplace_back(std::move(pTarget), name); + else + { + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog( + getDialog(), VclMessageType::Warning, VclButtonsType::Ok, + SfxResId(STR_REDACTION_TARGET_ADD_ERROR))); + xBox->run(); + } +} + +void SfxAutoRedactDialog::clearTargets() +{ + // Clear the targets box + m_xTargetsBox->clear(); + + // Clear the targets vector + m_aTableTargets.clear(); +} + +SfxAutoRedactDialog::SfxAutoRedactDialog(weld::Window* pParent) + : SfxDialogController(pParent, "sfx/ui/autoredactdialog.ui", "AutoRedactDialog") + , m_bIsValidState(true) + , m_bTargetsCopied(false) + , m_xRedactionTargetsLabel(m_xBuilder->weld_label("labelRedactionTargets")) + , m_xTargetsBox(new TargetsTable(m_xBuilder->weld_tree_view("targets"))) + , m_xLoadBtn(m_xBuilder->weld_button("btnLoadTargets")) + , m_xSaveBtn(m_xBuilder->weld_button("btnSaveTargets")) + , m_xAddBtn(m_xBuilder->weld_button("add")) + , m_xEditBtn(m_xBuilder->weld_button("edit")) + , m_xDeleteBtn(m_xBuilder->weld_button("delete")) +{ + // Can be used to remember the last set of redaction targets? + OUString sExtraData; + SvtViewOptions aDlgOpt(EViewType::Dialog, + OStringToOUString(m_xDialog->get_help_id(), RTL_TEXTENCODING_UTF8)); + + if (aDlgOpt.Exists()) + { + css::uno::Any aUserItem = aDlgOpt.GetUserItem("UserItem"); + aUserItem >>= sExtraData; + } + + // update the targets configuration if necessary + if (!sExtraData.isEmpty()) + { + weld::WaitObject aWaitCursor(m_xDialog.get()); + + try + { + // Create path string, and read JSON from file + boost::property_tree::ptree aTargetsJSON; + std::stringstream aStream(std::string(sExtraData.toUtf8())); + + boost::property_tree::read_json(aStream, aTargetsJSON); + + // Recreate & add the targets to the dialog + for (const boost::property_tree::ptree::value_type& rValue : + aTargetsJSON.get_child("RedactionTargets")) + { + addTarget(JSONtoRedactionTarget(rValue)); + } + } + catch (css::uno::Exception& e) + { + SAL_WARN("sfx.doc", + "Exception caught while trying to load the last dialog state: " << e.Message); + return; + //TODO: Warn the user with a message box + } + } + + // Handler connections + m_xLoadBtn->connect_clicked(LINK(this, SfxAutoRedactDialog, Load)); + m_xSaveBtn->connect_clicked(LINK(this, SfxAutoRedactDialog, Save)); + m_xAddBtn->connect_clicked(LINK(this, SfxAutoRedactDialog, AddHdl)); + m_xEditBtn->connect_clicked(LINK(this, SfxAutoRedactDialog, EditHdl)); + m_xDeleteBtn->connect_clicked(LINK(this, SfxAutoRedactDialog, DeleteHdl)); + m_xTargetsBox->connect_row_activated(LINK(this, SfxAutoRedactDialog, DoubleClickEditHdl)); +} + +SfxAutoRedactDialog::~SfxAutoRedactDialog() +{ + if (m_aTableTargets.empty()) + { + // Clear the dialog data + SvtViewOptions aDlgOpt(EViewType::Dialog, + OStringToOUString(m_xDialog->get_help_id(), RTL_TEXTENCODING_UTF8)); + aDlgOpt.Delete(); + return; + } + + try + { + // Put the targets into a JSON array + boost::property_tree::ptree aTargetsArray; + for (const auto& targetPair : m_aTableTargets) + { + aTargetsArray.push_back( + std::make_pair("", redactionTargetToJSON(targetPair.first.get()))); + } + + // Build the JSON tree + boost::property_tree::ptree aTargetsTree; + aTargetsTree.add_child("RedactionTargets", aTargetsArray); + std::stringstream aStream; + + boost::property_tree::write_json(aStream, aTargetsTree, false); + + OUString sUserDataStr(OUString::fromUtf8(aStream.str().c_str())); + + // Store the dialog data + SvtViewOptions aDlgOpt(EViewType::Dialog, + OStringToOUString(m_xDialog->get_help_id(), RTL_TEXTENCODING_UTF8)); + aDlgOpt.SetUserItem("UserItem", css::uno::Any(sUserDataStr)); + + if (!m_bTargetsCopied) + clearTargets(); + } + catch (css::uno::Exception& e) + { + SAL_WARN("sfx.doc", + "Exception caught while trying to store the dialog state: " << e.Message); + return; + //TODO: Warn the user with a message box + } +} + +bool SfxAutoRedactDialog::hasTargets() const +{ + //TODO: Add also some validity checks? + if (m_aTableTargets.empty()) + return false; + + return true; +} + +bool SfxAutoRedactDialog::getTargets(std::vector<std::pair<RedactionTarget, OUString>>& r_aTargets) +{ + if (m_aTableTargets.empty()) + return true; + + for (auto const& rPair : m_aTableTargets) + r_aTargets.push_back({ *rPair.first, rPair.second }); + m_bTargetsCopied = true; + return true; +} + +IMPL_LINK_NOARG(SfxAddTargetDialog, SelectTypeHdl, weld::ComboBox&, void) +{ + if (m_xType->get_active_id() == "predefined") + { + // Hide the usual content widgets + // We will just set the id as content + // And handle with proper regex in the SfxRedactionHelper + m_xLabelContent->set_sensitive(false); + m_xLabelContent->set_visible(false); + m_xContent->set_sensitive(false); + m_xContent->set_visible(false); + m_xWholeWords->set_sensitive(false); + m_xWholeWords->set_visible(false); + m_xCaseSensitive->set_sensitive(false); + m_xCaseSensitive->set_visible(false); + + // And show the predefined targets + m_xLabelPredefContent->set_sensitive(true); + m_xLabelPredefContent->set_visible(true); + m_xPredefContent->set_sensitive(true); + m_xPredefContent->set_visible(true); + } + else + { + m_xLabelPredefContent->set_sensitive(false); + m_xLabelPredefContent->set_visible(false); + m_xPredefContent->set_sensitive(false); + m_xPredefContent->set_visible(false); + + m_xLabelContent->set_sensitive(true); + m_xLabelContent->set_visible(true); + m_xContent->set_sensitive(true); + m_xContent->set_visible(true); + m_xWholeWords->set_sensitive(true); + m_xWholeWords->set_visible(true); + m_xCaseSensitive->set_sensitive(true); + m_xCaseSensitive->set_visible(true); + } +} + +SfxAddTargetDialog::SfxAddTargetDialog(weld::Window* pParent, const OUString& rName) + : GenericDialogController(pParent, "sfx/ui/addtargetdialog.ui", "AddTargetDialog") + , m_xName(m_xBuilder->weld_entry("name")) + , m_xType(m_xBuilder->weld_combo_box("type")) + , m_xLabelContent(m_xBuilder->weld_label("label_content")) + , m_xContent(m_xBuilder->weld_entry("content")) + , m_xLabelPredefContent(m_xBuilder->weld_label("label_content_predef")) + , m_xPredefContent(m_xBuilder->weld_combo_box("content_predef")) + , m_xCaseSensitive(m_xBuilder->weld_check_button("checkboxCaseSensitive")) + , m_xWholeWords(m_xBuilder->weld_check_button("checkboxWholeWords")) +{ + m_xName->set_text(rName); + m_xName->select_region(0, rName.getLength()); + + m_xType->connect_changed(LINK(this, SfxAddTargetDialog, SelectTypeHdl)); +} + +SfxAddTargetDialog::SfxAddTargetDialog(weld::Window* pParent, const OUString& sName, + const RedactionTargetType& eTargetType, + const OUString& sContent, bool bCaseSensitive, + bool bWholeWords) + : GenericDialogController(pParent, "sfx/ui/addtargetdialog.ui", "AddTargetDialog") + , m_xName(m_xBuilder->weld_entry("name")) + , m_xType(m_xBuilder->weld_combo_box("type")) + , m_xLabelContent(m_xBuilder->weld_label("label_content")) + , m_xContent(m_xBuilder->weld_entry("content")) + , m_xLabelPredefContent(m_xBuilder->weld_label("label_content_predef")) + , m_xPredefContent(m_xBuilder->weld_combo_box("content_predef")) + , m_xCaseSensitive(m_xBuilder->weld_check_button("checkboxCaseSensitive")) + , m_xWholeWords(m_xBuilder->weld_check_button("checkboxWholeWords")) +{ + m_xName->set_text(sName); + m_xName->select_region(0, sName.getLength()); + + m_xType->set_active_id(getTypeID(eTargetType)); + m_xType->connect_changed(LINK(this, SfxAddTargetDialog, SelectTypeHdl)); + + if (eTargetType == RedactionTargetType::REDACTION_TARGET_PREDEFINED) + { + SelectTypeHdl(*m_xPredefContent); + m_xPredefContent->set_active(o3tl::toInt32(o3tl::getToken(sContent, 0, ';'))); + } + else + { + m_xContent->set_text(sContent); + } + + m_xCaseSensitive->set_active(bCaseSensitive); + m_xWholeWords->set_active(bWholeWords); + + set_title(SfxResId(STR_REDACTION_EDIT_TARGET)); +} + +RedactionTargetType SfxAddTargetDialog::getType() const +{ + OUString sTypeID = m_xType->get_active_id(); + + if (sTypeID == "text") + return RedactionTargetType::REDACTION_TARGET_TEXT; + else if (sTypeID == "regex") + return RedactionTargetType::REDACTION_TARGET_REGEX; + else if (sTypeID == "predefined") + return RedactionTargetType::REDACTION_TARGET_PREDEFINED; + else + return RedactionTargetType::REDACTION_TARGET_UNKNOWN; +} + +OUString SfxAddTargetDialog::getContent() const +{ + if (m_xType->get_active_id() == "predefined") + { + return OUString(OUString::number(m_xPredefContent->get_active()) + ";" + + m_xPredefContent->get_active_text()); + } + + return m_xContent->get_text(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/sfx2/source/doc/docfac.cxx b/sfx2/source/doc/docfac.cxx new file mode 100644 index 000000000..a222ef7e4 --- /dev/null +++ b/sfx2/source/doc/docfac.cxx @@ -0,0 +1,354 @@ +/* -*- 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 <com/sun/star/container/XNameAccess.hpp> +#include <com/sun/star/ucb/SimpleFileAccess.hpp> +#include <com/sun/star/document/XTypeDetection.hpp> +#include <com/sun/star/frame/ModuleManager.hpp> +#include <com/sun/star/frame/XLoadable.hpp> +#include <com/sun/star/frame/XStorable.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <comphelper/processfactory.hxx> +#include <comphelper/propertyvalue.hxx> +#include <unotools/moduleoptions.hxx> +#include <comphelper/sequenceashashmap.hxx> +#include <comphelper/configurationhelper.hxx> + +#include <sfx2/docfilt.hxx> +#include <sfx2/docfac.hxx> +#include <sfx2/viewfac.hxx> +#include <sfx2/fcontnr.hxx> +#include <sfx2/module.hxx> +#include "syspath.hxx" +#include <osl/file.hxx> +#include <osl/security.hxx> + +#include <sal/log.hxx> +#include <tools/debug.hxx> +#include <tools/globname.hxx> + +#include <memory> + +using namespace ::com::sun::star; + + +struct SfxObjectFactory_Impl +{ + std::vector<SfxViewFactory*> aViewFactoryArr;// List of <SfxViewFactory>s + OUString aServiceName; + SfxFilterContainer* pFilterContainer; + SfxModule* pModule; + SvGlobalName aClassName; + + SfxObjectFactory_Impl() : + pFilterContainer ( nullptr ), + pModule ( nullptr ) + {} +}; + +SfxFilterContainer* SfxObjectFactory::GetFilterContainer() const +{ + return pImpl->pFilterContainer; +} + +SfxObjectFactory::SfxObjectFactory +( + const SvGlobalName& rName, + const OUString& sName +) : m_sFactoryName( sName ), + pImpl( new SfxObjectFactory_Impl ) +{ + pImpl->pFilterContainer = new SfxFilterContainer( m_sFactoryName ); + pImpl->aClassName = rName; +} + +SfxObjectFactory::~SfxObjectFactory() +{ + delete pImpl->pFilterContainer; +} + + +void SfxObjectFactory::RegisterViewFactory +( + SfxViewFactory &rFactory +) +{ +#if OSL_DEBUG_LEVEL > 0 + { + const OUString sViewName( rFactory.GetAPIViewName() ); + for (auto const& viewFactory : pImpl->aViewFactoryArr) + { + if ( viewFactory->GetAPIViewName() != sViewName ) + continue; + SAL_WARN( "sfx", "SfxObjectFactory::RegisterViewFactory: duplicate view name: " << sViewName ); + break; + } + } +#endif + auto it = std::find_if(pImpl->aViewFactoryArr.begin(), pImpl->aViewFactoryArr.end(), + [&rFactory](SfxViewFactory* pFactory) { return pFactory->GetOrdinal() > rFactory.GetOrdinal(); }); + pImpl->aViewFactoryArr.insert(it, &rFactory); +} + + +sal_uInt16 SfxObjectFactory::GetViewFactoryCount() const +{ + return pImpl->aViewFactoryArr.size(); +} + + +SfxViewFactory& SfxObjectFactory::GetViewFactory(sal_uInt16 i) const +{ + return *pImpl->aViewFactoryArr[i]; +} + + +SfxModule* SfxObjectFactory::GetModule() const +{ + return pImpl->pModule; +} + +void SfxObjectFactory::SetModule_Impl( SfxModule *pMod ) +{ + pImpl->pModule = pMod; +} + +void SfxObjectFactory::SetSystemTemplate( const OUString& rServiceName, const OUString& rTemplateName ) +{ + static const int nMaxPathSize = 16000; + + const OUString sConfPath = "Office/Factories/" + rServiceName; + static constexpr OUStringLiteral PROP_DEF_TEMPL_CHANGED + = u"ooSetupFactorySystemDefaultTemplateChanged"; + + static const char DEF_TPL_STR[] = "/soffice."; + + OUString sUserTemplateURL; + OUString sPath; + sal_Unicode aPathBuffer[nMaxPathSize]; + if ( SystemPath::GetUserTemplateLocation( aPathBuffer, nMaxPathSize )) + sPath = OUString( aPathBuffer ); + osl::FileBase::getFileURLFromSystemPath( sPath, sUserTemplateURL ); + + if ( sUserTemplateURL.isEmpty()) + return; + + try + { + uno::Reference< lang::XMultiServiceFactory > xFactory = ::comphelper::getProcessServiceFactory(); + uno::Reference< uno::XInterface > xConfig = ::comphelper::ConfigurationHelper::openConfig( + ::comphelper::getProcessComponentContext(), "/org.openoffice.Setup", ::comphelper::EConfigurationModes::Standard ); + + OUString aActualFilter; + ::comphelper::ConfigurationHelper::readRelativeKey( xConfig, sConfPath, "ooSetupFactoryActualFilter" ) >>= aActualFilter; + bool bChanged(false); + ::comphelper::ConfigurationHelper::readRelativeKey( xConfig, sConfPath, PROP_DEF_TEMPL_CHANGED ) >>= bChanged; + + uno::Reference< container::XNameAccess > xFilterFactory( + xFactory->createInstance( "com.sun.star.document.FilterFactory" ), uno::UNO_QUERY_THROW ); + uno::Reference< container::XNameAccess > xTypeDetection( + xFactory->createInstance( "com.sun.star.document.TypeDetection" ), uno::UNO_QUERY_THROW ); + + OUString aActualFilterTypeName; + uno::Sequence< beans::PropertyValue > aActuralFilterData; + xFilterFactory->getByName( aActualFilter ) >>= aActuralFilterData; + for ( const auto& rProp : std::as_const(aActuralFilterData) ) + if ( rProp.Name == "Type" ) + rProp.Value >>= aActualFilterTypeName; + ::comphelper::SequenceAsHashMap aProps1( xTypeDetection->getByName( aActualFilterTypeName ) ); + uno::Sequence< OUString > aAllExt = + aProps1.getUnpackedValueOrDefault("Extensions", uno::Sequence< OUString >() ); + //To-do: check if aAllExt is empty first + const OUString aExt = DEF_TPL_STR + aAllExt[0]; + + sUserTemplateURL += aExt; + + uno::Reference<ucb::XSimpleFileAccess3> xSimpleFileAccess( + ucb::SimpleFileAccess::create( ::comphelper::getComponentContext(xFactory) ) ); + + OUString aBackupURL; + ::osl::Security().getConfigDir(aBackupURL); + aBackupURL += "/temp"; + + if ( !xSimpleFileAccess->exists( aBackupURL ) ) + xSimpleFileAccess->createFolder( aBackupURL ); + + aBackupURL += aExt; + + if ( !rTemplateName.isEmpty() ) + { + if ( xSimpleFileAccess->exists( sUserTemplateURL ) && !bChanged ) + xSimpleFileAccess->copy( sUserTemplateURL, aBackupURL ); + + uno::Reference< document::XTypeDetection > xTypeDetector( xTypeDetection, uno::UNO_QUERY ); + ::comphelper::SequenceAsHashMap aProps2( xTypeDetection->getByName( xTypeDetector->queryTypeByURL( rTemplateName ) ) ); + OUString aFilterName = + aProps2.getUnpackedValueOrDefault("PreferredFilter", OUString() ); + + uno::Sequence< beans::PropertyValue > aArgs{ + comphelper::makePropertyValue("FilterName", aFilterName), + comphelper::makePropertyValue("AsTemplate", true), + comphelper::makePropertyValue("URL", rTemplateName) + }; + + uno::Reference< frame::XLoadable > xLoadable( xFactory->createInstance( rServiceName ), uno::UNO_QUERY ); + xLoadable->load( aArgs ); + + aArgs.realloc( 2 ); + auto pArgs = aArgs.getArray(); + pArgs[1].Name = "Overwrite"; + pArgs[1].Value <<= true; + + uno::Reference< frame::XStorable > xStorable( xLoadable, uno::UNO_QUERY ); + xStorable->storeToURL( sUserTemplateURL, aArgs ); + ::comphelper::ConfigurationHelper::writeRelativeKey( xConfig, sConfPath, PROP_DEF_TEMPL_CHANGED, uno::Any( true )); + ::comphelper::ConfigurationHelper::flush( xConfig ); + } + else + { + DBG_ASSERT( bChanged, "invalid ooSetupFactorySystemDefaultTemplateChanged value!" ); + + xSimpleFileAccess->copy( aBackupURL, sUserTemplateURL ); + xSimpleFileAccess->kill( aBackupURL ); + ::comphelper::ConfigurationHelper::writeRelativeKey( xConfig, sConfPath, PROP_DEF_TEMPL_CHANGED, uno::Any( false )); + ::comphelper::ConfigurationHelper::flush( xConfig ); + } + } + catch(const uno::Exception&) + { + } +} + +void SfxObjectFactory::SetStandardTemplate( const OUString& rServiceName, const OUString& rTemplate ) +{ + SvtModuleOptions::EFactory eFac = SvtModuleOptions::ClassifyFactoryByServiceName(rServiceName); + if (eFac == SvtModuleOptions::EFactory::UNKNOWN_FACTORY) + eFac = SvtModuleOptions::ClassifyFactoryByShortName(rServiceName); + if (eFac != SvtModuleOptions::EFactory::UNKNOWN_FACTORY) + { + SetSystemTemplate( rServiceName, rTemplate ); + SvtModuleOptions().SetFactoryStandardTemplate(eFac, rTemplate); + } +} + +OUString SfxObjectFactory::GetStandardTemplate( std::u16string_view rServiceName ) +{ + SvtModuleOptions::EFactory eFac = SvtModuleOptions::ClassifyFactoryByServiceName(rServiceName); + if (eFac == SvtModuleOptions::EFactory::UNKNOWN_FACTORY) + eFac = SvtModuleOptions::ClassifyFactoryByShortName(rServiceName); + + if (eFac != SvtModuleOptions::EFactory::UNKNOWN_FACTORY) + return SvtModuleOptions().GetFactoryStandardTemplate(eFac); + + return OUString(); +} + +std::shared_ptr<const SfxFilter> SfxObjectFactory::GetTemplateFilter() const +{ + sal_uInt16 nVersion=0; + SfxFilterMatcher aMatcher ( m_sFactoryName ); + SfxFilterMatcherIter aIter( aMatcher ); + std::shared_ptr<const SfxFilter> pFilter; + std::shared_ptr<const SfxFilter> pTemp = aIter.First(); + while ( pTemp ) + { + if( pTemp->IsOwnFormat() && pTemp->IsOwnTemplateFormat() && ( pTemp->GetVersion() > nVersion ) ) + { + pFilter = pTemp; + nVersion = static_cast<sal_uInt16>(pTemp->GetVersion()); + } + + pTemp = aIter.Next(); + } + + return pFilter; +} + +void SfxObjectFactory::SetDocumentServiceName( const OUString& rServiceName ) +{ + pImpl->aServiceName = rServiceName; +} + +const OUString& SfxObjectFactory::GetDocumentServiceName() const +{ + return pImpl->aServiceName; +} + +const SvGlobalName& SfxObjectFactory::GetClassId() const +{ + return pImpl->aClassName; +} + +OUString SfxObjectFactory::GetFactoryURL() const +{ + return "private:factory/" + m_sFactoryName; +} + +OUString SfxObjectFactory::GetModuleName() const +{ + try + { + css::uno::Reference< css::uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext(); + + css::uno::Reference< css::frame::XModuleManager2 > xModuleManager( + css::frame::ModuleManager::create(xContext)); + + ::comphelper::SequenceAsHashMap aPropSet( xModuleManager->getByName(GetDocumentServiceName()) ); + return aPropSet.getUnpackedValueOrDefault("ooSetupFactoryUIName", OUString()); + } + catch(const css::uno::RuntimeException&) + { + throw; + } + catch(const css::uno::Exception&) + { + } + + return OUString(); +} + + +sal_uInt16 SfxObjectFactory::GetViewNo_Impl( const SfxInterfaceId i_nViewId, const sal_uInt16 i_nFallback ) const +{ + for ( sal_uInt16 curViewNo = 0; curViewNo < GetViewFactoryCount(); ++curViewNo ) + { + const SfxInterfaceId curViewId = GetViewFactory( curViewNo ).GetOrdinal(); + if ( i_nViewId == curViewId ) + return curViewNo; + } + return i_nFallback; +} + +SfxViewFactory* SfxObjectFactory::GetViewFactoryByViewName( std::u16string_view i_rViewName ) const +{ + for ( sal_uInt16 nViewNo = 0; + nViewNo < GetViewFactoryCount(); + ++nViewNo + ) + { + SfxViewFactory& rViewFac( GetViewFactory( nViewNo ) ); + if ( ( rViewFac.GetAPIViewName() == i_rViewName ) + || ( rViewFac.GetLegacyViewName() == i_rViewName ) + ) + return &rViewFac; + } + return nullptr; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/docfile.cxx b/sfx2/source/doc/docfile.cxx new file mode 100644 index 000000000..fafe05d15 --- /dev/null +++ b/sfx2/source/doc/docfile.cxx @@ -0,0 +1,4752 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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 <config_features.h> + +#ifdef UNX +#include <sys/stat.h> +#endif + +#include <sfx2/docfile.hxx> +#include <sfx2/signaturestate.hxx> + +#include <com/sun/star/task/InteractionHandler.hpp> +#include <com/sun/star/task/XStatusIndicator.hpp> +#include <com/sun/star/uno/Reference.h> +#include <com/sun/star/ucb/XContent.hpp> +#include <com/sun/star/container/XChild.hpp> +#include <com/sun/star/document/XDocumentRevisionListPersistence.hpp> +#include <com/sun/star/document/LockedDocumentRequest.hpp> +#include <com/sun/star/document/LockedOnSavingRequest.hpp> +#include <com/sun/star/document/OwnLockOnDocumentRequest.hpp> +#include <com/sun/star/document/LockFileIgnoreRequest.hpp> +#include <com/sun/star/document/LockFileCorruptRequest.hpp> +#include <com/sun/star/document/ChangedByOthersRequest.hpp> +#include <com/sun/star/document/ReloadEditableRequest.hpp> +#include <com/sun/star/embed/XTransactedObject.hpp> +#include <com/sun/star/embed/ElementModes.hpp> +#include <com/sun/star/embed/UseBackupException.hpp> +#include <com/sun/star/embed/XOptimizedStorage.hpp> +#include <com/sun/star/frame/Desktop.hpp> +#include <com/sun/star/frame/XModel.hpp> +#include <com/sun/star/frame/XTerminateListener.hpp> +#include <com/sun/star/graphic/XGraphic.hpp> +#include <com/sun/star/ucb/ContentCreationException.hpp> +#include <com/sun/star/ucb/InteractiveIOException.hpp> +#include <com/sun/star/ucb/CommandFailedException.hpp> +#include <com/sun/star/ucb/CommandAbortedException.hpp> +#include <com/sun/star/ucb/InteractiveLockingLockedException.hpp> +#include <com/sun/star/ucb/InteractiveNetworkWriteException.hpp> +#include <com/sun/star/ucb/Lock.hpp> +#include <com/sun/star/ucb/NameClashException.hpp> +#include <com/sun/star/ucb/XCommandEnvironment.hpp> +#include <com/sun/star/ucb/XProgressHandler.hpp> +#include <com/sun/star/io/XOutputStream.hpp> +#include <com/sun/star/io/XInputStream.hpp> +#include <com/sun/star/io/XTruncate.hpp> +#include <com/sun/star/io/XSeekable.hpp> +#include <com/sun/star/lang/XSingleServiceFactory.hpp> +#include <com/sun/star/ucb/InsertCommandArgument.hpp> +#include <com/sun/star/ucb/NameClash.hpp> +#include <com/sun/star/beans/NamedValue.hpp> +#include <com/sun/star/beans/PropertyValue.hpp> +#include <com/sun/star/security/DocumentDigitalSignatures.hpp> +#include <com/sun/star/security/XCertificate.hpp> +#include <tools/urlobj.hxx> +#include <tools/fileutil.hxx> +#include <unotools/configmgr.hxx> +#include <unotools/tempfile.hxx> +#include <comphelper/fileurl.hxx> +#include <comphelper/processfactory.hxx> +#include <comphelper/propertyvalue.hxx> +#include <comphelper/interaction.hxx> +#include <comphelper/sequence.hxx> +#include <comphelper/simplefileaccessinteraction.hxx> +#include <comphelper/string.hxx> +#include <framework/interaction.hxx> +#include <utility> +#include <svl/stritem.hxx> +#include <svl/eitem.hxx> +#include <svtools/sfxecode.hxx> +#include <svl/itemset.hxx> +#include <svl/intitem.hxx> +#include <svtools/svparser.hxx> +#include <sal/log.hxx> + +#include <unotools/streamwrap.hxx> + +#include <osl/file.hxx> + +#include <comphelper/storagehelper.hxx> +#include <unotools/mediadescriptor.hxx> +#include <comphelper/docpasswordhelper.hxx> +#include <tools/datetime.hxx> +#include <unotools/pathoptions.hxx> +#include <svtools/asynclink.hxx> +#include <ucbhelper/commandenvironment.hxx> +#include <unotools/ucbstreamhelper.hxx> +#include <unotools/ucbhelper.hxx> +#include <unotools/progresshandlerwrap.hxx> +#include <ucbhelper/content.hxx> +#include <ucbhelper/interactionrequest.hxx> +#include <sot/storage.hxx> +#include <svl/documentlockfile.hxx> +#include <svl/msodocumentlockfile.hxx> +#include <com/sun/star/document/DocumentRevisionListPersistence.hpp> + +#include <sfx2/app.hxx> +#include <sfx2/frame.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/fcontnr.hxx> +#include <sfx2/docfilt.hxx> +#include <sfx2/sfxsids.hrc> +#include <sfx2/sfxuno.hxx> +#include <openflag.hxx> +#include <officecfg/Office/Common.hxx> +#include <comphelper/propertysequence.hxx> +#include <vcl/weld.hxx> +#include <vcl/svapp.hxx> +#include <tools/diagnose_ex.h> +#include <unotools/fltrcfg.hxx> +#include <sfx2/digitalsignatures.hxx> +#include <sfx2/viewfrm.hxx> +#include <comphelper/threadpool.hxx> +#include <o3tl/string_view.hxx> +#include <condition_variable> + +#include <com/sun/star/io/WrongFormatException.hpp> + +#include <memory> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::graphic; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::ucb; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::io; +using namespace ::com::sun::star::security; + +namespace +{ + +struct ReadOnlyMediumEntry +{ + ReadOnlyMediumEntry(std::shared_ptr<std::recursive_mutex> pMutex, + std::shared_ptr<bool> pIsDestructed) + : _pMutex(pMutex) + , _pIsDestructed(pIsDestructed) + { + } + std::shared_ptr<std::recursive_mutex> _pMutex; + std::shared_ptr<bool> _pIsDestructed; +}; + +} + +static std::mutex g_chkReadOnlyGlobalMutex; +static bool g_bChkReadOnlyTaskRunning = false; +static std::unordered_map<SfxMedium*, std::shared_ptr<ReadOnlyMediumEntry>> g_newReadOnlyDocs; +static std::unordered_map<SfxMedium*, std::shared_ptr<ReadOnlyMediumEntry>> g_existingReadOnlyDocs; + +namespace { + +#if HAVE_FEATURE_MULTIUSER_ENVIRONMENT + +bool IsSystemFileLockingUsed() +{ +#if HAVE_FEATURE_MACOSX_SANDBOX + return true; +#else + return officecfg::Office::Common::Misc::UseDocumentSystemFileLocking::get(); +#endif +} + + +bool IsOOoLockFileUsed() +{ +#if HAVE_FEATURE_MACOSX_SANDBOX + return false; +#else + return officecfg::Office::Common::Misc::UseDocumentOOoLockFile::get(); +#endif +} + +bool IsLockingUsed() +{ + return officecfg::Office::Common::Misc::UseLocking::get(); +} + +#endif + +#if HAVE_FEATURE_MULTIUSER_ENVIRONMENT +bool IsWebDAVLockingUsed() +{ + return officecfg::Office::Common::Misc::UseWebDAVFileLocking::get(); +} +#endif + +/// Gets default attributes of a file:// URL. +sal_uInt64 GetDefaultFileAttributes(const OUString& rURL) +{ + sal_uInt64 nRet = 0; + + if (!comphelper::isFileUrl(rURL)) + return nRet; + + // Make sure the file exists (and create it if not). + osl::File aFile(rURL); + osl::File::RC nRes = aFile.open(osl_File_OpenFlag_Create); + if (nRes != osl::File::E_None && nRes != osl::File::E_EXIST) + return nRet; + + aFile.close(); + + osl::DirectoryItem aItem; + if (osl::DirectoryItem::get(rURL, aItem) != osl::DirectoryItem::E_None) + return nRet; + + osl::FileStatus aStatus(osl_FileStatus_Mask_Attributes); + if (aItem.getFileStatus(aStatus) != osl::DirectoryItem::E_None) + return nRet; + + nRet = aStatus.getAttributes(); + return nRet; +} + +/// Determines if rURL is safe to move or not. +bool IsFileMovable(const INetURLObject& rURL) +{ +#ifdef MACOSX + (void)rURL; + // Hide extension macOS-specific file property would be lost. + return false; +#else + + if (rURL.GetProtocol() != INetProtocol::File) + // Not a file:// URL. + return false; + +#ifdef UNX + OUString sPath = rURL.getFSysPath(FSysStyle::Unix); + if (sPath.isEmpty()) + return false; + + struct stat buf; + if (lstat(sPath.toUtf8().getStr(), &buf) != 0) + return false; + + // Hardlink or symlink: osl::File::move() doesn't play with these nicely. + if (buf.st_nlink > 1 || S_ISLNK(buf.st_mode)) + return false; +#elif defined _WIN32 + if (tools::IsMappedWebDAVPath(rURL.GetMainURL(INetURLObject::DecodeMechanism::NONE))) + return false; +#endif + + return true; +#endif +} + +class CheckReadOnlyTaskTerminateListener + : public ::cppu::WeakImplHelper<css::frame::XTerminateListener> +{ +public: + // XEventListener + void SAL_CALL disposing(const css::lang::EventObject& Source) override; + + // XTerminateListener + void SAL_CALL queryTermination(const css::lang::EventObject& aEvent) override; + void SAL_CALL notifyTermination(const css::lang::EventObject& aEvent) override; + + bool bIsTerminated = false; + std::condition_variable mCond; + std::mutex mMutex; +}; + +class CheckReadOnlyTask : public comphelper::ThreadTask +{ +public: + CheckReadOnlyTask(const std::shared_ptr<comphelper::ThreadTaskTag>& pTag); + ~CheckReadOnlyTask(); + + virtual void doWork() override; + +private: + rtl::Reference<CheckReadOnlyTaskTerminateListener> m_xListener; +}; + +} // anonymous namespace + +CheckReadOnlyTask::CheckReadOnlyTask(const std::shared_ptr<comphelper::ThreadTaskTag>& pTag) + : ThreadTask(pTag) + , m_xListener(new CheckReadOnlyTaskTerminateListener) +{ + Reference<css::frame::XDesktop> xDesktop + = css::frame::Desktop::create(comphelper::getProcessComponentContext()); + if (xDesktop.is() && m_xListener != nullptr) + { + xDesktop->addTerminateListener(m_xListener); + } +} + +CheckReadOnlyTask::~CheckReadOnlyTask() +{ + Reference<css::frame::XDesktop> xDesktop + = css::frame::Desktop::create(comphelper::getProcessComponentContext()); + if (xDesktop.is() && m_xListener != nullptr) + { + std::unique_lock<std::mutex> lock(m_xListener->mMutex); + if (!m_xListener->bIsTerminated) + { + lock.unlock(); + xDesktop->removeTerminateListener(m_xListener); + } + } +} + +namespace +{ +void SAL_CALL +CheckReadOnlyTaskTerminateListener::disposing(const css::lang::EventObject& /*Source*/) +{ +} + +void SAL_CALL +CheckReadOnlyTaskTerminateListener::queryTermination(const css::lang::EventObject& /*aEvent*/) +{ +} + +void SAL_CALL +CheckReadOnlyTaskTerminateListener::notifyTermination(const css::lang::EventObject& /*aEvent*/) +{ + std::unique_lock<std::mutex> lock(mMutex); + bIsTerminated = true; + lock.unlock(); + mCond.notify_one(); +} +} + +class SfxMedium_Impl +{ +public: + StreamMode m_nStorOpenMode; + ErrCode m_eError; + + ::ucbhelper::Content aContent; + bool bUpdatePickList:1; + bool bIsTemp:1; + bool bDownloadDone:1; + bool bIsStorage:1; + bool bUseInteractionHandler:1; + bool bAllowDefaultIntHdl:1; + bool bDisposeStorage:1; + bool bStorageBasedOnInStream:1; + bool m_bSalvageMode:1; + bool m_bVersionsAlreadyLoaded:1; + bool m_bLocked:1; + bool m_bMSOLockFileCreated : 1; + bool m_bDisableUnlockWebDAV:1; + bool m_bGotDateTime:1; + bool m_bRemoveBackup:1; + bool m_bOriginallyReadOnly:1; + bool m_bOriginallyLoadedReadOnly:1; + bool m_bTriedStorage:1; + bool m_bRemote:1; + bool m_bInputStreamIsReadOnly:1; + bool m_bInCheckIn:1; + bool m_bDisableFileSync = false; + bool m_bNotifyWhenEditable = false; + + OUString m_aName; + OUString m_aLogicName; + OUString m_aLongName; + + mutable std::shared_ptr<SfxItemSet> m_pSet; + mutable std::unique_ptr<INetURLObject> m_pURLObj; + + std::shared_ptr<const SfxFilter> m_pFilter; + std::shared_ptr<const SfxFilter> m_pCustomFilter; + + std::shared_ptr<std::recursive_mutex> m_pCheckEditableWorkerMutex; + std::shared_ptr<bool> m_pIsDestructed; + ImplSVEvent* m_pReloadEvent; + + std::unique_ptr<SvStream> m_pInStream; + std::unique_ptr<SvStream> m_pOutStream; + + OUString aOrigURL; + DateTime aExpireTime; + SfxFrameWeakRef wLoadTargetFrame; + SvKeyValueIteratorRef xAttributes; + + svtools::AsynchronLink aDoneLink; + + uno::Sequence < util::RevisionTag > aVersions; + + std::unique_ptr<::utl::TempFile> pTempFile; + + uno::Reference<embed::XStorage> xStorage; + uno::Reference<embed::XStorage> m_xZipStorage; + uno::Reference<io::XInputStream> m_xInputStreamToLoadFrom; + uno::Reference<io::XInputStream> xInputStream; + uno::Reference<io::XStream> xStream; + uno::Reference<io::XStream> m_xLockingStream; + uno::Reference<task::XInteractionHandler> xInteraction; + + ErrCode nLastStorageError; + + OUString m_aBackupURL; + + // the following member is changed and makes sense only during saving + // TODO/LATER: in future the signature state should be controlled by the medium not by the document + // in this case the member will hold this information + SignatureState m_nSignatureState; + + bool m_bHasEmbeddedObjects = false; + + util::DateTime m_aDateTime; + + uno::Sequence<beans::PropertyValue> m_aArgs; + + explicit SfxMedium_Impl(); + ~SfxMedium_Impl(); + SfxMedium_Impl(const SfxMedium_Impl&) = delete; + SfxMedium_Impl& operator=(const SfxMedium_Impl&) = delete; + + OUString getFilterMimeType() const + { return !m_pFilter ? OUString() : m_pFilter->GetMimeType(); } +}; + +SfxMedium_Impl::SfxMedium_Impl() : + m_nStorOpenMode(SFX_STREAM_READWRITE), + m_eError(ERRCODE_NONE), + bUpdatePickList(true), + bIsTemp( false ), + bDownloadDone( true ), + bIsStorage( false ), + bUseInteractionHandler( true ), + bAllowDefaultIntHdl( false ), + bDisposeStorage( false ), + bStorageBasedOnInStream( false ), + m_bSalvageMode( false ), + m_bVersionsAlreadyLoaded( false ), + m_bLocked( false ), + m_bMSOLockFileCreated( false ), + m_bDisableUnlockWebDAV( false ), + m_bGotDateTime( false ), + m_bRemoveBackup( false ), + m_bOriginallyReadOnly(false), + m_bOriginallyLoadedReadOnly(false), + m_bTriedStorage(false), + m_bRemote(false), + m_bInputStreamIsReadOnly(false), + m_bInCheckIn(false), + m_pReloadEvent(nullptr), + aExpireTime( DateTime( DateTime::SYSTEM ) + static_cast<sal_Int32>(10) ), + nLastStorageError( ERRCODE_NONE ), + m_nSignatureState( SignatureState::NOSIGNATURES ) +{ +} + + +SfxMedium_Impl::~SfxMedium_Impl() +{ + aDoneLink.ClearPendingCall(); + + pTempFile.reset(); + m_pSet.reset(); + std::unique_lock<std::recursive_mutex> chkEditLock; + if (m_pCheckEditableWorkerMutex != nullptr) + chkEditLock = std::unique_lock<std::recursive_mutex>(*m_pCheckEditableWorkerMutex); + m_pURLObj.reset(); +} + +void SfxMedium::ResetError() +{ + pImpl->m_eError = ERRCODE_NONE; + if( pImpl->m_pInStream ) + pImpl->m_pInStream->ResetError(); + if( pImpl->m_pOutStream ) + pImpl->m_pOutStream->ResetError(); +} + +ErrCode const & SfxMedium::GetLastStorageCreationState() const +{ + return pImpl->nLastStorageError; +} + +void SfxMedium::SetError(ErrCode nError) +{ + pImpl->m_eError = nError; +} + +ErrCode SfxMedium::GetErrorCode() const +{ + ErrCode lError = pImpl->m_eError; + if(!lError && pImpl->m_pInStream) + lError = pImpl->m_pInStream->GetErrorCode(); + if(!lError && pImpl->m_pOutStream) + lError = pImpl->m_pOutStream->GetErrorCode(); + return lError; +} + +void SfxMedium::CheckFileDate( const util::DateTime& aInitDate ) +{ + GetInitFileDate( true ); + if ( pImpl->m_aDateTime.Seconds == aInitDate.Seconds + && pImpl->m_aDateTime.Minutes == aInitDate.Minutes + && pImpl->m_aDateTime.Hours == aInitDate.Hours + && pImpl->m_aDateTime.Day == aInitDate.Day + && pImpl->m_aDateTime.Month == aInitDate.Month + && pImpl->m_aDateTime.Year == aInitDate.Year ) + return; + + uno::Reference< task::XInteractionHandler > xHandler = GetInteractionHandler(); + + if ( !xHandler.is() ) + return; + + try + { + ::rtl::Reference< ::ucbhelper::InteractionRequest > xInteractionRequestImpl = new ::ucbhelper::InteractionRequest( uno::Any( + document::ChangedByOthersRequest() ) ); + uno::Sequence< uno::Reference< task::XInteractionContinuation > > aContinuations{ + new ::ucbhelper::InteractionAbort( xInteractionRequestImpl.get() ), + new ::ucbhelper::InteractionApprove( xInteractionRequestImpl.get() ) + }; + xInteractionRequestImpl->setContinuations( aContinuations ); + + xHandler->handle( xInteractionRequestImpl ); + + ::rtl::Reference< ::ucbhelper::InteractionContinuation > xSelected = xInteractionRequestImpl->getSelection(); + if ( uno::Reference< task::XInteractionAbort >( xSelected.get(), uno::UNO_QUERY ).is() ) + { + SetError(ERRCODE_ABORT); + } + } + catch ( const uno::Exception& ) + {} +} + +bool SfxMedium::DocNeedsFileDateCheck() const +{ + return ( !IsReadOnly() && ( GetURLObject().GetProtocol() == INetProtocol::File || + GetURLObject().isAnyKnownWebDAVScheme() ) ); +} + +util::DateTime const & SfxMedium::GetInitFileDate( bool bIgnoreOldValue ) +{ + if ( ( bIgnoreOldValue || !pImpl->m_bGotDateTime ) && !pImpl->m_aLogicName.isEmpty() ) + { + try + { + // add a default css::ucb::XCommandEnvironment + // in order to have the WebDAV UCP provider manage http/https authentication correctly + ::ucbhelper::Content aContent( GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ), + utl::UCBContentHelper::getDefaultCommandEnvironment(), + comphelper::getProcessComponentContext() ); + + aContent.getPropertyValue("DateModified") >>= pImpl->m_aDateTime; + pImpl->m_bGotDateTime = true; + } + catch ( const css::uno::Exception& ) + { + } + } + + return pImpl->m_aDateTime; +} + + +Reference < XContent > SfxMedium::GetContent() const +{ + if ( !pImpl->aContent.get().is() ) + { + Reference < css::ucb::XContent > xContent; + + // tdf#95144 add a default css::ucb::XCommandEnvironment + // in order to have the WebDAV UCP provider manage https protocol certificates correctly + css:: uno::Reference< task::XInteractionHandler > xIH( + css::task::InteractionHandler::createWithParent( comphelper::getProcessComponentContext(), nullptr ) ); + + css::uno::Reference< css::ucb::XProgressHandler > xProgress; + rtl::Reference<::ucbhelper::CommandEnvironment> pCommandEnv = new ::ucbhelper::CommandEnvironment( new comphelper::SimpleFileAccessInteraction( xIH ), xProgress ); + + const SfxUnoAnyItem* pItem = SfxItemSet::GetItem<SfxUnoAnyItem>(pImpl->m_pSet.get(), SID_CONTENT, false); + if ( pItem ) + pItem->GetValue() >>= xContent; + + if ( xContent.is() ) + { + try + { + pImpl->aContent = ::ucbhelper::Content( xContent, pCommandEnv, comphelper::getProcessComponentContext() ); + } + catch ( const Exception& ) + { + } + } + else + { + // TODO: SAL_WARN( "sfx.doc", "SfxMedium::GetContent()\nCreate Content? This code exists as fallback only. Please clarify, why it's used."); + OUString aURL; + if ( !pImpl->m_aName.isEmpty() ) + osl::FileBase::getFileURLFromSystemPath( pImpl->m_aName, aURL ); + else if ( !pImpl->m_aLogicName.isEmpty() ) + aURL = GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ); + if (!aURL.isEmpty() ) + (void)::ucbhelper::Content::create( aURL, pCommandEnv, comphelper::getProcessComponentContext(), pImpl->aContent ); + } + } + + return pImpl->aContent.get(); +} + +OUString SfxMedium::GetBaseURL( bool bForSaving ) +{ + OUString aBaseURL; + const SfxStringItem* pBaseURLItem = GetItemSet()->GetItem<SfxStringItem>(SID_DOC_BASEURL); + if ( pBaseURLItem ) + aBaseURL = pBaseURLItem->GetValue(); + else if (!utl::ConfigManager::IsFuzzing() && GetContent().is()) + { + try + { + Any aAny = pImpl->aContent.getPropertyValue("BaseURI"); + aAny >>= aBaseURL; + } + catch ( const css::uno::Exception& ) + { + } + + if ( aBaseURL.isEmpty() ) + aBaseURL = GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ); + } + + if ( bForSaving ) + { + bool bIsRemote = IsRemote(); + if( (bIsRemote && !officecfg::Office::Common::Save::URL::Internet::get()) + || (!pImpl->m_bRemote && !officecfg::Office::Common::Save::URL::FileSystem::get()) ) + return OUString(); + } + + return aBaseURL; +} + +bool SfxMedium::IsSkipImages() const +{ + const SfxStringItem* pSkipImagesItem = GetItemSet()->GetItem<SfxStringItem>(SID_FILE_FILTEROPTIONS); + return pSkipImagesItem && pSkipImagesItem->GetValue() == "SkipImages"; +} + +SvStream* SfxMedium::GetInStream() +{ + if ( pImpl->m_pInStream ) + return pImpl->m_pInStream.get(); + + if ( pImpl->pTempFile ) + { + pImpl->m_pInStream.reset( new SvFileStream(pImpl->m_aName, pImpl->m_nStorOpenMode) ); + + pImpl->m_eError = pImpl->m_pInStream->GetError(); + + if (!pImpl->m_eError && (pImpl->m_nStorOpenMode & StreamMode::WRITE) + && ! pImpl->m_pInStream->IsWritable() ) + { + pImpl->m_eError = ERRCODE_IO_ACCESSDENIED; + pImpl->m_pInStream.reset(); + } + else + return pImpl->m_pInStream.get(); + } + + GetMedium_Impl(); + + if ( GetError() ) + return nullptr; + + return pImpl->m_pInStream.get(); +} + + +void SfxMedium::CloseInStream() +{ + CloseInStream_Impl(); +} + +void SfxMedium::CloseInStream_Impl(bool bInDestruction) +{ + // if there is a storage based on the InStream, we have to + // close the storage, too, because otherwise the storage + // would use an invalid ( deleted ) stream. + if ( pImpl->m_pInStream && pImpl->xStorage.is() ) + { + if ( pImpl->bStorageBasedOnInStream ) + CloseStorage(); + } + + if ( pImpl->m_pInStream && !GetContent().is() && !bInDestruction ) + { + CreateTempFile(); + return; + } + + pImpl->m_pInStream.reset(); + if ( pImpl->m_pSet ) + pImpl->m_pSet->ClearItem( SID_INPUTSTREAM ); + + CloseZipStorage_Impl(); + pImpl->xInputStream.clear(); + + if ( !pImpl->m_pOutStream ) + { + // output part of the stream is not used so the whole stream can be closed + // TODO/LATER: is it correct? + pImpl->xStream.clear(); + if ( pImpl->m_pSet ) + pImpl->m_pSet->ClearItem( SID_STREAM ); + } +} + + +SvStream* SfxMedium::GetOutStream() +{ + if ( !pImpl->m_pOutStream ) + { + // Create a temp. file if there is none because we always + // need one. + CreateTempFile( false ); + + if ( pImpl->pTempFile ) + { + // On windows we try to re-use XOutStream from xStream if that exists; + // because opening new SvFileStream in this situation may fail with ERROR_SHARING_VIOLATION + // TODO: this is a horrible hack that should probably be removed, + // somebody needs to investigate this more thoroughly... + if (getenv("SFX_MEDIUM_REUSE_STREAM") && pImpl->xStream.is()) + { + assert(pImpl->xStream->getOutputStream().is()); // need that... + pImpl->m_pOutStream = utl::UcbStreamHelper::CreateStream( + pImpl->xStream, false); + } + else + { + // On Unix don't try to re-use XOutStream from xStream if that exists; + // it causes fdo#59022 (fails opening files via SMB on Linux) + pImpl->m_pOutStream.reset( new SvFileStream( + pImpl->m_aName, StreamMode::STD_READWRITE) ); + } + CloseStorage(); + } + } + + return pImpl->m_pOutStream.get(); +} + + +void SfxMedium::CloseOutStream() +{ + CloseOutStream_Impl(); +} + +void SfxMedium::CloseOutStream_Impl() +{ + if ( pImpl->m_pOutStream ) + { + // if there is a storage based on the OutStream, we have to + // close the storage, too, because otherwise the storage + // would use an invalid ( deleted ) stream. + //TODO/MBA: how to deal with this?! + //maybe we need a new flag when the storage was created from the outstream + if ( pImpl->xStorage.is() ) + { + CloseStorage(); + } + + pImpl->m_pOutStream.reset(); + } + + if ( !pImpl->m_pInStream ) + { + // input part of the stream is not used so the whole stream can be closed + // TODO/LATER: is it correct? + pImpl->xStream.clear(); + if ( pImpl->m_pSet ) + pImpl->m_pSet->ClearItem( SID_STREAM ); + } +} + + +const OUString& SfxMedium::GetPhysicalName() const +{ + if ( pImpl->m_aName.isEmpty() && !pImpl->m_aLogicName.isEmpty() ) + const_cast<SfxMedium*>(this)->CreateFileStream(); + + // return the name then + return pImpl->m_aName; +} + + +void SfxMedium::CreateFileStream() +{ + // force synchron + if( pImpl->m_pInStream ) + { + SvLockBytes* pBytes = pImpl->m_pInStream->GetLockBytes(); + if( pBytes ) + pBytes->SetSynchronMode(); + } + + GetInStream(); + if( pImpl->m_pInStream ) + { + CreateTempFile( false ); + pImpl->bIsTemp = true; + CloseInStream_Impl(); + } +} + + +bool SfxMedium::Commit() +{ + if( pImpl->xStorage.is() ) + StorageCommit_Impl(); + else if( pImpl->m_pOutStream ) + pImpl->m_pOutStream->FlushBuffer(); + else if( pImpl->m_pInStream ) + pImpl->m_pInStream->FlushBuffer(); + + if ( GetError() == ERRCODE_NONE ) + { + // does something only in case there is a temporary file ( means aName points to different location than aLogicName ) + Transfer_Impl(); + } + + bool bResult = ( GetError() == ERRCODE_NONE ); + + if ( bResult && DocNeedsFileDateCheck() ) + GetInitFileDate( true ); + + // remove truncation mode from the flags + pImpl->m_nStorOpenMode &= ~StreamMode::TRUNC; + return bResult; +} + + +bool SfxMedium::IsStorage() +{ + if ( pImpl->xStorage.is() ) + return true; + + if ( pImpl->m_bTriedStorage ) + return pImpl->bIsStorage; + + if ( pImpl->pTempFile ) + { + OUString aURL; + if ( osl::FileBase::getFileURLFromSystemPath( pImpl->m_aName, aURL ) + != osl::FileBase::E_None ) + { + SAL_WARN( "sfx.doc", "Physical name '" << pImpl->m_aName << "' not convertible to file URL"); + } + pImpl->bIsStorage = SotStorage::IsStorageFile( aURL ) && !SotStorage::IsOLEStorage( aURL); + if ( !pImpl->bIsStorage ) + pImpl->m_bTriedStorage = true; + } + else if ( GetInStream() ) + { + pImpl->bIsStorage = SotStorage::IsStorageFile( pImpl->m_pInStream.get() ) && !SotStorage::IsOLEStorage( pImpl->m_pInStream.get() ); + if ( !pImpl->m_pInStream->GetError() && !pImpl->bIsStorage ) + pImpl->m_bTriedStorage = true; + } + + return pImpl->bIsStorage; +} + + +bool SfxMedium::IsPreview_Impl() const +{ + bool bPreview = false; + const SfxBoolItem* pPreview = SfxItemSet::GetItem<SfxBoolItem>(GetItemSet(), SID_PREVIEW, false); + if ( pPreview ) + bPreview = pPreview->GetValue(); + else + { + const SfxStringItem* pFlags = SfxItemSet::GetItem<SfxStringItem>(GetItemSet(), SID_OPTIONS, false); + if ( pFlags ) + { + OUString aFileFlags = pFlags->GetValue(); + aFileFlags = aFileFlags.toAsciiUpperCase(); + if ( -1 != aFileFlags.indexOf( 'B' ) ) + bPreview = true; + } + } + + return bPreview; +} + + +void SfxMedium::StorageBackup_Impl() +{ + ::ucbhelper::Content aOriginalContent; + Reference< css::ucb::XCommandEnvironment > xDummyEnv; + + bool bBasedOnOriginalFile = + !pImpl->pTempFile + && ( pImpl->m_aLogicName.isEmpty() || !pImpl->m_bSalvageMode ) + && !GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ).isEmpty() + && GetURLObject().GetProtocol() == INetProtocol::File + && ::utl::UCBContentHelper::IsDocument( GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + + if ( bBasedOnOriginalFile && pImpl->m_aBackupURL.isEmpty() + && ::ucbhelper::Content::create( GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ), xDummyEnv, comphelper::getProcessComponentContext(), aOriginalContent ) ) + { + DoInternalBackup_Impl( aOriginalContent ); + if( pImpl->m_aBackupURL.isEmpty() ) + SetError(ERRCODE_SFX_CANTCREATEBACKUP); + } +} + + +OUString const & SfxMedium::GetBackup_Impl() +{ + if ( pImpl->m_aBackupURL.isEmpty() ) + StorageBackup_Impl(); + + return pImpl->m_aBackupURL; +} + + +uno::Reference < embed::XStorage > SfxMedium::GetOutputStorage() +{ + if ( GetError() ) + return uno::Reference< embed::XStorage >(); + + // if the medium was constructed with a Storage: use this one, not a temp. storage + // if a temporary storage already exists: use it + if ( pImpl->xStorage.is() && ( pImpl->m_aLogicName.isEmpty() || pImpl->pTempFile ) ) + return pImpl->xStorage; + + // if necessary close stream that was used for reading + if ( pImpl->m_pInStream && !pImpl->m_pInStream->IsWritable() ) + CloseInStream(); + + DBG_ASSERT( !pImpl->m_pOutStream, "OutStream in a readonly Medium?!" ); + + // TODO/LATER: The current solution is to store the document temporary and then copy it to the target location; + // in future it should be stored directly and then copied to the temporary location, since in this case no + // file attributes have to be preserved and system copying mechanics could be used instead of streaming. + CreateTempFileNoCopy(); + + return GetStorage(); +} + + +void SfxMedium::SetEncryptionDataToStorage_Impl() +{ + // in case media-descriptor contains password it should be used on opening + if ( !pImpl->xStorage.is() || !pImpl->m_pSet ) + return; + + uno::Sequence< beans::NamedValue > aEncryptionData; + if ( !GetEncryptionData_Impl( pImpl->m_pSet.get(), aEncryptionData ) ) + return; + + // replace the password with encryption data + pImpl->m_pSet->ClearItem( SID_PASSWORD ); + pImpl->m_pSet->Put( SfxUnoAnyItem( SID_ENCRYPTIONDATA, uno::Any( aEncryptionData ) ) ); + + try + { + ::comphelper::OStorageHelper::SetCommonStorageEncryptionData( pImpl->xStorage, aEncryptionData ); + } + catch( const uno::Exception& ) + { + SAL_WARN( "sfx.doc", "It must be possible to set a common password for the storage" ); + // TODO/LATER: set the error code in case of problem + // SetError(ERRCODE_IO_GENERAL); + } +} + +#if HAVE_FEATURE_MULTIUSER_ENVIRONMENT + +// FIXME: Hmm actually lock files should be used for sftp: documents +// even if !HAVE_FEATURE_MULTIUSER_ENVIRONMENT. Only the use of lock +// files for *local* documents is unnecessary in that case. But +// actually, the checks for sftp: here are just wishful thinking; I +// don't this there is any support for actually editing documents +// behind sftp: URLs anyway. + +// Sure, there could perhaps be a 3rd-party extension that brings UCB +// the potential to handle files behind sftp:. But there could also be +// an extension that handles some arbitrary foobar: scheme *and* it +// could be that lock files would be the correct thing to use for +// foobar: documents, too. But the hardcoded test below won't know +// that. Clearly the knowledge whether lock files should be used or +// not for some URL scheme belongs in UCB, not here. + +namespace +{ + +OUString tryMSOwnerFiles(std::u16string_view sDocURL) +{ + svt::MSODocumentLockFile aMSOLockFile(sDocURL); + LockFileEntry aData; + try + { + aData = aMSOLockFile.GetLockData(); + } + catch( const uno::Exception& ) + { + return OUString(); + } + + OUString sUserData = aData[LockFileComponent::OOOUSERNAME]; + + if (!sUserData.isEmpty()) + sUserData += " (MS Office)"; // Mention the used office suite + + return sUserData; +} + +OUString tryForeignLockfiles(std::u16string_view sDocURL) +{ + OUString sUserData = tryMSOwnerFiles(sDocURL); + // here we can test for empty result, and add other known applications' lockfile testing + return sUserData.trim(); +} +} + +SfxMedium::ShowLockResult SfxMedium::ShowLockedDocumentDialog(const LockFileEntry& aData, + bool bIsLoading, bool bOwnLock, + bool bHandleSysLocked) +{ + ShowLockResult nResult = ShowLockResult::NoLock; + + // tdf#92817: Simple check for empty lock file that needs to be deleted, when system locking is enabled + if( aData[LockFileComponent::OOOUSERNAME].isEmpty() && aData[LockFileComponent::SYSUSERNAME].isEmpty() && !bHandleSysLocked ) + bOwnLock=true; + + // show the interaction regarding the document opening + uno::Reference< task::XInteractionHandler > xHandler = GetInteractionHandler(); + + if ( xHandler.is() && ( bIsLoading || !bHandleSysLocked || bOwnLock ) ) + { + OUString aDocumentURL + = GetURLObject().GetLastName(INetURLObject::DecodeMechanism::WithCharset); + OUString aInfo; + ::rtl::Reference< ::ucbhelper::InteractionRequest > xInteractionRequestImpl; + + sal_Int32 nContinuations = 3; + + if ( bOwnLock ) + { + aInfo = aData[LockFileComponent::EDITTIME]; + + xInteractionRequestImpl = new ::ucbhelper::InteractionRequest( uno::Any( + document::OwnLockOnDocumentRequest( OUString(), uno::Reference< uno::XInterface >(), aDocumentURL, aInfo, !bIsLoading ) ) ); + } + else + { + // Use a fourth continuation in case there's no filesystem lock: + // "Ignore lock file and open/replace the document" + if (!bHandleSysLocked) + nContinuations = 4; + + if ( !aData[LockFileComponent::OOOUSERNAME].isEmpty() ) + aInfo = aData[LockFileComponent::OOOUSERNAME]; + else + aInfo = aData[LockFileComponent::SYSUSERNAME]; + + if (aInfo.isEmpty() && !GetURLObject().isAnyKnownWebDAVScheme()) + // Try to get name of user who has locked the file using other applications + aInfo = tryForeignLockfiles( + GetURLObject().GetMainURL(INetURLObject::DecodeMechanism::NONE)); + + if ( !aInfo.isEmpty() && !aData[LockFileComponent::EDITTIME].isEmpty() ) + aInfo += " ( " + aData[LockFileComponent::EDITTIME] + " )"; + + if (!bIsLoading) // so, !bHandleSysLocked + { + xInteractionRequestImpl = new ::ucbhelper::InteractionRequest(uno::Any( + document::LockedOnSavingRequest(OUString(), uno::Reference< uno::XInterface >(), aDocumentURL, aInfo))); + // Currently, only the last "Retry" continuation (meaning ignore the lock and try overwriting) can be returned. + } + else /*logically therefore bIsLoading is set */ + { + xInteractionRequestImpl = new ::ucbhelper::InteractionRequest( uno::Any( + document::LockedDocumentRequest( OUString(), uno::Reference< uno::XInterface >(), aDocumentURL, aInfo ) ) ); + } + } + + uno::Sequence< uno::Reference< task::XInteractionContinuation > > aContinuations(nContinuations); + auto pContinuations = aContinuations.getArray(); + pContinuations[0] = new ::ucbhelper::InteractionAbort( xInteractionRequestImpl.get() ); + pContinuations[1] = new ::ucbhelper::InteractionApprove( xInteractionRequestImpl.get() ); + pContinuations[2] = new ::ucbhelper::InteractionDisapprove( xInteractionRequestImpl.get() ); + if (nContinuations > 3) + { + // We use InteractionRetry to reflect that user wants to + // ignore the (stale?) alien lock file and open/overwrite the document + pContinuations[3] = new ::ucbhelper::InteractionRetry(xInteractionRequestImpl.get()); + } + xInteractionRequestImpl->setContinuations( aContinuations ); + + xHandler->handle( xInteractionRequestImpl ); + + bool bOpenReadOnly = false; + ::rtl::Reference< ::ucbhelper::InteractionContinuation > xSelected = xInteractionRequestImpl->getSelection(); + if ( uno::Reference< task::XInteractionAbort >( xSelected.get(), uno::UNO_QUERY ).is() ) + { + SetError(ERRCODE_ABORT); + } + else if ( uno::Reference< task::XInteractionDisapprove >( xSelected.get(), uno::UNO_QUERY ).is() ) + { + // own lock on loading, user has selected to ignore the lock + // own lock on saving, user has selected to ignore the lock + // alien lock on loading, user has selected to edit a copy of document + // TODO/LATER: alien lock on saving, user has selected to do SaveAs to different location + if ( !bOwnLock ) // bIsLoading implied from outermost condition + { + // means that a copy of the document should be opened + GetItemSet()->Put( SfxBoolItem( SID_TEMPLATE, true ) ); + } + else + nResult = ShowLockResult::Succeeded; + } + else if (uno::Reference< task::XInteractionRetry >(xSelected.get(), uno::UNO_QUERY).is()) + { + // User decided to ignore the alien (stale?) lock file without filesystem lock + nResult = ShowLockResult::Succeeded; + } + else if (uno::Reference< task::XInteractionApprove >( xSelected.get(), uno::UNO_QUERY ).is()) + { + bOpenReadOnly = true; + } + else // user selected "Notify" + { + pImpl->m_bNotifyWhenEditable = true; + AddToCheckEditableWorkerList(); + bOpenReadOnly = true; + } + + if (bOpenReadOnly) + { + // own lock on loading, user has selected to open readonly + // own lock on saving, user has selected to open readonly + // alien lock on loading, user has selected to retry saving + // TODO/LATER: alien lock on saving, user has selected to retry saving + + if (bIsLoading) + GetItemSet()->Put(SfxBoolItem(SID_DOC_READONLY, true)); + else + nResult = ShowLockResult::Try; + } + } + else + { + if ( bIsLoading ) + { + // if no interaction handler is provided the default answer is open readonly + // that usually happens in case the document is loaded per API + // so the document must be opened readonly for backward compatibility + GetItemSet()->Put( SfxBoolItem( SID_DOC_READONLY, true ) ); + } + else + SetError(ERRCODE_IO_ACCESSDENIED); + + } + + return nResult; +} + +bool SfxMedium::ShowLockFileProblemDialog(MessageDlg nWhichDlg) +{ + // system file locking is not active, ask user whether he wants to open the document without any locking + uno::Reference< task::XInteractionHandler > xHandler = GetInteractionHandler(); + + if (xHandler.is()) + { + ::rtl::Reference< ::ucbhelper::InteractionRequest > xIgnoreRequestImpl; + + switch (nWhichDlg) + { + case MessageDlg::LockFileIgnore: + xIgnoreRequestImpl = new ::ucbhelper::InteractionRequest(uno::Any( document::LockFileIgnoreRequest() )); + break; + case MessageDlg::LockFileCorrupt: + xIgnoreRequestImpl = new ::ucbhelper::InteractionRequest(uno::Any( document::LockFileCorruptRequest() )); + break; + } + + uno::Sequence< uno::Reference< task::XInteractionContinuation > > aContinuations{ + new ::ucbhelper::InteractionAbort(xIgnoreRequestImpl.get()), + new ::ucbhelper::InteractionApprove(xIgnoreRequestImpl.get()) + }; + xIgnoreRequestImpl->setContinuations(aContinuations); + + xHandler->handle(xIgnoreRequestImpl); + + ::rtl::Reference< ::ucbhelper::InteractionContinuation > xSelected = xIgnoreRequestImpl->getSelection(); + bool bReadOnly = true; + + if (uno::Reference<task::XInteractionAbort>(xSelected.get(), uno::UNO_QUERY).is()) + { + SetError(ERRCODE_ABORT); + bReadOnly = false; + } + else if (!uno::Reference<task::XInteractionApprove>(xSelected.get(), uno::UNO_QUERY).is()) + { + // user selected "Notify" + pImpl->m_bNotifyWhenEditable = true; + AddToCheckEditableWorkerList(); + } + + if (bReadOnly) + GetItemSet()->Put(SfxBoolItem(SID_DOC_READONLY, true)); + + return bReadOnly; + } + + return false; +} + +namespace +{ + bool isSuitableProtocolForLocking(const OUString & rLogicName) + { + INetURLObject aUrl( rLogicName ); + INetProtocol eProt = aUrl.GetProtocol(); +#if !HAVE_FEATURE_MACOSX_SANDBOX + if (eProt == INetProtocol::File) { + return true; + } +#endif + return eProt == INetProtocol::Smb || eProt == INetProtocol::Sftp; + } +} + +#endif // HAVE_FEATURE_MULTIUSER_ENVIRONMENT + +// sets SID_DOC_READONLY if the document cannot be opened for editing +// if user cancel the loading the ERROR_ABORT is set +SfxMedium::LockFileResult SfxMedium::LockOrigFileOnDemand(bool bLoading, bool bNoUI, + bool bTryIgnoreLockFile, + LockFileEntry* pLockData) +{ +#if !HAVE_FEATURE_MULTIUSER_ENVIRONMENT + (void) bLoading; + (void) bNoUI; + (void) bTryIgnoreLockFile; + (void) pLockData; + return LockFileResult::Succeeded; +#else + LockFileResult eResult = LockFileResult::Failed; + + // check if path scheme is http:// or https:// + // may be this is better if used always, in Android and iOS as well? + // if this code should be always there, remember to move the relevant code in UnlockFile method as well ! + + if ( GetURLObject().isAnyKnownWebDAVScheme() ) + { + // do nothing if WebDAV locking is disabled + if (!IsWebDAVLockingUsed()) + return LockFileResult::Succeeded; + + { + bool bResult = pImpl->m_bLocked; + bool bIsTemplate = false; + // so, this is webdav stuff... + if ( !bResult ) + { + // no read-write access is necessary on loading if the document is explicitly opened as copy + const SfxBoolItem* pTemplateItem = SfxItemSet::GetItem<SfxBoolItem>(GetItemSet(), SID_TEMPLATE, false); + bIsTemplate = ( bLoading && pTemplateItem && pTemplateItem->GetValue() ); + } + + if ( !bIsTemplate && !bResult && !IsReadOnly() ) + { + ShowLockResult bUIStatus = ShowLockResult::NoLock; + do + { + if( !bResult ) + { + uno::Reference< task::XInteractionHandler > xCHandler = GetInteractionHandler( true ); + Reference< css::ucb::XCommandEnvironment > xComEnv = new ::ucbhelper::CommandEnvironment( + xCHandler, Reference< css::ucb::XProgressHandler >() ); + + ucbhelper::Content aContentToLock( + GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ), + xComEnv, comphelper::getProcessComponentContext() ); + + try + { + aContentToLock.lock(); + bResult = true; + } + catch ( ucb::InteractiveLockingLockedException& ) + { + // received when the resource is already locked + if (!bNoUI || pLockData) + { + // get the lock owner, using a special ucb.webdav property + // the owner property retrieved here is what the other principal send the server + // when activating the lock. + // See http://tools.ietf.org/html/rfc4918#section-14.17 for details + LockFileEntry aLockData; + aLockData[LockFileComponent::OOOUSERNAME] = "Unknown user"; + // This solution works right when the LO user name and the WebDAV user + // name are the same. + // A better thing to do would be to obtain the 'real' WebDAV user name, + // but that's not possible from a WebDAV UCP provider client. + LockFileEntry aOwnData = svt::LockFileCommon::GenerateOwnEntry(); + // use the current LO user name as the system name + aLockData[LockFileComponent::SYSUSERNAME] + = aOwnData[LockFileComponent::SYSUSERNAME]; + + uno::Sequence<css::ucb::Lock> aLocks; + // getting the property, send a PROPFIND to the server over the net + if ((aContentToLock.getPropertyValue("DAV:lockdiscovery") >>= aLocks) && aLocks.hasElements()) + { + // got at least a lock, show the owner of the first lock returned + css::ucb::Lock aLock = aLocks[0]; + OUString aOwner; + if (aLock.Owner >>= aOwner) + { + // we need to display the WebDAV user name owning the lock, not the local one + aLockData[LockFileComponent::OOOUSERNAME] = aOwner; + } + } + + if (!bNoUI) + { + bUIStatus = ShowLockedDocumentDialog(aLockData, bLoading, false, + true); + } + + if (pLockData) + { + std::copy(aLockData.begin(), aLockData.end(), pLockData->begin()); + } + } + } + catch( ucb::InteractiveNetworkWriteException& ) + { + // This catch it's not really needed, here just for the sake of documentation on the behaviour. + // This is the most likely reason: + // - the remote site is a WebDAV with special configuration: read/only for read operations + // and read/write for write operations, the user is not allowed to lock/write and + // she cancelled the credentials request. + // this is not actually an error, but the exception is sent directly from ucb, avoiding the automatic + // management that takes part in cancelCommandExecution() + // Unfortunately there is no InteractiveNetwork*Exception available to signal this more correctly + // since it mostly happens on read/only part of webdav, this can be the most correct + // exception available + } + catch( uno::Exception& ) + { + TOOLS_WARN_EXCEPTION( "sfx.doc", "Locking exception: WebDAV while trying to lock the file" ); + } + } + } while( !bResult && bUIStatus == ShowLockResult::Try ); + } + + pImpl->m_bLocked = bResult; + + if ( !bResult && GetError() == ERRCODE_NONE ) + { + // the error should be set in case it is storing process + // or the document has been opened for editing explicitly + const SfxBoolItem* pReadOnlyItem = SfxItemSet::GetItem<SfxBoolItem>(pImpl->m_pSet.get(), SID_DOC_READONLY, false); + + if ( !bLoading || (pReadOnlyItem && !pReadOnlyItem->GetValue()) ) + SetError(ERRCODE_IO_ACCESSDENIED); + else + GetItemSet()->Put( SfxBoolItem( SID_DOC_READONLY, true ) ); + } + + // when the file is locked, get the current file date + if ( bResult && DocNeedsFileDateCheck() ) + GetInitFileDate( true ); + + if ( bResult ) + eResult = LockFileResult::Succeeded; + } + return eResult; + } + + if (!IsLockingUsed()) + return LockFileResult::Succeeded; + if (GetURLObject().HasError()) + return eResult; + + try + { + if ( pImpl->m_bLocked && bLoading + && GetURLObject().GetProtocol() == INetProtocol::File ) + { + // if the document is already locked the system locking might be temporarily off after storing + // check whether the system file locking should be taken again + GetLockingStream_Impl(); + } + + bool bResult = pImpl->m_bLocked; + + if ( !bResult ) + { + // no read-write access is necessary on loading if the document is explicitly opened as copy + const SfxBoolItem* pTemplateItem = SfxItemSet::GetItem<SfxBoolItem>(GetItemSet(), SID_TEMPLATE, false); + bResult = ( bLoading && pTemplateItem && pTemplateItem->GetValue() ); + } + + if ( !bResult && !IsReadOnly() ) + { + bool bContentReadonly = false; + if ( bLoading && GetURLObject().GetProtocol() == INetProtocol::File ) + { + // let the original document be opened to check the possibility to open it for editing + // and to let the writable stream stay open to hold the lock on the document + GetLockingStream_Impl(); + } + + // "IsReadOnly" property does not allow to detect whether the file is readonly always + // so we try always to open the file for editing + // the file is readonly only in case the read-write stream can not be opened + if ( bLoading && !pImpl->m_xLockingStream.is() ) + { + try + { + // MediaDescriptor does this check also, the duplication should be avoided in future + Reference< css::ucb::XCommandEnvironment > xDummyEnv; + ::ucbhelper::Content aContent( GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ), xDummyEnv, comphelper::getProcessComponentContext() ); + aContent.getPropertyValue("IsReadOnly") >>= bContentReadonly; + } + catch( const uno::Exception& ) {} + } + + // do further checks only if the file not readonly in fs + if ( !bContentReadonly ) + { + // the special file locking should be used only for suitable URLs + if ( isSuitableProtocolForLocking( pImpl->m_aLogicName ) ) + { + + // in case of storing the document should request the output before locking + if ( bLoading ) + { + // let the stream be opened to check the system file locking + GetMedium_Impl(); + if (GetError() != ERRCODE_NONE) { + return eResult; + } + } + + ShowLockResult bUIStatus = ShowLockResult::NoLock; + + // check whether system file locking has been used, the default value is false + bool bUseSystemLock = comphelper::isFileUrl( pImpl->m_aLogicName ) && IsSystemFileLockingUsed(); + + // TODO/LATER: This implementation does not allow to detect the system lock on saving here, actually this is no big problem + // if system lock is used the writeable stream should be available + bool bHandleSysLocked = ( bLoading && bUseSystemLock && !pImpl->xStream.is() && !pImpl->m_pOutStream ); + + // The file is attempted to get locked for the duration of lockfile creation on save + std::unique_ptr<osl::File> pFileLock; + if (!bLoading && bUseSystemLock && pImpl->pTempFile) + { + INetURLObject aDest(GetURLObject()); + OUString aDestURL(aDest.GetMainURL(INetURLObject::DecodeMechanism::NONE)); + + if (comphelper::isFileUrl(aDestURL) || !aDest.removeSegment()) + { + pFileLock = std::make_unique<osl::File>(aDestURL); + auto rc = pFileLock->open(osl_File_OpenFlag_Write); + if (rc == osl::FileBase::E_ACCES) + bHandleSysLocked = true; + } + } + + do + { + try + { + ::svt::DocumentLockFile aLockFile( pImpl->m_aLogicName ); + + std::unique_ptr<svt::MSODocumentLockFile> pMSOLockFile; + const SvtFilterOptions& rOpt = SvtFilterOptions::Get(); + if (rOpt.IsMSOLockFileCreationIsEnabled() && svt::MSODocumentLockFile::IsMSOSupportedFileFormat(pImpl->m_aLogicName)) + { + pMSOLockFile.reset(new svt::MSODocumentLockFile(pImpl->m_aLogicName)); + pImpl->m_bMSOLockFileCreated = true; + } + + bool bIoErr = false; + + if (!bHandleSysLocked) + { + try + { + bResult = aLockFile.CreateOwnLockFile(); + if(pMSOLockFile) + bResult &= pMSOLockFile->CreateOwnLockFile(); + } + catch (const uno::Exception&) + { + if (tools::IsMappedWebDAVPath(GetURLObject().GetMainURL( + INetURLObject::DecodeMechanism::NONE))) + { + // This is a path that redirects to a WebDAV resource; + // so failure creating lockfile is not an error here. + bResult = true; + } + else if (bLoading && !bNoUI) + { + bIoErr = true; + ShowLockFileProblemDialog(MessageDlg::LockFileIgnore); + bResult = true; // always delete the defect lock-file + } + } + + // in case OOo locking is turned off the lock file is still written if possible + // but it is ignored while deciding whether the document should be opened for editing or not + if (!bResult && !IsOOoLockFileUsed() && !bIoErr) + { + bResult = true; + // take the ownership over the lock file + aLockFile.OverwriteOwnLockFile(); + + if(pMSOLockFile) + pMSOLockFile->OverwriteOwnLockFile(); + } + } + + if ( !bResult ) + { + LockFileEntry aData; + try + { + aData = aLockFile.GetLockData(); + } + catch (const io::WrongFormatException&) + { + // we get empty or corrupt data + // info to the user + if (!bIoErr && bLoading && !bNoUI ) + bResult = ShowLockFileProblemDialog(MessageDlg::LockFileCorrupt); + + // not show the Lock Document Dialog + bIoErr = true; + } + catch( const uno::Exception& ) + { + // show the Lock Document Dialog, when locked from other app + bIoErr = !bHandleSysLocked; + } + + bool bOwnLock = false; + + if (!bHandleSysLocked) + { + LockFileEntry aOwnData = svt::LockFileCommon::GenerateOwnEntry(); + bOwnLock = aOwnData[LockFileComponent::SYSUSERNAME] == aData[LockFileComponent::SYSUSERNAME]; + + if (bOwnLock + && aOwnData[LockFileComponent::LOCALHOST] == aData[LockFileComponent::LOCALHOST] + && aOwnData[LockFileComponent::USERURL] == aData[LockFileComponent::USERURL]) + { + // this is own lock from the same installation, it could remain because of crash + bResult = true; + } + } + + if ( !bResult && !bIoErr) + { + if (!bNoUI) + bUIStatus = ShowLockedDocumentDialog( + aData, bLoading, bOwnLock, bHandleSysLocked); + else if (bLoading && bTryIgnoreLockFile && !bHandleSysLocked) + bUIStatus = ShowLockResult::Succeeded; + + if ( bUIStatus == ShowLockResult::Succeeded ) + { + // take the ownership over the lock file + bResult = aLockFile.OverwriteOwnLockFile(); + + if(pMSOLockFile) + pMSOLockFile->OverwriteOwnLockFile(); + } + else if (bLoading && !bHandleSysLocked) + eResult = LockFileResult::FailedLockFile; + + if (!bResult && pLockData) + { + std::copy(aData.begin(), aData.end(), pLockData->begin()); + } + } + } + } + catch( const uno::Exception& ) + { + } + } while( !bResult && bUIStatus == ShowLockResult::Try ); + + pImpl->m_bLocked = bResult; + } + else + { + // this is no file URL, check whether the file is readonly + bResult = !bContentReadonly; + } + } + else // read-only + { + AddToCheckEditableWorkerList(); + } + } + + if ( !bResult && GetError() == ERRCODE_NONE ) + { + // the error should be set in case it is storing process + // or the document has been opened for editing explicitly + const SfxBoolItem* pReadOnlyItem = SfxItemSet::GetItem<SfxBoolItem>(pImpl->m_pSet.get(), SID_DOC_READONLY, false); + + if ( !bLoading || (pReadOnlyItem && !pReadOnlyItem->GetValue()) ) + SetError(ERRCODE_IO_ACCESSDENIED); + else + GetItemSet()->Put( SfxBoolItem( SID_DOC_READONLY, true ) ); + } + + // when the file is locked, get the current file date + if ( bResult && DocNeedsFileDateCheck() ) + GetInitFileDate( true ); + + if ( bResult ) + eResult = LockFileResult::Succeeded; + } + catch( const uno::Exception& ) + { + TOOLS_WARN_EXCEPTION( "sfx.doc", "Locking exception: high probability, that the content has not been created" ); + } + + return eResult; +#endif +} + + +uno::Reference < embed::XStorage > SfxMedium::GetStorage( bool bCreateTempFile ) +{ + if ( pImpl->xStorage.is() || pImpl->m_bTriedStorage ) + return pImpl->xStorage; + + uno::Sequence< uno::Any > aArgs( 2 ); + auto pArgs = aArgs.getArray(); + + // the medium should be retrieved before temporary file creation + // to let the MediaDescriptor be filled with the streams + GetMedium_Impl(); + + if ( bCreateTempFile ) + CreateTempFile( false ); + + GetMedium_Impl(); + + if ( GetError() ) + return pImpl->xStorage; + + const SfxBoolItem* pRepairItem = SfxItemSet::GetItem<SfxBoolItem>(GetItemSet(), SID_REPAIRPACKAGE, false); + if ( pRepairItem && pRepairItem->GetValue() ) + { + // the storage should be created for repairing mode + CreateTempFile( false ); + GetMedium_Impl(); + + Reference< css::ucb::XProgressHandler > xProgressHandler; + Reference< css::task::XStatusIndicator > xStatusIndicator; + + const SfxUnoAnyItem* pxProgressItem = SfxItemSet::GetItem<SfxUnoAnyItem>(GetItemSet(), SID_PROGRESS_STATUSBAR_CONTROL, false); + if( pxProgressItem && ( pxProgressItem->GetValue() >>= xStatusIndicator ) ) + xProgressHandler.set( new utl::ProgressHandlerWrap( xStatusIndicator ) ); + + uno::Sequence< beans::PropertyValue > aAddProps{ + comphelper::makePropertyValue("RepairPackage", true), + comphelper::makePropertyValue("StatusIndicator", xProgressHandler) + }; + + // the first arguments will be filled later + aArgs.realloc( 3 ); + pArgs = aArgs.getArray(); + pArgs[2] <<= aAddProps; + } + + if ( pImpl->xStream.is() ) + { + // since the storage is based on temporary stream we open it always read-write + pArgs[0] <<= pImpl->xStream; + pArgs[1] <<= embed::ElementModes::READWRITE; + pImpl->bStorageBasedOnInStream = true; + if (pImpl->m_bDisableFileSync) + { + // Forward NoFileSync to the storage factory. + aArgs.realloc(3); // ??? this may re-write the data added above for pRepairItem + pArgs = aArgs.getArray(); + uno::Sequence<beans::PropertyValue> aProperties( + comphelper::InitPropertySequence({ { "NoFileSync", uno::Any(true) } })); + pArgs[2] <<= aProperties; + } + } + else if ( pImpl->xInputStream.is() ) + { + // since the storage is based on temporary stream we open it always read-write + pArgs[0] <<= pImpl->xInputStream; + pArgs[1] <<= embed::ElementModes::READ; + pImpl->bStorageBasedOnInStream = true; + } + else + { + CloseStreams_Impl(); + pArgs[0] <<= pImpl->m_aName; + pArgs[1] <<= embed::ElementModes::READ; + pImpl->bStorageBasedOnInStream = false; + } + + try + { + pImpl->xStorage.set( ::comphelper::OStorageHelper::GetStorageFactory()->createInstanceWithArguments( aArgs ), + uno::UNO_QUERY ); + } + catch( const uno::Exception& ) + { + // impossibility to create the storage is no error + } + + if( ( pImpl->nLastStorageError = GetError() ) != ERRCODE_NONE ) + { + pImpl->xStorage = nullptr; + if ( pImpl->m_pInStream ) + pImpl->m_pInStream->Seek(0); + return uno::Reference< embed::XStorage >(); + } + + pImpl->m_bTriedStorage = true; + + // TODO/LATER: Get versionlist on demand + if ( pImpl->xStorage.is() ) + { + SetEncryptionDataToStorage_Impl(); + GetVersionList(); + } + + const SfxInt16Item* pVersion = SfxItemSet::GetItem<SfxInt16Item>(pImpl->m_pSet.get(), SID_VERSION, false); + + bool bResetStorage = false; + if ( pVersion && pVersion->GetValue() ) + { + // Read all available versions + if ( pImpl->aVersions.hasElements() ) + { + // Search for the version fits the comment + // The versions are numbered starting with 1, versions with + // negative versions numbers are counted backwards from the + // current version + short nVersion = pVersion->GetValue(); + if ( nVersion<0 ) + nVersion = static_cast<short>(pImpl->aVersions.getLength()) + nVersion; + else // nVersion > 0; pVersion->GetValue() != 0 was the condition to this block + nVersion--; + + const util::RevisionTag& rTag = pImpl->aVersions[nVersion]; + { + // Open SubStorage for all versions + uno::Reference < embed::XStorage > xSub = pImpl->xStorage->openStorageElement( "Versions", + embed::ElementModes::READ ); + + DBG_ASSERT( xSub.is(), "Version list, but no Versions!" ); + + // There the version is stored as packed Stream + uno::Reference < io::XStream > xStr = xSub->openStreamElement( rTag.Identifier, embed::ElementModes::READ ); + std::unique_ptr<SvStream> pStream(utl::UcbStreamHelper::CreateStream( xStr )); + if ( pStream && pStream->GetError() == ERRCODE_NONE ) + { + // Unpack Stream in TempDir + ::utl::TempFile aTempFile; + const OUString& aTmpName = aTempFile.GetURL(); + SvFileStream aTmpStream( aTmpName, SFX_STREAM_READWRITE ); + + pStream->ReadStream( aTmpStream ); + pStream.reset(); + aTmpStream.Close(); + + // Open data as Storage + pImpl->m_nStorOpenMode = SFX_STREAM_READONLY; + pImpl->xStorage = comphelper::OStorageHelper::GetStorageFromURL( aTmpName, embed::ElementModes::READ ); + pImpl->bStorageBasedOnInStream = false; + OUString aTemp; + osl::FileBase::getSystemPathFromFileURL( aTmpName, aTemp ); + SetPhysicalName_Impl( aTemp ); + + pImpl->bIsTemp = true; + GetItemSet()->Put( SfxBoolItem( SID_DOC_READONLY, true ) ); + // TODO/MBA + pImpl->aVersions.realloc(0); + } + else + bResetStorage = true; + } + } + else + bResetStorage = true; + } + + if ( bResetStorage ) + { + pImpl->xStorage.clear(); + if ( pImpl->m_pInStream ) + pImpl->m_pInStream->Seek( 0 ); + } + + pImpl->bIsStorage = pImpl->xStorage.is(); + return pImpl->xStorage; +} + + +uno::Reference< embed::XStorage > const & SfxMedium::GetZipStorageToSign_Impl( bool bReadOnly ) +{ + if ( !GetError() && !pImpl->m_xZipStorage.is() ) + { + GetMedium_Impl(); + + try + { + // we can not sign document if there is no stream + // should it be possible at all? + if ( !bReadOnly && pImpl->xStream.is() ) + { + pImpl->m_xZipStorage = ::comphelper::OStorageHelper::GetStorageOfFormatFromStream( ZIP_STORAGE_FORMAT_STRING, pImpl->xStream ); + } + else if ( pImpl->xInputStream.is() ) + { + pImpl->m_xZipStorage = ::comphelper::OStorageHelper::GetStorageOfFormatFromInputStream( ZIP_STORAGE_FORMAT_STRING, pImpl->xInputStream ); + } + } + catch( const uno::Exception& ) + { + SAL_WARN( "sfx.doc", "No possibility to get readonly version of storage from medium!" ); + } + + if ( GetError() ) // do not remove warnings + ResetError(); + } + + return pImpl->m_xZipStorage; +} + + +void SfxMedium::CloseZipStorage_Impl() +{ + if ( pImpl->m_xZipStorage.is() ) + { + try { + pImpl->m_xZipStorage->dispose(); + } catch( const uno::Exception& ) + {} + + pImpl->m_xZipStorage.clear(); + } +} + +void SfxMedium::CloseStorage() +{ + if ( pImpl->xStorage.is() ) + { + uno::Reference < lang::XComponent > xComp = pImpl->xStorage; + // in the salvage mode the medium does not own the storage + if ( pImpl->bDisposeStorage && !pImpl->m_bSalvageMode ) + { + try { + xComp->dispose(); + } catch( const uno::Exception& ) + { + SAL_WARN( "sfx.doc", "Medium's storage is already disposed!" ); + } + } + + pImpl->xStorage.clear(); + pImpl->bStorageBasedOnInStream = false; + } + + pImpl->m_bTriedStorage = false; + pImpl->bIsStorage = false; +} + +void SfxMedium::CanDisposeStorage_Impl( bool bDisposeStorage ) +{ + pImpl->bDisposeStorage = bDisposeStorage; +} + +bool SfxMedium::WillDisposeStorageOnClose_Impl() +{ + return pImpl->bDisposeStorage; +} + +StreamMode SfxMedium::GetOpenMode() const +{ + return pImpl->m_nStorOpenMode; +} + +void SfxMedium::SetOpenMode( StreamMode nStorOpen, + bool bDontClose ) +{ + if ( pImpl->m_nStorOpenMode != nStorOpen ) + { + pImpl->m_nStorOpenMode = nStorOpen; + + if( !bDontClose ) + { + if ( pImpl->xStorage.is() ) + CloseStorage(); + + CloseStreams_Impl(); + } + } +} + + +bool SfxMedium::UseBackupToRestore_Impl( ::ucbhelper::Content& aOriginalContent, + const Reference< css::ucb::XCommandEnvironment >& xComEnv ) +{ + try + { + ::ucbhelper::Content aTransactCont( pImpl->m_aBackupURL, xComEnv, comphelper::getProcessComponentContext() ); + + Reference< XInputStream > aOrigInput = aTransactCont.openStream(); + aOriginalContent.writeStream( aOrigInput, true ); + return true; + } + catch( const Exception& ) + { + // in case of failure here the backup file should not be removed + // TODO/LATER: a message should be used to let user know about the backup + pImpl->m_bRemoveBackup = false; + // TODO/LATER: needs a specific error code + pImpl->m_eError = ERRCODE_IO_GENERAL; + } + + return false; +} + + +bool SfxMedium::StorageCommit_Impl() +{ + bool bResult = false; + Reference< css::ucb::XCommandEnvironment > xDummyEnv; + ::ucbhelper::Content aOriginalContent; + + if ( pImpl->xStorage.is() ) + { + if ( !GetError() ) + { + uno::Reference < embed::XTransactedObject > xTrans( pImpl->xStorage, uno::UNO_QUERY ); + if ( xTrans.is() ) + { + try + { + xTrans->commit(); + CloseZipStorage_Impl(); + bResult = true; + } + catch ( const embed::UseBackupException& aBackupExc ) + { + // since the temporary file is created always now, the scenario is close to be impossible + if ( !pImpl->pTempFile ) + { + OSL_ENSURE( !pImpl->m_aBackupURL.isEmpty(), "No backup on storage commit!" ); + if ( !pImpl->m_aBackupURL.isEmpty() + && ::ucbhelper::Content::create( GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ), + xDummyEnv, comphelper::getProcessComponentContext(), + aOriginalContent ) ) + { + // use backup to restore the file + // the storage has already disconnected from original location + CloseAndReleaseStreams_Impl(); + if ( !UseBackupToRestore_Impl( aOriginalContent, xDummyEnv ) ) + { + // connect the medium to the temporary file of the storage + pImpl->aContent = ::ucbhelper::Content(); + pImpl->m_aName = aBackupExc.TemporaryFileURL; + OSL_ENSURE( !pImpl->m_aName.isEmpty(), "The exception _must_ contain the temporary URL!" ); + } + } + } + + if (!GetError()) + SetError(ERRCODE_IO_GENERAL); + } + catch ( const uno::Exception& ) + { + //TODO/LATER: improve error handling + SetError(ERRCODE_IO_GENERAL); + } + } + } + } + + return bResult; +} + + +void SfxMedium::TransactedTransferForFS_Impl( const INetURLObject& aSource, + const INetURLObject& aDest, + const Reference< css::ucb::XCommandEnvironment >& xComEnv ) +{ + Reference< css::ucb::XCommandEnvironment > xDummyEnv; + ::ucbhelper::Content aOriginalContent; + + try + { + aOriginalContent = ::ucbhelper::Content( aDest.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xComEnv, comphelper::getProcessComponentContext() ); + } + catch ( const css::ucb::CommandAbortedException& ) + { + pImpl->m_eError = ERRCODE_ABORT; + } + catch ( const css::ucb::CommandFailedException& ) + { + pImpl->m_eError = ERRCODE_ABORT; + } + catch (const css::ucb::ContentCreationException& ex) + { + pImpl->m_eError = ERRCODE_IO_GENERAL; + if ( + (ex.eError == css::ucb::ContentCreationError_NO_CONTENT_PROVIDER ) || + (ex.eError == css::ucb::ContentCreationError_CONTENT_CREATION_FAILED) + ) + { + pImpl->m_eError = ERRCODE_IO_NOTEXISTSPATH; + } + } + catch (const css::uno::Exception&) + { + pImpl->m_eError = ERRCODE_IO_GENERAL; + } + + if( pImpl->m_eError && !pImpl->m_eError.IsWarning() ) + return; + + if ( pImpl->xStorage.is() ) + CloseStorage(); + + CloseStreams_Impl(); + + ::ucbhelper::Content aTempCont; + if( ::ucbhelper::Content::create( aSource.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xDummyEnv, comphelper::getProcessComponentContext(), aTempCont ) ) + { + bool bTransactStarted = false; + const SfxBoolItem* pOverWrite = SfxItemSet::GetItem<SfxBoolItem>(GetItemSet(), SID_OVERWRITE, false); + bool bOverWrite = !pOverWrite || pOverWrite->GetValue(); + bool bResult = false; + + try + { + // tdf#60237 - if the OverWrite property of the MediaDescriptor is set to false, + // try to write the file before trying to rename or copy it + if (!(bOverWrite + && ::utl::UCBContentHelper::IsDocument( + aDest.GetMainURL(INetURLObject::DecodeMechanism::NONE)))) + { + Reference< XInputStream > aTempInput = aTempCont.openStream(); + aOriginalContent.writeStream( aTempInput, bOverWrite ); + bResult = true; + } else { + OUString aSourceMainURL = aSource.GetMainURL(INetURLObject::DecodeMechanism::NONE); + OUString aDestMainURL = aDest.GetMainURL(INetURLObject::DecodeMechanism::NONE); + + sal_uInt64 nAttributes = GetDefaultFileAttributes(aDestMainURL); + if (IsFileMovable(aDest) + && osl::File::replace(aSourceMainURL, aDestMainURL) == osl::FileBase::E_None) + { + if (nAttributes) + // Adjust attributes, source might be created with + // the osl_File_OpenFlag_Private flag. + osl::File::setAttributes(aDestMainURL, nAttributes); + bResult = true; + } + else + { + if( pImpl->m_aBackupURL.isEmpty() ) + DoInternalBackup_Impl( aOriginalContent ); + + if( !pImpl->m_aBackupURL.isEmpty() ) + { + Reference< XInputStream > aTempInput = aTempCont.openStream(); + bTransactStarted = true; + aOriginalContent.setPropertyValue( "Size", uno::Any( sal_Int64(0) ) ); + aOriginalContent.writeStream( aTempInput, bOverWrite ); + bResult = true; + } + else + { + pImpl->m_eError = ERRCODE_SFX_CANTCREATEBACKUP; + } + } + } + } + catch ( const css::ucb::CommandAbortedException& ) + { + pImpl->m_eError = ERRCODE_ABORT; + } + catch ( const css::ucb::CommandFailedException& ) + { + pImpl->m_eError = ERRCODE_ABORT; + } + catch ( const css::ucb::InteractiveIOException& r ) + { + if ( r.Code == IOErrorCode_ACCESS_DENIED ) + pImpl->m_eError = ERRCODE_IO_ACCESSDENIED; + else if ( r.Code == IOErrorCode_NOT_EXISTING ) + pImpl->m_eError = ERRCODE_IO_NOTEXISTS; + else if ( r.Code == IOErrorCode_CANT_READ ) + pImpl->m_eError = ERRCODE_IO_CANTREAD; + else + pImpl->m_eError = ERRCODE_IO_GENERAL; + } + // tdf#60237 - if the file is already present, raise the appropriate error + catch (const css::ucb::NameClashException& ) + { + pImpl->m_eError = ERRCODE_IO_ALREADYEXISTS; + } + catch ( const css::uno::Exception& ) + { + pImpl->m_eError = ERRCODE_IO_GENERAL; + } + + if ( bResult ) + { + if ( pImpl->pTempFile ) + { + pImpl->pTempFile->EnableKillingFile(); + pImpl->pTempFile.reset(); + } + } + else if ( bTransactStarted ) + { + UseBackupToRestore_Impl( aOriginalContent, xDummyEnv ); + } + } + else + pImpl->m_eError = ERRCODE_IO_CANTREAD; +} + + +bool SfxMedium::TryDirectTransfer( const OUString& aURL, SfxItemSet const & aTargetSet ) +{ + if ( GetError() ) + return false; + + // if the document had no password it should be stored without password + // if the document had password it should be stored with the same password + // otherwise the stream copying can not be done + const SfxStringItem* pNewPassItem = aTargetSet.GetItem<SfxStringItem>(SID_PASSWORD, false); + const SfxStringItem* pOldPassItem = SfxItemSet::GetItem<SfxStringItem>(GetItemSet(), SID_PASSWORD, false); + if ( ( !pNewPassItem && !pOldPassItem ) + || ( pNewPassItem && pOldPassItem && pNewPassItem->GetValue() == pOldPassItem->GetValue() ) ) + { + // the filter must be the same + const SfxStringItem* pNewFilterItem = aTargetSet.GetItem<SfxStringItem>(SID_FILTER_NAME, false); + const SfxStringItem* pOldFilterItem = SfxItemSet::GetItem<SfxStringItem>(GetItemSet(), SID_FILTER_NAME, false); + if ( pNewFilterItem && pOldFilterItem && pNewFilterItem->GetValue() == pOldFilterItem->GetValue() ) + { + // get the input stream and copy it + // in case of success return true + uno::Reference< io::XInputStream > xInStream = GetInputStream(); + + ResetError(); + if ( xInStream.is() ) + { + try + { + uno::Reference< io::XSeekable > xSeek( xInStream, uno::UNO_QUERY ); + sal_Int64 nPos = 0; + if ( xSeek.is() ) + { + nPos = xSeek->getPosition(); + xSeek->seek( 0 ); + } + + uno::Reference < css::ucb::XCommandEnvironment > xEnv; + ::ucbhelper::Content aTargetContent( aURL, xEnv, comphelper::getProcessComponentContext() ); + + InsertCommandArgument aInsertArg; + aInsertArg.Data = xInStream; + const SfxBoolItem* pOverWrite = aTargetSet.GetItem<SfxBoolItem>(SID_OVERWRITE, false); + if ( pOverWrite && !pOverWrite->GetValue() ) // argument says: never overwrite + aInsertArg.ReplaceExisting = false; + else + aInsertArg.ReplaceExisting = true; // default is overwrite existing files + + Any aCmdArg; + aCmdArg <<= aInsertArg; + aTargetContent.executeCommand( "insert", + aCmdArg ); + + if ( xSeek.is() ) + xSeek->seek( nPos ); + + return true; + } + catch( const uno::Exception& ) + {} + } + } + } + + return false; +} + + +void SfxMedium::Transfer_Impl() +{ + // The transfer is required only in two cases: either if there is a temporary file or if there is a salvage item + OUString aNameURL; + if ( pImpl->pTempFile ) + aNameURL = pImpl->pTempFile->GetURL(); + else if ( !pImpl->m_aLogicName.isEmpty() && pImpl->m_bSalvageMode ) + { + // makes sense only in case logic name is set + if ( osl::FileBase::getFileURLFromSystemPath( pImpl->m_aName, aNameURL ) + != osl::FileBase::E_None ) + SAL_WARN( "sfx.doc", "The medium name is not convertible!" ); + } + + if ( aNameURL.isEmpty() || ( pImpl->m_eError && !pImpl->m_eError.IsWarning() ) ) + return; + + SAL_INFO( "sfx.doc", "SfxMedium::Transfer_Impl, copying to target" ); + + Reference < css::ucb::XCommandEnvironment > xEnv; + Reference< XOutputStream > rOutStream; + + // in case an output stream is provided from outside and the URL is correct + // commit to the stream + if (pImpl->m_aLogicName.startsWith("private:stream")) + { + // TODO/LATER: support storing to SID_STREAM + const SfxUnoAnyItem* pOutStreamItem = SfxItemSet::GetItem<SfxUnoAnyItem>(pImpl->m_pSet.get(), SID_OUTPUTSTREAM, false); + if( pOutStreamItem && ( pOutStreamItem->GetValue() >>= rOutStream ) ) + { + if ( pImpl->xStorage.is() ) + CloseStorage(); + + CloseStreams_Impl(); + + INetURLObject aSource( aNameURL ); + ::ucbhelper::Content aTempCont; + if( ::ucbhelper::Content::create( aSource.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xEnv, comphelper::getProcessComponentContext(), aTempCont ) ) + { + try + { + sal_Int32 nRead; + sal_Int32 nBufferSize = 32767; + Sequence < sal_Int8 > aSequence ( nBufferSize ); + Reference< XInputStream > aTempInput = aTempCont.openStream(); + + do + { + nRead = aTempInput->readBytes ( aSequence, nBufferSize ); + if ( nRead < nBufferSize ) + { + Sequence < sal_Int8 > aTempBuf ( aSequence.getConstArray(), nRead ); + rOutStream->writeBytes ( aTempBuf ); + } + else + rOutStream->writeBytes ( aSequence ); + } + while ( nRead == nBufferSize ); + + // remove temporary file + if ( pImpl->pTempFile ) + { + pImpl->pTempFile->EnableKillingFile(); + pImpl->pTempFile.reset(); + } + } + catch( const Exception& ) + {} + } + } + else + { + SAL_WARN( "sfx.doc", "Illegal Output stream parameter!" ); + SetError(ERRCODE_IO_GENERAL); + } + + // free the reference + if ( pImpl->m_pSet ) + pImpl->m_pSet->ClearItem( SID_OUTPUTSTREAM ); + + return; + } + + GetContent(); + if ( !pImpl->aContent.get().is() ) + { + pImpl->m_eError = ERRCODE_IO_NOTEXISTS; + return; + } + + INetURLObject aDest( GetURLObject() ); + + // source is the temp file written so far + INetURLObject aSource( aNameURL ); + + // a special case, an interaction handler should be used for + // authentication in case it is available + Reference< css::ucb::XCommandEnvironment > xComEnv; + bool bForceInteractionHandler = GetURLObject().isAnyKnownWebDAVScheme(); + Reference< css::task::XInteractionHandler > xInteractionHandler = GetInteractionHandler(bForceInteractionHandler); + if (xInteractionHandler.is()) + xComEnv = new ::ucbhelper::CommandEnvironment( xInteractionHandler, + Reference< css::ucb::XProgressHandler >() ); + + OUString aDestURL( aDest.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + + if ( comphelper::isFileUrl( aDestURL ) || !aDest.removeSegment() ) + { + TransactedTransferForFS_Impl( aSource, aDest, xComEnv ); + + if (!pImpl->m_bDisableFileSync) + { + // Hideous - no clean way to do this, so we re-open the file just to fsync it + osl::File aFile( aDestURL ); + if ( aFile.open( osl_File_OpenFlag_Write ) == osl::FileBase::E_None ) + { + aFile.sync(); + SAL_INFO( "sfx.doc", "fsync'd saved file '" << aDestURL << "'" ); + aFile.close(); + } + } + } + else + { + // create content for the parent folder and call transfer on that content with the source content + // and the destination file name as parameters + ::ucbhelper::Content aSourceContent; + ::ucbhelper::Content aTransferContent; + + ::ucbhelper::Content aDestContent; + (void)::ucbhelper::Content::create( aDestURL, xComEnv, comphelper::getProcessComponentContext(), aDestContent ); + // For checkin, we need the object URL, not the parent folder: + if ( !IsInCheckIn( ) ) + { + // Get the parent URL from the XChild if possible: why would the URL necessarily have + // a hierarchical path? It's not always the case for CMIS. + Reference< css::container::XChild> xChild( aDestContent.get(), uno::UNO_QUERY ); + OUString sParentUrl; + if ( xChild.is( ) ) + { + Reference< css::ucb::XContent > xParent( xChild->getParent( ), uno::UNO_QUERY ); + if ( xParent.is( ) ) + { + sParentUrl = xParent->getIdentifier( )->getContentIdentifier(); + } + } + + if ( sParentUrl.isEmpty() ) + aDestURL = aDest.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + // adjust to above aDest.removeSegment() + else + aDestURL = sParentUrl; + } + + // LongName wasn't defined anywhere, only used here... get the Title instead + // as it's less probably empty + OUString aFileName; + Any aAny = aDestContent.getPropertyValue("Title"); + aAny >>= aFileName; + aAny = aDestContent.getPropertyValue( "ObjectId" ); + OUString sObjectId; + aAny >>= sObjectId; + if ( aFileName.isEmpty() ) + aFileName = GetURLObject().getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset ); + + try + { + aTransferContent = ::ucbhelper::Content( aDestURL, xComEnv, comphelper::getProcessComponentContext() ); + } + catch (const css::ucb::ContentCreationException& ex) + { + pImpl->m_eError = ERRCODE_IO_GENERAL; + if ( + (ex.eError == css::ucb::ContentCreationError_NO_CONTENT_PROVIDER ) || + (ex.eError == css::ucb::ContentCreationError_CONTENT_CREATION_FAILED) + ) + { + pImpl->m_eError = ERRCODE_IO_NOTEXISTSPATH; + } + } + catch (const css::uno::Exception&) + { + pImpl->m_eError = ERRCODE_IO_GENERAL; + } + + if ( !pImpl->m_eError || pImpl->m_eError.IsWarning() ) + { + // free resources, otherwise the transfer may fail + if ( pImpl->xStorage.is() ) + CloseStorage(); + + CloseStreams_Impl(); + + (void)::ucbhelper::Content::create( aSource.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xEnv, comphelper::getProcessComponentContext(), aSourceContent ); + + // check for external parameters that may customize the handling of NameClash situations + const SfxBoolItem* pOverWrite = SfxItemSet::GetItem<SfxBoolItem>(GetItemSet(), SID_OVERWRITE, false); + sal_Int32 nNameClash; + if ( pOverWrite && !pOverWrite->GetValue() ) + // argument says: never overwrite + nNameClash = NameClash::ERROR; + else + // default is overwrite existing files + nNameClash = NameClash::OVERWRITE; + + try + { + OUString aMimeType = pImpl->getFilterMimeType(); + ::ucbhelper::InsertOperation eOperation = ::ucbhelper::InsertOperation::Copy; + bool bMajor = false; + OUString sComment; + if ( IsInCheckIn( ) ) + { + eOperation = ::ucbhelper::InsertOperation::Checkin; + const SfxBoolItem* pMajor = SfxItemSet::GetItem<SfxBoolItem>(GetItemSet(), SID_DOCINFO_MAJOR, false); + bMajor = pMajor && pMajor->GetValue( ); + const SfxStringItem* pComments = SfxItemSet::GetItem<SfxStringItem>(GetItemSet(), SID_DOCINFO_COMMENTS, false); + if ( pComments ) + sComment = pComments->GetValue( ); + } + OUString sResultURL; + aTransferContent.transferContent( + aSourceContent, eOperation, + aFileName, nNameClash, aMimeType, bMajor, sComment, + &sResultURL, sObjectId ); + + if ( !sResultURL.isEmpty( ) ) // Likely to happen only for checkin + SwitchDocumentToFile( sResultURL ); + try + { + if ( GetURLObject().isAnyKnownWebDAVScheme() && + eOperation == ::ucbhelper::InsertOperation::Copy ) + { + // tdf#95272 try to re-issue a lock command when a new file is created. + // This may be needed because some WebDAV servers fail to implement the + // 'LOCK on unallocated reference', see issue comment: + // <https://bugs.documentfoundation.org/show_bug.cgi?id=95792#c8> + // and specification at: + // <http://tools.ietf.org/html/rfc4918#section-7.3> + // If the WebDAV resource is already locked by this LO instance, nothing will + // happen, e.g. the LOCK method will not be sent to the server. + ::ucbhelper::Content aLockContent( GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ), xComEnv, comphelper::getProcessComponentContext() ); + aLockContent.lock(); + } + } + catch ( css::uno::Exception & ) + { + TOOLS_WARN_EXCEPTION( "sfx.doc", "LOCK not working while re-issuing it" ); + } + } + catch ( const css::ucb::CommandAbortedException& ) + { + pImpl->m_eError = ERRCODE_ABORT; + } + catch ( const css::ucb::CommandFailedException& ) + { + pImpl->m_eError = ERRCODE_ABORT; + } + catch ( const css::ucb::InteractiveIOException& r ) + { + if ( r.Code == IOErrorCode_ACCESS_DENIED ) + pImpl->m_eError = ERRCODE_IO_ACCESSDENIED; + else if ( r.Code == IOErrorCode_NOT_EXISTING ) + pImpl->m_eError = ERRCODE_IO_NOTEXISTS; + else if ( r.Code == IOErrorCode_CANT_READ ) + pImpl->m_eError = ERRCODE_IO_CANTREAD; + else + pImpl->m_eError = ERRCODE_IO_GENERAL; + } + catch ( const css::uno::Exception& ) + { + pImpl->m_eError = ERRCODE_IO_GENERAL; + } + + // do not switch from temporary file in case of nonfile protocol + } + } + + if ( ( !pImpl->m_eError || pImpl->m_eError.IsWarning() ) && !pImpl->pTempFile ) + { + // without a TempFile the physical and logical name should be the same after successful transfer + if (osl::FileBase::getSystemPathFromFileURL( + GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ), pImpl->m_aName ) + != osl::FileBase::E_None) + { + pImpl->m_aName.clear(); + } + pImpl->m_bSalvageMode = false; + } +} + + +void SfxMedium::DoInternalBackup_Impl( const ::ucbhelper::Content& aOriginalContent, + std::u16string_view aPrefix, + const OUString& aExtension, + const OUString& aDestDir ) +{ + if ( !pImpl->m_aBackupURL.isEmpty() ) + return; // the backup was done already + + ::utl::TempFile aTransactTemp( aPrefix, true, &aExtension, &aDestDir ); + + INetURLObject aBackObj( aTransactTemp.GetURL() ); + OUString aBackupName = aBackObj.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset ); + + Reference < css::ucb::XCommandEnvironment > xDummyEnv; + ::ucbhelper::Content aBackupCont; + if( ::ucbhelper::Content::create( aDestDir, xDummyEnv, comphelper::getProcessComponentContext(), aBackupCont ) ) + { + try + { + OUString sMimeType = pImpl->getFilterMimeType(); + aBackupCont.transferContent( aOriginalContent, + ::ucbhelper::InsertOperation::Copy, + aBackupName, + NameClash::OVERWRITE, + sMimeType ); + pImpl->m_aBackupURL = aBackObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + pImpl->m_bRemoveBackup = true; + } + catch( const Exception& ) + {} + } + + if ( pImpl->m_aBackupURL.isEmpty() ) + aTransactTemp.EnableKillingFile(); +} + + +void SfxMedium::DoInternalBackup_Impl( const ::ucbhelper::Content& aOriginalContent ) +{ + if ( !pImpl->m_aBackupURL.isEmpty() ) + return; // the backup was done already + + OUString aFileName = GetURLObject().getName( INetURLObject::LAST_SEGMENT, + true, + INetURLObject::DecodeMechanism::NONE ); + + sal_Int32 nPrefixLen = aFileName.lastIndexOf( '.' ); + OUString aPrefix = ( nPrefixLen == -1 ) ? aFileName : aFileName.copy( 0, nPrefixLen ); + OUString aExtension = ( nPrefixLen == -1 ) ? OUString() : aFileName.copy( nPrefixLen ); + OUString aBakDir = SvtPathOptions().GetBackupPath(); + + // create content for the parent folder ( = backup folder ) + ::ucbhelper::Content aContent; + Reference < css::ucb::XCommandEnvironment > xEnv; + if( ::utl::UCBContentHelper::ensureFolder(comphelper::getProcessComponentContext(), xEnv, aBakDir, aContent) ) + DoInternalBackup_Impl( aOriginalContent, aPrefix, aExtension, aBakDir ); + + if ( !pImpl->m_aBackupURL.isEmpty() ) + return; + + // the copying to the backup catalog failed ( for example because + // of using an encrypted partition as target catalog ) + // since the user did not specify to make backup explicitly + // office should try to make backup in another place, + // target catalog does not look bad for this case ( and looks + // to be the only way for encrypted partitions ) + + INetURLObject aDest = GetURLObject(); + if ( aDest.removeSegment() ) + DoInternalBackup_Impl( aOriginalContent, aPrefix, aExtension, aDest.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); +} + + +void SfxMedium::DoBackup_Impl() +{ + // source file name is the logical name of this medium + INetURLObject aSource( GetURLObject() ); + + // there is nothing to backup in case source file does not exist + if ( !::utl::UCBContentHelper::IsDocument( aSource.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ) ) + return; + + bool bSuccess = false; + + // get path for backups + OUString aBakDir = SvtPathOptions().GetBackupPath(); + if( !aBakDir.isEmpty() ) + { + // create content for the parent folder ( = backup folder ) + ::ucbhelper::Content aContent; + Reference < css::ucb::XCommandEnvironment > xEnv; + if( ::utl::UCBContentHelper::ensureFolder(comphelper::getProcessComponentContext(), xEnv, aBakDir, aContent) ) + { + // save as ".bak" file + INetURLObject aDest( aBakDir ); + aDest.insertName( aSource.getName() ); + aDest.setExtension( u"bak" ); + OUString aFileName = aDest.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset ); + + // create a content for the source file + ::ucbhelper::Content aSourceContent; + if ( ::ucbhelper::Content::create( aSource.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xEnv, comphelper::getProcessComponentContext(), aSourceContent ) ) + { + try + { + // do the transfer ( copy source file to backup dir ) + OUString sMimeType = pImpl->getFilterMimeType(); + aContent.transferContent( aSourceContent, + ::ucbhelper::InsertOperation::Copy, + aFileName, + NameClash::OVERWRITE, + sMimeType ); + pImpl->m_aBackupURL = aDest.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + pImpl->m_bRemoveBackup = false; + bSuccess = true; + } + catch ( const css::uno::Exception& ) + { + } + } + } + } + + if ( !bSuccess ) + { + pImpl->m_eError = ERRCODE_SFX_CANTCREATEBACKUP; + } +} + + +void SfxMedium::ClearBackup_Impl() +{ + if( pImpl->m_bRemoveBackup ) + { + // currently a document is always stored in a new medium, + // thus if a backup can not be removed the backup URL should not be cleaned + if ( !pImpl->m_aBackupURL.isEmpty() ) + { + if ( ::utl::UCBContentHelper::Kill( pImpl->m_aBackupURL ) ) + { + pImpl->m_bRemoveBackup = false; + pImpl->m_aBackupURL.clear(); + } + else + { + + SAL_WARN( "sfx.doc", "Couldn't remove backup file!"); + } + } + } + else + pImpl->m_aBackupURL.clear(); +} + + +void SfxMedium::GetLockingStream_Impl() +{ + if ( GetURLObject().GetProtocol() != INetProtocol::File + || pImpl->m_xLockingStream.is() ) + return; + + const SfxUnoAnyItem* pWriteStreamItem = SfxItemSet::GetItem<SfxUnoAnyItem>(pImpl->m_pSet.get(), SID_STREAM, false); + if ( pWriteStreamItem ) + pWriteStreamItem->GetValue() >>= pImpl->m_xLockingStream; + + if ( pImpl->m_xLockingStream.is() ) + return; + + // open the original document + uno::Sequence< beans::PropertyValue > xProps; + TransformItems( SID_OPENDOC, *GetItemSet(), xProps ); + utl::MediaDescriptor aMedium( xProps ); + + aMedium.addInputStreamOwnLock(); + + uno::Reference< io::XInputStream > xInputStream; + aMedium[utl::MediaDescriptor::PROP_STREAM] >>= pImpl->m_xLockingStream; + aMedium[utl::MediaDescriptor::PROP_INPUTSTREAM] >>= xInputStream; + + if ( !pImpl->pTempFile && pImpl->m_aName.isEmpty() ) + { + // the medium is still based on the original file, it makes sense to initialize the streams + if ( pImpl->m_xLockingStream.is() ) + pImpl->xStream = pImpl->m_xLockingStream; + + if ( xInputStream.is() ) + pImpl->xInputStream = xInputStream; + + if ( !pImpl->xInputStream.is() && pImpl->xStream.is() ) + pImpl->xInputStream = pImpl->xStream->getInputStream(); + } +} + + +void SfxMedium::GetMedium_Impl() +{ + if ( pImpl->m_pInStream + && (!pImpl->bIsTemp || pImpl->xInputStream.is() || pImpl->m_xInputStreamToLoadFrom.is() || pImpl->xStream.is() || pImpl->m_xLockingStream.is() ) ) + return; + + pImpl->bDownloadDone = false; + Reference< css::task::XInteractionHandler > xInteractionHandler = GetInteractionHandler(); + + //TODO/MBA: need support for SID_STREAM + const SfxUnoAnyItem* pWriteStreamItem = SfxItemSet::GetItem<SfxUnoAnyItem>(pImpl->m_pSet.get(), SID_STREAM, false); + const SfxUnoAnyItem* pInStreamItem = SfxItemSet::GetItem<SfxUnoAnyItem>(pImpl->m_pSet.get(), SID_INPUTSTREAM, false); + if ( pWriteStreamItem ) + { + pWriteStreamItem->GetValue() >>= pImpl->xStream; + + if ( pInStreamItem ) + pInStreamItem->GetValue() >>= pImpl->xInputStream; + + if ( !pImpl->xInputStream.is() && pImpl->xStream.is() ) + pImpl->xInputStream = pImpl->xStream->getInputStream(); + } + else if ( pInStreamItem ) + { + pInStreamItem->GetValue() >>= pImpl->xInputStream; + } + else + { + uno::Sequence < beans::PropertyValue > xProps; + OUString aFileName; + if (!pImpl->m_aName.isEmpty()) + { + if ( osl::FileBase::getFileURLFromSystemPath( pImpl->m_aName, aFileName ) + != osl::FileBase::E_None ) + { + SAL_WARN( "sfx.doc", "Physical name not convertible!"); + } + } + else + aFileName = GetName(); + + // in case the temporary file exists the streams should be initialized from it, + // but the original MediaDescriptor should not be changed + bool bFromTempFile = ( pImpl->pTempFile != nullptr ); + + if ( !bFromTempFile ) + { + GetItemSet()->Put( SfxStringItem( SID_FILE_NAME, aFileName ) ); + if( !(pImpl->m_nStorOpenMode & StreamMode::WRITE) ) + GetItemSet()->Put( SfxBoolItem( SID_DOC_READONLY, true ) ); + if (xInteractionHandler.is()) + GetItemSet()->Put( SfxUnoAnyItem( SID_INTERACTIONHANDLER, Any(xInteractionHandler) ) ); + } + + if ( pImpl->m_xInputStreamToLoadFrom.is() ) + { + pImpl->xInputStream = pImpl->m_xInputStreamToLoadFrom; + if (pImpl->m_bInputStreamIsReadOnly) + GetItemSet()->Put( SfxBoolItem( SID_DOC_READONLY, true ) ); + } + else + { + TransformItems( SID_OPENDOC, *GetItemSet(), xProps ); + utl::MediaDescriptor aMedium( xProps ); + + if ( pImpl->m_xLockingStream.is() && !bFromTempFile ) + { + // the medium is not based on the temporary file, so the original stream can be used + pImpl->xStream = pImpl->m_xLockingStream; + } + else + { + if ( bFromTempFile ) + { + aMedium[utl::MediaDescriptor::PROP_URL] <<= aFileName; + aMedium.erase( utl::MediaDescriptor::PROP_READONLY ); + aMedium.addInputStream(); + } + else if ( GetURLObject().GetProtocol() == INetProtocol::File ) + { + // use the special locking approach only for file URLs + aMedium.addInputStreamOwnLock(); + } + else + { + // add a check for protocol, if it's http or https or provide webdav then add + // the interaction handler to be used by the authentication dialog + if ( GetURLObject().isAnyKnownWebDAVScheme() ) + { + aMedium[utl::MediaDescriptor::PROP_AUTHENTICATIONHANDLER] <<= GetInteractionHandler( true ); + } + aMedium.addInputStream(); + } + // the ReadOnly property set in aMedium is ignored + // the check is done in LockOrigFileOnDemand() for file and non-file URLs + + //TODO/MBA: what happens if property is not there?! + aMedium[utl::MediaDescriptor::PROP_STREAM] >>= pImpl->xStream; + aMedium[utl::MediaDescriptor::PROP_INPUTSTREAM] >>= pImpl->xInputStream; + } + + GetContent(); + if ( !pImpl->xInputStream.is() && pImpl->xStream.is() ) + pImpl->xInputStream = pImpl->xStream->getInputStream(); + } + + if ( !bFromTempFile ) + { + //TODO/MBA: need support for SID_STREAM + if ( pImpl->xStream.is() ) + GetItemSet()->Put( SfxUnoAnyItem( SID_STREAM, Any( pImpl->xStream ) ) ); + + GetItemSet()->Put( SfxUnoAnyItem( SID_INPUTSTREAM, Any( pImpl->xInputStream ) ) ); + } + } + + //TODO/MBA: ErrorHandling - how to transport error from MediaDescriptor + if ( !GetError() && !pImpl->xStream.is() && !pImpl->xInputStream.is() ) + SetError(ERRCODE_IO_ACCESSDENIED); + + if ( !GetError() && !pImpl->m_pInStream ) + { + if ( pImpl->xStream.is() ) + pImpl->m_pInStream = utl::UcbStreamHelper::CreateStream( pImpl->xStream ); + else if ( pImpl->xInputStream.is() ) + pImpl->m_pInStream = utl::UcbStreamHelper::CreateStream( pImpl->xInputStream ); + } + + pImpl->bDownloadDone = true; + pImpl->aDoneLink.ClearPendingCall(); + ErrCode nError = GetError(); + pImpl->aDoneLink.Call( reinterpret_cast<void*>(sal_uInt32(nError)) ); +} + +bool SfxMedium::IsRemote() const +{ + return pImpl->m_bRemote; +} + +void SfxMedium::SetUpdatePickList(bool bVal) +{ + pImpl->bUpdatePickList = bVal; +} + +bool SfxMedium::IsUpdatePickList() const +{ + return pImpl->bUpdatePickList; +} + +void SfxMedium::SetLongName(const OUString &rName) +{ + pImpl->m_aLongName = rName; +} + +const OUString& SfxMedium::GetLongName() const +{ + return pImpl->m_aLongName; +} + +void SfxMedium::SetDoneLink( const Link<void*,void>& rLink ) +{ + pImpl->aDoneLink = rLink; +} + +void SfxMedium::Download( const Link<void*,void>& aLink ) +{ + SetDoneLink( aLink ); + GetInStream(); + if ( pImpl->m_pInStream && !aLink.IsSet() ) + { + while( !pImpl->bDownloadDone && !Application::IsQuit()) + Application::Yield(); + } +} + + +void SfxMedium::Init_Impl() +/* [Description] + Includes a valid:: sun:: com:: star:: util:: URL (If a file name was + previously in there) in the logical name and if available sets the + physical name as the file name. + */ + +{ + Reference< XOutputStream > rOutStream; + + // TODO/LATER: handle lifetime of storages + pImpl->bDisposeStorage = false; + + const SfxStringItem* pSalvageItem = SfxItemSet::GetItem<SfxStringItem>(pImpl->m_pSet.get(), SID_DOC_SALVAGE, false); + if ( pSalvageItem && pSalvageItem->GetValue().isEmpty() ) + { + pSalvageItem = nullptr; + pImpl->m_pSet->ClearItem( SID_DOC_SALVAGE ); + } + + if (!pImpl->m_aLogicName.isEmpty()) + { + INetURLObject aUrl( pImpl->m_aLogicName ); + INetProtocol eProt = aUrl.GetProtocol(); + if ( eProt == INetProtocol::NotValid ) + { + SAL_WARN( "sfx.doc", "URL <" << pImpl->m_aLogicName << "> with unknown protocol" ); + } + else + { + if ( aUrl.HasMark() ) + { + std::unique_lock<std::recursive_mutex> chkEditLock; + if (pImpl->m_pCheckEditableWorkerMutex != nullptr) + chkEditLock = std::unique_lock<std::recursive_mutex>( + *(pImpl->m_pCheckEditableWorkerMutex)); + pImpl->m_aLogicName = aUrl.GetURLNoMark( INetURLObject::DecodeMechanism::NONE ); + if (chkEditLock.owns_lock()) + chkEditLock.unlock(); + GetItemSet()->Put( SfxStringItem( SID_JUMPMARK, aUrl.GetMark() ) ); + } + + // try to convert the URL into a physical name - but never change a physical name + // physical name may be set if the logical name is changed after construction + if ( pImpl->m_aName.isEmpty() ) + osl::FileBase::getSystemPathFromFileURL( GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ), pImpl->m_aName ); + else + { + DBG_ASSERT( pSalvageItem, "Suspicious change of logical name!" ); + } + } + } + + if ( pSalvageItem && !pSalvageItem->GetValue().isEmpty() ) + { + std::unique_lock<std::recursive_mutex> chkEditLock; + if (pImpl->m_pCheckEditableWorkerMutex != nullptr) + chkEditLock + = std::unique_lock<std::recursive_mutex>(*(pImpl->m_pCheckEditableWorkerMutex)); + pImpl->m_aLogicName = pSalvageItem->GetValue(); + pImpl->m_pURLObj.reset(); + if (chkEditLock.owns_lock()) + chkEditLock.unlock(); + pImpl->m_bSalvageMode = true; + } + + // in case output stream is by mistake here + // clear the reference + const SfxUnoAnyItem* pOutStreamItem = SfxItemSet::GetItem<SfxUnoAnyItem>(pImpl->m_pSet.get(), SID_OUTPUTSTREAM, false); + if( pOutStreamItem + && ( !( pOutStreamItem->GetValue() >>= rOutStream ) + || !pImpl->m_aLogicName.startsWith("private:stream")) ) + { + pImpl->m_pSet->ClearItem( SID_OUTPUTSTREAM ); + SAL_WARN( "sfx.doc", "Unexpected Output stream parameter!" ); + } + + if (!pImpl->m_aLogicName.isEmpty()) + { + // if the logic name is set it should be set in MediaDescriptor as well + const SfxStringItem* pFileNameItem = SfxItemSet::GetItem<SfxStringItem>(pImpl->m_pSet.get(), SID_FILE_NAME, false); + if ( !pFileNameItem ) + { + // let the ItemSet be created if necessary + GetItemSet()->Put( + SfxStringItem( + SID_FILE_NAME, INetURLObject( pImpl->m_aLogicName ).GetMainURL( INetURLObject::DecodeMechanism::NONE ) ) ); + } + } + + SetIsRemote_Impl(); + + osl::DirectoryItem item; + if (osl::DirectoryItem::get(GetName(), item) == osl::FileBase::E_None) { + osl::FileStatus stat(osl_FileStatus_Mask_Attributes); + if (item.getFileStatus(stat) == osl::FileBase::E_None + && stat.isValid(osl_FileStatus_Mask_Attributes)) + { + if ((stat.getAttributes() & osl_File_Attribute_ReadOnly) != 0) + { + pImpl->m_bOriginallyReadOnly = true; + } + } + } +} + + +SfxMedium::SfxMedium() : pImpl(new SfxMedium_Impl) +{ + Init_Impl(); +} + + +void SfxMedium::UseInteractionHandler( bool bUse ) +{ + pImpl->bAllowDefaultIntHdl = bUse; +} + + +css::uno::Reference< css::task::XInteractionHandler > +SfxMedium::GetInteractionHandler( bool bGetAlways ) +{ + // if interaction isn't allowed explicitly ... return empty reference! + if ( !bGetAlways && !pImpl->bUseInteractionHandler ) + return css::uno::Reference< css::task::XInteractionHandler >(); + + // search a possible existing handler inside cached item set + if ( pImpl->m_pSet ) + { + css::uno::Reference< css::task::XInteractionHandler > xHandler; + const SfxUnoAnyItem* pHandler = SfxItemSet::GetItem<SfxUnoAnyItem>(pImpl->m_pSet.get(), SID_INTERACTIONHANDLER, false); + if ( pHandler && (pHandler->GetValue() >>= xHandler) && xHandler.is() ) + return xHandler; + } + + // if default interaction isn't allowed explicitly ... return empty reference! + if ( !bGetAlways && !pImpl->bAllowDefaultIntHdl ) + return css::uno::Reference< css::task::XInteractionHandler >(); + + // otherwise return cached default handler ... if it exist. + if ( pImpl->xInteraction.is() ) + return pImpl->xInteraction; + + // create default handler and cache it! + Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext(); + pImpl->xInteraction.set( + task::InteractionHandler::createWithParent(xContext, nullptr), UNO_QUERY_THROW ); + return pImpl->xInteraction; +} + +void SfxMedium::SetFilter( const std::shared_ptr<const SfxFilter>& pFilter ) +{ + pImpl->m_pFilter = pFilter; +} + +const std::shared_ptr<const SfxFilter>& SfxMedium::GetFilter() const +{ + return pImpl->m_pFilter; +} + +sal_uInt32 SfxMedium::CreatePasswordToModifyHash( std::u16string_view aPasswd, bool bWriter ) +{ + sal_uInt32 nHash = 0; + + if ( !aPasswd.empty() ) + { + if ( bWriter ) + { + nHash = ::comphelper::DocPasswordHelper::GetWordHashAsUINT32( aPasswd ); + } + else + { + rtl_TextEncoding nEncoding = osl_getThreadTextEncoding(); + nHash = ::comphelper::DocPasswordHelper::GetXLHashAsUINT16( aPasswd, nEncoding ); + } + } + + return nHash; +} + + +void SfxMedium::Close(bool bInDestruction) +{ + if ( pImpl->xStorage.is() ) + { + CloseStorage(); + } + + CloseStreams_Impl(bInDestruction); + + UnlockFile( false ); +} + +void SfxMedium::CloseAndRelease() +{ + if ( pImpl->xStorage.is() ) + { + CloseStorage(); + } + + CloseAndReleaseStreams_Impl(); + + UnlockFile( true ); +} + +void SfxMedium::DisableUnlockWebDAV( bool bDisableUnlockWebDAV ) +{ + pImpl->m_bDisableUnlockWebDAV = bDisableUnlockWebDAV; +} + +void SfxMedium::DisableFileSync(bool bDisableFileSync) +{ + pImpl->m_bDisableFileSync = bDisableFileSync; +} + +void SfxMedium::UnlockFile( bool bReleaseLockStream ) +{ +#if !HAVE_FEATURE_MULTIUSER_ENVIRONMENT + (void) bReleaseLockStream; +#else + // check if webdav + if ( GetURLObject().isAnyKnownWebDAVScheme() ) + { + // do nothing if WebDAV locking if disabled + // (shouldn't happen because we already skipped locking, + // see LockOrigFileOnDemand, but just in case ...) + if (!IsWebDAVLockingUsed()) + return; + + if ( pImpl->m_bLocked ) + { + // an interaction handler should be used for authentication, if needed + try { + uno::Reference< css::task::XInteractionHandler > xHandler = GetInteractionHandler( true ); + uno::Reference< css::ucb::XCommandEnvironment > xComEnv = new ::ucbhelper::CommandEnvironment( xHandler, + Reference< css::ucb::XProgressHandler >() ); + ucbhelper::Content aContentToUnlock( GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ), xComEnv, comphelper::getProcessComponentContext()); + pImpl->m_bLocked = false; + //check if WebDAV unlock was explicitly disabled + if ( !pImpl->m_bDisableUnlockWebDAV ) + aContentToUnlock.unlock(); + } + catch ( uno::Exception& ) + { + TOOLS_WARN_EXCEPTION( "sfx.doc", "Locking exception: WebDAV while trying to lock the file" ); + } + } + return; + } + + if ( pImpl->m_xLockingStream.is() ) + { + if ( bReleaseLockStream ) + { + try + { + uno::Reference< io::XInputStream > xInStream = pImpl->m_xLockingStream->getInputStream(); + uno::Reference< io::XOutputStream > xOutStream = pImpl->m_xLockingStream->getOutputStream(); + if ( xInStream.is() ) + xInStream->closeInput(); + if ( xOutStream.is() ) + xOutStream->closeOutput(); + } + catch( const uno::Exception& ) + {} + } + + pImpl->m_xLockingStream.clear(); + } + + if ( !pImpl->m_bLocked ) + return; + + ::svt::DocumentLockFile aLockFile( pImpl->m_aLogicName ); + + try + { + pImpl->m_bLocked = false; + // TODO/LATER: A warning could be shown in case the file is not the own one + aLockFile.RemoveFile(); + } + catch( const io::WrongFormatException& ) + { + try + { + // erase the empty or corrupt file + aLockFile.RemoveFileDirectly(); + } + catch( const uno::Exception& ) + {} + } + catch( const uno::Exception& ) + {} + + if(!pImpl->m_bMSOLockFileCreated) + return; + + ::svt::MSODocumentLockFile aMSOLockFile( pImpl->m_aLogicName ); + + try + { + pImpl->m_bLocked = false; + // TODO/LATER: A warning could be shown in case the file is not the own one + aMSOLockFile.RemoveFile(); + } + catch( const io::WrongFormatException& ) + { + try + { + // erase the empty or corrupt file + aMSOLockFile.RemoveFileDirectly(); + } + catch( const uno::Exception& ) + {} + } + catch( const uno::Exception& ) + {} + pImpl->m_bMSOLockFileCreated = false; +#endif +} + +void SfxMedium::CloseAndReleaseStreams_Impl() +{ + CloseZipStorage_Impl(); + + uno::Reference< io::XInputStream > xInToClose = pImpl->xInputStream; + uno::Reference< io::XOutputStream > xOutToClose; + if ( pImpl->xStream.is() ) + { + xOutToClose = pImpl->xStream->getOutputStream(); + + // if the locking stream is closed here the related member should be cleaned + if ( pImpl->xStream == pImpl->m_xLockingStream ) + pImpl->m_xLockingStream.clear(); + } + + // The probably existing SvStream wrappers should be closed first + CloseStreams_Impl(); + + // in case of salvage mode the storage is based on the streams + if ( pImpl->m_bSalvageMode ) + return; + + try + { + if ( xInToClose.is() ) + xInToClose->closeInput(); + if ( xOutToClose.is() ) + xOutToClose->closeOutput(); + } + catch ( const uno::Exception& ) + { + } +} + + +void SfxMedium::CloseStreams_Impl(bool bInDestruction) +{ + CloseInStream_Impl(bInDestruction); + CloseOutStream_Impl(); + + if ( pImpl->m_pSet ) + pImpl->m_pSet->ClearItem( SID_CONTENT ); + + pImpl->aContent = ::ucbhelper::Content(); +} + + +void SfxMedium::SetIsRemote_Impl() +{ + INetURLObject aObj( GetName() ); + switch( aObj.GetProtocol() ) + { + case INetProtocol::Ftp: + case INetProtocol::Http: + case INetProtocol::Https: + pImpl->m_bRemote = true; + break; + default: + pImpl->m_bRemote = GetName().startsWith("private:msgid"); + break; + } + + // As files that are written to the remote transmission must also be able + // to be read. + if (pImpl->m_bRemote) + pImpl->m_nStorOpenMode |= StreamMode::READ; +} + + +void SfxMedium::SetName( const OUString& aNameP, bool bSetOrigURL ) +{ + if (pImpl->aOrigURL.isEmpty()) + pImpl->aOrigURL = pImpl->m_aLogicName; + if( bSetOrigURL ) + pImpl->aOrigURL = aNameP; + std::unique_lock<std::recursive_mutex> chkEditLock; + if (pImpl->m_pCheckEditableWorkerMutex != nullptr) + chkEditLock = std::unique_lock<std::recursive_mutex>(*(pImpl->m_pCheckEditableWorkerMutex)); + pImpl->m_aLogicName = aNameP; + pImpl->m_pURLObj.reset(); + if (chkEditLock.owns_lock()) + chkEditLock.unlock(); + pImpl->aContent = ::ucbhelper::Content(); + Init_Impl(); +} + + +const OUString& SfxMedium::GetOrigURL() const +{ + return pImpl->aOrigURL.isEmpty() ? pImpl->m_aLogicName : pImpl->aOrigURL; +} + + +void SfxMedium::SetPhysicalName_Impl( const OUString& rNameP ) +{ + if ( rNameP != pImpl->m_aName ) + { + pImpl->pTempFile.reset(); + + if ( !pImpl->m_aName.isEmpty() || !rNameP.isEmpty() ) + pImpl->aContent = ::ucbhelper::Content(); + + pImpl->m_aName = rNameP; + pImpl->m_bTriedStorage = false; + pImpl->bIsStorage = false; + } +} + +void SfxMedium::ReOpen() +{ + bool bUseInteractionHandler = pImpl->bUseInteractionHandler; + pImpl->bUseInteractionHandler = false; + GetMedium_Impl(); + pImpl->bUseInteractionHandler = bUseInteractionHandler; +} + +void SfxMedium::CompleteReOpen() +{ + // do not use temporary file for reopen and in case of success throw the temporary file away + bool bUseInteractionHandler = pImpl->bUseInteractionHandler; + pImpl->bUseInteractionHandler = false; + + std::unique_ptr<::utl::TempFile> pTmpFile; + if ( pImpl->pTempFile ) + { + pTmpFile = std::move(pImpl->pTempFile); + pImpl->m_aName.clear(); + } + + GetMedium_Impl(); + + if ( GetError() ) + { + if ( pImpl->pTempFile ) + { + pImpl->pTempFile->EnableKillingFile(); + pImpl->pTempFile.reset(); + } + pImpl->pTempFile = std::move( pTmpFile ); + if ( pImpl->pTempFile ) + pImpl->m_aName = pImpl->pTempFile->GetFileName(); + } + else if (pTmpFile) + { + pTmpFile->EnableKillingFile(); + pTmpFile.reset(); + } + + pImpl->bUseInteractionHandler = bUseInteractionHandler; +} + +SfxMedium::SfxMedium(const OUString &rName, StreamMode nOpenMode, std::shared_ptr<const SfxFilter> pFilter, const std::shared_ptr<SfxItemSet>& pInSet) : + pImpl(new SfxMedium_Impl) +{ + pImpl->m_pSet = pInSet; + pImpl->m_pFilter = std::move(pFilter); + pImpl->m_aLogicName = rName; + pImpl->m_nStorOpenMode = nOpenMode; + Init_Impl(); +} + +SfxMedium::SfxMedium(const OUString &rName, const OUString &rReferer, StreamMode nOpenMode, std::shared_ptr<const SfxFilter> pFilter, const std::shared_ptr<SfxItemSet>& pInSet) : + pImpl(new SfxMedium_Impl) +{ + pImpl->m_pSet = pInSet; + SfxItemSet * s = GetItemSet(); + if (s->GetItem(SID_REFERER) == nullptr) { + s->Put(SfxStringItem(SID_REFERER, rReferer)); + } + pImpl->m_pFilter = std::move(pFilter); + pImpl->m_aLogicName = rName; + pImpl->m_nStorOpenMode = nOpenMode; + Init_Impl(); +} + +SfxMedium::SfxMedium( const uno::Sequence<beans::PropertyValue>& aArgs ) : + pImpl(new SfxMedium_Impl) +{ + SfxAllItemSet *pParams = new SfxAllItemSet( SfxGetpApp()->GetPool() ); + pImpl->m_pSet.reset( pParams ); + TransformParameters( SID_OPENDOC, aArgs, *pParams ); + SetArgs(aArgs); + + OUString aFilterProvider, aFilterName; + { + const SfxStringItem* pItem = nullptr; + if ((pItem = pImpl->m_pSet->GetItemIfSet(SID_FILTER_PROVIDER))) + aFilterProvider = pItem->GetValue(); + + if ((pItem = pImpl->m_pSet->GetItemIfSet(SID_FILTER_NAME))) + aFilterName = pItem->GetValue(); + } + + if (aFilterProvider.isEmpty()) + { + // This is a conventional filter type. + pImpl->m_pFilter = SfxGetpApp()->GetFilterMatcher().GetFilter4FilterName( aFilterName ); + } + else + { + // This filter is from an external provider such as orcus. + pImpl->m_pCustomFilter = std::make_shared<SfxFilter>(aFilterProvider, aFilterName); + pImpl->m_pFilter = pImpl->m_pCustomFilter; + } + + const SfxStringItem* pSalvageItem = SfxItemSet::GetItem<SfxStringItem>(pImpl->m_pSet.get(), SID_DOC_SALVAGE, false); + if( pSalvageItem ) + { + // QUESTION: there is some treatment of Salvage in Init_Impl; align! + if ( !pSalvageItem->GetValue().isEmpty() ) + { + // if a URL is provided in SalvageItem that means that the FileName refers to a temporary file + // that must be copied here + + const SfxStringItem* pFileNameItem = SfxItemSet::GetItem<SfxStringItem>(pImpl->m_pSet.get(), SID_FILE_NAME, false); + if (!pFileNameItem) throw uno::RuntimeException(); + OUString aNewTempFileURL = SfxMedium::CreateTempCopyWithExt( pFileNameItem->GetValue() ); + if ( !aNewTempFileURL.isEmpty() ) + { + pImpl->m_pSet->Put( SfxStringItem( SID_FILE_NAME, aNewTempFileURL ) ); + pImpl->m_pSet->ClearItem( SID_INPUTSTREAM ); + pImpl->m_pSet->ClearItem( SID_STREAM ); + pImpl->m_pSet->ClearItem( SID_CONTENT ); + } + else + { + SAL_WARN( "sfx.doc", "Can not create a new temporary file for crash recovery!" ); + } + } + } + + const SfxBoolItem* pReadOnlyItem = SfxItemSet::GetItem<SfxBoolItem>(pImpl->m_pSet.get(), SID_DOC_READONLY, false); + if ( pReadOnlyItem && pReadOnlyItem->GetValue() ) + pImpl->m_bOriginallyLoadedReadOnly = true; + + const SfxStringItem* pFileNameItem = SfxItemSet::GetItem<SfxStringItem>(pImpl->m_pSet.get(), SID_FILE_NAME, false); + if (!pFileNameItem) throw uno::RuntimeException(); + pImpl->m_aLogicName = pFileNameItem->GetValue(); + pImpl->m_nStorOpenMode = pImpl->m_bOriginallyLoadedReadOnly + ? SFX_STREAM_READONLY : SFX_STREAM_READWRITE; + Init_Impl(); +} + +void SfxMedium::SetArgs(const uno::Sequence<beans::PropertyValue>& rArgs) +{ + static constexpr OUStringLiteral sStream(u"Stream"); + static constexpr OUStringLiteral sInputStream(u"InputStream"); + comphelper::SequenceAsHashMap aArgsMap(rArgs); + aArgsMap.erase(sStream); + aArgsMap.erase(sInputStream); + pImpl->m_aArgs = aArgsMap.getAsConstPropertyValueList(); +} + +const uno::Sequence<beans::PropertyValue> & SfxMedium::GetArgs() const { return pImpl->m_aArgs; } + +SfxMedium::SfxMedium( const uno::Reference < embed::XStorage >& rStor, const OUString& rBaseURL, const std::shared_ptr<SfxItemSet>& p ) : + pImpl(new SfxMedium_Impl) +{ + OUString aType = SfxFilter::GetTypeFromStorage(rStor); + pImpl->m_pFilter = SfxGetpApp()->GetFilterMatcher().GetFilter4EA( aType ); + DBG_ASSERT( pImpl->m_pFilter, "No Filter for storage found!" ); + + Init_Impl(); + pImpl->xStorage = rStor; + pImpl->bDisposeStorage = false; + + // always take BaseURL first, could be overwritten by ItemSet + GetItemSet()->Put( SfxStringItem( SID_DOC_BASEURL, rBaseURL ) ); + if ( p ) + GetItemSet()->Put( *p ); +} + + +SfxMedium::SfxMedium( const uno::Reference < embed::XStorage >& rStor, const OUString& rBaseURL, const OUString &rTypeName, const std::shared_ptr<SfxItemSet>& p ) : + pImpl(new SfxMedium_Impl) +{ + pImpl->m_pFilter = SfxGetpApp()->GetFilterMatcher().GetFilter4EA( rTypeName ); + DBG_ASSERT( pImpl->m_pFilter, "No Filter for storage found!" ); + + Init_Impl(); + pImpl->xStorage = rStor; + pImpl->bDisposeStorage = false; + + // always take BaseURL first, could be overwritten by ItemSet + GetItemSet()->Put( SfxStringItem( SID_DOC_BASEURL, rBaseURL ) ); + if ( p ) + GetItemSet()->Put( *p ); +} + +// NOTE: should only be called on main thread +SfxMedium::~SfxMedium() +{ + CancelCheckEditableEntry(); + + // if there is a requirement to clean the backup this is the last possibility to do it + ClearBackup_Impl(); + + Close(/*bInDestruction*/true); + + if( !pImpl->bIsTemp || pImpl->m_aName.isEmpty() ) + return; + + OUString aTemp; + if ( osl::FileBase::getFileURLFromSystemPath( pImpl->m_aName, aTemp ) + != osl::FileBase::E_None ) + { + SAL_WARN( "sfx.doc", "Physical name not convertible!"); + } + + if ( !::utl::UCBContentHelper::Kill( aTemp ) ) + { + SAL_WARN( "sfx.doc", "Couldn't remove temporary file!"); + } +} + +const OUString& SfxMedium::GetName() const +{ + return pImpl->m_aLogicName; +} + +const INetURLObject& SfxMedium::GetURLObject() const +{ + std::unique_lock<std::recursive_mutex> chkEditLock; + if (pImpl->m_pCheckEditableWorkerMutex != nullptr) + chkEditLock = std::unique_lock<std::recursive_mutex>(*(pImpl->m_pCheckEditableWorkerMutex)); + + if (!pImpl->m_pURLObj) + { + pImpl->m_pURLObj.reset( new INetURLObject( pImpl->m_aLogicName ) ); + pImpl->m_pURLObj->SetMark(u""); + } + + return *pImpl->m_pURLObj; +} + +void SfxMedium::SetExpired_Impl( const DateTime& rDateTime ) +{ + pImpl->aExpireTime = rDateTime; +} + + +bool SfxMedium::IsExpired() const +{ + return pImpl->aExpireTime.IsValidAndGregorian() && pImpl->aExpireTime < DateTime( DateTime::SYSTEM ); +} + + +SfxFrame* SfxMedium::GetLoadTargetFrame() const +{ + return pImpl->wLoadTargetFrame; +} + +void SfxMedium::setStreamToLoadFrom(const css::uno::Reference<css::io::XInputStream>& xInputStream, bool bIsReadOnly ) +{ + pImpl->m_xInputStreamToLoadFrom = xInputStream; + pImpl->m_bInputStreamIsReadOnly = bIsReadOnly; +} + +void SfxMedium::SetLoadTargetFrame(SfxFrame* pFrame ) +{ + pImpl->wLoadTargetFrame = pFrame; +} + + +void SfxMedium::SetStorage_Impl( const uno::Reference < embed::XStorage >& rStor ) +{ + pImpl->xStorage = rStor; +} + + +SfxItemSet* SfxMedium::GetItemSet() const +{ + // this method *must* return an ItemSet, returning NULL can cause crashes + if (!pImpl->m_pSet) + pImpl->m_pSet = std::make_shared<SfxAllItemSet>( SfxGetpApp()->GetPool() ); + return pImpl->m_pSet.get(); +} + + +SvKeyValueIterator* SfxMedium::GetHeaderAttributes_Impl() +{ + if( !pImpl->xAttributes.is() ) + { + pImpl->xAttributes = SvKeyValueIteratorRef( new SvKeyValueIterator ); + + if ( GetContent().is() ) + { + try + { + Any aAny = pImpl->aContent.getPropertyValue("MediaType"); + OUString aContentType; + aAny >>= aContentType; + + pImpl->xAttributes->Append( SvKeyValue( "content-type", aContentType ) ); + } + catch ( const css::uno::Exception& ) + { + } + } + } + + return pImpl->xAttributes.get(); +} + +css::uno::Reference< css::io::XInputStream > const & SfxMedium::GetInputStream() +{ + if ( !pImpl->xInputStream.is() ) + GetMedium_Impl(); + return pImpl->xInputStream; +} + +const uno::Sequence < util::RevisionTag >& SfxMedium::GetVersionList( bool _bNoReload ) +{ + // if the medium has no name, then this medium should represent a new document and can have no version info + if ( ( !_bNoReload || !pImpl->m_bVersionsAlreadyLoaded ) && !pImpl->aVersions.hasElements() && + ( !pImpl->m_aName.isEmpty() || !pImpl->m_aLogicName.isEmpty() ) && GetStorage().is() ) + { + uno::Reference < document::XDocumentRevisionListPersistence > xReader = + document::DocumentRevisionListPersistence::create( comphelper::getProcessComponentContext() ); + try + { + pImpl->aVersions = xReader->load( GetStorage() ); + } + catch ( const uno::Exception& ) + { + } + } + + if ( !pImpl->m_bVersionsAlreadyLoaded ) + pImpl->m_bVersionsAlreadyLoaded = true; + + return pImpl->aVersions; +} + +uno::Sequence < util::RevisionTag > SfxMedium::GetVersionList( const uno::Reference < embed::XStorage >& xStorage ) +{ + uno::Reference < document::XDocumentRevisionListPersistence > xReader = + document::DocumentRevisionListPersistence::create( comphelper::getProcessComponentContext() ); + try + { + return xReader->load( xStorage ); + } + catch ( const uno::Exception& ) + { + } + + return uno::Sequence < util::RevisionTag >(); +} + +void SfxMedium::AddVersion_Impl( util::RevisionTag& rRevision ) +{ + if ( !GetStorage().is() ) + return; + + // To determine a unique name for the stream + std::vector<sal_uInt32> aLongs; + sal_Int32 nLength = pImpl->aVersions.getLength(); + for ( const auto& rVersion : std::as_const(pImpl->aVersions) ) + { + sal_uInt32 nVer = static_cast<sal_uInt32>( o3tl::toInt32(rVersion.Identifier.subView(7))); + size_t n; + for ( n=0; n<aLongs.size(); ++n ) + if ( nVer<aLongs[n] ) + break; + + aLongs.insert( aLongs.begin()+n, nVer ); + } + + std::vector<sal_uInt32>::size_type nKey; + for ( nKey=0; nKey<aLongs.size(); ++nKey ) + if ( aLongs[nKey] > nKey+1 ) + break; + + OUString aRevName = "Version" + OUString::number( nKey + 1 ); + pImpl->aVersions.realloc( nLength+1 ); + rRevision.Identifier = aRevName; + pImpl->aVersions.getArray()[nLength] = rRevision; +} + +void SfxMedium::RemoveVersion_Impl( const OUString& rName ) +{ + if ( !pImpl->aVersions.hasElements() ) + return; + + auto pVersion = std::find_if(std::cbegin(pImpl->aVersions), std::cend(pImpl->aVersions), + [&rName](const auto& rVersion) { return rVersion.Identifier == rName; }); + if (pVersion != std::cend(pImpl->aVersions)) + { + auto nIndex = static_cast<sal_Int32>(std::distance(std::cbegin(pImpl->aVersions), pVersion)); + comphelper::removeElementAt(pImpl->aVersions, nIndex); + } +} + +bool SfxMedium::TransferVersionList_Impl( SfxMedium const & rMedium ) +{ + if ( rMedium.pImpl->aVersions.hasElements() ) + { + pImpl->aVersions = rMedium.pImpl->aVersions; + return true; + } + + return false; +} + +void SfxMedium::SaveVersionList_Impl() +{ + if ( !GetStorage().is() ) + return; + + if ( !pImpl->aVersions.hasElements() ) + return; + + uno::Reference < document::XDocumentRevisionListPersistence > xWriter = + document::DocumentRevisionListPersistence::create( comphelper::getProcessComponentContext() ); + try + { + xWriter->store( GetStorage(), pImpl->aVersions ); + } + catch ( const uno::Exception& ) + { + } +} + +bool SfxMedium::IsReadOnly() const +{ + // a) ReadOnly filter can't produce read/write contents! + bool bReadOnly = pImpl->m_pFilter && (pImpl->m_pFilter->GetFilterFlags() & SfxFilterFlags::OPENREADONLY); + + // b) if filter allow read/write contents .. check open mode of the storage + if (!bReadOnly) + bReadOnly = !( GetOpenMode() & StreamMode::WRITE ); + + // c) the API can force the readonly state! + if (!bReadOnly) + { + const SfxBoolItem* pItem = SfxItemSet::GetItem<SfxBoolItem>(GetItemSet(), SID_DOC_READONLY, false); + if (pItem) + bReadOnly = pItem->GetValue(); + } + + return bReadOnly; +} + +bool SfxMedium::IsOriginallyReadOnly() const +{ + return pImpl->m_bOriginallyReadOnly; +} + +void SfxMedium::SetOriginallyReadOnly(bool val) +{ + pImpl->m_bOriginallyReadOnly = val; +} + +bool SfxMedium::IsOriginallyLoadedReadOnly() const +{ + return pImpl->m_bOriginallyLoadedReadOnly; +} + +bool SfxMedium::SetWritableForUserOnly( const OUString& aURL ) +{ + // UCB does not allow to allow write access only for the user, + // use osl API + bool bResult = false; + + ::osl::DirectoryItem aDirItem; + if ( ::osl::DirectoryItem::get( aURL, aDirItem ) == ::osl::FileBase::E_None ) + { + ::osl::FileStatus aFileStatus( osl_FileStatus_Mask_Attributes ); + if ( aDirItem.getFileStatus( aFileStatus ) == osl::FileBase::E_None + && aFileStatus.isValid( osl_FileStatus_Mask_Attributes ) ) + { + sal_uInt64 nAttributes = aFileStatus.getAttributes(); + + nAttributes &= ~(osl_File_Attribute_OwnWrite | + osl_File_Attribute_GrpWrite | + osl_File_Attribute_OthWrite | + osl_File_Attribute_ReadOnly); + nAttributes |= (osl_File_Attribute_OwnWrite | + osl_File_Attribute_OwnRead); + + bResult = ( osl::File::setAttributes( aURL, nAttributes ) == ::osl::FileBase::E_None ); + } + } + + return bResult; +} + +namespace +{ +/// Get the parent directory of a temporary file for output purposes. +OUString GetLogicBase(const INetURLObject& rURL, std::unique_ptr<SfxMedium_Impl> const & pImpl) +{ + OUString aLogicBase; + +#if HAVE_FEATURE_MACOSX_SANDBOX + // In a sandboxed environment we don't want to attempt to create temporary files in the same + // directory where the user has selected an output file to be stored. The sandboxed process has + // permission only to create the specifically named output file in that directory. + (void) rURL; + (void) pImpl; +#else + + if (!pImpl->m_bHasEmbeddedObjects // Embedded objects would mean a special base, ignore that. + && rURL.GetProtocol() == INetProtocol::File && !pImpl->m_pInStream) + { + // Try to create the temp file in the same directory when storing. + INetURLObject aURL(rURL); + aURL.removeSegment(); + aLogicBase = aURL.GetMainURL(INetURLObject::DecodeMechanism::WithCharset); + } + +#endif // !HAVE_FEATURE_MACOSX_SANDBOX + + return aLogicBase; +} +} + +void SfxMedium::CreateTempFile( bool bReplace ) +{ + if ( pImpl->pTempFile ) + { + if ( !bReplace ) + return; + + pImpl->pTempFile.reset(); + pImpl->m_aName.clear(); + } + + OUString aLogicBase = GetLogicBase(GetURLObject(), pImpl); + pImpl->pTempFile.reset(new ::utl::TempFile(&aLogicBase)); + pImpl->pTempFile->EnableKillingFile(); + pImpl->m_aName = pImpl->pTempFile->GetFileName(); + OUString aTmpURL = pImpl->pTempFile->GetURL(); + if ( pImpl->m_aName.isEmpty() || aTmpURL.isEmpty() ) + { + SetError(ERRCODE_IO_CANTWRITE); + return; + } + + if ( !(pImpl->m_nStorOpenMode & StreamMode::TRUNC) ) + { + bool bTransferSuccess = false; + + if ( GetContent().is() + && GetURLObject().GetProtocol() == INetProtocol::File + && ::utl::UCBContentHelper::IsDocument( GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ) ) ) + { + // if there is already such a document, we should copy it + // if it is a file system use OS copy process + try + { + uno::Reference< css::ucb::XCommandEnvironment > xComEnv; + INetURLObject aTmpURLObj( aTmpURL ); + OUString aFileName = aTmpURLObj.getName( INetURLObject::LAST_SEGMENT, + true, + INetURLObject::DecodeMechanism::WithCharset ); + if ( !aFileName.isEmpty() && aTmpURLObj.removeSegment() ) + { + ::ucbhelper::Content aTargetContent( aTmpURLObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xComEnv, comphelper::getProcessComponentContext() ); + OUString sMimeType = pImpl->getFilterMimeType(); + aTargetContent.transferContent( pImpl->aContent, ::ucbhelper::InsertOperation::Copy, aFileName, NameClash::OVERWRITE, sMimeType ); + SetWritableForUserOnly( aTmpURL ); + bTransferSuccess = true; + } + } + catch( const uno::Exception& ) + {} + + if ( bTransferSuccess ) + { + CloseOutStream(); + CloseInStream(); + } + } + + if ( !bTransferSuccess && pImpl->m_pInStream ) + { + // the case when there is no URL-access available or this is a remote protocol + // but there is an input stream + GetOutStream(); + if ( pImpl->m_pOutStream ) + { + std::unique_ptr<char[]> pBuf(new char [8192]); + ErrCode nErr = ERRCODE_NONE; + + pImpl->m_pInStream->Seek(0); + pImpl->m_pOutStream->Seek(0); + + while( !pImpl->m_pInStream->eof() && nErr == ERRCODE_NONE ) + { + sal_uInt32 nRead = pImpl->m_pInStream->ReadBytes(pBuf.get(), 8192); + nErr = pImpl->m_pInStream->GetError(); + pImpl->m_pOutStream->WriteBytes( pBuf.get(), nRead ); + } + + bTransferSuccess = true; + CloseInStream(); + } + CloseOutStream_Impl(); + } + else + { + // Quite strange design, but currently it is expected that in this case no transfer happens + // TODO/LATER: get rid of this inconsistent part of the call design + bTransferSuccess = true; + CloseInStream(); + } + + if ( !bTransferSuccess ) + { + SetError(ERRCODE_IO_CANTWRITE); + return; + } + } + + CloseStorage(); +} + + +void SfxMedium::CreateTempFileNoCopy() +{ + // this call always replaces the existing temporary file + pImpl->pTempFile.reset(); + + OUString aLogicBase = GetLogicBase(GetURLObject(), pImpl); + pImpl->pTempFile.reset(new ::utl::TempFile(&aLogicBase)); + pImpl->pTempFile->EnableKillingFile(); + pImpl->m_aName = pImpl->pTempFile->GetFileName(); + if ( pImpl->m_aName.isEmpty() ) + { + SetError(ERRCODE_IO_CANTWRITE); + return; + } + + CloseOutStream_Impl(); + CloseStorage(); +} + +bool SfxMedium::SignDocumentContentUsingCertificate( + const css::uno::Reference<css::frame::XModel>& xModel, bool bHasValidDocumentSignature, + const Reference<XCertificate>& xCertificate) +{ + bool bChanges = false; + + if (IsOpen() || GetError()) + { + SAL_WARN("sfx.doc", "The medium must be closed by the signer!"); + return bChanges; + } + + // The component should know if there was a valid document signature, since + // it should show a warning in this case + OUString aODFVersion(comphelper::OStorageHelper::GetODFVersionFromStorage(GetStorage())); + uno::Reference< security::XDocumentDigitalSignatures > xSigner( + security::DocumentDigitalSignatures::createWithVersionAndValidSignature( + comphelper::getProcessComponentContext(), aODFVersion, bHasValidDocumentSignature ) ); + auto xModelSigner = dynamic_cast<sfx2::DigitalSignatures*>(xSigner.get()); + if (!xModelSigner) + { + return bChanges; + } + + uno::Reference< embed::XStorage > xWriteableZipStor; + + // we can reuse the temporary file if there is one already + CreateTempFile( false ); + GetMedium_Impl(); + + try + { + if ( !pImpl->xStream.is() ) + throw uno::RuntimeException(); + + bool bODF = GetFilter()->IsOwnFormat(); + try + { + xWriteableZipStor = ::comphelper::OStorageHelper::GetStorageOfFormatFromStream( ZIP_STORAGE_FORMAT_STRING, pImpl->xStream ); + } + catch (const io::IOException&) + { + if (bODF) + { + TOOLS_WARN_EXCEPTION("sfx.doc", "ODF stream is not a zip storage"); + } + } + + if ( !xWriteableZipStor.is() && bODF ) + throw uno::RuntimeException(); + + uno::Reference< embed::XStorage > xMetaInf; + if (xWriteableZipStor.is() && xWriteableZipStor->hasByName("META-INF")) + { + xMetaInf = xWriteableZipStor->openStorageElement( + "META-INF", + embed::ElementModes::READWRITE ); + if ( !xMetaInf.is() ) + throw uno::RuntimeException(); + } + + { + if (xMetaInf.is()) + { + // ODF. + uno::Reference< io::XStream > xStream; + if (GetFilter() && GetFilter()->IsOwnFormat()) + xStream.set(xMetaInf->openStreamElement(xSigner->getDocumentContentSignatureDefaultStreamName(), embed::ElementModes::READWRITE), uno::UNO_SET_THROW); + + bool bSuccess = xModelSigner->SignModelWithCertificate( + xModel, xCertificate, GetZipStorageToSign_Impl(), xStream); + + if (bSuccess) + { + uno::Reference< embed::XTransactedObject > xTransact( xMetaInf, uno::UNO_QUERY_THROW ); + xTransact->commit(); + xTransact.set( xWriteableZipStor, uno::UNO_QUERY_THROW ); + xTransact->commit(); + + // the temporary file has been written, commit it to the original file + Commit(); + bChanges = true; + } + } + else if (xWriteableZipStor.is()) + { + // OOXML. + uno::Reference<io::XStream> xStream; + + // We need read-write to be able to add the signature relation. + bool bSuccess = xModelSigner->SignModelWithCertificate( + xModel, xCertificate, GetZipStorageToSign_Impl(/*bReadOnly=*/false), xStream); + + if (bSuccess) + { + uno::Reference<embed::XTransactedObject> xTransact(xWriteableZipStor, uno::UNO_QUERY_THROW); + xTransact->commit(); + + // the temporary file has been written, commit it to the original file + Commit(); + bChanges = true; + } + } + else + { + // Something not ZIP based: e.g. PDF. + std::unique_ptr<SvStream> pStream(utl::UcbStreamHelper::CreateStream(GetName(), StreamMode::READ | StreamMode::WRITE)); + uno::Reference<io::XStream> xStream(new utl::OStreamWrapper(*pStream)); + if (xModelSigner->SignModelWithCertificate( + xModel, xCertificate, uno::Reference<embed::XStorage>(), xStream)) + bChanges = true; + } + } + } + catch ( const uno::Exception& ) + { + SAL_WARN( "sfx.doc", "Couldn't use signing functionality!" ); + } + + CloseAndRelease(); + + ResetError(); + + return bChanges; +} + +bool SfxMedium::SignContents_Impl(weld::Window* pDialogParent, + bool bSignScriptingContent, + bool bHasValidDocumentSignature, + const OUString& aSignatureLineId, + const Reference<XCertificate>& xCert, + const Reference<XGraphic>& xValidGraphic, + const Reference<XGraphic>& xInvalidGraphic, + const OUString& aComment) +{ + bool bChanges = false; + + if (IsOpen() || GetError()) + { + SAL_WARN("sfx.doc", "The medium must be closed by the signer!"); + return bChanges; + } + + // The component should know if there was a valid document signature, since + // it should show a warning in this case + OUString aODFVersion(comphelper::OStorageHelper::GetODFVersionFromStorage(GetStorage())); + uno::Reference< security::XDocumentDigitalSignatures > xSigner( + security::DocumentDigitalSignatures::createWithVersionAndValidSignature( + comphelper::getProcessComponentContext(), aODFVersion, bHasValidDocumentSignature ) ); + if (pDialogParent) + xSigner->setParentWindow(pDialogParent->GetXWindow()); + + uno::Reference< embed::XStorage > xWriteableZipStor; + + // we can reuse the temporary file if there is one already + CreateTempFile( false ); + GetMedium_Impl(); + + try + { + if ( !pImpl->xStream.is() ) + throw uno::RuntimeException(); + + bool bODF = GetFilter()->IsOwnFormat(); + try + { + xWriteableZipStor = ::comphelper::OStorageHelper::GetStorageOfFormatFromStream( ZIP_STORAGE_FORMAT_STRING, pImpl->xStream ); + } + catch (const io::IOException&) + { + if (bODF) + { + TOOLS_WARN_EXCEPTION("sfx.doc", "ODF stream is not a zip storage"); + } + } + + if ( !xWriteableZipStor.is() && bODF ) + throw uno::RuntimeException(); + + uno::Reference< embed::XStorage > xMetaInf; + if (xWriteableZipStor.is() && xWriteableZipStor->hasByName("META-INF")) + { + xMetaInf = xWriteableZipStor->openStorageElement( + "META-INF", + embed::ElementModes::READWRITE ); + if ( !xMetaInf.is() ) + throw uno::RuntimeException(); + } + + if ( bSignScriptingContent ) + { + // If the signature has already the document signature it will be removed + // after the scripting signature is inserted. + uno::Reference< io::XStream > xStream( + xMetaInf->openStreamElement( xSigner->getScriptingContentSignatureDefaultStreamName(), + embed::ElementModes::READWRITE ), + uno::UNO_SET_THROW ); + + if ( xSigner->signScriptingContent( GetZipStorageToSign_Impl(), xStream ) ) + { + // remove the document signature if any + OUString aDocSigName = xSigner->getDocumentContentSignatureDefaultStreamName(); + if ( !aDocSigName.isEmpty() && xMetaInf->hasByName( aDocSigName ) ) + xMetaInf->removeElement( aDocSigName ); + + uno::Reference< embed::XTransactedObject > xTransact( xMetaInf, uno::UNO_QUERY_THROW ); + xTransact->commit(); + xTransact.set( xWriteableZipStor, uno::UNO_QUERY_THROW ); + xTransact->commit(); + + // the temporary file has been written, commit it to the original file + Commit(); + bChanges = true; + } + } + else + { + if (xMetaInf.is()) + { + // ODF. + uno::Reference< io::XStream > xStream; + if (GetFilter() && GetFilter()->IsOwnFormat()) + xStream.set(xMetaInf->openStreamElement(xSigner->getDocumentContentSignatureDefaultStreamName(), embed::ElementModes::READWRITE), uno::UNO_SET_THROW); + + bool bSuccess = false; + if (xCert.is()) + bSuccess = xSigner->signSignatureLine( + GetZipStorageToSign_Impl(), xStream, aSignatureLineId, xCert, + xValidGraphic, xInvalidGraphic, aComment); + else + bSuccess = xSigner->signDocumentContent(GetZipStorageToSign_Impl(), + xStream); + + if (bSuccess) + { + uno::Reference< embed::XTransactedObject > xTransact( xMetaInf, uno::UNO_QUERY_THROW ); + xTransact->commit(); + xTransact.set( xWriteableZipStor, uno::UNO_QUERY_THROW ); + xTransact->commit(); + + // the temporary file has been written, commit it to the original file + Commit(); + bChanges = true; + } + } + else if (xWriteableZipStor.is()) + { + // OOXML. + uno::Reference<io::XStream> xStream; + + bool bSuccess = false; + if (xCert.is()) + { + bSuccess = xSigner->signSignatureLine( + GetZipStorageToSign_Impl(/*bReadOnly=*/false), xStream, aSignatureLineId, + xCert, xValidGraphic, xInvalidGraphic, aComment); + } + else + { + // We need read-write to be able to add the signature relation. + bSuccess =xSigner->signDocumentContent( + GetZipStorageToSign_Impl(/*bReadOnly=*/false), xStream); + } + + if (bSuccess) + { + uno::Reference<embed::XTransactedObject> xTransact(xWriteableZipStor, uno::UNO_QUERY_THROW); + xTransact->commit(); + + // the temporary file has been written, commit it to the original file + Commit(); + bChanges = true; + } + } + else + { + // Something not ZIP based: e.g. PDF. + std::unique_ptr<SvStream> pStream(utl::UcbStreamHelper::CreateStream(GetName(), StreamMode::READ | StreamMode::WRITE)); + uno::Reference<io::XStream> xStream(new utl::OStreamWrapper(*pStream)); + if (xSigner->signDocumentContent(uno::Reference<embed::XStorage>(), xStream)) + bChanges = true; + } + } + } + catch ( const uno::Exception& ) + { + SAL_WARN( "sfx.doc", "Couldn't use signing functionality!" ); + } + + CloseAndRelease(); + + ResetError(); + + return bChanges; +} + + +SignatureState SfxMedium::GetCachedSignatureState_Impl() const +{ + return pImpl->m_nSignatureState; +} + + +void SfxMedium::SetCachedSignatureState_Impl( SignatureState nState ) +{ + pImpl->m_nSignatureState = nState; +} + +void SfxMedium::SetHasEmbeddedObjects(bool bHasEmbeddedObjects) +{ + pImpl->m_bHasEmbeddedObjects = bHasEmbeddedObjects; +} + +bool SfxMedium::HasStorage_Impl() const +{ + return pImpl->xStorage.is(); +} + +bool SfxMedium::IsOpen() const +{ + return pImpl->m_pInStream || pImpl->m_pOutStream || pImpl->xStorage.is(); +} + +OUString SfxMedium::CreateTempCopyWithExt( std::u16string_view aURL ) +{ + OUString aResult; + + if ( !aURL.empty() ) + { + size_t nPrefixLen = aURL.rfind( '.' ); + OUString aExt = ( nPrefixLen == std::u16string_view::npos ) ? OUString() : OUString(aURL.substr( nPrefixLen )); + + OUString aNewTempFileURL = ::utl::TempFile( u"", true, &aExt ).GetURL(); + if ( !aNewTempFileURL.isEmpty() ) + { + INetURLObject aSource( aURL ); + INetURLObject aDest( aNewTempFileURL ); + OUString aFileName = aDest.getName( INetURLObject::LAST_SEGMENT, + true, + INetURLObject::DecodeMechanism::WithCharset ); + if ( !aFileName.isEmpty() && aDest.removeSegment() ) + { + try + { + uno::Reference< css::ucb::XCommandEnvironment > xComEnv; + ::ucbhelper::Content aTargetContent( aDest.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xComEnv, comphelper::getProcessComponentContext() ); + ::ucbhelper::Content aSourceContent( aSource.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xComEnv, comphelper::getProcessComponentContext() ); + aTargetContent.transferContent( aSourceContent, + ::ucbhelper::InsertOperation::Copy, + aFileName, + NameClash::OVERWRITE ); + aResult = aNewTempFileURL; + } + catch( const uno::Exception& ) + {} + } + } + } + + return aResult; +} + +bool SfxMedium::CallApproveHandler(const uno::Reference< task::XInteractionHandler >& xHandler, const uno::Any& rRequest, bool bAllowAbort) +{ + bool bResult = false; + + if ( xHandler.is() ) + { + try + { + uno::Sequence< uno::Reference< task::XInteractionContinuation > > aContinuations( bAllowAbort ? 2 : 1 ); + auto pContinuations = aContinuations.getArray(); + + ::rtl::Reference< ::comphelper::OInteractionApprove > pApprove( new ::comphelper::OInteractionApprove ); + pContinuations[ 0 ] = pApprove.get(); + + if ( bAllowAbort ) + { + ::rtl::Reference< ::comphelper::OInteractionAbort > pAbort( new ::comphelper::OInteractionAbort ); + pContinuations[ 1 ] = pAbort.get(); + } + + xHandler->handle(::framework::InteractionRequest::CreateRequest(rRequest, aContinuations)); + bResult = pApprove->wasSelected(); + } + catch( const Exception& ) + { + } + } + + return bResult; +} + +OUString SfxMedium::SwitchDocumentToTempFile() +{ + // the method returns empty string in case of failure + OUString aResult; + OUString aOrigURL = pImpl->m_aLogicName; + + if ( !aOrigURL.isEmpty() ) + { + sal_Int32 nPrefixLen = aOrigURL.lastIndexOf( '.' ); + OUString const aExt = (nPrefixLen == -1) + ? OUString() + : aOrigURL.copy(nPrefixLen); + OUString aNewURL = ::utl::TempFile( u"", true, &aExt ).GetURL(); + + // TODO/LATER: In future the aLogicName should be set to shared folder URL + // and a temporary file should be created. Transport_Impl should be impossible then. + if ( !aNewURL.isEmpty() ) + { + uno::Reference< embed::XStorage > xStorage = GetStorage(); + uno::Reference< embed::XOptimizedStorage > xOptStorage( xStorage, uno::UNO_QUERY ); + + if ( xOptStorage.is() ) + { + // TODO/LATER: reuse the pImpl->pTempFile if it already exists + CanDisposeStorage_Impl( false ); + Close(); + SetPhysicalName_Impl( OUString() ); + SetName( aNewURL ); + + // remove the readonly state + bool bWasReadonly = false; + pImpl->m_nStorOpenMode = SFX_STREAM_READWRITE; + const SfxBoolItem* pReadOnlyItem = SfxItemSet::GetItem<SfxBoolItem>(pImpl->m_pSet.get(), SID_DOC_READONLY, false); + if ( pReadOnlyItem && pReadOnlyItem->GetValue() ) + bWasReadonly = true; + GetItemSet()->ClearItem( SID_DOC_READONLY ); + + GetMedium_Impl(); + LockOrigFileOnDemand( false, false ); + CreateTempFile(); + GetMedium_Impl(); + + if ( pImpl->xStream.is() ) + { + try + { + xOptStorage->writeAndAttachToStream( pImpl->xStream ); + pImpl->xStorage = xStorage; + aResult = aNewURL; + } + catch( const uno::Exception& ) + {} + } + + if (bWasReadonly) + { + // set the readonly state back + pImpl->m_nStorOpenMode = SFX_STREAM_READONLY; + GetItemSet()->Put(SfxBoolItem(SID_DOC_READONLY, true)); + } + + if ( aResult.isEmpty() ) + { + Close(); + SetPhysicalName_Impl( OUString() ); + SetName( aOrigURL ); + GetMedium_Impl(); + pImpl->xStorage = xStorage; + } + } + } + } + + return aResult; +} + +bool SfxMedium::SwitchDocumentToFile( const OUString& aURL ) +{ + // the method is only for storage based documents + bool bResult = false; + OUString aOrigURL = pImpl->m_aLogicName; + + if ( !aURL.isEmpty() && !aOrigURL.isEmpty() ) + { + uno::Reference< embed::XStorage > xStorage = GetStorage(); + uno::Reference< embed::XOptimizedStorage > xOptStorage( xStorage, uno::UNO_QUERY ); + + // TODO/LATER: reuse the pImpl->pTempFile if it already exists + CanDisposeStorage_Impl( false ); + Close(); + SetPhysicalName_Impl( OUString() ); + SetName( aURL ); + + // open the temporary file based document + GetMedium_Impl(); + LockOrigFileOnDemand( false, false ); + CreateTempFile(); + GetMedium_Impl(); + + if ( pImpl->xStream.is() ) + { + try + { + uno::Reference< io::XTruncate > xTruncate( pImpl->xStream, uno::UNO_QUERY_THROW ); + xTruncate->truncate(); + if ( xOptStorage.is() ) + xOptStorage->writeAndAttachToStream( pImpl->xStream ); + pImpl->xStorage = xStorage; + bResult = true; + } + catch( const uno::Exception& ) + {} + } + + if ( !bResult ) + { + Close(); + SetPhysicalName_Impl( OUString() ); + SetName( aOrigURL ); + GetMedium_Impl(); + pImpl->xStorage = xStorage; + } + } + + return bResult; +} + +void SfxMedium::SetInCheckIn( bool bInCheckIn ) +{ + pImpl->m_bInCheckIn = bInCheckIn; +} + +bool SfxMedium::IsInCheckIn( ) const +{ + return pImpl->m_bInCheckIn; +} + +// should only be called on main thread +const std::shared_ptr<std::recursive_mutex>& SfxMedium::GetCheckEditableMutex() const +{ + return pImpl->m_pCheckEditableWorkerMutex; +} + +// should only be called while holding pImpl->m_pCheckEditableWorkerMutex +void SfxMedium::SetWorkerReloadEvent(ImplSVEvent* pEvent) +{ + pImpl->m_pReloadEvent = pEvent; +} + +// should only be called while holding pImpl->m_pCheckEditableWorkerMutex +ImplSVEvent* SfxMedium::GetWorkerReloadEvent() const +{ + return pImpl->m_pReloadEvent; +} + +// should only be called on main thread +void SfxMedium::AddToCheckEditableWorkerList() +{ + if (!pImpl->m_bNotifyWhenEditable) + return; + + CancelCheckEditableEntry(); + + if (pImpl->m_pCheckEditableWorkerMutex == nullptr) + { + pImpl->m_pCheckEditableWorkerMutex = std::make_shared<std::recursive_mutex>(); + if (pImpl->m_pCheckEditableWorkerMutex == nullptr) + return; + } + + pImpl->m_pIsDestructed = std::make_shared<bool>(false); + if (pImpl->m_pIsDestructed == nullptr) + return; + + std::unique_lock<std::mutex> globalLock(g_chkReadOnlyGlobalMutex); + if (g_newReadOnlyDocs.find(this) == g_newReadOnlyDocs.end()) + { + bool bAddNewEntry = false; + if (!g_bChkReadOnlyTaskRunning) + { + std::shared_ptr<comphelper::ThreadTaskTag> pTag + = comphelper::ThreadPool::createThreadTaskTag(); + if (pTag != nullptr) + { + g_bChkReadOnlyTaskRunning = true; + bAddNewEntry = true; + comphelper::ThreadPool::getSharedOptimalPool().pushTask( + std::make_unique<CheckReadOnlyTask>(pTag)); + } + } + else + bAddNewEntry = true; + + if (bAddNewEntry) + { + std::shared_ptr<ReadOnlyMediumEntry> newEntry = std::make_shared<ReadOnlyMediumEntry>( + pImpl->m_pCheckEditableWorkerMutex, pImpl->m_pIsDestructed); + + if (newEntry != nullptr) + { + g_newReadOnlyDocs[this] = newEntry; + } + } + } +} + +// should only be called on main thread +void SfxMedium::CancelCheckEditableEntry(bool bRemoveEvent) +{ + if (pImpl->m_pCheckEditableWorkerMutex != nullptr) + { + std::unique_lock<std::recursive_mutex> lock(*(pImpl->m_pCheckEditableWorkerMutex)); + + if (pImpl->m_pReloadEvent != nullptr) + { + if (bRemoveEvent) + Application::RemoveUserEvent(pImpl->m_pReloadEvent); + // make sure destructor doesn't use a freed reference + // and reset the event so we can check again + pImpl->m_pReloadEvent = nullptr; + } + + if (pImpl->m_pIsDestructed != nullptr) + { + *(pImpl->m_pIsDestructed) = true; + pImpl->m_pIsDestructed = nullptr; + } + } +} + +/** callback function, which is triggered by worker thread after successfully checking if the file + is editable. Sent from <Application::PostUserEvent(..)> + Note: This method has to be run in the main thread. +*/ +IMPL_STATIC_LINK(SfxMedium, ShowReloadEditableDialog, void*, p, void) +{ + SfxMedium* pMed = static_cast<SfxMedium*>(p); + if (pMed == nullptr) + return; + + pMed->CancelCheckEditableEntry(false); + + uno::Reference<task::XInteractionHandler> xHandler = pMed->GetInteractionHandler(); + if (xHandler.is()) + { + OUString aDocumentURL + = pMed->GetURLObject().GetLastName(INetURLObject::DecodeMechanism::WithCharset); + ::rtl::Reference<::ucbhelper::InteractionRequest> xInteractionRequestImpl + = new ::ucbhelper::InteractionRequest(uno::Any(document::ReloadEditableRequest( + OUString(), uno::Reference<uno::XInterface>(), aDocumentURL))); + if (xInteractionRequestImpl != nullptr) + { + uno::Sequence<uno::Reference<task::XInteractionContinuation>> aContinuations{ + new ::ucbhelper::InteractionAbort(xInteractionRequestImpl.get()), + new ::ucbhelper::InteractionApprove(xInteractionRequestImpl.get()) + }; + xInteractionRequestImpl->setContinuations(aContinuations); + xHandler->handle(xInteractionRequestImpl); + ::rtl::Reference<::ucbhelper::InteractionContinuation> xSelected + = xInteractionRequestImpl->getSelection(); + if (uno::Reference<task::XInteractionApprove>(xSelected.get(), uno::UNO_QUERY).is()) + { + for (SfxViewFrame* pFrame = SfxViewFrame::GetFirst(); pFrame; + pFrame = SfxViewFrame::GetNext(*pFrame)) + { + if (pFrame->GetObjectShell()->GetMedium() == pMed) + { + // special case to ensure view isn't set to read-only in + // SfxViewFrame::ExecReload_Impl after reloading + pMed->SetOriginallyReadOnly(false); + pFrame->GetDispatcher()->Execute(SID_RELOAD); + break; + } + } + } + } + } +} + +bool SfxMedium::CheckCanGetLockfile() const +{ +#if !HAVE_FEATURE_MULTIUSER_ENVIRONMENT + bool bCanReload = true; +#else + bool bCanReload = false; + ::svt::DocumentLockFile aLockFile(GetName()); + LockFileEntry aData; + osl::DirectoryItem rItem; + auto nError1 = osl::DirectoryItem::get(aLockFile.GetURL(), rItem); + if (nError1 == osl::FileBase::E_None) + { + try + { + aData = aLockFile.GetLockData(); + } + catch (const io::WrongFormatException&) + { + // we get empty or corrupt data + return false; + } + catch (const uno::Exception&) + { + // locked from other app + return false; + } + LockFileEntry aOwnData = svt::LockFileCommon::GenerateOwnEntry(); + bool bOwnLock + = aOwnData[LockFileComponent::SYSUSERNAME] == aData[LockFileComponent::SYSUSERNAME]; + if (bOwnLock + && aOwnData[LockFileComponent::LOCALHOST] == aData[LockFileComponent::LOCALHOST] + && aOwnData[LockFileComponent::USERURL] == aData[LockFileComponent::USERURL]) + { + // this is own lock from the same installation, it could remain because of crash + bCanReload = true; + } + } + else if (nError1 == osl::FileBase::E_NOENT) // file doesn't exist + { + try + { + aLockFile.CreateOwnLockFile(); + try + { + // TODO/LATER: A warning could be shown in case the file is not the own one + aLockFile.RemoveFile(); + } + catch (const io::WrongFormatException&) + { + try + { + // erase the empty or corrupt file + aLockFile.RemoveFileDirectly(); + } + catch (const uno::Exception&) + { + } + } + bCanReload = true; + } + catch (const uno::Exception&) + { + } + } +#endif + return bCanReload; +} + +// worker thread method, should only be one thread globally +void CheckReadOnlyTask::doWork() +{ + if (m_xListener == nullptr) + return; + + while (true) + { + std::unique_lock<std::mutex> termLock(m_xListener->mMutex); + if (m_xListener->mCond.wait_for(termLock, std::chrono::seconds(60), + [this] { return m_xListener->bIsTerminated; })) + // signalled, spurious wakeups should not be possible + return; + + // must have timed-out + termLock.unlock(); + std::unique_lock<std::mutex> globalLock(g_chkReadOnlyGlobalMutex); + for (auto it = g_newReadOnlyDocs.begin(); it != g_newReadOnlyDocs.end(); ) + { + auto [pMed, roEntry] = *it; + g_existingReadOnlyDocs[pMed] = roEntry; + it = g_newReadOnlyDocs.erase(it); + } + if (g_existingReadOnlyDocs.size() == 0) + { + g_bChkReadOnlyTaskRunning = false; + return; + } + globalLock.unlock(); + + auto checkForErase = [](SfxMedium* pMed, const std::shared_ptr<ReadOnlyMediumEntry>& roEntry) -> bool + { + if (pMed == nullptr || roEntry == nullptr || roEntry->_pMutex == nullptr + || roEntry->_pIsDestructed == nullptr) + return true; + + std::unique_lock<std::recursive_mutex> medLock(*(roEntry->_pMutex)); + if (*(roEntry->_pIsDestructed) || pMed->GetWorkerReloadEvent() != nullptr) + return true; + + osl::File aFile( + pMed->GetURLObject().GetMainURL(INetURLObject::DecodeMechanism::WithCharset)); + if (aFile.open(osl_File_OpenFlag_Write) != osl::FileBase::E_None) + return false; + + if (!pMed->CheckCanGetLockfile()) + return false; + + if (aFile.close() != osl::FileBase::E_None) + return true; + + // we can load, ask user + ImplSVEvent* pEvent = Application::PostUserEvent( + LINK(nullptr, SfxMedium, ShowReloadEditableDialog), pMed); + pMed->SetWorkerReloadEvent(pEvent); + return true; + }; + + for (auto it = g_existingReadOnlyDocs.begin(); it != g_existingReadOnlyDocs.end(); ) + { + if (checkForErase(it->first, it->second)) + it = g_existingReadOnlyDocs.erase(it); + else + ++it; + } + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/docfilt.cxx b/sfx2/source/doc/docfilt.cxx new file mode 100644 index 000000000..7a23a2842 --- /dev/null +++ b/sfx2/source/doc/docfilt.cxx @@ -0,0 +1,199 @@ +/* -*- 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 . + */ + +#ifdef __sun +#include <ctime> +#endif + +#include <sot/exchange.hxx> +#include <sot/storage.hxx> +#include <comphelper/fileformat.h> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/embed/XStorage.hpp> +#include <sfx2/docfilt.hxx> +#include <sfx2/fcontnr.hxx> +#include <sfx2/objsh.hxx> + +using namespace ::com::sun::star; + +SfxFilter::SfxFilter( const OUString& rProvider, const OUString &rFilterName ) : + maFilterName(rFilterName), + maProvider(rProvider), + nFormatType(SfxFilterFlags::NONE), + nVersion(0), + lFormat(SotClipboardFormatId::NONE), + mbEnabled(true) +{ +} + +SfxFilter::SfxFilter( const OUString &rName, + std::u16string_view rWildCard, + SfxFilterFlags nType, + SotClipboardFormatId lFmt, + const OUString &rTypNm, + const OUString &rMimeType, + const OUString &rUsrDat, + const OUString &rServiceName, + bool bEnabled ): + aWildCard(rWildCard, ';'), + aTypeName(rTypNm), + aUserData(rUsrDat), + aServiceName(rServiceName), + aMimeType(rMimeType), + maFilterName(rName), + aUIName(maFilterName), + nFormatType(nType), + nVersion(SOFFICE_FILEFORMAT_50), + lFormat(lFmt), + mbEnabled(bEnabled) +{ + const OUString aExts = GetWildcard().getGlob(); + sal_Int32 nLen{ aExts.getLength() }; + if (nLen<=0) + return; + + // truncate to first empty extension + if (aExts[0]==';') + { + aWildCard.setGlob(u""); + return; + } + const sal_Int32 nIdx{ aExts.indexOf(";;") }; + if (nIdx>0) + nLen = nIdx; + else if (aExts[nLen-1]==';') + --nLen; + if (nLen<aExts.getLength()) + aWildCard.setGlob(aExts.subView(0, nLen)); +} + +SfxFilter::~SfxFilter() +{ +} + +OUString SfxFilter::GetDefaultExtension() const +{ + return GetWildcard().getGlob().getToken(0, ';'); +} + + +OUString SfxFilter::GetSuffixes() const +{ + OUString aRet = GetWildcard().getGlob(); + aRet = aRet.replaceAll( "*.", "" ); + aRet = aRet.replaceAll( ";", "," ); + return aRet; +} + +std::shared_ptr<const SfxFilter> SfxFilter::GetDefaultFilter( std::u16string_view rName ) +{ + return SfxFilterContainer::GetDefaultFilter_Impl( rName ); +} + +std::shared_ptr<const SfxFilter> SfxFilter::GetDefaultFilterFromFactory( const OUString& rFact ) +{ + return GetDefaultFilter( SfxObjectShell::GetServiceNameFromFactory( rFact ) ); +} + +std::shared_ptr<const SfxFilter> SfxFilter::GetFilterByName( const OUString& rName ) +{ + SfxFilterMatcher aMatch; + return aMatch.GetFilter4FilterName( rName, SfxFilterFlags::NONE, SfxFilterFlags::NONE ); +} + +OUString SfxFilter::GetTypeFromStorage( const SotStorage& rStg ) +{ + const char* pType=nullptr; + if ( rStg.IsStream( "WordDocument" ) ) + { + if ( rStg.IsStream( "0Table" ) || rStg.IsStream( "1Table" ) ) + pType = "writer_MS_Word_97"; + else + pType = "writer_MS_Word_95"; + } + else if ( rStg.IsStream( "Book" ) ) + { + pType = "calc_MS_Excel_95"; + } + else if ( rStg.IsStream( "Workbook" ) ) + { + pType = "calc_MS_Excel_97"; + } + else if ( rStg.IsStream( "PowerPoint Document" ) ) + { + pType = "impress_MS_PowerPoint_97"; + } + else if ( rStg.IsStream( "Equation Native" ) ) + { + pType = "math_MathType_3x"; + } + else + { + SotClipboardFormatId nClipId = const_cast<SotStorage&>(rStg).GetFormat(); + if ( nClipId != SotClipboardFormatId::NONE ) + { + std::shared_ptr<const SfxFilter> pFilter = SfxFilterMatcher().GetFilter4ClipBoardId( nClipId ); + if ( pFilter ) + return pFilter->GetTypeName(); + } + } + + return pType ? OUString::createFromAscii(pType) : OUString(); +} + +OUString SfxFilter::GetTypeFromStorage( + const uno::Reference<embed::XStorage>& xStorage ) +{ + SfxFilterMatcher aMatcher; + + css::uno::Reference< css::beans::XPropertySet > xProps( xStorage, css::uno::UNO_QUERY ); + if ( xProps.is() ) + { + OUString aMediaType; + xProps->getPropertyValue("MediaType") >>= aMediaType; + if ( !aMediaType.isEmpty() ) + { + css::datatransfer::DataFlavor aDataFlavor; + aDataFlavor.MimeType = aMediaType; + SotClipboardFormatId nClipId = SotExchange::GetFormat( aDataFlavor ); + if ( nClipId != SotClipboardFormatId::NONE ) + { + SfxFilterFlags const nMust = SfxFilterFlags::IMPORT; + // template filters shouldn't be detected if not explicitly asked for + SfxFilterFlags const nDont = SFX_FILTER_NOTINSTALLED | SfxFilterFlags::TEMPLATEPATH; + + // get filter from storage MediaType + std::shared_ptr<const SfxFilter> pFilter = aMatcher.GetFilter4ClipBoardId( nClipId, nMust, nDont ); + if ( !pFilter ) + // template filter is asked for , but there isn't one; so at least the "normal" format should be detected + // or storage *is* a template, but bTemplate is not set + pFilter = aMatcher.GetFilter4ClipBoardId( nClipId ); + + if ( pFilter ) + { + return pFilter->GetTypeName(); + } + } + } + } + + return OUString(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/docinf.cxx b/sfx2/source/doc/docinf.cxx new file mode 100644 index 000000000..949e1f19f --- /dev/null +++ b/sfx2/source/doc/docinf.cxx @@ -0,0 +1,324 @@ +/* -*- 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 <sfx2/docinf.hxx> +#include <com/sun/star/beans/PropertyAttribute.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/beans/XPropertyContainer.hpp> +#include <com/sun/star/document/XDocumentProperties.hpp> +#include <com/sun/star/document/XCompatWriterDocProperties.hpp> +#include <com/sun/star/uno/Exception.hpp> +#include <rtl/ustring.hxx> +#include <sal/log.hxx> +#include <tools/debug.hxx> +#include <comphelper/string.hxx> +#include <sot/storage.hxx> +#include <vcl/bitmapex.hxx> +#include <vcl/gdimtf.hxx> +#include <vcl/dibtools.hxx> +#include "oleprops.hxx" + + +// stream names +constexpr OUStringLiteral STREAM_SUMMARYINFO = u"\005SummaryInformation"; +constexpr OUStringLiteral STREAM_DOCSUMMARYINFO = u"\005DocumentSummaryInformation"; + +// usings +using namespace ::com::sun::star; + + +namespace sfx2 { + +ErrCode LoadOlePropertySet( + const uno::Reference< document::XDocumentProperties>& i_xDocProps, + SotStorage* i_pStorage ) +{ + // *** global properties from stream "005SummaryInformation" *** + + // load the property set + SfxOlePropertySet aGlobSet; + ErrCode nGlobError = aGlobSet.LoadPropertySet(i_pStorage, + STREAM_SUMMARYINFO ); + + // global section + SfxOleSectionRef xGlobSect = aGlobSet.GetSection( SECTION_GLOBAL ); + if( xGlobSect ) + { + // set supported properties + OUString aStrValue; + util::DateTime aDateTime; + + if( xGlobSect->GetStringValue( aStrValue, PROPID_TITLE ) ) + i_xDocProps->setTitle( aStrValue ); + if( xGlobSect->GetStringValue( aStrValue, PROPID_SUBJECT ) ) + i_xDocProps->setSubject( aStrValue ); + if( xGlobSect->GetStringValue( aStrValue, PROPID_KEYWORDS ) ) { + i_xDocProps->setKeywords( + ::comphelper::string::convertCommaSeparated(aStrValue) ); + } + if( xGlobSect->GetStringValue( aStrValue, PROPID_TEMPLATE ) ) + i_xDocProps->setTemplateName( aStrValue ); + if( xGlobSect->GetStringValue( aStrValue, PROPID_COMMENTS ) ) + i_xDocProps->setDescription( aStrValue ); + + util::DateTime aInvalid; + if( xGlobSect->GetStringValue( aStrValue, PROPID_AUTHOR) ) + i_xDocProps->setAuthor( aStrValue ); + else + i_xDocProps->setAuthor( OUString() ); + if( xGlobSect->GetFileTimeValue( aDateTime, PROPID_CREATED ) ) + i_xDocProps->setCreationDate( aDateTime ); + else + i_xDocProps->setCreationDate( aInvalid ); + + if( xGlobSect->GetStringValue( aStrValue, PROPID_LASTAUTHOR) ) + i_xDocProps->setModifiedBy( aStrValue ); + else + i_xDocProps->setModifiedBy( OUString() ); + if( xGlobSect->GetFileTimeValue( aDateTime, PROPID_LASTSAVED ) ) + i_xDocProps->setModificationDate( aDateTime ); + else + i_xDocProps->setModificationDate( aInvalid ); + + i_xDocProps->setPrintedBy( OUString() ); + if( xGlobSect->GetFileTimeValue( aDateTime, PROPID_LASTPRINTED ) ) + i_xDocProps->setPrintDate( aDateTime ); + else + i_xDocProps->setPrintDate( aInvalid ); + + if( xGlobSect->GetStringValue( aStrValue, PROPID_REVNUMBER ) ) + { + sal_Int16 nRevision = static_cast< sal_Int16 >( aStrValue.toInt32() ); + if ( nRevision > 0 ) + i_xDocProps->setEditingCycles( nRevision ); + } + + if( xGlobSect->GetFileTimeValue( aDateTime, PROPID_EDITTIME ) + && !(aDateTime.NanoSeconds == 0 && aDateTime.Seconds == 0 + && aDateTime.Minutes == 0 && aDateTime.Hours == 0 + && aDateTime.Day == 0 && aDateTime.Month == 0 + && aDateTime.Year == 0) ) + { + // subtract offset 1601-01-01 + aDateTime.Year -= 1601; + aDateTime.Month -= 1; + aDateTime.Day -= 1; + try + { + i_xDocProps->setEditingDuration( + aDateTime.Day * 60*60*24 + + aDateTime.Hours * 60*60 + + aDateTime.Minutes * 60 + + aDateTime.Seconds ); + } + catch (const lang::IllegalArgumentException &) + { + // ignore + } + } + } + + // *** custom properties from stream "005DocumentSummaryInformation" *** + + // load the property set + SfxOlePropertySet aDocSet; + ErrCode nDocError = aDocSet.LoadPropertySet(i_pStorage, + STREAM_DOCSUMMARYINFO ); + + // custom properties + SfxOleSectionRef xCustomSect = aDocSet.GetSection( SECTION_CUSTOM ); + if( xCustomSect ) + { + uno::Reference < beans::XPropertyContainer > xUserDefined( + i_xDocProps->getUserDefinedProperties(), uno::UNO_SET_THROW); + ::std::vector< sal_Int32 > aPropIds; + xCustomSect->GetPropertyIds( aPropIds ); + for( const auto& rPropId : aPropIds ) + { + const OUString aPropName = xCustomSect->GetPropertyName( rPropId ); + uno::Any aPropValue = xCustomSect->GetAnyValue( rPropId ); + if( !aPropName.isEmpty() && aPropValue.hasValue() ) + { + try + { + xUserDefined->addProperty( aPropName, + beans::PropertyAttribute::REMOVABLE, aPropValue ); + } + catch (const uno::Exception&) + { + //ignore + } + } + } + } + + uno::Reference< document::XCompatWriterDocProperties > xWriterProps( i_xDocProps, uno::UNO_QUERY ); + if ( xWriterProps.is() ) + { + SfxOleSectionRef xBuiltin = aDocSet.GetSection( SECTION_BUILTIN ); + if ( xBuiltin ) + { + try + { + OUString aStrValue; + if ( xBuiltin->GetStringValue( aStrValue, PROPID_MANAGER ) ) + xWriterProps->setManager( aStrValue ); + if ( xBuiltin->GetStringValue( aStrValue, PROPID_CATEGORY ) ) + xWriterProps->setCategory( aStrValue ); + if ( xBuiltin->GetStringValue( aStrValue, PROPID_COMPANY ) ) + xWriterProps->setCompany( aStrValue ); + } + catch (const uno::Exception&) + { + } + } + } + + // return code + return (nGlobError != ERRCODE_NONE) ? nGlobError : nDocError; +} + +bool SaveOlePropertySet( + const uno::Reference< document::XDocumentProperties>& i_xDocProps, + SotStorage* i_pStorage, + const uno::Sequence<sal_Int8> * i_pThumb, + const uno::Sequence<sal_Int8> * i_pGuid, + const uno::Sequence<sal_Int8> * i_pHyperlinks) +{ + // *** global properties into stream "005SummaryInformation" *** + + SfxOlePropertySet aGlobSet; + + // set supported properties + SfxOleSection& rGlobSect = aGlobSet.AddSection( SECTION_GLOBAL ); + rGlobSect.SetStringValue( PROPID_TITLE, i_xDocProps->getTitle() ); + rGlobSect.SetStringValue( PROPID_SUBJECT, i_xDocProps->getSubject() ); + const OUString aStr = ::comphelper::string::convertCommaSeparated( + i_xDocProps->getKeywords() ); + rGlobSect.SetStringValue( PROPID_KEYWORDS, aStr ); + rGlobSect.SetStringValue( PROPID_TEMPLATE, i_xDocProps->getTemplateName() ); + rGlobSect.SetStringValue( PROPID_COMMENTS, i_xDocProps->getDescription() ); + rGlobSect.SetStringValue( PROPID_AUTHOR, i_xDocProps->getAuthor() ); + rGlobSect.SetFileTimeValue(PROPID_CREATED, i_xDocProps->getCreationDate()); + rGlobSect.SetStringValue( PROPID_LASTAUTHOR, i_xDocProps->getModifiedBy() ); + rGlobSect.SetFileTimeValue(PROPID_LASTSAVED, + i_xDocProps->getModificationDate() ); + // note: apparently PrintedBy is not supported in file format + rGlobSect.SetFileTimeValue(PROPID_LASTPRINTED, i_xDocProps->getPrintDate()); + + sal_Int32 dur = i_xDocProps->getEditingDuration(); + util::DateTime aEditTime; + // add offset 1601-01-01 + aEditTime.Year = 1601; + aEditTime.Month = 1; + aEditTime.Day = 1; + aEditTime.Hours = static_cast<sal_Int16>(dur / 3600); + aEditTime.Minutes = static_cast<sal_Int16>((dur % 3600) / 60); + aEditTime.Seconds = static_cast<sal_Int16>(dur % 60); + rGlobSect.SetFileTimeValue( PROPID_EDITTIME, aEditTime ); + + rGlobSect.SetStringValue( PROPID_REVNUMBER, + OUString::number( i_xDocProps->getEditingCycles() ) ); + if ( i_pThumb && i_pThumb->hasElements() ) + rGlobSect.SetThumbnailValue( PROPID_THUMBNAIL, *i_pThumb ); + + // save the property set + ErrCode nGlobError = aGlobSet.SavePropertySet(i_pStorage, + STREAM_SUMMARYINFO); + + // *** custom properties into stream "005DocumentSummaryInformation" *** + + SfxOlePropertySet aDocSet; + + // set builtin properties + aDocSet.AddSection( SECTION_BUILTIN ); + + // set custom properties + SfxOleSection& rCustomSect = aDocSet.AddSection( SECTION_CUSTOM ); + + // write GUID + if (i_pGuid) { + const sal_Int32 nPropId = rCustomSect.GetFreePropertyId(); + rCustomSect.SetBlobValue( nPropId, *i_pGuid ); + rCustomSect.SetPropertyName( nPropId, + "_PID_GUID" ); + } + + // write hyperlinks + if (i_pHyperlinks) { + const sal_Int32 nPropId = rCustomSect.GetFreePropertyId(); + rCustomSect.SetBlobValue( nPropId, *i_pHyperlinks ); + rCustomSect.SetPropertyName( nPropId, + "_PID_HLINKS" ); + } + + uno::Reference<beans::XPropertySet> xUserDefinedProps( + i_xDocProps->getUserDefinedProperties(), uno::UNO_QUERY_THROW); + uno::Reference<beans::XPropertySetInfo> xPropInfo = + xUserDefinedProps->getPropertySetInfo(); + DBG_ASSERT(xPropInfo.is(), "UserDefinedProperties Info is null"); + const uno::Sequence<beans::Property> props = xPropInfo->getProperties(); + for (const auto& rProp : props) + { + try + { + // skip transient properties + if (~rProp.Attributes & beans::PropertyAttribute::TRANSIENT) + { + const OUString name = rProp.Name; + const sal_Int32 nPropId = rCustomSect.GetFreePropertyId(); + if (rCustomSect.SetAnyValue( nPropId, + xUserDefinedProps->getPropertyValue(name))) { + rCustomSect.SetPropertyName( nPropId, name ); + } + } + } + catch (const uno::Exception &) + { + // may happen with concurrent modification... + SAL_INFO("sfx", "SavePropertySet: exception"); + } + } + + // save the property set + ErrCode nDocError = aDocSet.SavePropertySet(i_pStorage, + STREAM_DOCSUMMARYINFO ); + + // return code + return (nGlobError == ERRCODE_NONE) && (nDocError == ERRCODE_NONE); +} + +uno::Sequence<sal_Int8> convertMetaFile(GDIMetaFile const * i_pThumb) +{ + if (i_pThumb) { + BitmapEx aBitmap; + SvMemoryStream aStream; + if (i_pThumb->CreateThumbnail(aBitmap)) + { + WriteDIB(aBitmap.GetBitmap(), aStream, false, false); + return uno::Sequence<sal_Int8>(static_cast< const sal_Int8* >( aStream.GetData() ), aStream.TellEnd()); + } + } + return uno::Sequence<sal_Int8>(); +} + +} // namespace sfx2 + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/docinsert.cxx b/sfx2/source/doc/docinsert.cxx new file mode 100644 index 000000000..d8fe42621 --- /dev/null +++ b/sfx2/source/doc/docinsert.cxx @@ -0,0 +1,292 @@ +/* -*- 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 <sfx2/app.hxx> +#include <sfx2/docinsert.hxx> +#include <sfx2/docfile.hxx> +#include <sfx2/fcontnr.hxx> +#include <sfx2/filedlghelper.hxx> +#include <appopen.hxx> +#include <openflag.hxx> +#include <sfx2/passwd.hxx> + +#include <sfx2/sfxsids.hrc> +#include <com/sun/star/ui/dialogs/ControlActions.hpp> +#include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp> +#include <com/sun/star/ui/dialogs/TemplateDescription.hpp> +#include <com/sun/star/ui/dialogs/XFilePicker3.hpp> +#include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp> +#include <com/sun/star/lang/IllegalArgumentException.hpp> +#include <tools/urlobj.hxx> +#include <svl/itemset.hxx> +#include <svl/eitem.hxx> +#include <svl/intitem.hxx> +#include <svl/stritem.hxx> +#include <memory> +#include <tools/diagnose_ex.h> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::ui::dialogs; +using namespace ::com::sun::star::uno; + +namespace +{ + +FileDialogFlags lcl_map_mode_to_flags(const sfx2::DocumentInserter::Mode mode) +{ + FileDialogFlags f {FileDialogFlags::NONE}; + switch (mode) + { + case sfx2::DocumentInserter::Mode::Insert: + f = FileDialogFlags::Insert; + break; + case sfx2::DocumentInserter::Mode::InsertMulti: + f = FileDialogFlags::Insert|FileDialogFlags::MultiSelection; + break; + case sfx2::DocumentInserter::Mode::Compare: + f = FileDialogFlags::InsertCompare; + break; + case sfx2::DocumentInserter::Mode::Merge: + f = FileDialogFlags::InsertMerge; + break; + } + return f; +} + +} + +namespace sfx2 { + +DocumentInserter::DocumentInserter(weld::Window* pParent, const OUString& rFactory, const Mode mode) + : m_pParent ( pParent ) + , m_sDocFactory ( rFactory ) + , m_nDlgFlags ( lcl_map_mode_to_flags(mode) ) + , m_nError ( ERRCODE_NONE ) +{ +} + +DocumentInserter::~DocumentInserter() +{ +} + +void DocumentInserter::StartExecuteModal( const Link<sfx2::FileDialogHelper*,void>& _rDialogClosedLink ) +{ + m_aDialogClosedLink = _rDialogClosedLink; + m_nError = ERRCODE_NONE; + if ( !m_pFileDlg ) + { + m_pFileDlg.reset( new FileDialogHelper( + ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE, + m_nDlgFlags, m_sDocFactory, SfxFilterFlags::NONE, SfxFilterFlags::NONE, m_pParent ) ); + } + m_pFileDlg->SetContext(FileDialogHelper::InsertDoc); + m_pFileDlg->StartExecuteModal( LINK( this, DocumentInserter, DialogClosedHdl ) ); +} + +std::unique_ptr<SfxMedium> DocumentInserter::CreateMedium(char const*const pFallbackHack) +{ + std::unique_ptr<SfxMedium> pMedium; + if (!m_nError && m_xItemSet && !m_pURLList.empty()) + { + DBG_ASSERT( m_pURLList.size() == 1, "DocumentInserter::CreateMedium(): invalid URL list count" ); + pMedium.reset(new SfxMedium( + m_pURLList[0], SFX_STREAM_READONLY, + SfxGetpApp()->GetFilterMatcher().GetFilter4FilterName( m_sFilter ), m_xItemSet )); + pMedium->UseInteractionHandler( true ); + std::optional<SfxFilterMatcher> pMatcher; + if ( !m_sDocFactory.isEmpty() ) + pMatcher.emplace(m_sDocFactory); + else + pMatcher.emplace(); + + std::shared_ptr<const SfxFilter> pFilter; + ErrCode nError = pMatcher->DetectFilter( *pMedium, pFilter ); + // tdf#101813 hack: check again if it's a global document + if (ERRCODE_NONE != nError && pFallbackHack) + { + pMatcher.emplace(OUString::createFromAscii(pFallbackHack)); + nError = pMatcher->DetectFilter( *pMedium, pFilter ); + } + if ( nError == ERRCODE_NONE && pFilter ) + pMedium->SetFilter( pFilter ); + else + pMedium.reset(); + + if ( pMedium && CheckPasswd_Impl( nullptr, pMedium.get() ) == ERRCODE_ABORT ) + pMedium.reset(); + } + + return pMedium; +} + +SfxMediumList DocumentInserter::CreateMediumList() +{ + SfxMediumList aMediumList; + if (!m_nError && m_xItemSet && !m_pURLList.empty()) + { + for (auto const& url : m_pURLList) + { + std::unique_ptr<SfxMedium> pMedium(new SfxMedium( + url, SFX_STREAM_READONLY, + SfxGetpApp()->GetFilterMatcher().GetFilter4FilterName( m_sFilter ), m_xItemSet )); + + pMedium->UseInteractionHandler( true ); + + SfxFilterMatcher aMatcher( m_sDocFactory ); + std::shared_ptr<const SfxFilter> pFilter; + ErrCode nError = aMatcher.DetectFilter( *pMedium, pFilter ); + if ( nError == ERRCODE_NONE && pFilter ) + pMedium->SetFilter( pFilter ); + else + pMedium.reset(); + + if( pMedium && CheckPasswd_Impl( nullptr, pMedium.get() ) != ERRCODE_ABORT ) + aMediumList.push_back( std::move(pMedium) ); + } + } + + return aMediumList; +} + +static void impl_FillURLList( sfx2::FileDialogHelper const * _pFileDlg, std::vector<OUString>& _rpURLList ) +{ + DBG_ASSERT( _pFileDlg, "DocumentInserter::fillURLList(): invalid file dialog" ); + + const Sequence < OUString > aPathSeq = _pFileDlg->GetSelectedFiles(); + + if ( aPathSeq.hasElements() ) + { + _rpURLList.clear(); + + std::transform(aPathSeq.begin(), aPathSeq.end(), std::back_inserter(_rpURLList), + [](const OUString& rPath) -> OUString { + INetURLObject aPathObj( rPath ); + return aPathObj.GetMainURL(INetURLObject::DecodeMechanism::NONE); + }); + } +} + +IMPL_LINK_NOARG(DocumentInserter, DialogClosedHdl, sfx2::FileDialogHelper*, void) +{ + DBG_ASSERT( m_pFileDlg, "DocumentInserter::DialogClosedHdl(): no file dialog" ); + + m_nError = m_pFileDlg->GetError(); + if ( ERRCODE_NONE == m_nError ) + impl_FillURLList( m_pFileDlg.get(), m_pURLList ); + + Reference < XFilePicker3 > xFP = m_pFileDlg->GetFilePicker(); + Reference < XFilePickerControlAccess > xCtrlAccess( xFP, UNO_QUERY ); + if ( xCtrlAccess.is() ) + { + // always create a new itemset + m_xItemSet = std::make_shared<SfxAllItemSet>( SfxGetpApp()->GetPool() ); + + short nDlgType = m_pFileDlg->GetDialogType(); + bool bHasPassword = ( + TemplateDescription::FILESAVE_AUTOEXTENSION_PASSWORD == nDlgType + || TemplateDescription::FILESAVE_AUTOEXTENSION_PASSWORD_FILTEROPTIONS == nDlgType ); + + // check, whether or not we have to display a password box + if ( bHasPassword && m_pFileDlg->IsPasswordEnabled() ) + { + try + { + Any aValue = xCtrlAccess->getValue( ExtendedFilePickerElementIds::CHECKBOX_PASSWORD, 0 ); + bool bPassWord = false; + if ( ( aValue >>= bPassWord ) && bPassWord ) + { + // ask for the password + SfxPasswordDialog aPasswordDlg(m_pParent); + aPasswordDlg.ShowExtras( SfxShowExtras::CONFIRM ); + short nRet = aPasswordDlg.run(); + if ( RET_OK == nRet ) + { + m_xItemSet->Put( SfxStringItem( SID_PASSWORD, aPasswordDlg.GetPassword() ) ); + } + else + { + m_xItemSet.reset(); + return; + } + } + } + catch( const IllegalArgumentException& ){} + } + + if ( m_nDlgFlags & FileDialogFlags::Export ) + { + try + { + Any aValue = xCtrlAccess->getValue( ExtendedFilePickerElementIds::CHECKBOX_SELECTION, 0 ); + bool bSelection = false; + if ( aValue >>= bSelection ) + m_xItemSet->Put( SfxBoolItem( SID_SELECTION, bSelection ) ); + } + catch( const IllegalArgumentException& ) + { + TOOLS_WARN_EXCEPTION( "sfx.doc", "FileDialogHelper_Impl::execute: caught an IllegalArgumentException!" ); + } + } + + + // set the read-only flag. When inserting a file, this flag is always set + if ( m_nDlgFlags & FileDialogFlags::Insert ) + m_xItemSet->Put( SfxBoolItem( SID_DOC_READONLY, true ) ); + else + { + if ( TemplateDescription::FILEOPEN_READONLY_VERSION == nDlgType ) + { + try + { + Any aValue = xCtrlAccess->getValue( ExtendedFilePickerElementIds::CHECKBOX_READONLY, 0 ); + bool bReadOnly = false; + if ( ( aValue >>= bReadOnly ) && bReadOnly ) + m_xItemSet->Put( SfxBoolItem( SID_DOC_READONLY, bReadOnly ) ); + } + catch( const IllegalArgumentException& ) + { + TOOLS_WARN_EXCEPTION( "sfx.doc", "FileDialogHelper_Impl::execute: caught an IllegalArgumentException!" ); + } + } + } + + if ( TemplateDescription::FILEOPEN_READONLY_VERSION == nDlgType ) + { + try + { + Any aValue = xCtrlAccess->getValue( ExtendedFilePickerElementIds::LISTBOX_VERSION, + ControlActions::GET_SELECTED_ITEM_INDEX ); + sal_Int32 nVersion = 0; + if ( ( aValue >>= nVersion ) && nVersion > 0 ) + // open a special version; 0 == current version + m_xItemSet->Put( SfxInt16Item( SID_VERSION, static_cast<short>(nVersion) ) ); + } + catch( const IllegalArgumentException& ){} + } + } + + m_sFilter = m_pFileDlg->GetRealFilter(); + + m_aDialogClosedLink.Call( m_pFileDlg.get() ); +} + +} // namespace sfx2 + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/docmacromode.cxx b/sfx2/source/doc/docmacromode.cxx new file mode 100644 index 000000000..3a8684113 --- /dev/null +++ b/sfx2/source/doc/docmacromode.cxx @@ -0,0 +1,431 @@ +/* -*- 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 <config_features.h> + +#include <sfx2/docmacromode.hxx> +#include <sfx2/signaturestate.hxx> +#include <sfx2/docfile.hxx> + +#include <com/sun/star/document/MacroExecMode.hpp> +#include <com/sun/star/task/ErrorCodeRequest.hpp> +#include <com/sun/star/task/DocumentMacroConfirmationRequest.hpp> +#include <com/sun/star/security/DocumentDigitalSignatures.hpp> +#include <com/sun/star/script/XLibraryContainer.hpp> +#include <com/sun/star/document/XEmbeddedScripts.hpp> + +#include <comphelper/processfactory.hxx> +#include <framework/interaction.hxx> +#include <osl/file.hxx> +#include <unotools/securityoptions.hxx> +#include <svtools/sfxecode.hxx> +#include <tools/diagnose_ex.h> +#include <tools/urlobj.hxx> + + +namespace sfx2 +{ + + + using ::com::sun::star::uno::Reference; + using ::com::sun::star::task::XInteractionHandler; + using ::com::sun::star::uno::Any; + using ::com::sun::star::uno::Sequence; + using ::com::sun::star::task::DocumentMacroConfirmationRequest; + using ::com::sun::star::task::ErrorCodeRequest; + using ::com::sun::star::uno::Exception; + using ::com::sun::star::security::DocumentDigitalSignatures; + using ::com::sun::star::security::XDocumentDigitalSignatures; + using ::com::sun::star::embed::XStorage; + using ::com::sun::star::document::XEmbeddedScripts; + using ::com::sun::star::script::XLibraryContainer; + using ::com::sun::star::container::XNameAccess; + using ::com::sun::star::uno::UNO_QUERY_THROW; + + namespace MacroExecMode = ::com::sun::star::document::MacroExecMode; + + + //= DocumentMacroMode_Data + + struct DocumentMacroMode_Data + { + IMacroDocumentAccess& m_rDocumentAccess; + bool m_bMacroDisabledMessageShown; + bool m_bDocMacroDisabledMessageShown; + + explicit DocumentMacroMode_Data( IMacroDocumentAccess& rDocumentAccess ) + :m_rDocumentAccess( rDocumentAccess ) + ,m_bMacroDisabledMessageShown( false ) + ,m_bDocMacroDisabledMessageShown( false ) + { + } + }; + + + //= helper + + namespace + { + + void lcl_showGeneralSfxErrorOnce( const Reference< XInteractionHandler >& rxHandler, ErrCode nSfxErrorCode, bool& rbAlreadyShown ) + { + if ( rbAlreadyShown ) + return; + + ErrorCodeRequest aErrorCodeRequest; + aErrorCodeRequest.ErrCode = sal_uInt32(nSfxErrorCode); + + SfxMedium::CallApproveHandler( rxHandler, Any( aErrorCodeRequest ), false ); + rbAlreadyShown = true; + } + + + void lcl_showMacrosDisabledError( const Reference< XInteractionHandler >& rxHandler, bool& rbAlreadyShown ) + { + lcl_showGeneralSfxErrorOnce( rxHandler, ERRCODE_SFX_MACROS_SUPPORT_DISABLED, rbAlreadyShown ); + } + + + void lcl_showDocumentMacrosDisabledError( const Reference< XInteractionHandler >& rxHandler, bool& rbAlreadyShown ) + { +#ifdef MACOSX + lcl_showGeneralSfxErrorOnce( rxHandler, ERRCODE_SFX_DOCUMENT_MACRO_DISABLED_MAC, rbAlreadyShown ); +#else + lcl_showGeneralSfxErrorOnce( rxHandler, ERRCODE_SFX_DOCUMENT_MACRO_DISABLED, rbAlreadyShown ); +#endif + } + + void lcl_showMacrosDisabledUnsignedContentError( const Reference< XInteractionHandler >& rxHandler, bool& rbAlreadyShown ) + { + lcl_showGeneralSfxErrorOnce( rxHandler, ERRCODE_SFX_DOCUMENT_MACRO_DISABLED_CONTENT_UNSIGNED, rbAlreadyShown ); + } + + bool lcl_showMacroWarning( const Reference< XInteractionHandler >& rxHandler, + const OUString& rDocumentLocation ) + { + DocumentMacroConfirmationRequest aRequest; + aRequest.DocumentURL = rDocumentLocation; + return SfxMedium::CallApproveHandler( rxHandler, Any( aRequest ), true ); + } + } + + //= DocumentMacroMode + DocumentMacroMode::DocumentMacroMode( IMacroDocumentAccess& rDocumentAccess ) + :m_xData( std::make_shared<DocumentMacroMode_Data>( rDocumentAccess ) ) + { + } + + bool DocumentMacroMode::allowMacroExecution() + { + m_xData->m_rDocumentAccess.setCurrentMacroExecMode( MacroExecMode::ALWAYS_EXECUTE_NO_WARN ); + return true; + } + + bool DocumentMacroMode::disallowMacroExecution() + { + m_xData->m_rDocumentAccess.setCurrentMacroExecMode( MacroExecMode::NEVER_EXECUTE ); + return false; + } + + bool DocumentMacroMode::adjustMacroMode( const Reference< XInteractionHandler >& rxInteraction, bool bHasValidContentSignature ) + { + sal_uInt16 nMacroExecutionMode = m_xData->m_rDocumentAccess.getCurrentMacroExecMode(); + + if ( SvtSecurityOptions::IsMacroDisabled() ) + { + // no macro should be executed at all + lcl_showMacrosDisabledError( rxInteraction, m_xData->m_bMacroDisabledMessageShown ); + return disallowMacroExecution(); + } + + // get setting from configuration if required + enum AutoConfirmation + { + eNoAutoConfirm, + eAutoConfirmApprove, + eAutoConfirmReject + }; + AutoConfirmation eAutoConfirm( eNoAutoConfirm ); + + if ( ( nMacroExecutionMode == MacroExecMode::USE_CONFIG ) + || ( nMacroExecutionMode == MacroExecMode::USE_CONFIG_REJECT_CONFIRMATION ) + || ( nMacroExecutionMode == MacroExecMode::USE_CONFIG_APPROVE_CONFIRMATION ) + ) + { + // check confirm first, as nMacroExecutionMode is always overwritten by the GetMacroSecurityLevel() switch + if (nMacroExecutionMode == MacroExecMode::USE_CONFIG_REJECT_CONFIRMATION) + eAutoConfirm = eAutoConfirmReject; + else if (nMacroExecutionMode == MacroExecMode::USE_CONFIG_APPROVE_CONFIRMATION) + eAutoConfirm = eAutoConfirmApprove; + + switch ( SvtSecurityOptions::GetMacroSecurityLevel() ) + { + case 3: + nMacroExecutionMode = MacroExecMode::FROM_LIST_NO_WARN; + break; + case 2: + nMacroExecutionMode = MacroExecMode::FROM_LIST_AND_SIGNED_WARN; + break; + case 1: + nMacroExecutionMode = MacroExecMode::ALWAYS_EXECUTE; + break; + case 0: + nMacroExecutionMode = MacroExecMode::ALWAYS_EXECUTE_NO_WARN; + break; + default: + OSL_FAIL( "DocumentMacroMode::adjustMacroMode: unexpected macro security level!" ); + nMacroExecutionMode = MacroExecMode::NEVER_EXECUTE; + } + } + + if ( nMacroExecutionMode == MacroExecMode::NEVER_EXECUTE ) + return false; + + if ( nMacroExecutionMode == MacroExecMode::ALWAYS_EXECUTE_NO_WARN ) + return true; + + try + { + // get document location from medium name and check whether it is a trusted one + // the service is created without document version, since it is not of interest here + Reference< XDocumentDigitalSignatures > xSignatures(DocumentDigitalSignatures::createDefault(::comphelper::getProcessComponentContext())); + INetURLObject aURLReferer( m_xData->m_rDocumentAccess.getDocumentLocation() ); + + OUString aLocation; + if ( aURLReferer.removeSegment() ) + aLocation = aURLReferer.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + + if ( !aLocation.isEmpty() && xSignatures->isLocationTrusted( aLocation ) ) + { + return allowMacroExecution(); + } + + // at this point it is clear that the document is not in the secure location + if ( nMacroExecutionMode == MacroExecMode::FROM_LIST_NO_WARN ) + { + lcl_showDocumentMacrosDisabledError( rxInteraction, m_xData->m_bDocMacroDisabledMessageShown ); + return disallowMacroExecution(); + } + + // check whether the document is signed with trusted certificate + if ( nMacroExecutionMode != MacroExecMode::FROM_LIST ) + { + // the trusted macro check will also retrieve the signature state ( small optimization ) + const bool bAllowUIToAddAuthor = nMacroExecutionMode != MacroExecMode::FROM_LIST_AND_SIGNED_NO_WARN + && (nMacroExecutionMode == MacroExecMode::ALWAYS_EXECUTE + || !SvtSecurityOptions::IsReadOnly(SvtSecurityOptions::EOption::MacroTrustedAuthors)); + const bool bHasTrustedMacroSignature = m_xData->m_rDocumentAccess.hasTrustedScriptingSignature(bAllowUIToAddAuthor); + + SignatureState nSignatureState = m_xData->m_rDocumentAccess.getScriptingSignatureState(); + if ( nSignatureState == SignatureState::BROKEN ) + { + if (!bAllowUIToAddAuthor) + lcl_showDocumentMacrosDisabledError(rxInteraction, m_xData->m_bDocMacroDisabledMessageShown); + return disallowMacroExecution(); + } + else if ( m_xData->m_rDocumentAccess.macroCallsSeenWhileLoading() && + bHasTrustedMacroSignature && + !bHasValidContentSignature) + { + // When macros are signed, and the document has events which call macros, the document content needs to be signed too. + lcl_showMacrosDisabledUnsignedContentError(rxInteraction, m_xData->m_bDocMacroDisabledMessageShown); + return disallowMacroExecution(); + } + else if ( bHasTrustedMacroSignature ) + { + // there is trusted macro signature, allow macro execution + return allowMacroExecution(); + } + else if ( nSignatureState == SignatureState::OK + || nSignatureState == SignatureState::NOTVALIDATED ) + { + // there is valid signature, but it is not from the trusted author + if (!bAllowUIToAddAuthor) + lcl_showDocumentMacrosDisabledError(rxInteraction, m_xData->m_bDocMacroDisabledMessageShown); + return disallowMacroExecution(); + } + } + + // at this point it is clear that the document is neither in secure location nor signed with trusted certificate + if ( ( nMacroExecutionMode == MacroExecMode::FROM_LIST_AND_SIGNED_NO_WARN ) + || ( nMacroExecutionMode == MacroExecMode::FROM_LIST_AND_SIGNED_WARN ) + ) + { + if ( nMacroExecutionMode == MacroExecMode::FROM_LIST_AND_SIGNED_WARN ) + lcl_showDocumentMacrosDisabledError( rxInteraction, m_xData->m_bDocMacroDisabledMessageShown ); + + return disallowMacroExecution(); + } + } + catch ( const Exception& ) + { + if ( ( nMacroExecutionMode == MacroExecMode::FROM_LIST_NO_WARN ) + || ( nMacroExecutionMode == MacroExecMode::FROM_LIST_AND_SIGNED_WARN ) + || ( nMacroExecutionMode == MacroExecMode::FROM_LIST_AND_SIGNED_NO_WARN ) + ) + { + return disallowMacroExecution(); + } + } + + // confirmation is required + bool bSecure = false; + + if ( eAutoConfirm == eNoAutoConfirm ) + { + OUString sReferrer( m_xData->m_rDocumentAccess.getDocumentLocation() ); + + OUString aSystemFileURL; + if ( osl::FileBase::getSystemPathFromFileURL( sReferrer, aSystemFileURL ) == osl::FileBase::E_None ) + sReferrer = aSystemFileURL; + + bSecure = lcl_showMacroWarning( rxInteraction, sReferrer ); + } + else + bSecure = ( eAutoConfirm == eAutoConfirmApprove ); + + return ( bSecure ? allowMacroExecution() : disallowMacroExecution() ); + } + + + bool DocumentMacroMode::isMacroExecutionDisallowed() const + { + return m_xData->m_rDocumentAccess.getCurrentMacroExecMode() == MacroExecMode::NEVER_EXECUTE; + } + + + bool DocumentMacroMode::containerHasBasicMacros( const Reference< XLibraryContainer >& xContainer ) + { + bool bHasMacroLib = false; + try + { + if ( xContainer.is() ) + { + // a library container exists; check if it's empty + + // if there are libraries except the "Standard" library + // we assume that they are not empty (because they have been created by the user) + if ( !xContainer->hasElements() ) + bHasMacroLib = false; + else + { + static const OUStringLiteral aStdLibName( u"Standard" ); + static const OUStringLiteral aVBAProject( u"VBAProject" ); + const Sequence< OUString > aElements = xContainer->getElementNames(); + for( const OUString& aElement : aElements ) + { + if( aElement == aStdLibName || aElement == aVBAProject ) + { + Reference < XNameAccess > xLib; + Any aAny = xContainer->getByName( aElement ); + aAny >>= xLib; + if ( xLib.is() && xLib->hasElements() ) + return true; + } + else + return true; + } + } + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("sfx.doc"); + } + return bHasMacroLib; + } + + + bool DocumentMacroMode::hasMacroLibrary() const + { + bool bHasMacroLib = false; +#if HAVE_FEATURE_SCRIPTING + try + { + Reference< XEmbeddedScripts > xScripts( m_xData->m_rDocumentAccess.getEmbeddedDocumentScripts() ); + Reference< XLibraryContainer > xContainer; + if ( xScripts.is() ) + xContainer.set( xScripts->getBasicLibraries(), UNO_QUERY_THROW ); + bHasMacroLib = containerHasBasicMacros( xContainer ); + + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("sfx.doc"); + } +#endif + return bHasMacroLib; + } + + + bool DocumentMacroMode::storageHasMacros( const Reference< XStorage >& rxStorage ) + { + bool bHasMacros = false; + if ( rxStorage.is() ) + { + try + { + static constexpr OUStringLiteral s_sBasicStorageName( u"Basic" ); + static constexpr OUStringLiteral s_sScriptsStorageName( u"Scripts" ); + + bHasMacros =( ( rxStorage->hasByName( s_sBasicStorageName ) + && rxStorage->isStorageElement( s_sBasicStorageName ) + ) + || ( rxStorage->hasByName( s_sScriptsStorageName ) + && rxStorage->isStorageElement( s_sScriptsStorageName ) + ) + ); + } + catch ( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("sfx.doc"); + } + } + return bHasMacros; + } + + + bool DocumentMacroMode::checkMacrosOnLoading( const Reference< XInteractionHandler >& rxInteraction, bool bHasValidContentSignature ) + { + bool bAllow = false; + if ( SvtSecurityOptions::IsMacroDisabled() ) + { + // no macro should be executed at all + bAllow = disallowMacroExecution(); + } + else + { + if (m_xData->m_rDocumentAccess.documentStorageHasMacros() || hasMacroLibrary() || m_xData->m_rDocumentAccess.macroCallsSeenWhileLoading()) + { + bAllow = adjustMacroMode( rxInteraction, bHasValidContentSignature ); + } + else if ( !isMacroExecutionDisallowed() ) + { + // if macros will be added by the user later, the security check is obsolete + bAllow = allowMacroExecution(); + } + } + return bAllow; + } + + +} // namespace sfx2 + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/docstoragemodifylistener.cxx b/sfx2/source/doc/docstoragemodifylistener.cxx new file mode 100644 index 000000000..5c68c2bb8 --- /dev/null +++ b/sfx2/source/doc/docstoragemodifylistener.cxx @@ -0,0 +1,73 @@ +/* -*- 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 <sfx2/docstoragemodifylistener.hxx> +#include <comphelper/solarmutex.hxx> + + +namespace sfx2 +{ + + + using ::com::sun::star::lang::EventObject; + + + //= + + + DocumentStorageModifyListener::DocumentStorageModifyListener( IModifiableDocument& _rDocument, comphelper::SolarMutex& _rMutex ) + :m_pDocument( &_rDocument ) + ,m_rMutex( _rMutex ) + { + } + + + DocumentStorageModifyListener::~DocumentStorageModifyListener() + { + } + + + void DocumentStorageModifyListener::dispose() + { + ::osl::Guard< comphelper::SolarMutex > aGuard( m_rMutex ); + m_pDocument = nullptr; + } + + + void SAL_CALL DocumentStorageModifyListener::modified( const EventObject& /*aEvent*/ ) + { + ::osl::Guard< comphelper::SolarMutex > aGuard( m_rMutex ); + // storageIsModified must not contain any locking! + if ( m_pDocument ) + m_pDocument->storageIsModified(); + } + + + void SAL_CALL DocumentStorageModifyListener::disposing( const EventObject& /*Source*/ ) + { + // not interested in. In particular, we do *not* dispose ourself when a storage we're + // listening at is disposed. The reason here is that this listener instance is *reused* + // in case the document is re-based to another storage. + } + + +} // namespace sfx2 + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/doctempl.cxx b/sfx2/source/doc/doctempl.cxx new file mode 100644 index 000000000..ebf2ddce4 --- /dev/null +++ b/sfx2/source/doc/doctempl.cxx @@ -0,0 +1,1745 @@ +/* -*- 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 <limits.h> +#include <string_view> + +#include <com/sun/star/uno/Any.h> +#include <osl/mutex.hxx> +#include <sal/log.hxx> + +#include <unotools/pathoptions.hxx> +#include <tools/urlobj.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> +#include <comphelper/processfactory.hxx> +#include <comphelper/propertyvalue.hxx> +#include <ucbhelper/content.hxx> +#include <com/sun/star/beans/PropertyValue.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/beans/XPropertySetInfo.hpp> +#include <com/sun/star/document/XTypeDetection.hpp> +#include <com/sun/star/document/DocumentProperties.hpp> +#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp> +#include <com/sun/star/frame/Desktop.hpp> +#include <com/sun/star/frame/DocumentTemplates.hpp> +#include <com/sun/star/frame/XDocumentTemplates.hpp> +#include <com/sun/star/io/IOException.hpp> +#include <com/sun/star/io/XPersist.hpp> +#include <com/sun/star/lang/XLocalizable.hpp> +#include <com/sun/star/sdbc/XResultSet.hpp> +#include <com/sun/star/sdbc/XRow.hpp> +#include <com/sun/star/ucb/ContentCreationException.hpp> +#include <com/sun/star/ucb/NameClash.hpp> +#include <com/sun/star/ucb/TransferInfo.hpp> +#include <com/sun/star/ucb/XContent.hpp> +#include <com/sun/star/ucb/XContentAccess.hpp> +#include <com/sun/star/ucb/AnyCompareFactory.hpp> +#include <com/sun/star/ucb/NumberedSortingInfo.hpp> + +#include "doctemplateslocal.hxx" +#include <sfxurlrelocator.hxx> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::frame; +using namespace ::com::sun::star::io; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::sdbc; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::ucb; +using namespace ::com::sun::star::document; +using namespace ::rtl; +using namespace ::ucbhelper; + + +#include <sfx2/doctempl.hxx> +#include <sfx2/objsh.hxx> +#include <sfx2/sfxresid.hxx> +#include <sfx2/strings.hrc> +#include <strings.hxx> +#include <svtools/templatefoldercache.hxx> + +#include <memory> +#include <vector> + + +constexpr OUStringLiteral TITLE = u"Title"; +constexpr OUStringLiteral TARGET_URL = u"TargetURL"; + +constexpr OUStringLiteral COMMAND_TRANSFER = u"transfer"; + +namespace { + +class RegionData_Impl; + +} + +namespace DocTempl { + +namespace { + +class DocTempl_EntryData_Impl +{ + RegionData_Impl* mpParent; + + // the following member must be SfxObjectShellLock since it controls that SfxObjectShell lifetime by design + // and users of this class expect it to be so. + SfxObjectShellLock mxObjShell; + + OUString maTitle; + OUString maOwnURL; + OUString maTargetURL; + +public: + DocTempl_EntryData_Impl( RegionData_Impl* pParent, + const OUString& rTitle ); + + const OUString& GetTitle() const { return maTitle; } + const OUString& GetTargetURL(); + const OUString& GetHierarchyURL(); + + void SetTitle( const OUString& rTitle ) { maTitle = rTitle; } + void SetTargetURL( const OUString& rURL ) { maTargetURL = rURL; } + void SetHierarchyURL( const OUString& rURL) { maOwnURL = rURL; } + + int Compare( std::u16string_view rTitle ) const; +}; + +} + +} + +using namespace ::DocTempl; + +namespace { + +class RegionData_Impl +{ + const SfxDocTemplate_Impl* mpParent; + std::vector<std::unique_ptr<DocTempl_EntryData_Impl>> maEntries; + OUString maTitle; + OUString maOwnURL; + +private: + size_t GetEntryPos( std::u16string_view rTitle, + bool& rFound ) const; + +public: + RegionData_Impl( const SfxDocTemplate_Impl* pParent, + const OUString& rTitle ); + + void SetHierarchyURL( const OUString& rURL) { maOwnURL = rURL; } + + DocTempl_EntryData_Impl* GetEntry( size_t nIndex ) const; + DocTempl_EntryData_Impl* GetEntry( std::u16string_view rName ) const; + + const OUString& GetTitle() const { return maTitle; } + const OUString& GetHierarchyURL(); + + size_t GetCount() const; + + void SetTitle( const OUString& rTitle ) { maTitle = rTitle; } + + void AddEntry( const OUString& rTitle, + const OUString& rTargetURL, + const size_t *pPos ); + void DeleteEntry( size_t nIndex ); + + int Compare( RegionData_Impl const * pCompareWith ) const; +}; + +} + +class SfxDocTemplate_Impl : public SvRefBase +{ + uno::Reference< XPersist > mxInfo; + uno::Reference< XDocumentTemplates > mxTemplates; + + ::osl::Mutex maMutex; + OUString maRootURL; + OUString maStandardGroup; + std::vector<std::unique_ptr<RegionData_Impl>> maRegions; + bool mbConstructed; + + uno::Reference< XAnyCompareFactory > m_rCompareFactory; + + // the following member is intended to prevent clearing of the global data when it is in use + // TODO/LATER: it still does not make the implementation complete thread-safe + sal_Int32 mnLockCounter; + +private: + void Clear(); + +public: + SfxDocTemplate_Impl(); + virtual ~SfxDocTemplate_Impl() override; + + void IncrementLock(); + void DecrementLock(); + + bool Construct( ); + void CreateFromHierarchy( Content &rTemplRoot ); + void ReInitFromComponent(); + void AddRegion( const OUString& rTitle, + Content& rContent ); + + void Rescan(); + + void DeleteRegion( size_t nIndex ); + + size_t GetRegionCount() const + { return maRegions.size(); } + RegionData_Impl* GetRegion( std::u16string_view rName ) const; + RegionData_Impl* GetRegion( size_t nIndex ) const; + + bool GetTitleFromURL( const OUString& rURL, OUString& aTitle ); + bool InsertRegion( std::unique_ptr<RegionData_Impl> pData, size_t nPos ); + const OUString& GetRootURL() const { return maRootURL; } + + const uno::Reference< XDocumentTemplates >& getDocTemplates() const { return mxTemplates; } +}; + +namespace { + +class DocTemplLocker_Impl +{ + SfxDocTemplate_Impl& m_aDocTempl; +public: + explicit DocTemplLocker_Impl( SfxDocTemplate_Impl& aDocTempl ) + : m_aDocTempl( aDocTempl ) + { + m_aDocTempl.IncrementLock(); + } + + ~DocTemplLocker_Impl() + { + m_aDocTempl.DecrementLock(); + } +}; + +} + +static SfxDocTemplate_Impl *gpTemplateData = nullptr; + + +static bool getTextProperty_Impl( Content& rContent, + const OUString& rPropName, + OUString& rPropValue ); + + +OUString SfxDocumentTemplates::GetFullRegionName +( + sal_uInt16 nIdx // Region Index +) const + +/* [Description] + + Returns the logical name of a region and its path + + [Return value] Reference to the Region name + +*/ + +{ + // First: find the RegionData for the index + + DocTemplLocker_Impl aLocker( *pImp ); + + if ( pImp->Construct() ) + { + RegionData_Impl *pData1 = pImp->GetRegion( nIdx ); + + if ( pData1 ) + return pData1->GetTitle(); + + // --**-- here was some code which appended the path to the + // group if there was more than one with the same name. + // this should not happen anymore + } + + return OUString(); +} + + +OUString SfxDocumentTemplates::GetRegionName +( + sal_uInt16 nIdx // Region Index +) const + +/* [Description] + + Returns the logical name of a region + + [Return value] + + const String& Reference to the Region name + +*/ +{ + DocTemplLocker_Impl aLocker( *pImp ); + + if ( pImp->Construct() ) + { + RegionData_Impl *pData = pImp->GetRegion( nIdx ); + + if ( pData ) + return pData->GetTitle(); + } + + return OUString(); +} + + +sal_uInt16 SfxDocumentTemplates::GetRegionCount() const + +/* [Description] + + Returns the number of Regions + + [Return value] + + sal_uInt16 Number of Regions +*/ +{ + DocTemplLocker_Impl aLocker( *pImp ); + + if ( !pImp->Construct() ) + return 0; + + return pImp->GetRegionCount(); +} + + +sal_uInt16 SfxDocumentTemplates::GetCount +( + sal_uInt16 nRegion /* Region index whose number is + to be determined */ + +) const + +/* [Description] + + Number of entries in Region + + [Return value] Number of entries +*/ + +{ + DocTemplLocker_Impl aLocker( *pImp ); + + if ( !pImp->Construct() ) + return 0; + + RegionData_Impl *pData = pImp->GetRegion( nRegion ); + + if ( !pData ) + return 0; + + return pData->GetCount(); +} + + +OUString SfxDocumentTemplates::GetName +( + sal_uInt16 nRegion, // Region Index, in which the entry lies + sal_uInt16 nIdx // Index of the entry +) const + +/* [Description] + + Returns the logical name of an entry in Region + + [Return value] + + const String& Entry Name +*/ + +{ + DocTemplLocker_Impl aLocker( *pImp ); + + if ( pImp->Construct() ) + { + RegionData_Impl *pRegion = pImp->GetRegion( nRegion ); + + if ( pRegion ) + { + DocTempl_EntryData_Impl *pEntry = pRegion->GetEntry( nIdx ); + if ( pEntry ) + return pEntry->GetTitle(); + } + } + + return OUString(); +} + + +OUString SfxDocumentTemplates::GetPath +( + sal_uInt16 nRegion, // Region Index, in which the entry lies + sal_uInt16 nIdx // Index of the entry +) const + +/* [Description] + + Returns the file name with full path to the file assigned to an entry + + [Return value] + + String File name with full path +*/ +{ + DocTemplLocker_Impl aLocker( *pImp ); + + if ( !pImp->Construct() ) + return OUString(); + + RegionData_Impl *pRegion = pImp->GetRegion( nRegion ); + + if ( pRegion ) + { + DocTempl_EntryData_Impl *pEntry = pRegion->GetEntry( nIdx ); + if ( pEntry ) + return pEntry->GetTargetURL(); + } + + return OUString(); +} + + +OUString SfxDocumentTemplates::GetTemplateTargetURLFromComponent( std::u16string_view aGroupName, + std::u16string_view aTitle ) +{ + DocTemplLocker_Impl aLocker( *pImp ); + + INetURLObject aTemplateObj( pImp->GetRootURL() ); + + aTemplateObj.insertName( aGroupName, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + + aTemplateObj.insertName( aTitle, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + + + Content aTemplate; + uno::Reference< XCommandEnvironment > aCmdEnv; + if ( Content::create( aTemplateObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ), aCmdEnv, comphelper::getProcessComponentContext(), aTemplate ) ) + { + OUString aResult; + getTextProperty_Impl( aTemplate, TARGET_URL, aResult ); + return SvtPathOptions().SubstituteVariable( aResult ); + } + + return OUString(); +} + + +/** Convert a template name to its localised pair if it exists. + @param rString + Name to be translated. + @return + The localised pair of rString or rString if the former does not exist. +*/ +OUString SfxDocumentTemplates::ConvertResourceString(const OUString& rString) +{ + static constexpr rtl::OUStringConstExpr aTemplateNames[] = + { + STR_TEMPLATE_NAME1_DEF, + STR_TEMPLATE_NAME2_DEF, + STR_TEMPLATE_NAME3_DEF, + STR_TEMPLATE_NAME4_DEF, + STR_TEMPLATE_NAME5_DEF, + STR_TEMPLATE_NAME6_DEF, + STR_TEMPLATE_NAME7_DEF, + STR_TEMPLATE_NAME8_DEF, + STR_TEMPLATE_NAME9_DEF, + STR_TEMPLATE_NAME10_DEF, + STR_TEMPLATE_NAME11_DEF, + STR_TEMPLATE_NAME12_DEF, + STR_TEMPLATE_NAME13_DEF, + STR_TEMPLATE_NAME14_DEF, + STR_TEMPLATE_NAME15_DEF, + STR_TEMPLATE_NAME16_DEF, + STR_TEMPLATE_NAME17_DEF, + STR_TEMPLATE_NAME18_DEF, + STR_TEMPLATE_NAME19_DEF, + STR_TEMPLATE_NAME20_DEF, + STR_TEMPLATE_NAME21_DEF, + STR_TEMPLATE_NAME22_DEF, + STR_TEMPLATE_NAME23_DEF, + STR_TEMPLATE_NAME24_DEF, + STR_TEMPLATE_NAME25_DEF, + STR_TEMPLATE_NAME26_DEF, + STR_TEMPLATE_NAME27_DEF, + STR_TEMPLATE_NAME28_DEF, + STR_TEMPLATE_NAME29_DEF, + STR_TEMPLATE_NAME30_DEF, + STR_TEMPLATE_NAME31_DEF, + STR_TEMPLATE_NAME32_DEF, + }; + + TranslateId STR_TEMPLATE_NAME[] = + { + STR_TEMPLATE_NAME1, + STR_TEMPLATE_NAME2, + STR_TEMPLATE_NAME3, + STR_TEMPLATE_NAME4, + STR_TEMPLATE_NAME5, + STR_TEMPLATE_NAME6, + STR_TEMPLATE_NAME7, + STR_TEMPLATE_NAME8, + STR_TEMPLATE_NAME9, + STR_TEMPLATE_NAME10, + STR_TEMPLATE_NAME11, + STR_TEMPLATE_NAME12, + STR_TEMPLATE_NAME13, + STR_TEMPLATE_NAME14, + STR_TEMPLATE_NAME15, + STR_TEMPLATE_NAME16, + STR_TEMPLATE_NAME17, + STR_TEMPLATE_NAME18, + STR_TEMPLATE_NAME19, + STR_TEMPLATE_NAME20, + STR_TEMPLATE_NAME21, + STR_TEMPLATE_NAME22, + STR_TEMPLATE_NAME23, + STR_TEMPLATE_NAME24, + STR_TEMPLATE_NAME25, + STR_TEMPLATE_NAME26, + STR_TEMPLATE_NAME27, + STR_TEMPLATE_NAME28, + STR_TEMPLATE_NAME29, + STR_TEMPLATE_NAME30, + STR_TEMPLATE_NAME31, + STR_TEMPLATE_NAME32, + }; + + static_assert(SAL_N_ELEMENTS(aTemplateNames) == SAL_N_ELEMENTS(STR_TEMPLATE_NAME)); + + for (size_t i = 0; i < SAL_N_ELEMENTS(STR_TEMPLATE_NAME); ++i) + { + if (rString == aTemplateNames[i]) + return SfxResId(STR_TEMPLATE_NAME[i]); + } + return rString; +} + + +bool SfxDocumentTemplates::CopyOrMove +( + sal_uInt16 nTargetRegion, // Target Region Index + sal_uInt16 nTargetIdx, // Target position Index + sal_uInt16 nSourceRegion, // Source Region Index + sal_uInt16 nSourceIdx, /* Index to be copied / to moved template */ + bool bMove // Copy / Move +) + +/* [Description] + + Copy or move a document template + + [Return value] + + sal_Bool sal_True, Action could be performed + sal_False, Action could not be performed + + [Cross-references] + + <SfxDocumentTemplates::Move(sal_uInt16,sal_uInt16,sal_uInt16,sal_uInt16)> + <SfxDocumentTemplates::Copy(sal_uInt16,sal_uInt16,sal_uInt16,sal_uInt16)> +*/ + +{ + /* to perform a copy or move, we need to send a transfer command to + the destination folder with the URL of the source as parameter. + ( If the destination content doesn't support the transfer command, + we could try a copy ( and delete ) instead. ) + We need two transfers ( one for the real template and one for its + representation in the hierarchy ) + ... + */ + + DocTemplLocker_Impl aLocker( *pImp ); + + if ( !pImp->Construct() ) + return false; + + // Don't copy or move any folders + if( nSourceIdx == USHRT_MAX ) + return false ; + + if ( nSourceRegion == nTargetRegion ) + { + SAL_WARN( "sfx.doc", "Don't know, what to do!" ); + return false; + } + + RegionData_Impl *pSourceRgn = pImp->GetRegion( nSourceRegion ); + if ( !pSourceRgn ) + return false; + + DocTempl_EntryData_Impl *pSource = pSourceRgn->GetEntry( nSourceIdx ); + if ( !pSource ) + return false; + + RegionData_Impl *pTargetRgn = pImp->GetRegion( nTargetRegion ); + if ( !pTargetRgn ) + return false; + + const OUString aTitle = pSource->GetTitle(); + + uno::Reference< XDocumentTemplates > xTemplates = pImp->getDocTemplates(); + + if ( xTemplates->addTemplate( pTargetRgn->GetTitle(), + aTitle, + pSource->GetTargetURL() ) ) + { + const OUString aNewTargetURL = GetTemplateTargetURLFromComponent( pTargetRgn->GetTitle(), aTitle ); + if ( aNewTargetURL.isEmpty() ) + return false; + + if ( bMove ) + { + // --**-- delete the original file + bool bDeleted = xTemplates->removeTemplate( pSourceRgn->GetTitle(), + pSource->GetTitle() ); + if ( bDeleted ) + pSourceRgn->DeleteEntry( nSourceIdx ); + else + { + if ( xTemplates->removeTemplate( pTargetRgn->GetTitle(), aTitle ) ) + return false; // will trigger retry with copy instead of move + + // if it is not possible to remove just created template ( must be possible! ) + // it is better to report success here, since at least the copy has succeeded + // TODO/LATER: solve it more gracefully in future + } + } + + // todo: fix SfxDocumentTemplates to handle size_t instead of sal_uInt16 + size_t temp_nTargetIdx = nTargetIdx; + pTargetRgn->AddEntry( aTitle, aNewTargetURL, &temp_nTargetIdx ); + + return true; + } + + // --**-- if the current file is opened, + // it must be re-opened afterwards. + + return false; +} + + +bool SfxDocumentTemplates::Move +( + sal_uInt16 nTargetRegion, // Target Region Index + sal_uInt16 nTargetIdx, // Target position Index + sal_uInt16 nSourceRegion, // Source Region Index + sal_uInt16 nSourceIdx /* Index to be copied / to moved template */ +) + +/* [Description] + + Moving a template + + [Return value] + + sal_Bool sal_True, Action could be performed + sal_False, Action could not be performed + + [Cross-references] + + <SfxDocumentTemplates::CopyOrMove(sal_uInt16,sal_uInt16,sal_uInt16,sal_uInt16,sal_Bool)> +*/ +{ + DocTemplLocker_Impl aLocker( *pImp ); + + return CopyOrMove( nTargetRegion, nTargetIdx, + nSourceRegion, nSourceIdx, true ); +} + + +bool SfxDocumentTemplates::Copy +( + sal_uInt16 nTargetRegion, // Target Region Index + sal_uInt16 nTargetIdx, // Target position Index + sal_uInt16 nSourceRegion, // Source Region Index + sal_uInt16 nSourceIdx /* Index to be copied / to moved template */ +) + +/* [Description] + + Copying a template + + [Return value] + + sal_Bool sal_True, Action could be performed + sal_False, Action could not be performed + + [Cross-references] + + <SfxDocumentTemplates::CopyOrMove(sal_uInt16,sal_uInt16,sal_uInt16,sal_uInt16,sal_Bool)> +*/ + +{ + DocTemplLocker_Impl aLocker( *pImp ); + + return CopyOrMove( nTargetRegion, nTargetIdx, + nSourceRegion, nSourceIdx, false ); +} + + +bool SfxDocumentTemplates::CopyTo +( + sal_uInt16 nRegion, // Region of the template to be exported + sal_uInt16 nIdx, // Index of the template to be exported + std::u16string_view rName /* File name under which the template is to + be created */ +) const + +/* [Description] + + Exporting a template into the file system + + [Return value] + + sal_Bool sal_True, Action could be performed + sal_False, Action could not be performed + + [Cross-references] + + <SfxDocumentTemplates::CopyFrom(sal_uInt16,sal_uInt16,String&)> +*/ + +{ + DocTemplLocker_Impl aLocker( *pImp ); + + if ( ! pImp->Construct() ) + return false; + + RegionData_Impl *pSourceRgn = pImp->GetRegion( nRegion ); + if ( !pSourceRgn ) + return false; + + DocTempl_EntryData_Impl *pSource = pSourceRgn->GetEntry( nIdx ); + if ( !pSource ) + return false; + + INetURLObject aTargetURL( rName ); + + const OUString aTitle( aTargetURL.getName( INetURLObject::LAST_SEGMENT, true, + INetURLObject::DecodeMechanism::WithCharset ) ); + aTargetURL.removeSegment(); + + const OUString aParentURL = aTargetURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + + uno::Reference< XCommandEnvironment > aCmdEnv; + Content aTarget; + + try + { + aTarget = Content( aParentURL, aCmdEnv, comphelper::getProcessComponentContext() ); + + TransferInfo aTransferInfo; + aTransferInfo.MoveData = false; + aTransferInfo.SourceURL = pSource->GetTargetURL(); + aTransferInfo.NewTitle = aTitle; + aTransferInfo.NameClash = NameClash::RENAME; + + Any aArg( aTransferInfo ); + aTarget.executeCommand( COMMAND_TRANSFER, aArg ); + } + catch ( ContentCreationException& ) + { return false; } + catch ( Exception& ) + { return false; } + + return true; +} + + +bool SfxDocumentTemplates::CopyFrom +( + sal_uInt16 nRegion, /* Region in which the template is to be + imported */ + sal_uInt16 nIdx, // Index of the new template in this Region + OUString& rName /* File name of the template to be imported + as an out parameter of the (automatically + generated from the file name) logical name + of the template */ +) + +/* [Description] + + Import a template from the file system + + [Return value] Success (sal_True) or serfpTargetDirectory->GetContent()); + + sal_Bool sal_True, Action could be performed + sal_False, Action could not be performed + + [Cross-references] + + <SfxDocumentTemplates::CopyTo(sal_uInt16,sal_uInt16,const String&)> +*/ + +{ + DocTemplLocker_Impl aLocker( *pImp ); + + if ( ! pImp->Construct() ) + return false; + + RegionData_Impl *pTargetRgn = pImp->GetRegion( nRegion ); + + if ( !pTargetRgn ) + return false; + + uno::Reference< XDocumentTemplates > xTemplates = pImp->getDocTemplates(); + if ( !xTemplates.is() ) + return false; + + OUString aTitle; + bool bTemplateAdded = false; + + if( pImp->GetTitleFromURL( rName, aTitle ) ) + { + bTemplateAdded = xTemplates->addTemplate( pTargetRgn->GetTitle(), aTitle, rName ); + } + else + { + uno::Reference< XDesktop2 > xDesktop = Desktop::create( ::comphelper::getProcessComponentContext() ); + + Sequence< PropertyValue > aArgs{ comphelper::makePropertyValue("Hidden", true) }; + + INetURLObject aTemplURL( rName ); + uno::Reference< XDocumentPropertiesSupplier > xDocPropsSupplier; + uno::Reference< XStorable > xStorable; + try + { + xStorable.set( + xDesktop->loadComponentFromURL( aTemplURL.GetMainURL(INetURLObject::DecodeMechanism::NONE), + "_blank", + 0, + aArgs ), + UNO_QUERY ); + + xDocPropsSupplier.set( xStorable, UNO_QUERY ); + } + catch( Exception& ) + { + } + + if( xStorable.is() ) + { + // get Title from XDocumentPropertiesSupplier + if( xDocPropsSupplier.is() ) + { + uno::Reference< XDocumentProperties > xDocProps + = xDocPropsSupplier->getDocumentProperties(); + if (xDocProps.is() ) { + aTitle = xDocProps->getTitle(); + } + } + + if( aTitle.isEmpty() ) + { + INetURLObject aURL( aTemplURL ); + aURL.CutExtension(); + aTitle = aURL.getName( INetURLObject::LAST_SEGMENT, true, + INetURLObject::DecodeMechanism::WithCharset ); + } + + // write a template using XStorable interface + bTemplateAdded = xTemplates->storeTemplate( pTargetRgn->GetTitle(), aTitle, xStorable ); + } + } + + + if( bTemplateAdded ) + { + INetURLObject aTemplObj( pTargetRgn->GetHierarchyURL() ); + aTemplObj.insertName( aTitle, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + const OUString aTemplURL = aTemplObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + + uno::Reference< XCommandEnvironment > aCmdEnv; + Content aTemplCont; + + if( Content::create( aTemplURL, aCmdEnv, comphelper::getProcessComponentContext(), aTemplCont ) ) + { + OUString aTemplName; + if( getTextProperty_Impl( aTemplCont, TARGET_URL, aTemplName ) ) + { + if ( nIdx == USHRT_MAX ) + nIdx = 0; + else + ++nIdx; + + // todo: fix SfxDocumentTemplates to handle size_t instead of sal_uInt16 + size_t temp_nIdx = nIdx; + pTargetRgn->AddEntry( aTitle, aTemplName, &temp_nIdx ); + rName = aTitle; + return true; + } + else + { + SAL_WARN( "sfx.doc", "CopyFrom(): The content should contain target URL!" ); + } + } + else + { + SAL_WARN( "sfx.doc", "CopyFrom(): The content just was created!" ); + } + } + + return false; +} + + +bool SfxDocumentTemplates::Delete +( + sal_uInt16 nRegion, // Region Index + sal_uInt16 nIdx /* Index of the entry or USHRT_MAX, + if a directory is meant. */ +) + +/* [Description] + + Deleting an entry or a directory + + [Return value] + + sal_Bool sal_True, Action could be performed + sal_False, Action could not be performed + + [Cross-references] + + <SfxDocumentTemplates::InsertDir(const String&,sal_uInt16)> + <SfxDocumentTemplates::KillDir(SfxTemplateDir&)> +*/ + +{ + DocTemplLocker_Impl aLocker( *pImp ); + + /* delete the template or folder in the hierarchy and in the + template folder by sending a delete command to the content. + Then remove the data from the lists + */ + if ( ! pImp->Construct() ) + return false; + + RegionData_Impl *pRegion = pImp->GetRegion( nRegion ); + + if ( !pRegion ) + return false; + + bool bRet; + uno::Reference< XDocumentTemplates > xTemplates = pImp->getDocTemplates(); + + if ( nIdx == USHRT_MAX ) + { + bRet = xTemplates->removeGroup( pRegion->GetTitle() ); + if ( bRet ) + pImp->DeleteRegion( nRegion ); + } + else + { + DocTempl_EntryData_Impl *pEntry = pRegion->GetEntry( nIdx ); + + if ( !pEntry ) + return false; + + bRet = xTemplates->removeTemplate( pRegion->GetTitle(), + pEntry->GetTitle() ); + if( bRet ) + pRegion->DeleteEntry( nIdx ); + } + + return bRet; +} + + +bool SfxDocumentTemplates::InsertDir +( + const OUString& rText, // the logical name of the new Region + sal_uInt16 nRegion // Region Index +) + +/* [Description] + + Insert an index + + [Return value] + + sal_Bool sal_True, Action could be performed + sal_False, Action could not be performed + + [Cross-references] + + <SfxDocumentTemplates::KillDir(SfxTemplateDir&)> +*/ +{ + DocTemplLocker_Impl aLocker( *pImp ); + + if ( ! pImp->Construct() ) + return false; + + RegionData_Impl *pRegion = pImp->GetRegion( rText ); + + if ( pRegion ) + return false; + + uno::Reference< XDocumentTemplates > xTemplates = pImp->getDocTemplates(); + + if ( xTemplates->addGroup( rText ) ) + { + return pImp->InsertRegion( std::make_unique<RegionData_Impl>( pImp.get(), rText ), nRegion ); + } + + return false; +} + +bool SfxDocumentTemplates::InsertTemplate(sal_uInt16 nSourceRegion, sal_uInt16 nIdx, const OUString &rName, const OUString &rPath) +{ + DocTemplLocker_Impl aLocker( *pImp ); + + if ( ! pImp->Construct() ) + return false; + + RegionData_Impl *pRegion = pImp->GetRegion( nSourceRegion ); + + if ( !pRegion ) + return false; + + size_t pos = nIdx; + pRegion->AddEntry( rName, rPath, &pos ); + + return true; +} + +bool SfxDocumentTemplates::SetName( const OUString& rName, sal_uInt16 nRegion, sal_uInt16 nIdx ) + +{ + DocTemplLocker_Impl aLocker( *pImp ); + + if ( ! pImp->Construct() ) + return false; + + RegionData_Impl *pRegion = pImp->GetRegion( nRegion ); + + if ( !pRegion ) + return false; + + uno::Reference< XDocumentTemplates > xTemplates = pImp->getDocTemplates(); + + if ( nIdx == USHRT_MAX ) + { + if ( pRegion->GetTitle() == rName ) + return true; + + // we have to rename a region + if ( xTemplates->renameGroup( pRegion->GetTitle(), rName ) ) + { + pRegion->SetTitle( rName ); + pRegion->SetHierarchyURL( "" ); + return true; + } + } + else + { + DocTempl_EntryData_Impl *pEntry = pRegion->GetEntry( nIdx ); + + if ( !pEntry ) + return false; + + if ( pEntry->GetTitle() == rName ) + return true; + + if ( xTemplates->renameTemplate( pRegion->GetTitle(), + pEntry->GetTitle(), + rName ) ) + { + pEntry->SetTitle( rName ); + pEntry->SetTargetURL( "" ); + pEntry->SetHierarchyURL( "" ); + return true; + } + } + + return false; +} + + +bool SfxDocumentTemplates::GetFull +( + std::u16string_view rRegion, // Region Name + std::u16string_view rName, // Template Name + OUString &rPath // Out: Path + File name +) + +/* [Description] + + Returns Path + File name of the template specified by rRegion and rName. + + [Return value] + + sal_Bool sal_True, Action could be performed + sal_False, Action could not be performed + + [Cross-references] + + <SfxDocumentTemplates::GetLogicNames(const String&,String&,String&)> +*/ + +{ + DocTemplLocker_Impl aLocker( *pImp ); + + // We don't search for empty names! + if ( rName.empty() ) + return false; + + if ( ! pImp->Construct() ) + return false; + + DocTempl_EntryData_Impl* pEntry = nullptr; + const sal_uInt16 nCount = GetRegionCount(); + + for ( sal_uInt16 i = 0; i < nCount; ++i ) + { + RegionData_Impl *pRegion = pImp->GetRegion( i ); + + if( pRegion && + ( rRegion.empty() || ( rRegion == pRegion->GetTitle() ) ) ) + { + pEntry = pRegion->GetEntry( rName ); + + if ( pEntry ) + { + rPath = pEntry->GetTargetURL(); + break; + } + } + } + + return ( pEntry != nullptr ); +} + + +bool SfxDocumentTemplates::GetLogicNames +( + std::u16string_view rPath, // Full Path to the template + OUString &rRegion, // Out: Region name + OUString &rName // Out: Template name +) const + +/* [Description] + + Returns and logical path name to the template specified by rPath + + [Return value] + + sal_Bool sal_True, Action could be performed + sal_False, Action could not be performed + + [Cross-references] + + <SfxDocumentTemplates::GetFull(const String&,const String&,DirEntry&)> +*/ + +{ + DocTemplLocker_Impl aLocker( *pImp ); + + if ( ! pImp->Construct() ) + return false; + + INetURLObject aFullPath; + + aFullPath.SetSmartProtocol( INetProtocol::File ); + aFullPath.SetURL( rPath ); + const OUString aPath( aFullPath.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + + const sal_uInt16 nCount = GetRegionCount(); + + for ( sal_uInt16 i=0; i<nCount; ++i ) + { + RegionData_Impl *pData = pImp->GetRegion( i ); + if ( pData ) + { + const sal_uInt16 nChildCount = pData->GetCount(); + + for ( sal_uInt16 j=0; j<nChildCount; ++j ) + { + DocTempl_EntryData_Impl *pEntry = pData->GetEntry( j ); + if ( pEntry && pEntry->GetTargetURL() == aPath ) + { + rRegion = pData->GetTitle(); + rName = pEntry->GetTitle(); + return true; + } + } + } + } + + return false; +} + + +SfxDocumentTemplates::SfxDocumentTemplates() + +/* [Description] + + Constructor +*/ +{ + if ( !gpTemplateData ) + gpTemplateData = new SfxDocTemplate_Impl; + + pImp = gpTemplateData; +} + + +SfxDocumentTemplates::~SfxDocumentTemplates() + +/* [Description] + + Destructor + Release of administrative data +*/ + +{ + pImp = nullptr; +} + +void SfxDocumentTemplates::Update( ) +{ + if ( ::svt::TemplateFolderCache( true ).needsUpdate() ) // update is really necessary + { + if ( pImp->Construct() ) + pImp->Rescan(); + } +} + +void SfxDocumentTemplates::ReInitFromComponent() +{ + pImp->ReInitFromComponent(); +} + +DocTempl_EntryData_Impl::DocTempl_EntryData_Impl( RegionData_Impl* pParent, + const OUString& rTitle ) +{ + mpParent = pParent; + maTitle = SfxDocumentTemplates::ConvertResourceString(rTitle); +} + + +int DocTempl_EntryData_Impl::Compare( std::u16string_view rTitle ) const +{ + return maTitle.compareTo( rTitle ); +} + + +const OUString& DocTempl_EntryData_Impl::GetHierarchyURL() +{ + if ( maOwnURL.isEmpty() ) + { + INetURLObject aTemplateObj( mpParent->GetHierarchyURL() ); + + aTemplateObj.insertName( GetTitle(), false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + + maOwnURL = aTemplateObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + DBG_ASSERT( !maOwnURL.isEmpty(), "GetHierarchyURL(): Could not create URL!" ); + } + + return maOwnURL; +} + + +const OUString& DocTempl_EntryData_Impl::GetTargetURL() +{ + if ( maTargetURL.isEmpty() ) + { + uno::Reference< XCommandEnvironment > aCmdEnv; + Content aRegion; + + if ( Content::create( GetHierarchyURL(), aCmdEnv, comphelper::getProcessComponentContext(), aRegion ) ) + { + getTextProperty_Impl( aRegion, TARGET_URL, maTargetURL ); + } + else + { + SAL_WARN( "sfx.doc", "GetTargetURL(): Could not create hierarchy content!" ); + } + } + + return maTargetURL; +} + + +RegionData_Impl::RegionData_Impl( const SfxDocTemplate_Impl* pParent, + const OUString& rTitle ) + : mpParent(pParent), maTitle(rTitle) +{ +} + + +size_t RegionData_Impl::GetEntryPos( std::u16string_view rTitle, bool& rFound ) const +{ + const size_t nCount = maEntries.size(); + + for ( size_t i=0; i<nCount; ++i ) + { + auto &pData = maEntries[ i ]; + + if ( pData->Compare( rTitle ) == 0 ) + { + rFound = true; + return i; + } + } + + rFound = false; + return nCount; +} + + +void RegionData_Impl::AddEntry( const OUString& rTitle, + const OUString& rTargetURL, + const size_t *pPos ) +{ + INetURLObject aLinkObj( GetHierarchyURL() ); + aLinkObj.insertName( rTitle, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + const OUString aLinkURL = aLinkObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + + bool bFound = false; + size_t nPos = GetEntryPos( rTitle, bFound ); + + if ( bFound ) + return; + + if ( pPos ) + nPos = *pPos; + + auto pEntry = std::make_unique<DocTempl_EntryData_Impl>( + this, rTitle ); + pEntry->SetTargetURL( rTargetURL ); + pEntry->SetHierarchyURL( aLinkURL ); + if ( nPos < maEntries.size() ) { + auto it = maEntries.begin(); + std::advance( it, nPos ); + maEntries.insert( it, std::move(pEntry) ); + } + else + maEntries.push_back( std::move(pEntry) ); +} + + +size_t RegionData_Impl::GetCount() const +{ + return maEntries.size(); +} + + +const OUString& RegionData_Impl::GetHierarchyURL() +{ + if ( maOwnURL.isEmpty() ) + { + INetURLObject aRegionObj( mpParent->GetRootURL() ); + + aRegionObj.insertName( GetTitle(), false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + + maOwnURL = aRegionObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + DBG_ASSERT( !maOwnURL.isEmpty(), "GetHierarchyURL(): Could not create URL!" ); + } + + return maOwnURL; +} + + +DocTempl_EntryData_Impl* RegionData_Impl::GetEntry( std::u16string_view rName ) const +{ + bool bFound = false; + tools::Long nPos = GetEntryPos( rName, bFound ); + + if ( bFound ) + return maEntries[ nPos ].get(); + return nullptr; +} + + +DocTempl_EntryData_Impl* RegionData_Impl::GetEntry( size_t nIndex ) const +{ + if ( nIndex < maEntries.size() ) + return maEntries[ nIndex ].get(); + return nullptr; +} + + +void RegionData_Impl::DeleteEntry( size_t nIndex ) +{ + if ( nIndex < maEntries.size() ) + { + auto it = maEntries.begin(); + std::advance( it, nIndex ); + maEntries.erase( it ); + } +} + + +int RegionData_Impl::Compare( RegionData_Impl const * pCompare ) const +{ + return maTitle.compareTo( pCompare->maTitle ); +} + + +SfxDocTemplate_Impl::SfxDocTemplate_Impl() +: mbConstructed( false ) +, mnLockCounter( 0 ) +{ +} + + +SfxDocTemplate_Impl::~SfxDocTemplate_Impl() +{ + gpTemplateData = nullptr; +} + + +void SfxDocTemplate_Impl::IncrementLock() +{ + ::osl::MutexGuard aGuard( maMutex ); + mnLockCounter++; +} + + +void SfxDocTemplate_Impl::DecrementLock() +{ + ::osl::MutexGuard aGuard( maMutex ); + if ( mnLockCounter ) + mnLockCounter--; +} + + +RegionData_Impl* SfxDocTemplate_Impl::GetRegion( size_t nIndex ) const +{ + if ( nIndex < maRegions.size() ) + return maRegions[ nIndex ].get(); + return nullptr; +} + + +RegionData_Impl* SfxDocTemplate_Impl::GetRegion( std::u16string_view rName ) + const +{ + for (auto& pData : maRegions) + { + if( pData->GetTitle() == rName ) + return pData.get(); + } + return nullptr; +} + + +void SfxDocTemplate_Impl::DeleteRegion( size_t nIndex ) +{ + if ( nIndex < maRegions.size() ) + { + auto it = maRegions.begin(); + std::advance( it, nIndex ); + maRegions.erase( it ); + } +} + + +/* AddRegion adds a Region to the RegionList +*/ +void SfxDocTemplate_Impl::AddRegion( const OUString& rTitle, + Content& rContent ) +{ + auto pRegion = std::make_unique<RegionData_Impl>( this, rTitle ); + auto pRegionTmp = pRegion.get(); + + if ( ! InsertRegion( std::move(pRegion), size_t(-1) ) ) + { + return; + } + + // now get the content of the region + uno::Reference< XResultSet > xResultSet; + + try + { + xResultSet = rContent.createSortedCursor( { TITLE, TARGET_URL }, { { 1, true } }, m_rCompareFactory, INCLUDE_DOCUMENTS_ONLY ); + } + catch ( Exception& ) {} + + if ( !xResultSet.is() ) + return; + + uno::Reference< XRow > xRow( xResultSet, UNO_QUERY ); + + try + { + while ( xResultSet->next() ) + { + pRegionTmp->AddEntry( xRow->getString( 1 ), xRow->getString( 2 ), nullptr ); + } + } + catch ( Exception& ) {} +} + + +void SfxDocTemplate_Impl::CreateFromHierarchy( Content &rTemplRoot ) +{ + uno::Reference< XResultSet > xResultSet; + Sequence< OUString > aProps { TITLE }; + + try + { + xResultSet = rTemplRoot.createSortedCursor( + aProps, + { // Sequence + { // NumberedSortingInfo + /* ColumnIndex */ 1, /* Ascending */ true + } + }, + m_rCompareFactory, + INCLUDE_FOLDERS_ONLY + ); + } + catch ( Exception& ) {} + + if ( !xResultSet.is() ) + return; + + uno::Reference< XCommandEnvironment > aCmdEnv; + uno::Reference< XContentAccess > xContentAccess( xResultSet, UNO_QUERY ); + uno::Reference< XRow > xRow( xResultSet, UNO_QUERY ); + + try + { + while ( xResultSet->next() ) + { + const OUString aId = xContentAccess->queryContentIdentifierString(); + Content aContent( aId, aCmdEnv, comphelper::getProcessComponentContext() ); + + AddRegion( xRow->getString( 1 ), aContent ); + } + } + catch ( Exception& ) {} +} + + +bool SfxDocTemplate_Impl::Construct( ) +{ + ::osl::MutexGuard aGuard( maMutex ); + + if ( mbConstructed ) + return true; + + uno::Reference< XComponentContext > xContext = ::comphelper::getProcessComponentContext(); + + uno::Reference< XPersist > xInfo( document::DocumentProperties::create(xContext), UNO_QUERY ); + mxInfo = xInfo; + + mxTemplates = frame::DocumentTemplates::create(xContext); + + uno::Reference< XLocalizable > xLocalizable( mxTemplates, UNO_QUERY ); + + m_rCompareFactory = AnyCompareFactory::createWithLocale(xContext, xLocalizable->getLocale()); + + uno::Reference < XContent > aRootContent = mxTemplates->getContent(); + uno::Reference < XCommandEnvironment > aCmdEnv; + + if ( ! aRootContent.is() ) + return false; + + mbConstructed = true; + maRootURL = aRootContent->getIdentifier()->getContentIdentifier(); + + maStandardGroup = DocTemplLocaleHelper::GetStandardGroupString(); + Content aTemplRoot( aRootContent, aCmdEnv, xContext ); + CreateFromHierarchy( aTemplRoot ); + + return true; +} + + +void SfxDocTemplate_Impl::ReInitFromComponent() +{ + uno::Reference< XDocumentTemplates > xTemplates = getDocTemplates(); + if ( xTemplates.is() ) + { + uno::Reference < XContent > aRootContent = xTemplates->getContent(); + uno::Reference < XCommandEnvironment > aCmdEnv; + Content aTemplRoot( aRootContent, aCmdEnv, comphelper::getProcessComponentContext() ); + Clear(); + CreateFromHierarchy( aTemplRoot ); + } +} + + +bool SfxDocTemplate_Impl::InsertRegion( std::unique_ptr<RegionData_Impl> pNew, size_t nPos ) +{ + ::osl::MutexGuard aGuard( maMutex ); + + // return false (not inserted) if the entry already exists + for (auto const& pRegion : maRegions) + if ( pRegion->Compare( pNew.get() ) == 0 ) + return false; + + size_t newPos = nPos; + if ( pNew->GetTitle() == maStandardGroup ) + newPos = 0; + + if ( newPos < maRegions.size() ) + { + auto it = maRegions.begin(); + std::advance( it, newPos ); + maRegions.emplace( it, std::move(pNew) ); + } + else + maRegions.emplace_back( std::move(pNew) ); + + return true; +} + + +void SfxDocTemplate_Impl::Rescan() +{ + Clear(); + + try + { + uno::Reference< XDocumentTemplates > xTemplates = getDocTemplates(); + DBG_ASSERT( xTemplates.is(), "SfxDocTemplate_Impl::Rescan:invalid template instance!" ); + if ( xTemplates.is() ) + { + xTemplates->update(); + + uno::Reference < XContent > aRootContent = xTemplates->getContent(); + uno::Reference < XCommandEnvironment > aCmdEnv; + + Content aTemplRoot( aRootContent, aCmdEnv, comphelper::getProcessComponentContext() ); + CreateFromHierarchy( aTemplRoot ); + } + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "sfx.doc", "SfxDocTemplate_Impl::Rescan: caught an exception while doing the update" ); + } +} + + +bool SfxDocTemplate_Impl::GetTitleFromURL( const OUString& rURL, + OUString& aTitle ) +{ + if ( mxInfo.is() ) + { + try + { + mxInfo->read( rURL ); + } + catch ( Exception& ) + { + // the document is not a StarOffice document + return false; + } + + + try + { + uno::Reference< XPropertySet > aPropSet( mxInfo, UNO_QUERY ); + if ( aPropSet.is() ) + { + Any aValue = aPropSet->getPropertyValue( TITLE ); + aValue >>= aTitle; + } + } + catch ( IOException& ) {} + catch ( UnknownPropertyException& ) {} + catch ( Exception& ) {} + } + + if ( aTitle.isEmpty() ) + { + INetURLObject aURL( rURL ); + aURL.CutExtension(); + aTitle = aURL.getName( INetURLObject::LAST_SEGMENT, true, + INetURLObject::DecodeMechanism::WithCharset ); + } + + return true; +} + + +void SfxDocTemplate_Impl::Clear() +{ + ::osl::MutexGuard aGuard( maMutex ); + if ( mnLockCounter ) + return; + maRegions.clear(); +} + + +bool getTextProperty_Impl( Content& rContent, + const OUString& rPropName, + OUString& rPropValue ) +{ + bool bGotProperty = false; + + // Get the property + try + { + uno::Reference< XPropertySetInfo > aPropInfo = rContent.getProperties(); + + // check, whether or not the property exists + if ( !aPropInfo.is() || !aPropInfo->hasPropertyByName( rPropName ) ) + { + return false; + } + + // now get the property + Any aAnyValue = rContent.getPropertyValue( rPropName ); + aAnyValue >>= rPropValue; + + if ( SfxURLRelocator_Impl::propertyCanContainOfficeDir( rPropName ) ) + { + SfxURLRelocator_Impl aRelocImpl( ::comphelper::getProcessComponentContext() ); + aRelocImpl.makeAbsoluteURL( rPropValue ); + } + + bGotProperty = true; + } + catch ( RuntimeException& ) {} + catch ( Exception& ) {} + + return bGotProperty; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/doctemplates.cxx b/sfx2/source/doc/doctemplates.cxx new file mode 100644 index 000000000..6005aa5fd --- /dev/null +++ b/sfx2/source/doc/doctemplates.cxx @@ -0,0 +1,2734 @@ +/* -*- 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 <osl/mutex.hxx> +#include <tools/diagnose_ex.h> +#include <tools/urlobj.hxx> +#include <rtl/ustring.hxx> +#include <sal/log.hxx> +#include <vcl/svapp.hxx> +#include <vcl/wrkwin.hxx> +#include <unotools/pathoptions.hxx> +#include <comphelper/processfactory.hxx> +#include <comphelper/propertysequence.hxx> +#include <comphelper/propertyvalue.hxx> +#include <comphelper/sequenceashashmap.hxx> +#include <comphelper/storagehelper.hxx> +#include <comphelper/string.hxx> +#include <cppuhelper/implbase.hxx> +#include <cppuhelper/supportsservice.hxx> +#include <com/sun/star/beans/IllegalTypeException.hpp> +#include <com/sun/star/beans/PropertyAttribute.hpp> +#include <com/sun/star/beans/PropertyExistException.hpp> +#include <com/sun/star/beans/XPropertySetInfo.hpp> +#include <com/sun/star/beans/XPropertyContainer.hpp> +#include <com/sun/star/beans/StringPair.hpp> +#include <com/sun/star/ucb/SimpleFileAccess.hpp> +#include <com/sun/star/util/theMacroExpander.hpp> +#include <com/sun/star/util/theOfficeInstallationDirectories.hpp> +#include <com/sun/star/configuration/theDefaultProvider.hpp> +#include <com/sun/star/document/XTypeDetection.hpp> +#include <com/sun/star/document/DocumentProperties.hpp> +#include <com/sun/star/io/TempFile.hpp> +#include <com/sun/star/sdbc/XResultSet.hpp> +#include <com/sun/star/sdbc/XRow.hpp> +#include <com/sun/star/ucb/ContentCreationException.hpp> +#include <com/sun/star/ucb/NameClash.hpp> +#include <com/sun/star/ucb/NameClashException.hpp> +#include <com/sun/star/ucb/XCommandEnvironment.hpp> +#include <com/sun/star/ucb/XContentAccess.hpp> +#include <com/sun/star/frame/ModuleManager.hpp> +#include <com/sun/star/uno/Exception.hpp> +#include <com/sun/star/task/InteractionHandler.hpp> +#include <com/sun/star/ucb/XProgressHandler.hpp> +#include <com/sun/star/container/XNameAccess.hpp> +#include <com/sun/star/frame/XDocumentTemplates.hpp> +#include <com/sun/star/frame/XStorable.hpp> +#include <com/sun/star/lang/Locale.hpp> +#include <com/sun/star/lang/XLocalizable.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/ucb/XContent.hpp> +#include <com/sun/star/beans/PropertyValue.hpp> +#include <com/sun/star/uno/RuntimeException.hpp> +#include <com/sun/star/uno/XComponentContext.hpp> +#include <com/sun/star/util/thePathSettings.hpp> + +#include <svtools/templatefoldercache.hxx> +#include <unotools/configmgr.hxx> +#include <unotools/ucbhelper.hxx> +#include <i18nlangtag/languagetag.hxx> +#include <ucbhelper/content.hxx> +#include <o3tl/string_view.hxx> + +#include <sfx2/sfxresid.hxx> +#include <sfxurlrelocator.hxx> +#include "doctemplateslocal.hxx" +#include <sfx2/docfac.hxx> +#include <sfx2/strings.hrc> +#include <doctempl.hrc> + +#include <memory> +#include <vector> + +constexpr OUStringLiteral SERVICENAME_TYPEDETECTION = u"com.sun.star.document.TypeDetection"; + +constexpr OUStringLiteral TEMPLATE_ROOT_URL = u"vnd.sun.star.hier:/templates"; +constexpr OUStringLiteral TITLE = u"Title"; +constexpr OUStringLiteral IS_FOLDER = u"IsFolder"; +constexpr OUStringLiteral IS_DOCUMENT = u"IsDocument"; +constexpr OUStringLiteral TARGET_URL = u"TargetURL"; +constexpr OUStringLiteral TEMPLATE_VERSION = u"TemplateComponentVersion"; +constexpr OUStringLiteral TEMPLATE_VERSION_VALUE = u"2"; +constexpr OUStringLiteral TYPE_FOLDER = u"application/vnd.sun.star.hier-folder"; +constexpr OUStringLiteral TYPE_LINK = u"application/vnd.sun.star.hier-link"; +constexpr OUStringLiteral TYPE_FSYS_FOLDER = u"application/vnd.sun.staroffice.fsys-folder"; +constexpr OUStringLiteral TYPE_FSYS_FILE = u"application/vnd.sun.staroffice.fsys-file"; + +constexpr OUStringLiteral PROPERTY_DIRLIST = u"DirectoryList"; +constexpr OUStringLiteral PROPERTY_NEEDSUPDATE = u"NeedsUpdate"; +constexpr OUStringLiteral PROPERTY_TYPE = u"TypeDescription"; + +constexpr OUStringLiteral TARGET_DIR_URL = u"TargetDirURL"; +constexpr OUStringLiteral COMMAND_DELETE = u"delete"; + +constexpr OUStringLiteral STANDARD_FOLDER = u"standard"; + +#define C_DELIM ';' + +using namespace ::com::sun::star; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::document; +using namespace ::com::sun::star::io; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::sdbc; +using namespace ::com::sun::star::ucb; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::util; + +using namespace ::ucbhelper; +using namespace ::comphelper; + +using ::std::vector; + +namespace { + +class WaitWindow_Impl : public WorkWindow +{ + tools::Rectangle maRect; + OUString maText; + static constexpr DrawTextFlags gnTextStyle = DrawTextFlags::Center | DrawTextFlags::VCenter | DrawTextFlags::WordBreak | DrawTextFlags::MultiLine; + +public: + WaitWindow_Impl(); + virtual ~WaitWindow_Impl() override; + virtual void dispose() override; + virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override; +}; + +#define X_OFFSET 15 +#define Y_OFFSET 15 + + +struct NamePair_Impl +{ + OUString maShortName; + OUString maLongName; +}; + +class DocTemplates_EntryData_Impl; +class GroupData_Impl; + +typedef vector< std::unique_ptr<GroupData_Impl> > GroupList_Impl; + + +class TplTaskEnvironment : public ::cppu::WeakImplHelper< ucb::XCommandEnvironment > +{ + uno::Reference< task::XInteractionHandler > m_xInteractionHandler; + +public: + explicit TplTaskEnvironment( const uno::Reference< task::XInteractionHandler>& rxInteractionHandler ) + : m_xInteractionHandler( rxInteractionHandler ) + {} + + virtual uno::Reference<task::XInteractionHandler> SAL_CALL getInteractionHandler() override + { return m_xInteractionHandler; } + + virtual uno::Reference<ucb::XProgressHandler> SAL_CALL getProgressHandler() override + { return uno::Reference<ucb::XProgressHandler>(); } +}; + +class SfxDocTplService_Impl +{ + uno::Reference< XComponentContext > mxContext; + uno::Reference< XCommandEnvironment > maCmdEnv; + uno::Reference< XDocumentProperties> m_xDocProps; + uno::Reference< XTypeDetection > mxType; + + ::osl::Mutex maMutex; + Sequence< OUString > maTemplateDirs; + Sequence< OUString > maInternalTemplateDirs; + OUString maRootURL; + std::vector< NamePair_Impl > maNames; + lang::Locale maLocale; + Content maRootContent; + bool mbIsInitialized : 1; + bool mbLocaleSet : 1; + + SfxURLRelocator_Impl maRelocator; + + void init_Impl(); + void getDefaultLocale(); + void getDirList(); + void readFolderList(); + bool needsUpdate(); + OUString getLongName( const OUString& rShortName ); + bool setTitleForURL( const OUString& rURL, const OUString& aTitle ); + void getTitleFromURL( const OUString& rURL, OUString& aTitle, OUString& aType, bool& bDocHasTitle ); + + bool addEntry( Content& rParentFolder, + const OUString& rTitle, + const OUString& rTargetURL, + const OUString& rType ); + + bool createFolder( const OUString& rNewFolderURL, + bool bCreateParent, + bool bFsysFolder, + Content &rNewFolder ); + + static bool CreateNewUniqueFolderWithPrefix( std::u16string_view aPath, + const OUString& aPrefix, + OUString& aNewFolderName, + OUString& aNewFolderURL, + Content& aNewFolder ); + static OUString CreateNewUniqueFileWithPrefix( std::u16string_view aPath, + const OUString& aPrefix, + const OUString& aExt ); + + std::vector< beans::StringPair > ReadUINamesForTemplateDir_Impl( std::u16string_view aUserPath ); + bool UpdateUINamesForTemplateDir_Impl( std::u16string_view aUserPath, + const OUString& aGroupName, + const OUString& aNewFolderName ); + bool ReplaceUINamesForTemplateDir_Impl( std::u16string_view aUserPath, + const OUString& aFsysGroupName, + std::u16string_view aOldGroupName, + const OUString& aNewGroupName ); + void RemoveUINamesForTemplateDir_Impl( std::u16string_view aUserPath, + std::u16string_view aGroupName ); + bool WriteUINamesForTemplateDir_Impl( std::u16string_view aUserPath, + const std::vector< beans::StringPair >& aUINames ); + + OUString CreateNewGroupFsys( const OUString& rGroupName, Content& aGroup ); + + static bool removeContent( Content& rContent ); + bool removeContent( const OUString& rContentURL ); + + bool setProperty( Content& rContent, + const OUString& rPropName, + const Any& rPropValue ); + bool getProperty( Content& rContent, + const OUString& rPropName, + Any& rPropValue ); + + void createFromContent( GroupList_Impl& rList, + Content &rContent, + bool bHierarchy, + bool bWriteableContent ); + void addHierGroup( GroupList_Impl& rList, + const OUString& rTitle, + const OUString& rOwnURL ); + void addFsysGroup( GroupList_Impl& rList, + const OUString& rTitle, + const OUString& rUITitle, + const OUString& rOwnURL, + bool bWriteableGroup ); + void removeFromHierarchy( DocTemplates_EntryData_Impl const *pData ); + void addToHierarchy( GroupData_Impl const *pGroup, + DocTemplates_EntryData_Impl const *pData ); + + void removeFromHierarchy( GroupData_Impl const *pGroup ); + void addGroupToHierarchy( GroupData_Impl *pGroup ); + + void updateData( DocTemplates_EntryData_Impl const *pData ); + + //See: #i66157# and rhbz#1065807 + //return which template dir the rURL is a subpath of + OUString findParentTemplateDir(const OUString& rURL) const; + + //See: #i66157# and rhbz#1065807 + //return true if rURL is a path (or subpath of) a dir which is not a user path + //which implies neither it or its contents can be removed + bool isInternalTemplateDir(const OUString& rURL) const; +public: + explicit SfxDocTplService_Impl( const uno::Reference< XComponentContext > & xContext ); + ~SfxDocTplService_Impl(); + + bool init() { if ( !mbIsInitialized ) init_Impl(); return mbIsInitialized; } + const Content& getContent() const { return maRootContent; } + + void setLocale( const lang::Locale & rLocale ); + lang::Locale getLocale(); + + bool storeTemplate( const OUString& rGroupName, + const OUString& rTemplateName, + const uno::Reference< frame::XStorable >& rStorable ); + + bool addTemplate( const OUString& rGroupName, + const OUString& rTemplateName, + const OUString& rSourceURL ); + bool removeTemplate( std::u16string_view rGroupName, + std::u16string_view rTemplateName ); + bool renameTemplate( std::u16string_view rGroupName, + std::u16string_view rOldName, + const OUString& rNewName ); + + bool addGroup( const OUString& rGroupName ); + bool removeGroup( std::u16string_view rGroupName ); + bool renameGroup( std::u16string_view rOldName, + const OUString& rNewName ); + + void update(); + void doUpdate(); +}; + + +class DocTemplates_EntryData_Impl +{ + OUString maTitle; + OUString maType; + OUString maTargetURL; + OUString maHierarchyURL; + + bool mbInHierarchy : 1; + bool mbInUse : 1; + bool mbUpdateType : 1; + bool mbUpdateLink : 1; + +public: + explicit DocTemplates_EntryData_Impl( const OUString& rTitle ); + + void setInUse() { mbInUse = true; } + void setHierarchy( bool bInHierarchy ) { mbInHierarchy = bInHierarchy; } + void setUpdateLink( bool bUpdateLink ) { mbUpdateLink = bUpdateLink; } + void setUpdateType( bool bUpdateType ) { mbUpdateType = bUpdateType; } + + bool getInUse() const { return mbInUse; } + bool getInHierarchy() const { return mbInHierarchy; } + bool getUpdateLink() const { return mbUpdateLink; } + bool getUpdateType() const { return mbUpdateType; } + + const OUString& getHierarchyURL() const { return maHierarchyURL; } + const OUString& getTargetURL() const { return maTargetURL; } + const OUString& getTitle() const { return maTitle; } + const OUString& getType() const { return maType; } + + void setHierarchyURL( const OUString& rURL ) { maHierarchyURL = rURL; } + void setTargetURL( const OUString& rURL ) { maTargetURL = rURL; } + void setType( const OUString& rType ) { maType = rType; } +}; + + +class GroupData_Impl +{ + std::vector< std::unique_ptr<DocTemplates_EntryData_Impl> > maEntries; + OUString maTitle; + OUString maHierarchyURL; + OUString maTargetURL; + bool mbInUse : 1; + bool mbInHierarchy : 1; + +public: + explicit GroupData_Impl( const OUString& rTitle ); + + void setInUse() { mbInUse = true; } + void setHierarchy( bool bInHierarchy ) { mbInHierarchy = bInHierarchy; } + void setHierarchyURL( const OUString& rURL ) { maHierarchyURL = rURL; } + void setTargetURL( const OUString& rURL ) { maTargetURL = rURL; } + + bool getInUse() const { return mbInUse; } + bool getInHierarchy() const { return mbInHierarchy; } + const OUString& getHierarchyURL() const { return maHierarchyURL; } + const OUString& getTargetURL() const { return maTargetURL; } + const OUString& getTitle() const { return maTitle; } + + DocTemplates_EntryData_Impl* addEntry( const OUString& rTitle, + const OUString& rTargetURL, + const OUString& rType, + const OUString& rHierURL ); + size_t count() { return maEntries.size(); } + DocTemplates_EntryData_Impl* getEntry( size_t nPos ) { return maEntries[ nPos ].get(); } +}; + + +// private SfxDocTplService_Impl + +void SfxDocTplService_Impl::init_Impl() +{ + uno::Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext(); + uno::Reference < task::XInteractionHandler > xInteractionHandler( + task::InteractionHandler::createWithParent(xContext, nullptr), uno::UNO_QUERY_THROW ); + maCmdEnv = new TplTaskEnvironment( xInteractionHandler ); + + ::osl::ClearableMutexGuard aGuard( maMutex ); + bool bIsInitialized = false; + bool bNeedsUpdate = false; + + if ( !mbLocaleSet ) + getDefaultLocale(); + + // convert locale to string + // set maRootContent to the root of the templates hierarchy. Create the + // entry if necessary + + maRootURL = TEMPLATE_ROOT_URL + "/" + LanguageTag::convertToBcp47(maLocale); + + const OUString aTemplVersPropName( TEMPLATE_VERSION ); + const OUString aTemplVers( TEMPLATE_VERSION_VALUE ); + if ( Content::create( maRootURL, maCmdEnv, comphelper::getProcessComponentContext(), maRootContent ) ) + { + uno::Any aValue; + OUString aPropValue; + if ( getProperty( maRootContent, aTemplVersPropName, aValue ) + && ( aValue >>= aPropValue ) + && aPropValue == aTemplVers ) + { + bIsInitialized = true; + } + else + removeContent( maRootContent ); + } + + if ( !bIsInitialized ) + { + if ( createFolder( maRootURL, true, false, maRootContent ) + && setProperty( maRootContent, aTemplVersPropName, uno::Any( aTemplVers ) ) ) + bIsInitialized = true; + + bNeedsUpdate = true; + } + + if ( bIsInitialized ) + { + try { + m_xDocProps.set(document::DocumentProperties::create( + ::comphelper::getProcessComponentContext())); + } catch (uno::RuntimeException const&) { + TOOLS_WARN_EXCEPTION("sfx.doc", "SfxDocTplService_Impl::init_Impl: cannot create DocumentProperties service:"); + } + + mxType.set( mxContext->getServiceManager()->createInstanceWithContext(SERVICENAME_TYPEDETECTION, mxContext), UNO_QUERY ); + + getDirList(); + readFolderList(); + + if ( bNeedsUpdate ) + { + aGuard.clear(); + SolarMutexClearableGuard aSolarGuard; + + VclPtrInstance< WaitWindow_Impl > pWin; + aSolarGuard.clear(); + { + osl::MutexGuard anotherGuard(maMutex); + update(); + } + SolarMutexGuard aSecondSolarGuard; + + pWin.disposeAndClear(); + } + else if ( needsUpdate() ) + // the UI should be shown only on the first update + update(); + } + else + { + SAL_WARN( "sfx.doc", "init_Impl(): Could not create root" ); + } + + mbIsInitialized = bIsInitialized; +} + + +void SfxDocTplService_Impl::getDefaultLocale() +{ + if ( !mbLocaleSet ) + { + ::osl::MutexGuard aGuard( maMutex ); + if ( !mbLocaleSet ) + { + maLocale = LanguageTag::convertToLocale( utl::ConfigManager::getUILocale(), false); + mbLocaleSet = true; + } + } +} + +const char* TEMPLATE_SHORT_NAMES_ARY[] = +{ + "standard", + "styles", + "officorr", + "offimisc", + "personal", + "forms", + "finance", + "educate", + "layout", + "presnt", + "misc", + "labels" +}; + +void SfxDocTplService_Impl::readFolderList() +{ + SolarMutexGuard aGuard; + + static_assert( SAL_N_ELEMENTS(TEMPLATE_SHORT_NAMES_ARY) == SAL_N_ELEMENTS(TEMPLATE_LONG_NAMES_ARY), "mismatch array lengths" ); + const size_t nCount = std::min(SAL_N_ELEMENTS(TEMPLATE_SHORT_NAMES_ARY), SAL_N_ELEMENTS(TEMPLATE_LONG_NAMES_ARY)); + for (size_t i = 0; i < nCount; ++i) + { + NamePair_Impl aPair; + aPair.maShortName = OUString::createFromAscii(TEMPLATE_SHORT_NAMES_ARY[i]); + aPair.maLongName = SfxResId(TEMPLATE_LONG_NAMES_ARY[i]); + + maNames.push_back( aPair ); + } +} + + +OUString SfxDocTplService_Impl::getLongName( const OUString& rShortName ) +{ + OUString aRet; + + for (auto const & rPair : maNames) + { + if ( rPair.maShortName == rShortName ) + { + aRet = rPair.maLongName; + break; + } + } + + if ( aRet.isEmpty() ) + aRet = rShortName; + + return aRet; +} + + +void SfxDocTplService_Impl::getDirList() +{ + Any aValue; + + // Get the template dir list + // TODO/LATER: let use service, register listener + INetURLObject aURL; + OUString aDirs = SvtPathOptions().GetTemplatePath(); + sal_Int32 nCount = comphelper::string::getTokenCount(aDirs, C_DELIM); + + maTemplateDirs = Sequence< OUString >( nCount ); + + uno::Reference< util::XMacroExpander > xExpander = util::theMacroExpander::get(mxContext); + static const OUStringLiteral aPrefix( + u"vnd.sun.star.expand:" ); + + sal_Int32 nIdx{ 0 }; + for (auto& rTemplateDir : asNonConstRange(maTemplateDirs)) + { + aURL.SetSmartProtocol( INetProtocol::File ); + aURL.SetURL( o3tl::getToken(aDirs, 0, C_DELIM, nIdx ) ); + rTemplateDir = aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + + if ( xExpander.is() ) + { + const sal_Int32 nIndex{ rTemplateDir.indexOf( aPrefix ) }; + if (nIndex<0) + continue; + + rTemplateDir = rTemplateDir.replaceAt(nIndex, aPrefix.getLength(), u""); + rTemplateDir = xExpander->expandMacros( rTemplateDir ); + } + } + + aValue <<= maTemplateDirs; + + css::uno::Reference< css::util::XPathSettings > xPathSettings = + css::util::thePathSettings::get(mxContext); + + // load internal paths + Any aAny = xPathSettings->getPropertyValue( "Template_internal" ); + aAny >>= maInternalTemplateDirs; + + for (auto& rInternalTemplateDir : asNonConstRange(maInternalTemplateDirs)) + { + //expand vnd.sun.star.expand: and remove "..." from them + //to normalize into the expected url patterns + maRelocator.makeRelocatableURL(rInternalTemplateDir); + maRelocator.makeAbsoluteURL(rInternalTemplateDir); + } + + // Store the template dir list + setProperty( maRootContent, PROPERTY_DIRLIST, aValue ); +} + + +bool SfxDocTplService_Impl::needsUpdate() +{ + bool bNeedsUpdate = true; + Any aValue; + + // Get the template dir list + bool bHasProperty = getProperty( maRootContent, PROPERTY_NEEDSUPDATE, aValue ); + + if ( bHasProperty ) + aValue >>= bNeedsUpdate; + + // the old template component also checks this state, but it is initialized from this component + // so if this component was already updated the old component does not need such an update + ::svt::TemplateFolderCache aTempCache; + if ( !bNeedsUpdate ) + bNeedsUpdate = aTempCache.needsUpdate(); + + if ( bNeedsUpdate ) + aTempCache.storeState(); + + return bNeedsUpdate; +} + + +bool SfxDocTplService_Impl::setTitleForURL( const OUString& rURL, const OUString& aTitle ) +{ + if (m_xDocProps.is()) + { + try + { + m_xDocProps->loadFromMedium(rURL, Sequence<PropertyValue>()); + m_xDocProps->setTitle(aTitle); + + uno::Reference< embed::XStorage > xStorage = ::comphelper::OStorageHelper::GetStorageFromURL( + rURL, embed::ElementModes::READWRITE); + + uno::Sequence<beans::PropertyValue> medium( comphelper::InitPropertySequence({ + { "DocumentBaseURL", Any(rURL) }, + { "URL", Any(rURL) } + })); + + m_xDocProps->storeToStorage(xStorage, medium); + return true; + } + catch ( Exception& ) + { + } + } + return false; +} + + +void SfxDocTplService_Impl::getTitleFromURL( const OUString& rURL, OUString& aTitle, OUString& aType, bool& bDocHasTitle ) +{ + bDocHasTitle = false; + + if (m_xDocProps.is()) + { + try + { + m_xDocProps->loadFromMedium(rURL, Sequence<PropertyValue>()); + aTitle = m_xDocProps->getTitle(); + } + catch ( Exception& ) + { + } + } + + if ( aType.isEmpty() && mxType.is() ) + { + const OUString aDocType {mxType->queryTypeByURL( rURL )}; + if ( !aDocType.isEmpty() ) + try + { + uno::Reference< container::XNameAccess > xTypeDetection( mxType, uno::UNO_QUERY_THROW ); + SequenceAsHashMap aTypeProps( xTypeDetection->getByName( aDocType ) ); + aType = aTypeProps.getUnpackedValueOrDefault( + "MediaType", + OUString() ); + } + catch( uno::Exception& ) + {} + } + + if ( aTitle.isEmpty() ) + { + INetURLObject aURL( rURL ); + aURL.CutExtension(); + aTitle = aURL.getName( INetURLObject::LAST_SEGMENT, true, + INetURLObject::DecodeMechanism::WithCharset ); + } + else + bDocHasTitle = true; +} + + +bool SfxDocTplService_Impl::addEntry( Content& rParentFolder, + const OUString& rTitle, + const OUString& rTargetURL, + const OUString& rType ) +{ + bool bAddedEntry = false; + + INetURLObject aLinkObj( rParentFolder.getURL() ); + aLinkObj.insertName( rTitle, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + const OUString aLinkURL {aLinkObj.GetMainURL( INetURLObject::DecodeMechanism::NONE )}; + + Content aLink; + + if ( ! Content::create( aLinkURL, maCmdEnv, comphelper::getProcessComponentContext(), aLink ) ) + { + Sequence< Any > aValues{ Any(rTitle), Any(false), Any(rTargetURL) }; + + try + { + rParentFolder.insertNewContent( TYPE_LINK, { TITLE, IS_FOLDER, TARGET_URL }, aValues, aLink ); + setProperty( aLink, PROPERTY_TYPE, Any( rType ) ); + bAddedEntry = true; + } + catch( Exception& ) + {} + } + return bAddedEntry; +} + + +bool SfxDocTplService_Impl::createFolder( const OUString& rNewFolderURL, + bool bCreateParent, + bool bFsysFolder, + Content &rNewFolder ) +{ + Content aParent; + bool bCreatedFolder = false; + INetURLObject aParentURL( rNewFolderURL ); + const OUString aFolderName {aParentURL.getName( INetURLObject::LAST_SEGMENT, true, + INetURLObject::DecodeMechanism::WithCharset )}; + + // compute the parent folder url from the new folder url + // and remove the final slash, because Content::create doesn't + // like it + aParentURL.removeSegment(); + if ( aParentURL.getSegmentCount() >= 1 ) + aParentURL.removeFinalSlash(); + + // if the parent exists, we can continue with the creation of the + // new folder, we have to create the parent otherwise ( as long as + // bCreateParent is set to true ) + if ( Content::create( aParentURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), maCmdEnv, comphelper::getProcessComponentContext(), aParent ) ) + { + try + { + Sequence< Any > aValues{ Any(aFolderName), Any(true) }; + OUString aType; + + if ( bFsysFolder ) + aType = TYPE_FSYS_FOLDER; + else + aType = TYPE_FOLDER; + + aParent.insertNewContent( aType, { TITLE, IS_FOLDER }, aValues, rNewFolder ); + bCreatedFolder = true; + } + catch( Exception const & ) + { + TOOLS_WARN_EXCEPTION( "sfx.doc", "createFolder(): Could not create new folder" ); + } + } + else if ( bCreateParent ) + { + // if the parent doesn't exists and bCreateParent is set to true, + // we try to create the parent and if this was successful, we + // try to create the new folder again ( but this time, we set + // bCreateParent to false to avoid endless recursions ) + if ( ( aParentURL.getSegmentCount() >= 1 ) && + createFolder( aParentURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), bCreateParent, bFsysFolder, aParent ) ) + { + bCreatedFolder = createFolder( rNewFolderURL, false, bFsysFolder, rNewFolder ); + } + } + + return bCreatedFolder; +} + + +bool SfxDocTplService_Impl::CreateNewUniqueFolderWithPrefix( std::u16string_view aPath, + const OUString& aPrefix, + OUString& aNewFolderName, + OUString& aNewFolderURL, + Content& aNewFolder ) +{ + bool bCreated = false; + INetURLObject aDirPath( aPath ); + + Content aParent; + uno::Reference< XCommandEnvironment > aQuietEnv; + if ( Content::create( aDirPath.GetMainURL( INetURLObject::DecodeMechanism::NONE ), aQuietEnv, comphelper::getProcessComponentContext(), aParent ) ) + { + for ( sal_Int32 nInd = 0; nInd < 32000; nInd++ ) + { + OUString aTryName = aPrefix; + if ( nInd ) + aTryName += OUString::number( nInd ); + + try + { + Sequence< Any > aValues{ Any(aTryName), Any(true) }; + bCreated = aParent.insertNewContent( TYPE_FSYS_FOLDER, { TITLE, IS_FOLDER }, aValues, aNewFolder ); + } + catch( ucb::NameClashException& ) + { + // if there is already an element, retry + } + catch( Exception& ) + { + INetURLObject aObjPath( aDirPath ); + aObjPath.insertName( aTryName, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + // if there is already an element, retry + // if there was another error, do not try any more + if ( !::utl::UCBContentHelper::Exists( aObjPath.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ) ) + break; + } + + if ( bCreated ) + { + aNewFolderName = aTryName; + aNewFolderURL = aNewFolder.get()->getIdentifier()->getContentIdentifier(); + break; + } + } + } + + return bCreated; +} + + +OUString SfxDocTplService_Impl::CreateNewUniqueFileWithPrefix( std::u16string_view aPath, + const OUString& aPrefix, + const OUString& aExt ) +{ + OUString aNewFileURL; + INetURLObject aDirPath( aPath ); + + Content aParent; + + uno::Reference< XCommandEnvironment > aQuietEnv; + if ( Content::create( aDirPath.GetMainURL( INetURLObject::DecodeMechanism::NONE ), aQuietEnv, comphelper::getProcessComponentContext(), aParent ) ) + { + for ( sal_Int32 nInd = 0; nInd < 32000; nInd++ ) + { + Content aNewFile; + bool bCreated = false; + OUString aTryName = aPrefix; + if ( nInd ) + aTryName += OUString::number( nInd ); + if ( aExt.toChar() != '.' ) + aTryName += "."; + aTryName += aExt; + + try + { + Sequence< Any > aValues{ Any(aTryName), Any(true) }; + bCreated = aParent.insertNewContent( TYPE_FSYS_FILE, { TITLE, IS_DOCUMENT }, aValues, aNewFile ); + } + catch( ucb::NameClashException& ) + { + // if there is already an element, retry + } + catch( Exception& ) + { + INetURLObject aObjPath( aPath ); + aObjPath.insertName( aTryName, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + // if there is already an element, retry + // if there was another error, do not try any more + if ( !::utl::UCBContentHelper::Exists( aObjPath.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ) ) + break; + } + + if ( bCreated ) + { + aNewFileURL = aNewFile.get()->getIdentifier()->getContentIdentifier(); + break; + } + } + } + + return aNewFileURL; +} + + +bool SfxDocTplService_Impl::removeContent( Content& rContent ) +{ + bool bRemoved = false; + try + { + Any aArg( true ); + + rContent.executeCommand( COMMAND_DELETE, aArg ); + bRemoved = true; + } + catch ( RuntimeException& ) {} + catch ( Exception& ) {} + + return bRemoved; +} + + +bool SfxDocTplService_Impl::removeContent( const OUString& rContentURL ) +{ + Content aContent; + + if ( Content::create( rContentURL, maCmdEnv, comphelper::getProcessComponentContext(), aContent ) ) + return removeContent( aContent ); + return false; +} + + +bool SfxDocTplService_Impl::setProperty( Content& rContent, + const OUString& rPropName, + const Any& rPropValue ) +{ + bool bPropertySet = false; + + // Store the property + try + { + Any aPropValue( rPropValue ); + uno::Reference< XPropertySetInfo > aPropInfo = rContent.getProperties(); + + // check, whether or not the property exists, create it, when not + if ( !aPropInfo.is() || !aPropInfo->hasPropertyByName( rPropName ) ) + { + uno::Reference< XPropertyContainer > xProperties( rContent.get(), UNO_QUERY ); + if ( xProperties.is() ) + { + try + { + xProperties->addProperty( rPropName, PropertyAttribute::MAYBEVOID, rPropValue ); + } + catch( PropertyExistException& ) {} + catch( IllegalTypeException& ) { + TOOLS_WARN_EXCEPTION( "sfx.doc", "" ); + } + catch( IllegalArgumentException& ) { + TOOLS_WARN_EXCEPTION( "sfx.doc", "" ); + } + } + } + + // To ensure a reloctable office installation, the path to the + // office installation directory must never be stored directly. + if ( SfxURLRelocator_Impl::propertyCanContainOfficeDir( rPropName ) ) + { + OUString aValue; + if ( rPropValue >>= aValue ) + { + maRelocator.makeRelocatableURL( aValue ); + aPropValue <<= aValue; + } + else + { + Sequence< OUString > aValues; + if ( rPropValue >>= aValues ) + { + for ( auto& rValue : asNonConstRange(aValues) ) + { + maRelocator.makeRelocatableURL( rValue ); + } + aPropValue <<= aValues; + } + else + { + OSL_FAIL( "Unsupported property value type" ); + } + } + } + + // now set the property + + rContent.setPropertyValue( rPropName, aPropValue ); + bPropertySet = true; + } + catch ( RuntimeException& ) {} + catch ( Exception& ) {} + + return bPropertySet; +} + + +bool SfxDocTplService_Impl::getProperty(Content& rContent, const OUString& rPropName, Any& rPropValue) +{ + bool bGotProperty = false; + + // Get the property + try + { + uno::Reference< XPropertySetInfo > aPropInfo = rContent.getProperties(); + + // check, whether or not the property exists + if ( !aPropInfo.is() || !aPropInfo->hasPropertyByName( rPropName ) ) + { + return false; + } + + // now get the property + + rPropValue = rContent.getPropertyValue( rPropName ); + + // To ensure a reloctable office installation, the path to the + // office installation directory must never be stored directly. + if ( SfxURLRelocator_Impl::propertyCanContainOfficeDir( rPropName ) ) + { + OUString aValue; + if ( rPropValue >>= aValue ) + { + maRelocator.makeAbsoluteURL( aValue ); + rPropValue <<= aValue; + } + else + { + Sequence< OUString > aValues; + if ( rPropValue >>= aValues ) + { + for ( auto& rValue : asNonConstRange(aValues) ) + { + maRelocator.makeAbsoluteURL( rValue ); + } + rPropValue <<= aValues; + } + else + { + OSL_FAIL( "Unsupported property value type" ); + } + } + } + + bGotProperty = true; + } + catch ( RuntimeException& ) {} + catch ( Exception& ) {} + + return bGotProperty; +} + +SfxDocTplService_Impl::SfxDocTplService_Impl( const uno::Reference< XComponentContext > & xContext ) + : mxContext(xContext), mbIsInitialized(false), mbLocaleSet(false), maRelocator(xContext) +{ +} + + +SfxDocTplService_Impl::~SfxDocTplService_Impl() +{ + ::osl::MutexGuard aGuard( maMutex ); + maNames.clear(); +} + + +lang::Locale SfxDocTplService_Impl::getLocale() +{ + ::osl::MutexGuard aGuard( maMutex ); + + if ( !mbLocaleSet ) + getDefaultLocale(); + + return maLocale; +} + + +void SfxDocTplService_Impl::setLocale( const lang::Locale &rLocale ) +{ + ::osl::MutexGuard aGuard( maMutex ); + + if ( mbLocaleSet && ( + ( maLocale.Language != rLocale.Language ) || + ( maLocale.Country != rLocale.Country ) || + ( maLocale.Variant != rLocale.Variant ) ) ) + mbIsInitialized = false; + + maLocale = rLocale; + mbLocaleSet = true; +} + + +void SfxDocTplService_Impl::update() +{ + ::osl::MutexGuard aGuard( maMutex ); + + doUpdate(); +} + + +void SfxDocTplService_Impl::doUpdate() +{ + ::osl::MutexGuard aGuard( maMutex ); + + const OUString aPropName( PROPERTY_NEEDSUPDATE ); + Any aValue; + + aValue <<= true; + setProperty( maRootContent, aPropName, aValue ); + + GroupList_Impl aGroupList; + + // get the entries from the hierarchy + createFromContent( aGroupList, maRootContent, true, false ); + + // get the entries from the template directories + sal_Int32 nCountDir = maTemplateDirs.getLength(); + const OUString* pDirs = maTemplateDirs.getConstArray(); + Content aDirContent; + + // the last directory in the list must be writable + bool bWriteableDirectory = true; + + // the target folder might not exist, for this reason no interaction handler should be used + uno::Reference< XCommandEnvironment > aQuietEnv; + + while ( nCountDir ) + { + nCountDir--; + if ( Content::create( pDirs[ nCountDir ], aQuietEnv, comphelper::getProcessComponentContext(), aDirContent ) ) + { + createFromContent( aGroupList, aDirContent, false, bWriteableDirectory ); + } + + bWriteableDirectory = false; + } + + // now check the list + for(std::unique_ptr<GroupData_Impl>& pGroup : aGroupList) + { + if ( pGroup->getInUse() ) + { + if ( pGroup->getInHierarchy() ) + { + Content aGroup; + if ( Content::create( pGroup->getHierarchyURL(), maCmdEnv, comphelper::getProcessComponentContext(), aGroup ) ) + setProperty( aGroup, + TARGET_DIR_URL, + Any( pGroup->getTargetURL() ) ); + + size_t nCount = pGroup->count(); + for ( size_t i=0; i<nCount; i++ ) + { + DocTemplates_EntryData_Impl *pData = pGroup->getEntry( i ); + if ( ! pData->getInUse() ) + { + if ( pData->getInHierarchy() ) + removeFromHierarchy( pData ); // delete entry in hierarchy + else + addToHierarchy( pGroup.get(), pData ); // add entry to hierarchy + } + else if ( pData->getUpdateType() || + pData->getUpdateLink() ) + { + updateData( pData ); + } + } + } + else + { + addGroupToHierarchy( pGroup.get() ); // add group to hierarchy + } + } + else + removeFromHierarchy( pGroup.get() ); // delete group from hierarchy + } + aGroupList.clear(); + + aValue <<= false; + setProperty( maRootContent, aPropName, aValue ); +} + + +std::vector< beans::StringPair > SfxDocTplService_Impl::ReadUINamesForTemplateDir_Impl( std::u16string_view aUserPath ) +{ + INetURLObject aLocObj( aUserPath ); + aLocObj.insertName( u"groupuinames.xml", false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + Content aLocContent; + + // TODO/LATER: Use hashmap in future + std::vector< beans::StringPair > aUINames; + if ( Content::create( aLocObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ), uno::Reference < ucb::XCommandEnvironment >(), comphelper::getProcessComponentContext(), aLocContent ) ) + { + try + { + uno::Reference< io::XInputStream > xLocStream = aLocContent.openStream(); + if ( xLocStream.is() ) + aUINames = DocTemplLocaleHelper::ReadGroupLocalizationSequence( xLocStream, mxContext ); + } + catch( uno::Exception& ) + {} + } + + return aUINames; +} + + +bool SfxDocTplService_Impl::UpdateUINamesForTemplateDir_Impl( std::u16string_view aUserPath, + const OUString& aGroupName, + const OUString& aNewFolderName ) +{ + std::vector< beans::StringPair > aUINames = ReadUINamesForTemplateDir_Impl( aUserPath ); + sal_Int32 nLen = aUINames.size(); + + // it is possible that the name is used already, but it should be checked before + for ( sal_Int32 nInd = 0; nInd < nLen; nInd++ ) + if ( aUINames[nInd].First == aNewFolderName ) + return false; + + aUINames.resize( ++nLen ); + aUINames[nLen-1].First = aNewFolderName; + aUINames[nLen-1].Second = aGroupName; + + return WriteUINamesForTemplateDir_Impl( aUserPath, aUINames ); +} + + +bool SfxDocTplService_Impl::ReplaceUINamesForTemplateDir_Impl( std::u16string_view aUserPath, + const OUString& aDefaultFsysGroupName, + std::u16string_view aOldGroupName, + const OUString& aNewGroupName ) +{ + std::vector< beans::StringPair > aUINames = ReadUINamesForTemplateDir_Impl( aUserPath ); + sal_Int32 nLen = aUINames.size(); + + bool bChanged = false; + for ( sal_Int32 nInd = 0; nInd < nLen; nInd++ ) + if ( aUINames[nInd].Second == aOldGroupName ) + { + aUINames[nInd].Second = aNewGroupName; + bChanged = true; + } + + if ( !bChanged ) + { + aUINames.resize( ++nLen ); + aUINames[nLen-1].First = aDefaultFsysGroupName; + aUINames[nLen-1].Second = aNewGroupName; + } + return WriteUINamesForTemplateDir_Impl( aUserPath, aUINames ); +} + + +void SfxDocTplService_Impl::RemoveUINamesForTemplateDir_Impl( std::u16string_view aUserPath, + std::u16string_view aGroupName ) +{ + std::vector< beans::StringPair > aUINames = ReadUINamesForTemplateDir_Impl( aUserPath ); + sal_Int32 nLen = aUINames.size(); + std::vector< beans::StringPair > aNewUINames( nLen ); + sal_Int32 nNewLen = 0; + + bool bChanged = false; + for ( sal_Int32 nInd = 0; nInd < nLen; nInd++ ) + if ( aUINames[nInd].Second == aGroupName ) + bChanged = true; + else + { + nNewLen++; + aNewUINames[nNewLen-1].First = aUINames[nInd].First; + aNewUINames[nNewLen-1].Second = aUINames[nInd].Second; + } + + aNewUINames.resize( nNewLen ); + + if (bChanged) + WriteUINamesForTemplateDir_Impl( aUserPath, aNewUINames ); +} + + +bool SfxDocTplService_Impl::WriteUINamesForTemplateDir_Impl( std::u16string_view aUserPath, + const std::vector< beans::StringPair >& aUINames ) +{ + bool bResult = false; + try { + uno::Reference< io::XTempFile > xTempFile( + io::TempFile::create(mxContext), + uno::UNO_SET_THROW ); + + uno::Reference< io::XOutputStream > xOutStream = xTempFile->getOutputStream(); + if ( !xOutStream.is() ) + throw uno::RuntimeException(); + + DocTemplLocaleHelper::WriteGroupLocalizationSequence( xOutStream, aUINames, mxContext); + try { + // the SAX writer might close the stream + xOutStream->closeOutput(); + } catch( uno::Exception& ) + {} + + Content aTargetContent( OUString(aUserPath), maCmdEnv, comphelper::getProcessComponentContext() ); + Content aSourceContent( xTempFile->getUri(), maCmdEnv, comphelper::getProcessComponentContext() ); + aTargetContent.transferContent( aSourceContent, + InsertOperation::Copy, + "groupuinames.xml", + ucb::NameClash::OVERWRITE, + "text/xml" ); + + bResult = true; + } + catch ( uno::Exception& ) + { + TOOLS_WARN_EXCEPTION("sfx.doc", ""); + } + + return bResult; +} + + +OUString SfxDocTplService_Impl::CreateNewGroupFsys( const OUString& rGroupName, Content& aGroup ) +{ + OUString aResultURL; + + if ( maTemplateDirs.hasElements() ) + { + OUString aTargetPath = maTemplateDirs[ maTemplateDirs.getLength() - 1 ]; + + // create a new folder with the given name + Content aNewFolder; + OUString aNewFolderName; + + // the Fsys name instead of GroupName should be used, the groupuinames must be added also + if ( !CreateNewUniqueFolderWithPrefix( aTargetPath, + rGroupName, + aNewFolderName, + aResultURL, + aNewFolder ) + && !CreateNewUniqueFolderWithPrefix( aTargetPath, + "UserGroup", + aNewFolderName, + aResultURL, + aNewFolder ) ) + + return OUString(); + + if ( !UpdateUINamesForTemplateDir_Impl( aTargetPath, rGroupName, aNewFolderName ) ) + { + // we could not create the groupuinames for the folder, so we delete the group in + // the folder and return + removeContent( aNewFolder ); + return OUString(); + } + + // Now set the target url for this group and we are done + Any aValue( aResultURL ); + + if ( ! setProperty( aGroup, TARGET_DIR_URL, aValue ) ) + { + removeContent( aNewFolder ); + return OUString(); + } + } + + return aResultURL; +} + + +bool SfxDocTplService_Impl::addGroup( const OUString& rGroupName ) +{ + ::osl::MutexGuard aGuard( maMutex ); + + // Check, whether or not there is a group with this name + Content aNewGroup; + OUString aNewGroupURL; + INetURLObject aNewGroupObj( maRootURL ); + + aNewGroupObj.insertName( rGroupName, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + + aNewGroupURL = aNewGroupObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + + if ( Content::create( aNewGroupURL, maCmdEnv, comphelper::getProcessComponentContext(), aNewGroup ) || + ! createFolder( aNewGroupURL, false, false, aNewGroup ) ) + { + // if there already was a group with this name or the new group + // could not be created, we return here + return false; + } + + // Get the user template path entry ( new group will always + // be added in the user template path ) + sal_Int32 nIndex; + OUString aUserPath; + + nIndex = maTemplateDirs.getLength(); + if ( nIndex ) + nIndex--; + else + return false; // We don't know where to add the group + + aUserPath = maTemplateDirs[ nIndex ]; + + // create a new folder with the given name + Content aNewFolder; + OUString aNewFolderName; + OUString aNewFolderURL; + + // the Fsys name instead of GroupName should be used, the groupuinames must be added also + if ( !CreateNewUniqueFolderWithPrefix( aUserPath, + rGroupName, + aNewFolderName, + aNewFolderURL, + aNewFolder ) + && !CreateNewUniqueFolderWithPrefix( aUserPath, + "UserGroup", + aNewFolderName, + aNewFolderURL, + aNewFolder ) ) + { + // we could not create the folder, so we delete the group in the + // hierarchy and return + removeContent( aNewGroup ); + return false; + } + + if ( !UpdateUINamesForTemplateDir_Impl( aUserPath, rGroupName, aNewFolderName ) ) + { + // we could not create the groupuinames for the folder, so we delete the group in the + // hierarchy, the folder and return + removeContent( aNewGroup ); + removeContent( aNewFolder ); + return false; + } + + // Now set the target url for this group and we are done + Any aValue( aNewFolderURL ); + + if ( ! setProperty( aNewGroup, TARGET_DIR_URL, aValue ) ) + { + removeContent( aNewGroup ); + removeContent( aNewFolder ); + return false; + } + + return true; +} + + +bool SfxDocTplService_Impl::removeGroup( std::u16string_view rGroupName ) +{ + // remove all the elements that have the prefix aTargetURL + // if the group does not have other elements remove it + + ::osl::MutexGuard aGuard( maMutex ); + + bool bResult = false; + + // create the group url + INetURLObject aGroupObj( maRootURL ); + aGroupObj.insertName( rGroupName, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + + // Get the target url + Content aGroup; + const OUString aGroupURL = aGroupObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + + if ( Content::create( aGroupURL, maCmdEnv, comphelper::getProcessComponentContext(), aGroup ) ) + { + const OUString aPropName( TARGET_DIR_URL ); + Any aValue; + + OUString aGroupTargetURL; + if ( getProperty( aGroup, aPropName, aValue ) ) + aValue >>= aGroupTargetURL; + + if ( aGroupTargetURL.isEmpty() ) + return false; // nothing is allowed to be removed + + if ( !maTemplateDirs.hasElements() ) + return false; + + // check that the fs location is in writable folder and this is not a "My templates" folder + INetURLObject aGroupParentFolder( aGroupTargetURL ); + if (!aGroupParentFolder.removeSegment()) + return false; + + OUString aGeneralTempPath = findParentTemplateDir( + aGroupParentFolder.GetMainURL(INetURLObject::DecodeMechanism::NONE)); + + if (aGeneralTempPath.isEmpty()) + return false; + + // now get the content of the Group + uno::Reference< XResultSet > xResultSet; + Sequence< OUString > aProps { TARGET_URL }; + + try + { + xResultSet = aGroup.createCursor( aProps, INCLUDE_DOCUMENTS_ONLY ); + + if ( xResultSet.is() ) + { + bool bHasNonRemovable = false; + bool bHasShared = false; + + uno::Reference< XContentAccess > xContentAccess( xResultSet, UNO_QUERY_THROW ); + uno::Reference< XRow > xRow( xResultSet, UNO_QUERY_THROW ); + + while ( xResultSet->next() ) + { + OUString aTemplTargetURL( xRow->getString( 1 ) ); + OUString aHierURL = xContentAccess->queryContentIdentifierString(); + + if ( ::utl::UCBContentHelper::IsSubPath( aGroupTargetURL, aTemplTargetURL ) ) + { + // this is a user template, and it can be removed + if ( removeContent( aTemplTargetURL ) ) + removeContent( aHierURL ); + else + bHasNonRemovable = true; + } + else + bHasShared = true; + } + + if ( !bHasNonRemovable && !bHasShared ) + { + if ( removeContent( aGroupTargetURL ) + || !::utl::UCBContentHelper::Exists( aGroupTargetURL ) ) + { + removeContent( aGroupURL ); + RemoveUINamesForTemplateDir_Impl( aGeneralTempPath, rGroupName ); + bResult = true; // the operation is successful only if the whole group is removed + } + } + else if ( !bHasNonRemovable ) + { + if ( removeContent( aGroupTargetURL ) + || !::utl::UCBContentHelper::Exists( aGroupTargetURL ) ) + { + RemoveUINamesForTemplateDir_Impl( aGeneralTempPath, rGroupName ); + setProperty( aGroup, aPropName, uno::Any( OUString() ) ); + } + } + } + } + catch ( Exception& ) {} + } + + return bResult; +} + + +bool SfxDocTplService_Impl::renameGroup( std::u16string_view rOldName, + const OUString& rNewName ) +{ + ::osl::MutexGuard aGuard( maMutex ); + + // create the group url + Content aGroup; + INetURLObject aGroupObj( maRootURL ); + aGroupObj.insertName( rNewName, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + OUString aGroupURL = aGroupObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + + // Check, if there is a group with the new name, return false + // if there is one. + if ( Content::create( aGroupURL, maCmdEnv, comphelper::getProcessComponentContext(), aGroup ) ) + return false; + + aGroupObj.removeSegment(); + aGroupObj.insertName( rOldName, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + aGroupURL = aGroupObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + + // When there is no group with the old name, we can't rename it + if ( ! Content::create( aGroupURL, maCmdEnv, comphelper::getProcessComponentContext(), aGroup ) ) + return false; + + OUString aGroupTargetURL; + // there is no need to check whether target dir url is in target path, since if the target path is changed + // the target dir url should be already generated new + Any aValue; + if ( getProperty( aGroup, TARGET_DIR_URL, aValue ) ) + aValue >>= aGroupTargetURL; + + if ( aGroupTargetURL.isEmpty() ) + return false; + + if ( !maTemplateDirs.hasElements() ) + return false; + + // check that the fs location is in writable folder and this is not a "My templates" folder + INetURLObject aGroupParentFolder( aGroupTargetURL ); + if (!aGroupParentFolder.removeSegment() || + isInternalTemplateDir(aGroupParentFolder.GetMainURL(INetURLObject::DecodeMechanism::NONE))) + { + return false; + } + + // check that the group can be renamed ( all the contents must be in target location ) + bool bCanBeRenamed = false; + try + { + uno::Reference< XResultSet > xResultSet; + Sequence< OUString > aProps { TARGET_URL }; + xResultSet = aGroup.createCursor( aProps, INCLUDE_DOCUMENTS_ONLY ); + + if ( xResultSet.is() ) + { + uno::Reference< XContentAccess > xContentAccess( xResultSet, UNO_QUERY_THROW ); + uno::Reference< XRow > xRow( xResultSet, UNO_QUERY_THROW ); + + while ( xResultSet->next() ) + { + if ( !::utl::UCBContentHelper::IsSubPath( aGroupTargetURL, xRow->getString( 1 ) ) ) + throw uno::Exception("not sub path", nullptr); + } + + bCanBeRenamed = true; + } + } + catch ( Exception& ) {} + + if ( bCanBeRenamed ) + { + INetURLObject aGroupTargetObj( aGroupTargetURL ); + const OUString aFsysName = aGroupTargetObj.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset ); + + if ( aGroupTargetObj.removeSegment() + && ReplaceUINamesForTemplateDir_Impl( aGroupTargetObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ), + aFsysName, + rOldName, + rNewName ) ) + { + // rename the group in the hierarchy + Any aTitleValue; + aTitleValue <<= rNewName; + + return setProperty( aGroup, TITLE, aTitleValue ); + } + } + + return false; +} + + +bool SfxDocTplService_Impl::storeTemplate( const OUString& rGroupName, + const OUString& rTemplateName, + const uno::Reference< frame::XStorable >& rStorable ) +{ + ::osl::MutexGuard aGuard( maMutex ); + + // Check, whether or not there is a group with this name + // Return false, if there is no group with the given name + Content aGroup, aTemplateToRemove; + INetURLObject aGroupObj( maRootURL ); + bool bRemoveOldTemplateContent = false; + + aGroupObj.insertName( rGroupName, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + const OUString aGroupURL {aGroupObj.GetMainURL( INetURLObject::DecodeMechanism::NONE )}; + + if ( ! Content::create( aGroupURL, maCmdEnv, comphelper::getProcessComponentContext(), aGroup ) ) + return false; + + OUString aGroupTargetURL; + Any aValue; + if ( getProperty( aGroup, TARGET_DIR_URL, aValue ) ) + aValue >>= aGroupTargetURL; + + + // Check, if there's a template with the given name in this group + // the target template should be overwritten if it is imported by user + // in case the template is installed by office installation of by an add-in + // it can not be replaced + aGroupObj.insertName( rTemplateName, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + const OUString aTemplateURL {aGroupObj.GetMainURL( INetURLObject::DecodeMechanism::NONE )}; + + OUString aTemplateToRemoveTargetURL; + + if ( Content::create( aTemplateURL, maCmdEnv, comphelper::getProcessComponentContext(), aTemplateToRemove ) ) + { + bRemoveOldTemplateContent = true; + if ( getProperty( aTemplateToRemove, TARGET_URL, aValue ) ) + aValue >>= aTemplateToRemoveTargetURL; + + if ( aGroupTargetURL.isEmpty() || !maTemplateDirs.hasElements() + || (!aTemplateToRemoveTargetURL.isEmpty() && isInternalTemplateDir(aTemplateToRemoveTargetURL)) ) + return false; // it is not allowed to remove the template + } + + try + { + uno::Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext(); + + // get document service name + uno::Reference< frame::XModuleManager2 > xModuleManager( frame::ModuleManager::create(xContext) ); + const OUString sDocServiceName {xModuleManager->identify( uno::Reference< uno::XInterface >( rStorable, uno::UNO_QUERY ) )}; + if ( sDocServiceName.isEmpty() ) + throw uno::RuntimeException(); + + // get the actual filter name + uno::Reference< lang::XMultiServiceFactory > xConfigProvider = + configuration::theDefaultProvider::get( xContext ); + + uno::Sequence<uno::Any> aArgs(comphelper::InitAnyPropertySequence( + { + {"nodepath", uno::Any(OUString( "/org.openoffice.Setup/Office/Factories/" ))} + })); + uno::Reference< container::XNameAccess > xSOFConfig( + xConfigProvider->createInstanceWithArguments( + "com.sun.star.configuration.ConfigurationAccess", + aArgs ), + uno::UNO_QUERY_THROW ); + + uno::Reference< container::XNameAccess > xApplConfig; + xSOFConfig->getByName( sDocServiceName ) >>= xApplConfig; + if ( !xApplConfig.is() ) + throw uno::RuntimeException(); + + OUString aFilterName; + xApplConfig->getByName("ooSetupFactoryActualTemplateFilter") >>= aFilterName; + if ( aFilterName.isEmpty() ) + throw uno::RuntimeException(); + + // find the related type name + uno::Reference< container::XNameAccess > xFilterFactory( + mxContext->getServiceManager()->createInstanceWithContext("com.sun.star.document.FilterFactory", mxContext), + uno::UNO_QUERY_THROW ); + + uno::Sequence< beans::PropertyValue > aFilterData; + xFilterFactory->getByName( aFilterName ) >>= aFilterData; + OUString aTypeName; + for ( const auto& rProp : std::as_const(aFilterData) ) + if ( rProp.Name == "Type" ) + rProp.Value >>= aTypeName; + + if ( aTypeName.isEmpty() ) + throw uno::RuntimeException(); + + // find the mediatype and extension + uno::Reference< container::XNameAccess > xTypeDetection = + mxType.is() ? + uno::Reference< container::XNameAccess >( mxType, uno::UNO_QUERY_THROW ) : + uno::Reference< container::XNameAccess >( + mxContext->getServiceManager()->createInstanceWithContext("com.sun.star.document.TypeDetection", mxContext), + uno::UNO_QUERY_THROW ); + + SequenceAsHashMap aTypeProps( xTypeDetection->getByName( aTypeName ) ); + uno::Sequence< OUString > aAllExt = + aTypeProps.getUnpackedValueOrDefault("Extensions", Sequence< OUString >() ); + if ( !aAllExt.hasElements() ) + throw uno::RuntimeException(); + + const OUString aMediaType {aTypeProps.getUnpackedValueOrDefault("MediaType", OUString() )}; + const OUString aExt {aAllExt[0]}; + + if ( aMediaType.isEmpty() || aExt.isEmpty() ) + throw uno::RuntimeException(); + + // construct destination url + if ( aGroupTargetURL.isEmpty() ) + { + aGroupTargetURL = CreateNewGroupFsys( rGroupName, aGroup ); + + if ( aGroupTargetURL.isEmpty() ) + throw uno::RuntimeException(); + } + + OUString aNewTemplateTargetURL = CreateNewUniqueFileWithPrefix( aGroupTargetURL, rTemplateName, aExt ); + if ( aNewTemplateTargetURL.isEmpty() ) + { + aNewTemplateTargetURL = CreateNewUniqueFileWithPrefix( aGroupTargetURL, "UserTemplate", aExt ); + + if ( aNewTemplateTargetURL.isEmpty() ) + throw uno::RuntimeException(); + } + + // store template + uno::Sequence< PropertyValue > aStoreArgs{ + comphelper::makePropertyValue("FilterName", aFilterName), + comphelper::makePropertyValue("DocumentTitle", rTemplateName) + }; + + if( !::utl::UCBContentHelper::EqualURLs( aNewTemplateTargetURL, rStorable->getLocation() )) + rStorable->storeToURL( aNewTemplateTargetURL, aStoreArgs ); + else + rStorable->store(); + + // the storing was successful, now the old template with the same name can be removed if it existed + if ( !aTemplateToRemoveTargetURL.isEmpty() ) + { + removeContent( aTemplateToRemoveTargetURL ); + + /* + * pb: #i79496# + * if the old template was the standard template + * it is necessary to change the standard template with the new file name + */ + const OUString sStdTmplFile = SfxObjectFactory::GetStandardTemplate( sDocServiceName ); + if ( INetURLObject( sStdTmplFile ) == INetURLObject( aTemplateToRemoveTargetURL ) ) + { + SfxObjectFactory::SetStandardTemplate( sDocServiceName, aNewTemplateTargetURL ); + } + } + + if ( bRemoveOldTemplateContent ) + removeContent( aTemplateToRemove ); + + // add the template to hierarchy + return addEntry( aGroup, rTemplateName, aNewTemplateTargetURL, aMediaType ); + } + catch( Exception& ) + { + // the template was not stored + return false; + } +} + + +bool SfxDocTplService_Impl::addTemplate( const OUString& rGroupName, + const OUString& rTemplateName, + const OUString& rSourceURL ) +{ + ::osl::MutexGuard aGuard( maMutex ); + + // Check, whether or not there is a group with this name + // Return false, if there is no group with the given name + Content aGroup, aTemplate, aTargetGroup; + INetURLObject aGroupObj( maRootURL ); + + aGroupObj.insertName( rGroupName, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + const OUString aGroupURL = aGroupObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + + if ( ! Content::create( aGroupURL, maCmdEnv, comphelper::getProcessComponentContext(), aGroup ) ) + return false; + + // Check, if there's a template with the given name in this group + // Return false, if there already is a template + aGroupObj.insertName( rTemplateName, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + const OUString aTemplateURL {aGroupObj.GetMainURL( INetURLObject::DecodeMechanism::NONE )}; + + if ( Content::create( aTemplateURL, maCmdEnv, comphelper::getProcessComponentContext(), aTemplate ) ) + return false; + + // get the target url of the group + OUString aTargetURL; + Any aValue; + + if ( getProperty( aGroup, TARGET_DIR_URL, aValue ) ) + aValue >>= aTargetURL; + + if ( aTargetURL.isEmpty() ) + { + aTargetURL = CreateNewGroupFsys( rGroupName, aGroup ); + + if ( aTargetURL.isEmpty() ) + return false; + } + + // Get the content type + OUString aTitle, aType; + + bool bDocHasTitle = false; + getTitleFromURL( rSourceURL, aTitle, aType, bDocHasTitle ); + + INetURLObject aSourceObj( rSourceURL ); + if ( rTemplateName == aTitle ) + { + // addTemplate will sometimes be called just to add an entry in the + // hierarchy; the target URL and the source URL will be the same in + // this scenario + // TODO/LATER: get rid of this old hack + + INetURLObject aTargetObj( aTargetURL ); + + aTargetObj.insertName( rTemplateName, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + aTargetObj.setExtension( aSourceObj.getExtension() ); + + const OUString aTargetURL2 = aTargetObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + + if ( aTargetURL2 == rSourceURL ) + return addEntry( aGroup, rTemplateName, aTargetURL2, aType ); + } + + // copy the template into the new group (targeturl) + + INetURLObject aTmpURL( aSourceObj ); + aTmpURL.CutExtension(); + const OUString aPattern {aTmpURL.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset )}; + + const OUString aNewTemplateTargetURL {CreateNewUniqueFileWithPrefix( aTargetURL, aPattern, aSourceObj.getExtension() )}; + INetURLObject aNewTemplateTargetObj( aNewTemplateTargetURL ); + const OUString aNewTemplateTargetName {aNewTemplateTargetObj.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset )}; + if ( aNewTemplateTargetURL.isEmpty() || aNewTemplateTargetName.isEmpty() ) + return false; + + // get access to source file + Content aSourceContent; + uno::Reference < ucb::XCommandEnvironment > xEnv; + INetURLObject aSourceURL( rSourceURL ); + if( ! Content::create( aSourceURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), xEnv, comphelper::getProcessComponentContext(), aSourceContent ) ) + return false; + + if( ! Content::create( aTargetURL, xEnv, comphelper::getProcessComponentContext(), aTargetGroup ) ) + return false; + + // transfer source file + try + { + aTargetGroup.transferContent( aSourceContent, + InsertOperation::Copy, + aNewTemplateTargetName, + NameClash::OVERWRITE, + aType ); + + // allow to edit the added template + Content aResultContent; + if ( Content::create( aNewTemplateTargetURL, xEnv, comphelper::getProcessComponentContext(), aResultContent ) ) + { + static const OUStringLiteral aPropertyName( u"IsReadOnly" ); + uno::Any aProperty; + bool bReadOnly = false; + if ( getProperty( aResultContent, aPropertyName, aProperty ) && ( aProperty >>= bReadOnly ) && bReadOnly ) + setProperty( aResultContent, aPropertyName, uno::Any( false ) ); + } + } + catch ( ContentCreationException& ) + { return false; } + catch ( Exception& ) + { return false; } + + + // either the document has title and it is the same as requested, or we have to set it + bool bCorrectTitle = ( bDocHasTitle && aTitle == rTemplateName ); + if ( !bCorrectTitle ) + { + if ( !bDocHasTitle ) + { + INetURLObject aNewTmpObj( aNewTemplateTargetObj ); + aNewTmpObj.CutExtension(); + bCorrectTitle = ( aNewTmpObj.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset ) == rTemplateName ); + } + + if ( !bCorrectTitle ) + bCorrectTitle = setTitleForURL( aNewTemplateTargetURL, rTemplateName ); + } + + if ( bCorrectTitle ) + { + // create a new entry in the hierarchy + return addEntry( aGroup, rTemplateName, aNewTemplateTargetURL, aType ); + } + + // TODO/LATER: The user could be notified here that the renaming has failed + // create a new entry in the hierarchy + addEntry( aGroup, aTitle, aNewTemplateTargetURL, aType ); + return false; +} + +bool SfxDocTplService_Impl::isInternalTemplateDir(const OUString& rURL) const +{ + return std::any_of(maInternalTemplateDirs.begin(), maInternalTemplateDirs.end(), + [&rURL](const OUString& rDir) { return ::utl::UCBContentHelper::IsSubPath(rDir, rURL); }); +} + +OUString SfxDocTplService_Impl::findParentTemplateDir(const OUString& rURL) const +{ + const OUString* pDirs = std::find_if(maTemplateDirs.begin(), maTemplateDirs.end(), + [&rURL](const OUString& rDir) { return ::utl::UCBContentHelper::IsSubPath(rDir, rURL); }); + if (pDirs != maTemplateDirs.end()) + return *pDirs; + return OUString(); +} + +bool SfxDocTplService_Impl::removeTemplate( std::u16string_view rGroupName, + std::u16string_view rTemplateName ) +{ + ::osl::MutexGuard aGuard( maMutex ); + + // Check, whether or not there is a group with this name + // Return false, if there is no group with the given name + Content aGroup, aTemplate; + INetURLObject aGroupObj( maRootURL ); + + aGroupObj.insertName( rGroupName, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + const OUString aGroupURL {aGroupObj.GetMainURL( INetURLObject::DecodeMechanism::NONE )}; + + if ( ! Content::create( aGroupURL, maCmdEnv, comphelper::getProcessComponentContext(), aGroup ) ) + return false; + + // Check, if there's a template with the given name in this group + // Return false, if there is no template + aGroupObj.insertName( rTemplateName, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + const OUString aTemplateURL {aGroupObj.GetMainURL( INetURLObject::DecodeMechanism::NONE )}; + + if ( !Content::create( aTemplateURL, maCmdEnv, comphelper::getProcessComponentContext(), aTemplate ) ) + return false; + + // get the target URL from the template + OUString aTargetURL; + Any aValue; + + if ( getProperty( aTemplate, TARGET_URL, aValue ) ) + aValue >>= aTargetURL; + + // delete the target template + if ( !aTargetURL.isEmpty() ) + { + if (isInternalTemplateDir(aTargetURL)) + return false; + + removeContent( aTargetURL ); + } + + // delete the template entry + return removeContent( aTemplate ); +} + + +bool SfxDocTplService_Impl::renameTemplate( std::u16string_view rGroupName, + std::u16string_view rOldName, + const OUString& rNewName ) +{ + ::osl::MutexGuard aGuard( maMutex ); + + // Check, whether or not there is a group with this name + // Return false, if there is no group with the given name + Content aGroup, aTemplate; + INetURLObject aGroupObj( maRootURL ); + + aGroupObj.insertName( rGroupName, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + const OUString aGroupURL {aGroupObj.GetMainURL( INetURLObject::DecodeMechanism::NONE )}; + + if ( ! Content::create( aGroupURL, maCmdEnv, comphelper::getProcessComponentContext(), aGroup ) ) + return false; + + // Check, if there's a template with the new name in this group + // Return false, if there is one + aGroupObj.insertName( rNewName, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + OUString aTemplateURL {aGroupObj.GetMainURL( INetURLObject::DecodeMechanism::NONE )}; + + if ( Content::create( aTemplateURL, maCmdEnv, comphelper::getProcessComponentContext(), aTemplate ) ) + return false; + + // Check, if there's a template with the old name in this group + // Return false, if there is no template + aGroupObj.removeSegment(); + aGroupObj.insertName( rOldName, false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + aTemplateURL = aGroupObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + + if ( !Content::create( aTemplateURL, maCmdEnv, comphelper::getProcessComponentContext(), aTemplate ) ) + return false; + + OUString aTemplateTargetURL; + Any aTargetValue; + + if ( getProperty( aTemplate, TARGET_URL, aTargetValue ) ) + aTargetValue >>= aTemplateTargetURL; + + if ( !setTitleForURL( aTemplateTargetURL, rNewName ) ) + return false; + + // rename the template entry in the cache + Any aTitleValue; + aTitleValue <<= rNewName; + + return setProperty( aTemplate, TITLE, aTitleValue ); +} + + +class SfxDocTplService: public ::cppu::WeakImplHelper< css::lang::XLocalizable, css::frame::XDocumentTemplates, css::lang::XServiceInfo > +{ + std::unique_ptr<SfxDocTplService_Impl> pImp; + +public: + explicit SfxDocTplService( const css::uno::Reference < uno::XComponentContext >& xContext ); + + virtual OUString SAL_CALL getImplementationName() override + { + return "com.sun.star.comp.sfx2.DocumentTemplates"; + } + + virtual sal_Bool SAL_CALL supportsService(OUString const & ServiceName) override + { + return cppu::supportsService(this, ServiceName); + } + + virtual css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override + { + css::uno::Sequence< OUString > aSeq { "com.sun.star.frame.DocumentTemplates" }; + return aSeq; + } + + + // --- XLocalizable --- + void SAL_CALL setLocale( const css::lang::Locale & eLocale ) override; + css::lang::Locale SAL_CALL getLocale() override; + + // --- XDocumentTemplates --- + css::uno::Reference< css::ucb::XContent > SAL_CALL getContent() override; + sal_Bool SAL_CALL storeTemplate( const OUString& GroupName, + const OUString& TemplateName, + const css::uno::Reference< css::frame::XStorable >& Storable ) override; + sal_Bool SAL_CALL addTemplate( const OUString& GroupName, + const OUString& TemplateName, + const OUString& SourceURL ) override; + sal_Bool SAL_CALL removeTemplate( const OUString& GroupName, + const OUString& TemplateName ) override; + sal_Bool SAL_CALL renameTemplate( const OUString& GroupName, + const OUString& OldTemplateName, + const OUString& NewTemplateName ) override; + sal_Bool SAL_CALL addGroup( const OUString& GroupName ) override; + sal_Bool SAL_CALL removeGroup( const OUString& GroupName ) override; + sal_Bool SAL_CALL renameGroup( const OUString& OldGroupName, + const OUString& NewGroupName ) override; + void SAL_CALL update() override; +}; + + +SfxDocTplService::SfxDocTplService( const uno::Reference< XComponentContext >& xContext ) +{ + pImp.reset( new SfxDocTplService_Impl(xContext) ); +} + + + +//--- XLocalizable --- + + +lang::Locale SAL_CALL SfxDocTplService::getLocale() +{ + return pImp->getLocale(); +} + + +void SAL_CALL SfxDocTplService::setLocale( const lang::Locale & rLocale ) +{ + pImp->setLocale( rLocale ); +} + + +//--- XDocumentTemplates --- + +uno::Reference< ucb::XContent > SAL_CALL SfxDocTplService::getContent() +{ + if ( pImp->init() ) + return pImp->getContent().get(); + return nullptr; +} + + +sal_Bool SAL_CALL SfxDocTplService::storeTemplate( const OUString& GroupName, + const OUString& TemplateName, + const uno::Reference< frame::XStorable >& Storable ) +{ + return pImp->init() && pImp->storeTemplate( GroupName, TemplateName, Storable ); +} + + +sal_Bool SAL_CALL SfxDocTplService::addTemplate( const OUString& rGroupName, + const OUString& rTemplateName, + const OUString& rSourceURL ) +{ + return pImp->init() && pImp->addTemplate( rGroupName, rTemplateName, rSourceURL ); +} + + +sal_Bool SAL_CALL SfxDocTplService::removeTemplate( const OUString& rGroupName, + const OUString& rTemplateName ) +{ + return pImp->init() && pImp->removeTemplate( rGroupName, rTemplateName ); +} + + +sal_Bool SAL_CALL SfxDocTplService::renameTemplate( const OUString& rGroupName, + const OUString& rOldName, + const OUString& rNewName ) +{ + if ( rOldName == rNewName ) + return true; + + return pImp->init() && pImp->renameTemplate( rGroupName, rOldName, rNewName ); +} + + +sal_Bool SAL_CALL SfxDocTplService::addGroup( const OUString& rGroupName ) +{ + return pImp->init() && pImp->addGroup( rGroupName ); +} + + +sal_Bool SAL_CALL SfxDocTplService::removeGroup( const OUString& rGroupName ) +{ + return pImp->init() && pImp->removeGroup( rGroupName ); +} + + +sal_Bool SAL_CALL SfxDocTplService::renameGroup( const OUString& rOldName, + const OUString& rNewName ) +{ + if ( rOldName == rNewName ) + return true; + + return pImp->init() && pImp->renameGroup( rOldName, rNewName ); +} + + +void SAL_CALL SfxDocTplService::update() +{ + if ( pImp->init() ) + pImp->update(); +} + +WaitWindow_Impl::WaitWindow_Impl() : WorkWindow(nullptr, WB_BORDER | WB_3DLOOK) +{ + tools::Rectangle aRect(0, 0, 300, 30000); + maText = SfxResId(RID_CNT_STR_WAITING); + maRect = GetTextRect(aRect, maText, gnTextStyle); + aRect = maRect; + aRect.AdjustRight(2 * X_OFFSET ); + aRect.AdjustBottom(2 * Y_OFFSET ); + maRect.SetPos(Point(X_OFFSET, Y_OFFSET)); + SetOutputSizePixel(aRect.GetSize()); + + Show(); + PaintImmediately(); + GetOutDev()->Flush(); +} + + +WaitWindow_Impl::~WaitWindow_Impl() +{ + disposeOnce(); +} + +void WaitWindow_Impl::dispose() +{ + Hide(); + WorkWindow::dispose(); +} + + +void WaitWindow_Impl::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& /*rRect*/) +{ + rRenderContext.DrawText(maRect, maText, gnTextStyle); +} + +void SfxDocTplService_Impl::addHierGroup( GroupList_Impl& rList, + const OUString& rTitle, + const OUString& rOwnURL ) +{ + // now get the content of the Group + Content aContent; + uno::Reference<XResultSet> xResultSet; + + try + { + aContent = Content(rOwnURL, maCmdEnv, comphelper::getProcessComponentContext()); + xResultSet = aContent.createCursor( { TITLE, TARGET_URL, PROPERTY_TYPE }, INCLUDE_DOCUMENTS_ONLY ); + } + catch (ContentCreationException&) + { + TOOLS_WARN_EXCEPTION( "sfx.doc", "" ); + } + catch (Exception&) {} + + if ( !xResultSet.is() ) + return; + + GroupData_Impl *pGroup = new GroupData_Impl( rTitle ); + pGroup->setHierarchy( true ); + pGroup->setHierarchyURL( rOwnURL ); + rList.push_back( std::unique_ptr<GroupData_Impl>(pGroup) ); + + uno::Reference< XContentAccess > xContentAccess( xResultSet, UNO_QUERY ); + uno::Reference< XRow > xRow( xResultSet, UNO_QUERY ); + + try + { + while ( xResultSet->next() ) + { + bool bUpdateType = false; + DocTemplates_EntryData_Impl *pData; + + const OUString aTitle( xRow->getString( 1 ) ); + const OUString aTargetDir( xRow->getString( 2 ) ); + OUString aType( xRow->getString( 3 ) ); + const OUString aHierURL {xContentAccess->queryContentIdentifierString()}; + + if ( aType.isEmpty() ) + { + OUString aTmpTitle; + + bool bDocHasTitle = false; + getTitleFromURL( aTargetDir, aTmpTitle, aType, bDocHasTitle ); + + if ( !aType.isEmpty() ) + bUpdateType = true; + } + + pData = pGroup->addEntry( aTitle, aTargetDir, aType, aHierURL ); + pData->setUpdateType( bUpdateType ); + } + } + catch ( Exception& ) {} +} + + +void SfxDocTplService_Impl::addFsysGroup( GroupList_Impl& rList, + const OUString& rTitle, + const OUString& rUITitle, + const OUString& rOwnURL, + bool bWriteableGroup ) +{ + OUString aTitle; + + if ( rUITitle.isEmpty() ) + { + // reserved FS names that should not be used + if ( rTitle == "wizard" ) + return; + else if ( rTitle == "internal" ) + return; + + aTitle = getLongName( rTitle ); + } + else + aTitle = rUITitle; + + if ( aTitle.isEmpty() ) + return; + + GroupData_Impl* pGroup = nullptr; + for (const std::unique_ptr<GroupData_Impl>& i : rList) + { + if ( i->getTitle() == aTitle ) + { + pGroup = i.get(); + break; + } + } + + if ( !pGroup ) + { + pGroup = new GroupData_Impl( aTitle ); + rList.push_back( std::unique_ptr<GroupData_Impl>(pGroup) ); + } + + if ( bWriteableGroup ) + pGroup->setTargetURL( rOwnURL ); + + pGroup->setInUse(); + + // now get the content of the Group + Content aContent; + uno::Reference< XResultSet > xResultSet; + Sequence< OUString > aProps { TITLE }; + + try + { + // this method is only used during checking of the available template-folders + // that should happen quietly + uno::Reference< XCommandEnvironment > aQuietEnv; + aContent = Content( rOwnURL, aQuietEnv, comphelper::getProcessComponentContext() ); + xResultSet = aContent.createCursor( aProps, INCLUDE_DOCUMENTS_ONLY ); + } + catch ( Exception& ) {} + + if ( !xResultSet.is() ) + return; + + uno::Reference< XContentAccess > xContentAccess( xResultSet, UNO_QUERY ); + uno::Reference< XRow > xRow( xResultSet, UNO_QUERY ); + + try + { + while ( xResultSet->next() ) + { + OUString aChildTitle( xRow->getString( 1 ) ); + const OUString aTargetURL {xContentAccess->queryContentIdentifierString()}; + OUString aType; + + if ( aChildTitle == "sfx.tlx" || aChildTitle == "groupuinames.xml" ) + continue; + + bool bDocHasTitle = false; + getTitleFromURL( aTargetURL, aChildTitle, aType, bDocHasTitle ); + + pGroup->addEntry( aChildTitle, aTargetURL, aType, OUString() ); + } + } + catch ( Exception& ) {} +} + + +void SfxDocTplService_Impl::createFromContent( GroupList_Impl& rList, + Content &rContent, + bool bHierarchy, + bool bWriteableContent ) +{ + const OUString aTargetURL {rContent.get()->getIdentifier()->getContentIdentifier()}; + + // when scanning the file system, we have to add the 'standard' group, too + if ( ! bHierarchy ) + { + const OUString aUIStdTitle {getLongName( STANDARD_FOLDER )}; + addFsysGroup( rList, OUString(), aUIStdTitle, aTargetURL, bWriteableContent ); + } + + // search for predefined UI names + INetURLObject aLayerObj( aTargetURL ); + + // TODO/LATER: Use hashmap in future + std::vector< beans::StringPair > aUINames; + if ( !bHierarchy ) + aUINames = ReadUINamesForTemplateDir_Impl( aLayerObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + + uno::Reference< XResultSet > xResultSet; + Sequence< OUString > aProps { TITLE }; + + try + { + xResultSet = rContent.createCursor( aProps, INCLUDE_FOLDERS_ONLY ); + } + catch ( Exception& ) {} + + if ( !xResultSet.is() ) + return; + + uno::Reference< XContentAccess > xContentAccess( xResultSet, UNO_QUERY ); + uno::Reference< XRow > xRow( xResultSet, UNO_QUERY ); + + try + { + while ( xResultSet->next() ) + { + // TODO/LATER: clarify the encoding of the Title + const OUString aTitle( xRow->getString( 1 ) ); + const OUString aTargetSubfolderURL( xContentAccess->queryContentIdentifierString() ); + + if ( bHierarchy ) + addHierGroup( rList, aTitle, aTargetSubfolderURL ); + else + { + OUString aUITitle; + for (const beans::StringPair & rUIName : aUINames) + if ( rUIName.First == aTitle ) + { + aUITitle = rUIName.Second; + break; + } + + addFsysGroup( rList, aTitle, aUITitle, aTargetSubfolderURL, bWriteableContent ); + } + } + } + catch ( Exception& ) {} +} + + +void SfxDocTplService_Impl::removeFromHierarchy( DocTemplates_EntryData_Impl const *pData ) +{ + Content aTemplate; + + if ( Content::create( pData->getHierarchyURL(), maCmdEnv, comphelper::getProcessComponentContext(), aTemplate ) ) + { + removeContent( aTemplate ); + } +} + + +void SfxDocTplService_Impl::addToHierarchy( GroupData_Impl const *pGroup, + DocTemplates_EntryData_Impl const *pData ) +{ + Content aGroup, aTemplate; + + if ( ! Content::create( pGroup->getHierarchyURL(), maCmdEnv, comphelper::getProcessComponentContext(), aGroup ) ) + return; + + // Check, if there's a template with the given name in this group + // Return if there is already a template + INetURLObject aGroupObj( pGroup->getHierarchyURL() ); + + aGroupObj.insertName( pData->getTitle(), false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + + const OUString aTemplateURL {aGroupObj.GetMainURL( INetURLObject::DecodeMechanism::NONE )}; + + if ( Content::create( aTemplateURL, maCmdEnv, comphelper::getProcessComponentContext(), aTemplate ) ) + return; + + addEntry( aGroup, pData->getTitle(), + pData->getTargetURL(), + pData->getType() ); +} + + +void SfxDocTplService_Impl::updateData( DocTemplates_EntryData_Impl const *pData ) +{ + Content aTemplate; + + if ( ! Content::create( pData->getHierarchyURL(), maCmdEnv, comphelper::getProcessComponentContext(), aTemplate ) ) + return; + + if ( pData->getUpdateType() ) + { + setProperty( aTemplate, PROPERTY_TYPE, Any( pData->getType() ) ); + } + + if ( pData->getUpdateLink() ) + { + setProperty( aTemplate, TARGET_URL, Any( pData->getTargetURL() ) ); + } +} + + +void SfxDocTplService_Impl::addGroupToHierarchy( GroupData_Impl *pGroup ) +{ + Content aGroup; + + INetURLObject aNewGroupObj( maRootURL ); + aNewGroupObj.insertName( pGroup->getTitle(), false, + INetURLObject::LAST_SEGMENT, + INetURLObject::EncodeMechanism::All ); + + const OUString aNewGroupURL {aNewGroupObj.GetMainURL( INetURLObject::DecodeMechanism::NONE )}; + + if ( createFolder( aNewGroupURL, false, false, aGroup ) ) + { + setProperty( aGroup, TARGET_DIR_URL, Any( pGroup->getTargetURL() ) ); + pGroup->setHierarchyURL( aNewGroupURL ); + + size_t nCount = pGroup->count(); + for ( size_t i = 0; i < nCount; i++ ) + { + DocTemplates_EntryData_Impl *pData = pGroup->getEntry( i ); + addToHierarchy( pGroup, pData ); // add entry to hierarchy + } + } +} + + +void SfxDocTplService_Impl::removeFromHierarchy( GroupData_Impl const *pGroup ) +{ + Content aGroup; + + if ( Content::create( pGroup->getHierarchyURL(), maCmdEnv, comphelper::getProcessComponentContext(), aGroup ) ) + { + removeContent( aGroup ); + } +} + + +GroupData_Impl::GroupData_Impl( const OUString& rTitle ) + : maTitle(rTitle), mbInUse(false), mbInHierarchy(false) +{ +} + + +DocTemplates_EntryData_Impl* GroupData_Impl::addEntry( const OUString& rTitle, + const OUString& rTargetURL, + const OUString& rType, + const OUString& rHierURL ) +{ + DocTemplates_EntryData_Impl* pData = nullptr; + bool EntryFound = false; + + for (auto const & p : maEntries) + { + pData = p.get(); + if ( pData->getTitle() == rTitle ) + { + EntryFound = true; + break; + } + } + + if ( !EntryFound ) + { + pData = new DocTemplates_EntryData_Impl( rTitle ); + pData->setTargetURL( rTargetURL ); + pData->setType( rType ); + if ( !rHierURL.isEmpty() ) + { + pData->setHierarchyURL( rHierURL ); + pData->setHierarchy( true ); + } + maEntries.emplace_back( pData ); + } + else + { + if ( !rHierURL.isEmpty() ) + { + pData->setHierarchyURL( rHierURL ); + pData->setHierarchy( true ); + } + + if ( pData->getInHierarchy() ) + pData->setInUse(); + + if ( rTargetURL != pData->getTargetURL() ) + { + pData->setTargetURL( rTargetURL ); + pData->setUpdateLink( true ); + } + } + + return pData; +} + + +DocTemplates_EntryData_Impl::DocTemplates_EntryData_Impl( const OUString& rTitle ) + : maTitle(rTitle), mbInHierarchy(false), mbInUse(false), mbUpdateType(false), mbUpdateLink(false) +{ +} + +} + +// static +bool SfxURLRelocator_Impl::propertyCanContainOfficeDir( + std::u16string_view rPropName ) +{ + // Note: TargetURL is handled by UCB itself (because it is a property + // with a predefined semantic). Additional Core properties introduced + // be a client app must be handled by the client app itself, because + // the UCB does not know the semantics of those properties. + return ( rPropName == TARGET_DIR_URL || rPropName == PROPERTY_DIRLIST ); +} + + +SfxURLRelocator_Impl::SfxURLRelocator_Impl( const uno::Reference< XComponentContext > & xContext ) +: mxContext( xContext ) +{ +} + + +SfxURLRelocator_Impl::~SfxURLRelocator_Impl() +{ +} + + +void SfxURLRelocator_Impl::initOfficeInstDirs() +{ + if ( !mxOfficeInstDirs.is() ) + { + std::scoped_lock aGuard( maMutex ); + if ( !mxOfficeInstDirs.is() ) + { + OSL_ENSURE( mxContext.is(), "No service manager!" ); + + mxOfficeInstDirs = theOfficeInstallationDirectories::get(mxContext); + } + } +} + + +void SfxURLRelocator_Impl::implExpandURL( OUString& io_url ) +{ + const INetURLObject aParser( io_url ); + if ( aParser.GetProtocol() != INetProtocol::VndSunStarExpand ) + return; + + io_url = aParser.GetURLPath( INetURLObject::DecodeMechanism::WithCharset ); + try + { + if ( !mxMacroExpander.is() ) + { + mxMacroExpander.set( theMacroExpander::get(mxContext), UNO_SET_THROW ); + } + io_url = mxMacroExpander->expandMacros( io_url ); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("sfx.doc"); + } +} + + +void SfxURLRelocator_Impl::makeRelocatableURL( OUString & rURL ) +{ + if ( !rURL.isEmpty() ) + { + initOfficeInstDirs(); + implExpandURL( rURL ); + rURL = mxOfficeInstDirs->makeRelocatableURL( rURL ); + } +} + + +void SfxURLRelocator_Impl::makeAbsoluteURL( OUString & rURL ) +{ + if ( !rURL.isEmpty() ) + { + initOfficeInstDirs(); + implExpandURL( rURL ); + rURL = mxOfficeInstDirs->makeAbsoluteURL( rURL ); + } +} + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * +com_sun_star_comp_sfx2_DocumentTemplates_get_implementation( + css::uno::XComponentContext *context, + css::uno::Sequence<css::uno::Any> const &) +{ + return cppu::acquire(new SfxDocTplService(context)); +} + +OUString DocTemplLocaleHelper::GetStandardGroupString() +{ + return SfxResId(TEMPLATE_LONG_NAMES_ARY[0]); +} + +std::vector<OUString> DocTemplLocaleHelper::GetBuiltInGroupNames() +{ + std::vector<OUString> aGroups; + for(auto const & aGroupName : TEMPLATE_LONG_NAMES_ARY) + aGroups.push_back(SfxResId(aGroupName)); + return aGroups; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/doctemplateslocal.cxx b/sfx2/source/doc/doctemplateslocal.cxx new file mode 100644 index 000000000..5a55df72a --- /dev/null +++ b/sfx2/source/doc/doctemplateslocal.cxx @@ -0,0 +1,213 @@ +/* -*- 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 <com/sun/star/beans/StringPair.hpp> +#include <com/sun/star/xml/sax/Parser.hpp> +#include <com/sun/star/xml/sax/SAXException.hpp> +#include <com/sun/star/xml/sax/Writer.hpp> +#include <com/sun/star/xml/sax/XDocumentHandler.hpp> + +#include <comphelper/attributelist.hxx> +#include <rtl/ref.hxx> + +#include "doctemplateslocal.hxx" + +using namespace ::com::sun::star; + +namespace +{ + +// Relations info related strings +constexpr OUStringLiteral g_sGroupListElement(u"groupuinames:template-group-list"); +constexpr OUStringLiteral g_sGroupElement(u"groupuinames:template-group"); +constexpr OUStringLiteral g_sNameAttr(u"groupuinames:name"); +constexpr OUStringLiteral g_sUINameAttr(u"groupuinames:default-ui-name"); + +} + +std::vector< beans::StringPair > DocTemplLocaleHelper::ReadGroupLocalizationSequence( const uno::Reference< io::XInputStream >& xInStream, const uno::Reference< uno::XComponentContext >& xContext ) +{ + return ReadLocalizationSequence_Impl( xInStream, "groupuinames.xml", xContext ); +} + + +void DocTemplLocaleHelper::WriteGroupLocalizationSequence( const uno::Reference< io::XOutputStream >& xOutStream, const std::vector< beans::StringPair >& aSequence, const uno::Reference< uno::XComponentContext >& xContext ) +{ + if ( !xOutStream.is() ) + throw uno::RuntimeException(); + + uno::Reference< xml::sax::XWriter > xWriterHandler( + xml::sax::Writer::create(xContext) ); + + xWriterHandler->setOutputStream( xOutStream ); + + static const OUStringLiteral aCDATAString( u"CDATA" ); + static const OUStringLiteral aWhiteSpace( u" " ); + + // write the namespace + rtl::Reference<::comphelper::AttributeList> pRootAttrList = new ::comphelper::AttributeList; + pRootAttrList->AddAttribute( + "xmlns:groupuinames", + aCDATAString, + "http://openoffice.org/2006/groupuinames" ); + + xWriterHandler->startDocument(); + xWriterHandler->startElement( g_sGroupListElement, pRootAttrList ); + + for (const auto & i : aSequence) + { + rtl::Reference<::comphelper::AttributeList> pAttrList = new ::comphelper::AttributeList; + pAttrList->AddAttribute( g_sNameAttr, aCDATAString, i.First ); + pAttrList->AddAttribute( g_sUINameAttr, aCDATAString, i.Second ); + + xWriterHandler->startElement( g_sGroupElement, pAttrList ); + xWriterHandler->ignorableWhitespace( aWhiteSpace ); + xWriterHandler->endElement( g_sGroupElement ); + } + + xWriterHandler->ignorableWhitespace( aWhiteSpace ); + xWriterHandler->endElement( g_sGroupListElement ); + xWriterHandler->endDocument(); +} + + +std::vector< beans::StringPair > DocTemplLocaleHelper::ReadLocalizationSequence_Impl( const uno::Reference< io::XInputStream >& xInStream, const OUString& aStringID, const uno::Reference< uno::XComponentContext >& xContext ) +{ + if ( !xContext.is() || !xInStream.is() ) + throw uno::RuntimeException(); + + uno::Reference< xml::sax::XParser > xParser = xml::sax::Parser::create( xContext ); + + rtl::Reference<DocTemplLocaleHelper> pHelper = new DocTemplLocaleHelper(); + xml::sax::InputSource aParserInput; + aParserInput.aInputStream = xInStream; + aParserInput.sSystemId = aStringID; + xParser->setDocumentHandler( pHelper ); + xParser->parseStream( aParserInput ); + xParser->setDocumentHandler( uno::Reference < xml::sax::XDocumentHandler > () ); + + return pHelper->GetParsingResult(); +} + + +DocTemplLocaleHelper::DocTemplLocaleHelper() +{ +} + + +DocTemplLocaleHelper::~DocTemplLocaleHelper() +{ +} + + +std::vector< beans::StringPair > const & DocTemplLocaleHelper::GetParsingResult() const +{ + if ( !m_aElementsSeq.empty() ) + throw uno::RuntimeException("The parsing has still not finished!"); + + return m_aResultSeq; +} + + +void SAL_CALL DocTemplLocaleHelper::startDocument() +{ +} + + +void SAL_CALL DocTemplLocaleHelper::endDocument() +{ +} + + +void SAL_CALL DocTemplLocaleHelper::startElement( const OUString& aName, const uno::Reference< xml::sax::XAttributeList >& xAttribs ) +{ + if ( aName == g_sGroupListElement ) + { + if ( !m_aElementsSeq.empty() ) + throw xml::sax::SAXException(); // TODO: this element must be the first level element + + m_aElementsSeq.push_back( aName ); + + return; // nothing to do + } + else if ( aName == g_sGroupElement ) + { + if ( m_aElementsSeq.size() != 1 ) + throw xml::sax::SAXException(); // TODO: this element must be the second level element + + m_aElementsSeq.push_back( aName ); + + const auto nNewEntryNum = m_aResultSeq.size(); + m_aResultSeq.resize( nNewEntryNum+1 ); + + const OUString aNameValue = xAttribs->getValueByName( g_sNameAttr ); + if ( aNameValue.isEmpty() ) + throw xml::sax::SAXException(); // TODO: the ID value must present + + const OUString aUINameValue = xAttribs->getValueByName( g_sUINameAttr ); + if ( aUINameValue.isEmpty() ) + throw xml::sax::SAXException(); // TODO: the ID value must present + + m_aResultSeq[nNewEntryNum].First = aNameValue; + m_aResultSeq[nNewEntryNum].Second = aUINameValue; + } + else + { + // accept future extensions + if ( m_aElementsSeq.empty() ) + throw xml::sax::SAXException(); // TODO: the extension element must not be the first level element + + m_aElementsSeq.push_back( aName ); + } +} + + +void SAL_CALL DocTemplLocaleHelper::endElement( const OUString& aName ) +{ + if ( m_aElementsSeq.empty() ) + throw xml::sax::SAXException(); // TODO: no other end elements expected! + + if ( m_aElementsSeq.back() != aName ) + throw xml::sax::SAXException(); // TODO: unexpected element ended + + m_aElementsSeq.pop_back(); +} + + +void SAL_CALL DocTemplLocaleHelper::characters( const OUString& /*aChars*/ ) +{ +} + + +void SAL_CALL DocTemplLocaleHelper::ignorableWhitespace( const OUString& /*aWhitespaces*/ ) +{ +} + + +void SAL_CALL DocTemplLocaleHelper::processingInstruction( const OUString& /*aTarget*/, const OUString& /*aData*/ ) +{ +} + + +void SAL_CALL DocTemplLocaleHelper::setDocumentLocator( const uno::Reference< xml::sax::XLocator >& /*xLocator*/ ) +{ +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/doctemplateslocal.hxx b/sfx2/source/doc/doctemplateslocal.hxx new file mode 100644 index 000000000..466c847db --- /dev/null +++ b/sfx2/source/doc/doctemplateslocal.hxx @@ -0,0 +1,78 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_SFX2_SOURCE_DOC_DOCTEMPLATESLOCAL_HXX +#define INCLUDED_SFX2_SOURCE_DOC_DOCTEMPLATESLOCAL_HXX + +#include <com/sun/star/xml/sax/XDocumentHandler.hpp> +#include <com/sun/star/beans/StringPair.hpp> +#include <com/sun/star/io/XInputStream.hpp> +#include <com/sun/star/io/XOutputStream.hpp> +#include <com/sun/star/uno/XComponentContext.hpp> +#include <cppuhelper/implbase.hxx> +#include <vector> + + +class DocTemplLocaleHelper : public cppu::WeakImplHelper < css::xml::sax::XDocumentHandler > +{ + std::vector< css::beans::StringPair > m_aResultSeq; + std::vector< OUString > m_aElementsSeq; // stack of elements being parsed + + DocTemplLocaleHelper(); + std::vector< css::beans::StringPair > const & GetParsingResult() const; + + /// @throws css::uno::Exception + static std::vector< css::beans::StringPair > ReadLocalizationSequence_Impl( const css::uno::Reference< css::io::XInputStream >& xInStream, const OUString& aStringID, const css::uno::Reference< css::uno::XComponentContext >& xContext ); + +public: + virtual ~DocTemplLocaleHelper() override; + + // returns sequence of pairs ( GroupName, GroupUIName ) + /// @throws css::uno::Exception + static + std::vector< css::beans::StringPair > + ReadGroupLocalizationSequence( + const css::uno::Reference< css::io::XInputStream >& xInStream, + const css::uno::Reference< css::uno::XComponentContext >& xContext ); + + // writes sequence of elements ( GroupName, GroupUIName ) + /// @throws css::uno::Exception + static + void WriteGroupLocalizationSequence( + const css::uno::Reference< css::io::XOutputStream >& xOutStream, + const std::vector< css::beans::StringPair >& aSequence, + const css::uno::Reference< css::uno::XComponentContext >& xContext ); + + static OUString GetStandardGroupString(); + static std::vector<OUString> GetBuiltInGroupNames(); + + // XDocumentHandler + virtual void SAL_CALL startDocument() override; + virtual void SAL_CALL endDocument() override; + virtual void SAL_CALL startElement( const OUString& aName, const css::uno::Reference< css::xml::sax::XAttributeList >& xAttribs ) override; + virtual void SAL_CALL endElement( const OUString& aName ) override; + virtual void SAL_CALL characters( const OUString& aChars ) override; + virtual void SAL_CALL ignorableWhitespace( const OUString& aWhitespaces ) override; + virtual void SAL_CALL processingInstruction( const OUString& aTarget, const OUString& aData ) override; + virtual void SAL_CALL setDocumentLocator( const css::uno::Reference< css::xml::sax::XLocator >& xLocator ) override; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/docundomanager.cxx b/sfx2/source/doc/docundomanager.cxx new file mode 100644 index 000000000..ab7438a7b --- /dev/null +++ b/sfx2/source/doc/docundomanager.cxx @@ -0,0 +1,423 @@ +/* -*- 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 <docundomanager.hxx> +#include <sfx2/sfxbasemodel.hxx> +#include <sfx2/objsh.hxx> +#include <sfx2/viewfrm.hxx> +#include <sfx2/viewsh.hxx> +#include <sfx2/bindings.hxx> +#include <sfx2/sfxsids.hrc> +#include <com/sun/star/lang/NoSupportException.hpp> +#include <com/sun/star/lang/NotInitializedException.hpp> +#include <svl/undo.hxx> +#include <tools/diagnose_ex.h> +#include <framework/undomanagerhelper.hxx> +#include <framework/imutex.hxx> + + +namespace sfx2 +{ + + + using ::com::sun::star::uno::Reference; + using ::com::sun::star::uno::XInterface; + using ::com::sun::star::uno::RuntimeException; + using ::com::sun::star::uno::Sequence; + using ::com::sun::star::document::XUndoAction; + using ::com::sun::star::lang::NotInitializedException; + using ::com::sun::star::document::XUndoManagerListener; + using ::com::sun::star::document::XUndoManager; + using ::com::sun::star::lang::NoSupportException; + using ::com::sun::star::frame::XModel; + + //= DocumentUndoManager_Impl + + struct DocumentUndoManager_Impl : public ::framework::IUndoManagerImplementation + { + DocumentUndoManager& rAntiImpl; + SfxUndoManager* pUndoManager; + ::framework::UndoManagerHelper aUndoHelper; + + explicit DocumentUndoManager_Impl( DocumentUndoManager& i_antiImpl ) + :rAntiImpl( i_antiImpl ) + ,pUndoManager( impl_retrieveUndoManager( i_antiImpl.getBaseModel() ) ) + // do this *before* the construction of aUndoHelper (which actually means: put pUndoManager before + // aUndoHelper in the member list)! + ,aUndoHelper( *this ) + { + } + + virtual ~DocumentUndoManager_Impl() + { + }; + + // IUndoManagerImplementation + virtual SfxUndoManager& getImplUndoManager() override; + virtual Reference< XUndoManager > getThis() override; + + void disposing() + { + aUndoHelper.disposing(); + ENSURE_OR_RETURN_VOID( pUndoManager, "DocumentUndoManager_Impl::disposing: already disposed!" ); + pUndoManager = nullptr; + } + + void invalidateXDo_nolck(); + + private: + static SfxUndoManager* impl_retrieveUndoManager( SfxBaseModel& i_baseModel ) + { + SfxUndoManager* pUndoManager( nullptr ); + SfxObjectShell* pObjectShell = i_baseModel.GetObjectShell(); + if ( pObjectShell != nullptr ) + pUndoManager = pObjectShell->GetUndoManager(); + if ( !pUndoManager ) + throw NotInitializedException( OUString(), i_baseModel ); + return pUndoManager; + } + }; + + + SfxUndoManager& DocumentUndoManager_Impl::getImplUndoManager() + { + ENSURE_OR_THROW( pUndoManager != nullptr, "DocumentUndoManager_Impl::getImplUndoManager: no access to the doc's UndoManager implementation!" ); + +#if OSL_DEBUG_LEVEL > 0 + // in a non-product build, assert if the current UndoManager at the shell is not the same we obtained + // (and cached) at construction time + SfxObjectShell* pObjectShell = rAntiImpl.getBaseModel().GetObjectShell(); + OSL_ENSURE( ( pObjectShell != nullptr ) && ( pUndoManager == pObjectShell->GetUndoManager() ), + "DocumentUndoManager_Impl::getImplUndoManager: the UndoManager changed meanwhile - what about our listener?" ); +#endif + + return *pUndoManager; + } + + + Reference< XUndoManager > DocumentUndoManager_Impl::getThis() + { + return static_cast< XUndoManager* >( &rAntiImpl ); + } + + + void DocumentUndoManager_Impl::invalidateXDo_nolck() + { + SfxModelGuard aGuard( rAntiImpl ); + + const SfxObjectShell* pDocShell = rAntiImpl.getBaseModel().GetObjectShell(); + ENSURE_OR_THROW( pDocShell != nullptr, "lcl_invalidateUndo: no access to the doc shell!" ); + SfxViewFrame* pViewFrame = SfxViewFrame::GetFirst( pDocShell ); + while ( pViewFrame ) + { + pViewFrame->GetBindings().Invalidate( SID_UNDO ); + pViewFrame->GetBindings().Invalidate( SID_REDO ); + pViewFrame = SfxViewFrame::GetNext( *pViewFrame, pDocShell ); + } + } + + + //= SolarMutexFacade + + namespace { + + /** a facade for the SolarMutex, implementing ::framework::IMutex + */ + class SolarMutexFacade : public ::framework::IMutex + { + public: + SolarMutexFacade() + { + } + + virtual ~SolarMutexFacade() {} + + virtual void acquire() override + { + Application::GetSolarMutex().acquire(); + } + + virtual void release() override + { + Application::GetSolarMutex().release(); + } + }; + + + //= UndoManagerGuard + + class UndoManagerGuard :public ::framework::IMutexGuard + { + public: + explicit UndoManagerGuard( DocumentUndoManager& i_undoManager ) + :m_guard( i_undoManager ) + { + } + + virtual ~UndoManagerGuard() + { + } + + UndoManagerGuard(const UndoManagerGuard&) = delete; + UndoManagerGuard& operator=(const UndoManagerGuard&) = delete; + + virtual void clear() override + { + m_guard.clear(); + } + + virtual ::framework::IMutex& getGuardedMutex() override + { + // note that this means that we *know* that SfxModelGuard also locks the SolarMutex (nothing more, nothing less). + // If this ever changes, we need to adjust this code here, too. + return m_solarMutexFacade; + } + + private: + SfxModelGuard m_guard; + SolarMutexFacade m_solarMutexFacade; + }; + + } + + //= DocumentUndoManager + + + DocumentUndoManager::DocumentUndoManager( SfxBaseModel& i_document ) + :SfxModelSubComponent( i_document ) + ,m_pImpl( new DocumentUndoManager_Impl( *this ) ) + { + } + + DocumentUndoManager::~DocumentUndoManager() + { + } + + void DocumentUndoManager::disposing() + { + m_pImpl->disposing(); + } + + + bool DocumentUndoManager::isInContext() const + { + // No mutex locking within this method, no disposal check - this is the responsibility of the owner. + return m_pImpl->getImplUndoManager().IsInListAction(); + } + + + void SAL_CALL DocumentUndoManager::acquire() noexcept + { + OWeakObject::acquire(); + SfxModelSubComponent::acquireModel(); + } + + + void SAL_CALL DocumentUndoManager::release() noexcept + { + SfxModelSubComponent::releaseModel(); + OWeakObject::release(); + } + + + void SAL_CALL DocumentUndoManager::enterUndoContext( const OUString& i_title ) + { + // SYNCHRONIZED ---> + UndoManagerGuard aGuard( *this ); + m_pImpl->aUndoHelper.enterUndoContext( i_title, aGuard ); + // <--- SYNCHRONIZED + m_pImpl->invalidateXDo_nolck(); + } + + + void SAL_CALL DocumentUndoManager::enterHiddenUndoContext( ) + { + // SYNCHRONIZED ---> + UndoManagerGuard aGuard( *this ); + m_pImpl->aUndoHelper.enterHiddenUndoContext( aGuard ); + // <--- SYNCHRONIZED + m_pImpl->invalidateXDo_nolck(); + } + + + void SAL_CALL DocumentUndoManager::leaveUndoContext( ) + { + // SYNCHRONIZED ---> + UndoManagerGuard aGuard( *this ); + m_pImpl->aUndoHelper.leaveUndoContext( aGuard ); + // <--- SYNCHRONIZED + m_pImpl->invalidateXDo_nolck(); + } + + + void SAL_CALL DocumentUndoManager::addUndoAction( const Reference< XUndoAction >& i_action ) + { + // SYNCHRONIZED ---> + UndoManagerGuard aGuard( *this ); + m_pImpl->aUndoHelper.addUndoAction( i_action, aGuard ); + // <--- SYNCHRONIZED + m_pImpl->invalidateXDo_nolck(); + } + + + void SAL_CALL DocumentUndoManager::undo( ) + { + // SYNCHRONIZED ---> + UndoManagerGuard aGuard( *this ); + m_pImpl->aUndoHelper.undo( aGuard ); + // <--- SYNCHRONIZED + m_pImpl->invalidateXDo_nolck(); + } + + + void SAL_CALL DocumentUndoManager::redo( ) + { + // SYNCHRONIZED ---> + UndoManagerGuard aGuard( *this ); + m_pImpl->aUndoHelper.redo( aGuard ); + // <--- SYNCHRONIZED + m_pImpl->invalidateXDo_nolck(); + } + + + sal_Bool SAL_CALL DocumentUndoManager::isUndoPossible( ) + { + UndoManagerGuard aGuard( *this ); + return m_pImpl->aUndoHelper.isUndoPossible(); + } + + + sal_Bool SAL_CALL DocumentUndoManager::isRedoPossible( ) + { + UndoManagerGuard aGuard( *this ); + return m_pImpl->aUndoHelper.isRedoPossible(); + } + + + OUString SAL_CALL DocumentUndoManager::getCurrentUndoActionTitle( ) + { + UndoManagerGuard aGuard( *this ); + return m_pImpl->aUndoHelper.getCurrentUndoActionTitle(); + } + + + OUString SAL_CALL DocumentUndoManager::getCurrentRedoActionTitle( ) + { + UndoManagerGuard aGuard( *this ); + return m_pImpl->aUndoHelper.getCurrentRedoActionTitle(); + } + + + Sequence< OUString > SAL_CALL DocumentUndoManager::getAllUndoActionTitles( ) + { + UndoManagerGuard aGuard( *this ); + return m_pImpl->aUndoHelper.getAllUndoActionTitles(); + } + + + Sequence< OUString > SAL_CALL DocumentUndoManager::getAllRedoActionTitles( ) + { + UndoManagerGuard aGuard( *this ); + return m_pImpl->aUndoHelper.getAllRedoActionTitles(); + } + + + void SAL_CALL DocumentUndoManager::clear( ) + { + // SYNCHRONIZED ---> + UndoManagerGuard aGuard( *this ); + m_pImpl->aUndoHelper.clear( aGuard ); + // <--- SYNCHRONIZED + m_pImpl->invalidateXDo_nolck(); + } + + + void SAL_CALL DocumentUndoManager::clearRedo( ) + { + // SYNCHRONIZED ---> + UndoManagerGuard aGuard( *this ); + m_pImpl->aUndoHelper.clearRedo( aGuard ); + // <--- SYNCHRONIZED + m_pImpl->invalidateXDo_nolck(); + } + + + void SAL_CALL DocumentUndoManager::reset() + { + // SYNCHRONIZED ---> + UndoManagerGuard aGuard( *this ); + m_pImpl->aUndoHelper.reset( aGuard ); + // <--- SYNCHRONIZED + m_pImpl->invalidateXDo_nolck(); + } + + + void SAL_CALL DocumentUndoManager::lock( ) + { + UndoManagerGuard aGuard( *this ); + m_pImpl->aUndoHelper.lock(); + } + + + void SAL_CALL DocumentUndoManager::unlock( ) + { + UndoManagerGuard aGuard( *this ); + m_pImpl->aUndoHelper.unlock(); + } + + + sal_Bool SAL_CALL DocumentUndoManager::isLocked( ) + { + UndoManagerGuard aGuard( *this ); + return m_pImpl->aUndoHelper.isLocked(); + } + + + void SAL_CALL DocumentUndoManager::addUndoManagerListener( const Reference< XUndoManagerListener >& i_listener ) + { + UndoManagerGuard aGuard( *this ); + return m_pImpl->aUndoHelper.addUndoManagerListener( i_listener ); + } + + + void SAL_CALL DocumentUndoManager::removeUndoManagerListener( const Reference< XUndoManagerListener >& i_listener ) + { + UndoManagerGuard aGuard( *this ); + return m_pImpl->aUndoHelper.removeUndoManagerListener( i_listener ); + } + + + Reference< XInterface > SAL_CALL DocumentUndoManager::getParent( ) + { + UndoManagerGuard aGuard( *this ); + return static_cast< XModel* >( &getBaseModel() ); + } + + + void SAL_CALL DocumentUndoManager::setParent( const Reference< XInterface >& ) + { + throw NoSupportException( OUString(), m_pImpl->getThis() ); + } + + +} // namespace sfx2 + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/exoticfileloadexception.cxx b/sfx2/source/doc/exoticfileloadexception.cxx new file mode 100644 index 000000000..91dc9c273 --- /dev/null +++ b/sfx2/source/doc/exoticfileloadexception.cxx @@ -0,0 +1,37 @@ +/* -*- 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/. + */ + +#include "exoticfileloadexception.hxx" + +#include <comphelper/interaction.hxx> +#include <com/sun/star/document/ExoticFileLoadException.hpp> + +using namespace com::sun::star; + +ExoticFileLoadException::ExoticFileLoadException(const OUString& rURL, + const OUString& rFilterUIName) + : m_xAbort(new comphelper::OInteractionAbort) + , m_xApprove(new comphelper::OInteractionApprove) + , m_lContinuations{ m_xApprove, m_xAbort } +{ + document::ExoticFileLoadException aReq; + aReq.URL = rURL; + aReq.FilterUIName = rFilterUIName; + + m_aRequest <<= aReq; +} + +bool ExoticFileLoadException::isApprove() const +{ + comphelper::OInteractionApprove* pBase + = static_cast<comphelper::OInteractionApprove*>(m_xApprove.get()); + return pBase->wasSelected(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/exoticfileloadexception.hxx b/sfx2/source/doc/exoticfileloadexception.hxx new file mode 100644 index 000000000..8204d6f55 --- /dev/null +++ b/sfx2/source/doc/exoticfileloadexception.hxx @@ -0,0 +1,43 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_SFX2_EXOTICFILELOADEXCEPTION_HXX +#define INCLUDED_SFX2_EXOTICFILELOADEXCEPTION_HXX + +#include <com/sun/star/task/XInteractionContinuation.hpp> +#include <com/sun/star/task/XInteractionRequest.hpp> +#include <cppuhelper/implbase.hxx> + +class ExoticFileLoadException : public cppu::WeakImplHelper<css::task::XInteractionRequest> +{ + // C++ interface +public: + ExoticFileLoadException(const OUString& rURL, const OUString& rFilterUIName); + bool isApprove() const; + + // UNO interface +public: + virtual css::uno::Sequence<css::uno::Reference<css::task::XInteractionContinuation>> + SAL_CALL getContinuations() override + { + return m_lContinuations; + } + css::uno::Any SAL_CALL getRequest() override { return m_aRequest; } + + // member +private: + css::uno::Any m_aRequest; + css::uno::Reference<css::task::XInteractionContinuation> m_xAbort; + css::uno::Reference<css::task::XInteractionContinuation> m_xApprove; + css::uno::Sequence<css::uno::Reference<css::task::XInteractionContinuation>> m_lContinuations; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/frmdescr.cxx b/sfx2/source/doc/frmdescr.cxx new file mode 100644 index 000000000..43183986d --- /dev/null +++ b/sfx2/source/doc/frmdescr.cxx @@ -0,0 +1,57 @@ +/* -*- 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 <svl/itemset.hxx> + +#include <sfx2/frmdescr.hxx> +#include <sfx2/app.hxx> +#include <memory> + +SfxFrameDescriptor::SfxFrameDescriptor() : + aMargin( -1, -1 ), + eScroll( ScrollingMode::Auto ), + bHasBorder( true ), + bHasBorderSet( false ) +{ +} + +SfxFrameDescriptor::~SfxFrameDescriptor() +{ +} + +SfxItemSet* SfxFrameDescriptor::GetArgs() +{ + if( !m_pArgs ) + m_pArgs.reset( new SfxAllItemSet( SfxGetpApp()->GetPool() ) ); + return m_pArgs.get(); +} + +void SfxFrameDescriptor::SetURL( std::u16string_view rURL ) +{ + aURL = INetURLObject(rURL); + SetActualURL(); +} + +void SfxFrameDescriptor::SetActualURL() +{ + if ( m_pArgs ) + m_pArgs->ClearItem(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/graphhelp.cxx b/sfx2/source/doc/graphhelp.cxx new file mode 100644 index 000000000..136e3ac9a --- /dev/null +++ b/sfx2/source/doc/graphhelp.cxx @@ -0,0 +1,260 @@ +/* -*- 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 . + */ + + +#ifdef _WIN32 +#include <prewin.h> +#include <postwin.h> +#endif + +#include <com/sun/star/uno/Exception.hpp> +#include <com/sun/star/graphic/GraphicProvider.hpp> +#include <com/sun/star/graphic/XGraphicProvider.hpp> +#include <com/sun/star/graphic/XGraphic.hpp> + + +#include <vcl/gdimtf.hxx> +#include <vcl/graph.hxx> +#include <vcl/cvtgrf.hxx> +#include <vcl/bitmapex.hxx> +#include <vcl/graphicfilter.hxx> + +#include <tools/stream.hxx> +#include <unotools/ucbstreamhelper.hxx> +#include <comphelper/processfactory.hxx> +#include <comphelper/propertyvalue.hxx> +#include <o3tl/char16_t2wchar_t.hxx> +#include <o3tl/string_view.hxx> + +#include "graphhelp.hxx" +#include <bitmaps.hlst> + +#include <memory> + +#if defined _WIN32 +#include <unotools/tempfile.hxx> +#include <vcl/outdev.hxx> +#endif + +using namespace css; + +std::unique_ptr<SvMemoryStream> GraphicHelper::getFormatStrFromGDI_Impl( const GDIMetaFile* pGDIMeta, ConvertDataFormat nFormat ) +{ + std::unique_ptr<SvMemoryStream> pResult; + if ( pGDIMeta ) + { + std::unique_ptr<SvMemoryStream> pStream(new SvMemoryStream( 65535, 65535 )); + Graphic aGraph( *pGDIMeta ); + if ( GraphicConverter::Export( *pStream, aGraph, nFormat ) == ERRCODE_NONE ) + pResult = std::move(pStream); + } + + return pResult; +} + + +// static +void* GraphicHelper::getEnhMetaFileFromGDI_Impl( const GDIMetaFile* pGDIMeta ) +{ + void* pResult = nullptr; + +#ifdef _WIN32 + if ( pGDIMeta ) + { + OUString const aStr(".emf"); + ::utl::TempFile aTempFile( u"", true, &aStr ); + + OUString aMetaFile = aTempFile.GetFileName(); + OUString aMetaURL = aTempFile.GetURL(); + + std::unique_ptr<SvStream> pStream = ::utl::UcbStreamHelper::CreateStream( aMetaURL, StreamMode::STD_READWRITE ); + if ( pStream ) + { + Graphic aGraph( *pGDIMeta ); + ErrCode nFailed = GraphicConverter::Export( *pStream, aGraph, ConvertDataFormat::EMF ); + pStream->Flush(); + pStream.reset(); + + if ( !nFailed ) + pResult = GetEnhMetaFileW( o3tl::toW(aMetaFile.getStr()) ); + } + } +#else + (void)pGDIMeta; // unused +#endif + + return pResult; +} + + +// static +void* GraphicHelper::getWinMetaFileFromGDI_Impl( const GDIMetaFile* pGDIMeta, const Size& aMetaSize ) +{ + void* pResult = nullptr; + +#ifdef _WIN32 + if ( pGDIMeta ) + { + SvMemoryStream pStream( 65535, 65535 ); + Graphic aGraph( *pGDIMeta ); + ErrCode nFailed = GraphicConverter::Export( pStream, aGraph, ConvertDataFormat::WMF ); + pStream.Flush(); + if ( !nFailed ) + { + sal_Int32 nLength = pStream.TellEnd(); + if ( nLength > 22 ) + { + HMETAFILE hMeta = SetMetaFileBitsEx( nLength - 22, + static_cast< const unsigned char*>( pStream.GetData() ) + 22 ); + + if ( hMeta ) + { + HGLOBAL hMemory = GlobalAlloc( GMEM_DDESHARE | GMEM_MOVEABLE, sizeof( METAFILEPICT ) ); + + if ( hMemory ) + { + METAFILEPICT* pMF = static_cast<METAFILEPICT*>(GlobalLock( hMemory )); + + pMF->hMF = hMeta; + pMF->mm = MM_ANISOTROPIC; + + MapMode aWinMode( MapUnit::Map100thMM ); + + if ( aWinMode == pGDIMeta->GetPrefMapMode() ) + { + pMF->xExt = aMetaSize.Width(); + pMF->yExt = aMetaSize.Height(); + } + else + { + Size aWinSize = OutputDevice::LogicToLogic( Size( aMetaSize.Width(), aMetaSize.Height() ), + pGDIMeta->GetPrefMapMode(), + aWinMode ); + pMF->xExt = aWinSize.Width(); + pMF->yExt = aWinSize.Height(); + } + + GlobalUnlock( hMemory ); + pResult = static_cast<void*>(hMemory); + } + else + DeleteMetaFile( hMeta ); + } + } + } + } +#else + (void)pGDIMeta; // unused + (void)aMetaSize; // unused +#endif + + + return pResult; +} + + +// static +bool GraphicHelper::getThumbnailFormatFromBitmap_Impl(const BitmapEx& rBitmap, const uno::Reference<io::XStream>& xStream) +{ + if (rBitmap.IsEmpty() || !xStream.is()) + return false; + + std::unique_ptr<SvStream> pStream(utl::UcbStreamHelper::CreateStream(xStream)); + + if (pStream->GetError()) + return false; + + BitmapEx bitmap(rBitmap); + bitmap.Convert(BmpConversion::N8BitColors); + + GraphicFilter& rFilter = GraphicFilter::GetGraphicFilter(); + + if (rFilter.compressAsPNG(bitmap, *pStream) != ERRCODE_NONE) + return false; + + pStream->FlushBuffer(); + + return !pStream->GetError(); +} + +// static +bool GraphicHelper::getThumbnailReplacement_Impl(std::u16string_view rResID, const uno::Reference< io::XStream >& xStream ) +{ + bool bResult = false; + if (!rResID.empty() && xStream.is()) + { + uno::Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext(); + try + { + uno::Reference< graphic::XGraphicProvider > xGraphProvider(graphic::GraphicProvider::create(xContext)); + const OUString aURL{OUString::Concat("private:graphicrepository/") + rResID}; + + uno::Sequence< beans::PropertyValue > aMediaProps{ comphelper::makePropertyValue("URL", + aURL) }; + + uno::Reference< graphic::XGraphic > xGraphic = xGraphProvider->queryGraphic( aMediaProps ); + if ( xGraphic.is() ) + { + uno::Sequence< beans::PropertyValue > aStoreProps{ + comphelper::makePropertyValue("OutputStream", xStream), + comphelper::makePropertyValue("MimeType", OUString("image/png")) + }; + + xGraphProvider->storeGraphic( xGraphic, aStoreProps ); + bResult = true; + } + } + catch(const uno::Exception&) + { + } + } + + return bResult; +} + +// static +OUString GraphicHelper::getThumbnailReplacementIDByFactoryName_Impl( std::u16string_view aFactoryShortName ) +{ + OUString sResult; + + if ( aFactoryShortName == u"scalc" ) + { + sResult = BMP_128X128_CALC_DOC; + } + else if ( aFactoryShortName == u"sdraw" ) + { + sResult = BMP_128X128_DRAW_DOC; + } + else if ( aFactoryShortName == u"simpress" ) + { + sResult = BMP_128X128_IMPRESS_DOC; + } + else if ( aFactoryShortName == u"smath" ) + { + sResult = BMP_128X128_MATH_DOC; + } + else if ( aFactoryShortName == u"swriter" || o3tl::starts_with(aFactoryShortName, u"swriter/") ) + { + sResult = BMP_128X128_WRITER_DOC; + } + + return sResult; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/graphhelp.hxx b/sfx2/source/doc/graphhelp.hxx new file mode 100644 index 000000000..1945661fc --- /dev/null +++ b/sfx2/source/doc/graphhelp.hxx @@ -0,0 +1,71 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_SFX2_SOURCE_DOC_GRAPHHELP_HXX +#define INCLUDED_SFX2_SOURCE_DOC_GRAPHHELP_HXX + +#include <sal/config.h> + +#include <string_view> + +#include <com/sun/star/uno/Reference.hxx> +#include <com/sun/star/io/XStream.hpp> +#include <rtl/ustring.hxx> +#include <tools/gen.hxx> + +class SvMemoryStream; +class GDIMetaFile; +class BitmapEx; +enum class ConvertDataFormat; + +class GraphicHelper +{ +public: + + static std::unique_ptr<SvMemoryStream> getFormatStrFromGDI_Impl( const GDIMetaFile* pGDIMeta, ConvertDataFormat nFormat ); + + static void* getEnhMetaFileFromGDI_Impl( const GDIMetaFile* pGDIMeta ); + + static void* getWinMetaFileFromGDI_Impl( const GDIMetaFile* pGDIMeta, const Size& aMetaSize ); + + static bool supportsMetaFileHandle_Impl() + { +#ifdef _WIN32 + return true; +#else + return false; +#endif + } + + static bool getThumbnailFormatFromBitmap_Impl( + const BitmapEx& rBitmap, + const css::uno::Reference< css::io::XStream >& xStream ); + + static OUString getThumbnailReplacementIDByFactoryName_Impl( + std::u16string_view aFactoryShortName); + + static bool getThumbnailReplacement_Impl( + std::u16string_view rResID, + const css::uno::Reference< css::io::XStream >& xStream ); + +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/guisaveas.cxx b/sfx2/source/doc/guisaveas.cxx new file mode 100644 index 000000000..23c75f296 --- /dev/null +++ b/sfx2/source/doc/guisaveas.cxx @@ -0,0 +1,1857 @@ +/* -*- 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 <com/sun/star/ui/dialogs/XExecutableDialog.hpp> +#include <com/sun/star/ui/dialogs/XFilePicker3.hpp> +#include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp> +#include <com/sun/star/ui/dialogs/CommonFilePickerElementIds.hpp> +#include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp> +#include <com/sun/star/ui/dialogs/TemplateDescription.hpp> +#include <com/sun/star/view/XSelectionSupplier.hpp> +#include <com/sun/star/beans/PropertyExistException.hpp> +#include <com/sun/star/beans/XPropertyAccess.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/beans/XPropertyContainer.hpp> +#include <com/sun/star/beans/PropertyAttribute.hpp> +#include <com/sun/star/document/XExporter.hpp> +#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp> +#include <com/sun/star/document/XDocumentProperties.hpp> +#include <com/sun/star/task/ErrorCodeIOException.hpp> +#include <com/sun/star/task/InteractionHandler.hpp> +#include <com/sun/star/util/URLTransformer.hpp> +#include <com/sun/star/util/XURLTransformer.hpp> +#include <com/sun/star/frame/ModuleManager.hpp> +#include <com/sun/star/frame/XStorable.hpp> +#include <com/sun/star/frame/XStorable2.hpp> +#include <com/sun/star/frame/XDispatchProvider.hpp> +#include <com/sun/star/frame/XDispatch.hpp> +#include <com/sun/star/frame/XTitle.hpp> +#include <com/sun/star/util/XModifiable.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> + +#include <com/sun/star/util/XCloneable.hpp> + +#include <guisaveas.hxx> + +#include <sal/log.hxx> +#include <svl/itemset.hxx> +#include <svl/eitem.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> +#include <tools/urlobj.hxx> +#include <comphelper/processfactory.hxx> +#include <comphelper/propertysequence.hxx> +#include <comphelper/propertyvalue.hxx> +#include <comphelper/sequenceashashmap.hxx> +#include <comphelper/mimeconfighelper.hxx> +#include <comphelper/lok.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> +#include <o3tl/char16_t2wchar_t.hxx> + +#include <sfx2/sfxsids.hrc> +#include <sfx2/strings.hrc> +#include <sfx2/sfxresid.hxx> +#include <sfx2/filedlghelper.hxx> +#include <sfx2/app.hxx> +#include <sfx2/sfxuno.hxx> +#include <alienwarn.hxx> + +#include <memory> +#include <string_view> + +#include <officecfg/Office/Common.hxx> + +#include <vcl/FilterConfigItem.hxx> +#include <com/sun/star/system/SystemShellExecute.hpp> +#include <com/sun/star/system/SystemShellExecuteFlags.hpp> + +#include <osl/file.hxx> + +#ifdef _WIN32 +#include <Shlobj.h> +#ifdef GetTempPath +#undef GetTempPath +#endif +#endif + +// flags that specify requested operation +#define EXPORT_REQUESTED 1 +#define PDFEXPORT_REQUESTED 2 +#define PDFDIRECTEXPORT_REQUESTED 4 +#define WIDEEXPORT_REQUESTED 8 +#define SAVE_REQUESTED 16 +#define SAVEAS_REQUESTED 32 +#define SAVEACOPY_REQUESTED 64 +#define EPUBEXPORT_REQUESTED 128 +#define EPUBDIRECTEXPORT_REQUESTED 256 +#define SAVEASREMOTE_REQUESTED -1 + +// possible statuses of save operation +#define STATUS_NO_ACTION 0 +#define STATUS_SAVE 1 +#define STATUS_SAVEAS 2 +#define STATUS_SAVEAS_STANDARDNAME 3 + +constexpr OUStringLiteral aFilterNameString = u"FilterName"; +constexpr OUStringLiteral aFilterOptionsString = u"FilterOptions"; +constexpr OUStringLiteral aFilterDataString = u"FilterData"; + +using namespace ::com::sun::star; +using namespace css::system; + +namespace { + +sal_uInt16 getSlotIDFromMode( sal_Int16 nStoreMode ) +{ + // This is a temporary hardcoded solution must be removed when + // dialogs do not need parameters in SidSet representation any more + + sal_uInt16 nResult = 0; + if ( nStoreMode == EXPORT_REQUESTED || nStoreMode == ( EXPORT_REQUESTED | SAVEACOPY_REQUESTED | WIDEEXPORT_REQUESTED ) ) + nResult = SID_EXPORTDOC; + else if ( nStoreMode == ( EXPORT_REQUESTED | PDFEXPORT_REQUESTED ) ) + nResult = SID_EXPORTDOCASPDF; + else if ( nStoreMode == ( EXPORT_REQUESTED | EPUBEXPORT_REQUESTED ) ) + nResult = SID_EXPORTDOCASEPUB; + else if ( nStoreMode == ( EXPORT_REQUESTED | PDFEXPORT_REQUESTED | PDFDIRECTEXPORT_REQUESTED ) ) + nResult = SID_DIRECTEXPORTDOCASPDF; + else if ( nStoreMode == ( EXPORT_REQUESTED | EPUBEXPORT_REQUESTED | EPUBDIRECTEXPORT_REQUESTED ) ) + nResult = SID_DIRECTEXPORTDOCASEPUB; + else if ( nStoreMode == SAVEAS_REQUESTED || nStoreMode == ( EXPORT_REQUESTED | WIDEEXPORT_REQUESTED ) ) + nResult = SID_SAVEASDOC; + else if ( nStoreMode == SAVEASREMOTE_REQUESTED ) + nResult = SID_SAVEASREMOTE; + else { + SAL_WARN( "sfx.doc", "Unacceptable slot name is provided!" ); + } + + return nResult; +} + + +sal_Int16 getStoreModeFromSlotName( std::u16string_view aSlotName ) +{ + sal_Int16 nResult = 0; + if ( aSlotName == u"ExportTo" ) + nResult = EXPORT_REQUESTED; + else if ( aSlotName == u"ExportToPDF" ) + nResult = EXPORT_REQUESTED | PDFEXPORT_REQUESTED; + else if ( aSlotName == u"ExportDirectToPDF" ) + nResult = EXPORT_REQUESTED | PDFEXPORT_REQUESTED | PDFDIRECTEXPORT_REQUESTED; + else if ( aSlotName == u"ExportToEPUB" ) + nResult = EXPORT_REQUESTED | EPUBEXPORT_REQUESTED; + else if ( aSlotName == u"ExportDirectToEPUB" ) + nResult = EXPORT_REQUESTED | EPUBEXPORT_REQUESTED | EPUBDIRECTEXPORT_REQUESTED; + else if ( aSlotName == u"Save" ) + nResult = SAVE_REQUESTED; + else if ( aSlotName == u"SaveAs" ) + nResult = SAVEAS_REQUESTED; + else if ( aSlotName == u"SaveAsRemote" ) + nResult = SAVEASREMOTE_REQUESTED; + else + throw task::ErrorCodeIOException( + (OUString::Concat("getStoreModeFromSlotName(\"") + aSlotName + + "): ERRCODE_IO_INVALIDPARAMETER"), + uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_INVALIDPARAMETER) ); + + return nResult; +} + + +SfxFilterFlags getMustFlags( sal_Int16 nStoreMode ) +{ + return ( SfxFilterFlags::EXPORT + | ( ( ( nStoreMode & EXPORT_REQUESTED ) && !( nStoreMode & WIDEEXPORT_REQUESTED ) ) ? SfxFilterFlags::NONE : SfxFilterFlags::IMPORT ) ); +} + + +SfxFilterFlags getDontFlags( sal_Int16 nStoreMode ) +{ + return ( SfxFilterFlags::INTERNAL + | SfxFilterFlags::NOTINFILEDLG + | ( ( ( nStoreMode & EXPORT_REQUESTED ) && !( nStoreMode & WIDEEXPORT_REQUESTED ) ) ? SfxFilterFlags::IMPORT : SfxFilterFlags::NONE ) ); +} + + + + +class DocumentSettingsGuard +{ + uno::Reference< beans::XPropertySet > m_xDocumentSettings; + bool m_bPreserveReadOnly; + bool m_bReadOnlySupported; + + bool m_bRestoreSettings; +public: + DocumentSettingsGuard( const uno::Reference< frame::XModel >& xModel, bool bReadOnly, bool bRestore ) + : m_bPreserveReadOnly( false ) + , m_bReadOnlySupported( false ) + , m_bRestoreSettings( bRestore ) + { + try + { + uno::Reference< lang::XMultiServiceFactory > xDocSettingsSupplier( xModel, uno::UNO_QUERY_THROW ); + m_xDocumentSettings.set( + xDocSettingsSupplier->createInstance( "com.sun.star.document.Settings" ), + uno::UNO_QUERY_THROW ); + + try + { + OUString aLoadReadonlyString( "LoadReadonly" ); + m_xDocumentSettings->getPropertyValue( aLoadReadonlyString ) >>= m_bPreserveReadOnly; + m_xDocumentSettings->setPropertyValue( aLoadReadonlyString, uno::Any( bReadOnly ) ); + m_bReadOnlySupported = true; + } + catch( const uno::Exception& ) + {} + } + catch( const uno::Exception& ) + {} + + if ( bReadOnly && !m_bReadOnlySupported ) + throw uno::RuntimeException(); // the user could provide the data, so it must be stored + } + + ~DocumentSettingsGuard() + { + if ( m_bRestoreSettings ) + { + try + { + if ( m_bReadOnlySupported ) + m_xDocumentSettings->setPropertyValue( "LoadReadonly", uno::Any( m_bPreserveReadOnly ) ); + } + catch( const uno::Exception& ) + { + TOOLS_WARN_EXCEPTION( "sfx.doc", "" ); + } + } + } +}; +} // anonymous namespace + + + +class ModelData_Impl +{ + SfxStoringHelper* m_pOwner; + uno::Reference< frame::XModel > m_xModel; + uno::Reference< frame::XStorable > m_xStorable; + uno::Reference< frame::XStorable2 > m_xStorable2; + + OUString m_aModuleName; + std::unique_ptr<::comphelper::SequenceAsHashMap> m_pDocumentPropsHM; + std::unique_ptr<::comphelper::SequenceAsHashMap> m_pModulePropsHM; + + ::comphelper::SequenceAsHashMap m_aMediaDescrHM; + + bool m_bRecommendReadOnly; + +public: + ModelData_Impl( SfxStoringHelper& aOwner, + const uno::Reference< frame::XModel >& xModel, + const uno::Sequence< beans::PropertyValue >& aMediaDescr ); + + ~ModelData_Impl(); + + void FreeDocumentProps(); + + uno::Reference< frame::XModel > const & GetModel() const; + uno::Reference< frame::XStorable > const & GetStorable(); + uno::Reference< frame::XStorable2 > const & GetStorable2(); + + ::comphelper::SequenceAsHashMap& GetMediaDescr() { return m_aMediaDescrHM; } + + bool IsRecommendReadOnly() const { return m_bRecommendReadOnly; } + + const ::comphelper::SequenceAsHashMap& GetDocProps(); + + OUString const & GetModuleName(); + const ::comphelper::SequenceAsHashMap& GetModuleProps(); + + void CheckInteractionHandler(); + + + OUString GetDocServiceName(); + uno::Sequence< beans::PropertyValue > GetDocServiceDefaultFilterCheckFlags( SfxFilterFlags nMust, SfxFilterFlags nDont ); + uno::Sequence< beans::PropertyValue > GetDocServiceAnyFilter( SfxFilterFlags nMust, SfxFilterFlags nDont ); + uno::Sequence< beans::PropertyValue > GetPreselectedFilter_Impl( sal_Int16 nStoreMode ); + uno::Sequence< beans::PropertyValue > GetDocServiceDefaultFilter(); + + bool ExecuteFilterDialog_Impl( const OUString& aFilterName ); + + sal_Int8 CheckSaveAcceptable( sal_Int8 nCurStatus ); + sal_Int8 CheckStateForSave(); + + sal_Int8 CheckFilter( const OUString& ); + + bool CheckFilterOptionsDialogExistence(); + + bool OutputFileDialog( sal_Int16 nStoreMode, + const ::comphelper::SequenceAsHashMap& aPreselectedFilterPropsHM, + bool bSetStandardName, + OUString& aSuggestedName, + bool bPreselectPassword, + OUString& aSuggestedDir, + sal_Int16 nDialog, + const OUString& rStandardDir, + const css::uno::Sequence< OUString >& rDenyList + ); + + bool ShowDocumentInfoDialog(); + + static OUString GetRecommendedExtension( const OUString& aTypeName ); + OUString GetRecommendedDir( const OUString& aSuggestedDir ); + OUString GetRecommendedName( const OUString& aSuggestedName, + const OUString& aTypeName ); + +}; + + +ModelData_Impl::ModelData_Impl( SfxStoringHelper& aOwner, + const uno::Reference< frame::XModel >& xModel, + const uno::Sequence< beans::PropertyValue >& aMediaDescr ) +: m_pOwner( &aOwner ) +, m_xModel( xModel ) +, m_aMediaDescrHM( aMediaDescr ) +, m_bRecommendReadOnly( false ) +{ + CheckInteractionHandler(); +} + + +ModelData_Impl::~ModelData_Impl() +{ + FreeDocumentProps(); + m_pDocumentPropsHM.reset(); + m_pModulePropsHM.reset(); +} + + +void ModelData_Impl::FreeDocumentProps() +{ + m_pDocumentPropsHM.reset(); +} + + +uno::Reference< frame::XModel > const & ModelData_Impl::GetModel() const +{ + if ( !m_xModel.is() ) + throw uno::RuntimeException(); + + return m_xModel; +} + + +uno::Reference< frame::XStorable > const & ModelData_Impl::GetStorable() +{ + if ( !m_xStorable.is() ) + { + m_xStorable.set( m_xModel, uno::UNO_QUERY_THROW ); + } + + return m_xStorable; +} + + +uno::Reference< frame::XStorable2 > const & ModelData_Impl::GetStorable2() +{ + if ( !m_xStorable2.is() ) + { + m_xStorable2.set( m_xModel, uno::UNO_QUERY_THROW ); + } + + return m_xStorable2; +} + + +const ::comphelper::SequenceAsHashMap& ModelData_Impl::GetDocProps() +{ + if ( !m_pDocumentPropsHM ) + m_pDocumentPropsHM.reset( new ::comphelper::SequenceAsHashMap( GetModel()->getArgs() ) ); + + return *m_pDocumentPropsHM; +} + + +OUString const & ModelData_Impl::GetModuleName() +{ + if ( m_aModuleName.isEmpty() ) + { + m_aModuleName = m_pOwner->GetModuleManager()->identify( + uno::Reference< uno::XInterface >( m_xModel, uno::UNO_QUERY ) ); + if ( m_aModuleName.isEmpty() ) + throw uno::RuntimeException(); // TODO: + } + return m_aModuleName; +} + + +const ::comphelper::SequenceAsHashMap& ModelData_Impl::GetModuleProps() +{ + if ( !m_pModulePropsHM ) + { + uno::Sequence< beans::PropertyValue > aModuleProps; + m_pOwner->GetModuleManager()->getByName( GetModuleName() ) >>= aModuleProps; + if ( !aModuleProps.hasElements() ) + throw uno::RuntimeException(); // TODO; + m_pModulePropsHM.reset( new ::comphelper::SequenceAsHashMap( aModuleProps ) ); + } + + return *m_pModulePropsHM; +} + + +OUString ModelData_Impl::GetDocServiceName() +{ + return GetModuleProps().getUnpackedValueOrDefault("ooSetupFactoryDocumentService", OUString()); +} + + +void ModelData_Impl::CheckInteractionHandler() +{ + const OUString sInteractionHandler {"InteractionHandler"}; + ::comphelper::SequenceAsHashMap::const_iterator aInteractIter = + m_aMediaDescrHM.find( sInteractionHandler ); + + if ( aInteractIter == m_aMediaDescrHM.end() ) + { + try { + m_aMediaDescrHM[ sInteractionHandler ] + <<= task::InteractionHandler::createWithParent( comphelper::getProcessComponentContext(), nullptr); + } + catch( const uno::Exception& ) + { + } + } + else + { + uno::Reference< task::XInteractionHandler > xInteract; + DBG_ASSERT( ( aInteractIter->second >>= xInteract ) && xInteract.is(), "Broken interaction handler is provided!\n" ); + } +} + + +uno::Sequence< beans::PropertyValue > ModelData_Impl::GetDocServiceDefaultFilter() +{ + uno::Sequence< beans::PropertyValue > aProps; + + const OUString aFilterName = GetModuleProps().getUnpackedValueOrDefault( "ooSetupFactoryDefaultFilter", OUString() ); + + m_pOwner->GetFilterConfiguration()->getByName( aFilterName ) >>= aProps; + + return aProps; +} + + +uno::Sequence< beans::PropertyValue > ModelData_Impl::GetDocServiceDefaultFilterCheckFlags( SfxFilterFlags nMust, + SfxFilterFlags nDont ) +{ + uno::Sequence< beans::PropertyValue > aFilterProps; + uno::Sequence< beans::PropertyValue > aProps = GetDocServiceDefaultFilter(); + if ( aProps.hasElements() ) + { + ::comphelper::SequenceAsHashMap aFiltHM( aProps ); + SfxFilterFlags nFlags = static_cast<SfxFilterFlags>(aFiltHM.getUnpackedValueOrDefault("Flags", + sal_Int32(0) )); + if ( ( ( nFlags & nMust ) == nMust ) && !( nFlags & nDont ) ) + aFilterProps = aProps; + } + + return aFilterProps; +} + + +uno::Sequence< beans::PropertyValue > ModelData_Impl::GetDocServiceAnyFilter( SfxFilterFlags nMust, SfxFilterFlags nDont ) +{ + uno::Sequence< beans::NamedValue > aSearchRequest { { "DocumentService", css::uno::Any(GetDocServiceName()) } }; + + return ::comphelper::MimeConfigurationHelper::SearchForFilter( m_pOwner->GetFilterQuery(), aSearchRequest, nMust, nDont ); +} + + +uno::Sequence< beans::PropertyValue > ModelData_Impl::GetPreselectedFilter_Impl( sal_Int16 nStoreMode ) +{ + if ( nStoreMode == SAVEASREMOTE_REQUESTED ) + nStoreMode = SAVEAS_REQUESTED; + + uno::Sequence< beans::PropertyValue > aFilterProps; + + SfxFilterFlags nMust = getMustFlags( nStoreMode ); + SfxFilterFlags nDont = getDontFlags( nStoreMode ); + + if ( ( nStoreMode != SAVEASREMOTE_REQUESTED ) && ( nStoreMode & PDFEXPORT_REQUESTED ) ) + { + // Preselect PDF-Filter for EXPORT + uno::Sequence< beans::NamedValue > aSearchRequest + { + { "Type", css::uno::Any(OUString("pdf_Portable_Document_Format")) }, + { "DocumentService", css::uno::Any(GetDocServiceName()) } + }; + + aFilterProps = ::comphelper::MimeConfigurationHelper::SearchForFilter( m_pOwner->GetFilterQuery(), aSearchRequest, nMust, nDont ); + } + else if ( ( nStoreMode != SAVEASREMOTE_REQUESTED ) && ( nStoreMode & EPUBEXPORT_REQUESTED ) ) + { + // Preselect EPUB filter for export. + uno::Sequence<beans::NamedValue> aSearchRequest + { + { "Type", css::uno::Any(OUString("writer_EPUB_Document")) }, + { "DocumentService", css::uno::Any(GetDocServiceName()) } + }; + + aFilterProps = ::comphelper::MimeConfigurationHelper::SearchForFilter( m_pOwner->GetFilterQuery(), aSearchRequest, nMust, nDont ); + } + else + { + aFilterProps = GetDocServiceDefaultFilterCheckFlags( nMust, nDont ); + + if ( !aFilterProps.hasElements() ) + { + // the default filter was not found, use just the first acceptable one + aFilterProps = GetDocServiceAnyFilter( nMust, nDont ); + } + } + + return aFilterProps; +} + + +bool ModelData_Impl::ExecuteFilterDialog_Impl( const OUString& aFilterName ) +{ + bool bDialogUsed = false; + + try { + uno::Sequence < beans::PropertyValue > aProps; + uno::Any aAny = m_pOwner->GetFilterConfiguration()->getByName( aFilterName ); + if ( aAny >>= aProps ) + { + auto pProp = std::find_if(std::cbegin(aProps), std::cend(aProps), + [](const beans::PropertyValue& rProp) { return rProp.Name == "UIComponent"; }); + if (pProp != std::cend(aProps)) + { + OUString aServiceName; + pProp->Value >>= aServiceName; + if( !aServiceName.isEmpty() ) + { + uno::Sequence<uno::Any> aDialogArgs(comphelper::InitAnyPropertySequence( + { + {"ParentWindow", uno::Any(SfxStoringHelper::GetModelXWindow(m_xModel))}, + })); + + uno::Reference< ui::dialogs::XExecutableDialog > xFilterDialog( + comphelper::getProcessServiceFactory()->createInstanceWithArguments(aServiceName, aDialogArgs), uno::UNO_QUERY ); + uno::Reference< beans::XPropertyAccess > xFilterProperties( xFilterDialog, uno::UNO_QUERY ); + + if( xFilterDialog.is() && xFilterProperties.is() ) + { + bDialogUsed = true; + + uno::Reference< document::XExporter > xExporter( xFilterDialog, uno::UNO_QUERY ); + if( xExporter.is() ) + xExporter->setSourceDocument( GetModel() ); + + uno::Sequence< beans::PropertyValue > aPropsForDialog; + GetMediaDescr() >> aPropsForDialog; + xFilterProperties->setPropertyValues( aPropsForDialog ); + + if( !xFilterDialog->execute() ) + { + throw task::ErrorCodeIOException( + ("ModelData_Impl::ExecuteFilterDialog_Impl:" + " ERRCODE_IO_ABORT"), + uno::Reference< uno::XInterface >(), + sal_uInt32(ERRCODE_IO_ABORT)); + } + + const uno::Sequence< beans::PropertyValue > aPropsFromDialog = + xFilterProperties->getPropertyValues(); + for ( const auto& rProp : aPropsFromDialog ) + GetMediaDescr()[rProp.Name] = rProp.Value; + } + } + } + } + } + catch( const container::NoSuchElementException& e ) + { + // the filter name is unknown + throw task::ErrorCodeIOException( + ("ModelData_Impl::ExecuteFilterDialog_Impl: NoSuchElementException" + " \"" + e.Message + "\": ERRCODE_IO_ABORT"), + uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_INVALIDPARAMETER)); + } + catch( const task::ErrorCodeIOException& ) + { + throw; + } + catch( const uno::Exception& ) + { + TOOLS_WARN_EXCEPTION("sfx.doc", "ignoring"); + } + + return bDialogUsed; +} + + +sal_Int8 ModelData_Impl::CheckSaveAcceptable( sal_Int8 nCurStatus ) +{ + sal_Int8 nResult = nCurStatus; + + if ( nResult != STATUS_NO_ACTION && GetStorable()->hasLocation() ) + { + // the saving is acceptable + // in case the configuration entry is not set or set to false + // or in case of version creation + if ( officecfg::Office::Common::Save::Document::AlwaysSaveAs::get() + && GetMediaDescr().find( OUString("VersionComment") ) == GetMediaDescr().end() ) + { + // notify the user that SaveAs is going to be done + std::unique_ptr<weld::MessageDialog> xMessageBox(Application::CreateMessageDialog(SfxStoringHelper::GetModelWindow(m_xModel), + VclMessageType::Question, VclButtonsType::OkCancel, SfxResId(STR_NEW_FILENAME_SAVE))); + if (xMessageBox->run() == RET_OK) + nResult = STATUS_SAVEAS; + else + nResult = STATUS_NO_ACTION; + } + } + + return nResult; +} + + +sal_Int8 ModelData_Impl::CheckStateForSave() +{ + // if the document is readonly or a new one a SaveAs operation must be used + if ( !GetStorable()->hasLocation() || GetStorable()->isReadonly() ) + return STATUS_SAVEAS; + + // check acceptable entries for media descriptor + ::comphelper::SequenceAsHashMap aAcceptedArgs; + + static const OUStringLiteral aVersionCommentString(u"VersionComment"); + static const OUStringLiteral aAuthorString(u"Author"); + static const OUStringLiteral aDontTerminateEdit(u"DontTerminateEdit"); + static const OUStringLiteral aInteractionHandlerString(u"InteractionHandler"); + static const OUStringLiteral aStatusIndicatorString(u"StatusIndicator"); + static const OUStringLiteral aFailOnWarningString(u"FailOnWarning"); + static const OUStringLiteral aNoFileSync(u"NoFileSync"); + + if ( GetMediaDescr().find( aVersionCommentString ) != GetMediaDescr().end() ) + aAcceptedArgs[ aVersionCommentString ] = GetMediaDescr()[ aVersionCommentString ]; + if ( GetMediaDescr().find( aAuthorString ) != GetMediaDescr().end() ) + aAcceptedArgs[ aAuthorString ] = GetMediaDescr()[ aAuthorString ]; + if ( GetMediaDescr().find( aDontTerminateEdit ) != GetMediaDescr().end() ) + aAcceptedArgs[ aDontTerminateEdit ] = GetMediaDescr()[ aDontTerminateEdit ]; + if ( GetMediaDescr().find( aInteractionHandlerString ) != GetMediaDescr().end() ) + aAcceptedArgs[ aInteractionHandlerString ] = GetMediaDescr()[ aInteractionHandlerString ]; + if ( GetMediaDescr().find( aStatusIndicatorString ) != GetMediaDescr().end() ) + aAcceptedArgs[ aStatusIndicatorString ] = GetMediaDescr()[ aStatusIndicatorString ]; + if ( GetMediaDescr().find( aFailOnWarningString ) != GetMediaDescr().end() ) + aAcceptedArgs[ aFailOnWarningString ] = GetMediaDescr()[ aFailOnWarningString ]; + if (GetMediaDescr().find(aNoFileSync) != GetMediaDescr().end()) + aAcceptedArgs[aNoFileSync] = GetMediaDescr()[aNoFileSync]; + + // remove unacceptable entry if there is any + DBG_ASSERT( GetMediaDescr().size() == aAcceptedArgs.size(), + "Unacceptable parameters are provided in Save request!\n" ); + if ( GetMediaDescr().size() != aAcceptedArgs.size() ) + GetMediaDescr() = aAcceptedArgs; + + // check that the old filter is acceptable + return CheckFilter( GetDocProps().getUnpackedValueOrDefault(aFilterNameString, OUString()) ); +} + +sal_Int8 ModelData_Impl::CheckFilter( const OUString& aFilterName ) +{ + ::comphelper::SequenceAsHashMap aFiltPropsHM; + SfxFilterFlags nFiltFlags = SfxFilterFlags::NONE; + if ( !aFilterName.isEmpty() ) + { + // get properties of filter + uno::Sequence< beans::PropertyValue > aFilterProps; + m_pOwner->GetFilterConfiguration()->getByName( aFilterName ) >>= aFilterProps; + + aFiltPropsHM = ::comphelper::SequenceAsHashMap( aFilterProps ); + nFiltFlags = static_cast<SfxFilterFlags>(aFiltPropsHM.getUnpackedValueOrDefault("Flags", sal_Int32(0) )); + } + + // only a temporary solution until default filter retrieving feature is implemented + // then GetDocServiceDefaultFilter() must be used + ::comphelper::SequenceAsHashMap aDefFiltPropsHM = GetDocServiceDefaultFilterCheckFlags( SfxFilterFlags::IMPORT | SfxFilterFlags::EXPORT, SfxFilterFlags::NONE ); + SfxFilterFlags nDefFiltFlags = static_cast<SfxFilterFlags>(aDefFiltPropsHM.getUnpackedValueOrDefault("Flags", sal_Int32(0) )); + + bool bAsk = false; + + // if the old filter is not acceptable + // and there is no default filter or it is not acceptable for requested parameters then proceed with saveAs + if ( ( aFiltPropsHM.empty() || !( nFiltFlags & SfxFilterFlags::EXPORT ) ) + && ( aDefFiltPropsHM.empty() || !( nDefFiltFlags & SfxFilterFlags::EXPORT ) || nDefFiltFlags & SfxFilterFlags::INTERNAL ) ) + return STATUS_SAVEAS; + + // so at this point there is either an acceptable old filter or default one + if ( aFiltPropsHM.empty() || !( nFiltFlags & SfxFilterFlags::EXPORT ) ) + { + // so the default filter must be acceptable + return STATUS_SAVEAS_STANDARDNAME; + } + else if ( ( !( nFiltFlags & SfxFilterFlags::OWN ) || ( nFiltFlags & SfxFilterFlags::ALIEN ) ) + && !aDefFiltPropsHM.empty() + && ( nDefFiltFlags & SfxFilterFlags::EXPORT ) && !( nDefFiltFlags & SfxFilterFlags::INTERNAL )) + { + bAsk = true; + } + + // check if EncryptionData supports this output format + { + OUString aSupportedFilters; + const ::comphelper::SequenceAsHashMap& rDocumentProperties = GetDocProps(); + const css::uno::Sequence<css::beans::NamedValue> aEncryptionData = rDocumentProperties.getUnpackedValueOrDefault("EncryptionData", css::uno::Sequence<css::beans::NamedValue>()); + if (aEncryptionData != css::uno::Sequence<css::beans::NamedValue>()) + { + for (const css::beans::NamedValue& aNamedValue : aEncryptionData) + { + if (aNamedValue.Name == "SupportedFilters") + { + aNamedValue.Value >>= aSupportedFilters; + } + } + } + + // if 'SupportedFilters' is empty assume that all filters are supported. + if (!aSupportedFilters.isEmpty()) + { + const OUString aSelectedFilter = aFiltPropsHM.getUnpackedValueOrDefault("UIName", OUString()); + + aSupportedFilters = ";" + aSupportedFilters + ";"; + const OUString aSearchToken = ";" + aSelectedFilter + ";"; + bAsk = (aSupportedFilters.indexOf(aSearchToken) < 0); + } + } + + if (bAsk) + { + // the default filter is acceptable and the old filter is alien one + // so ask to make a saveAs operation + const OUString aUIName = aFiltPropsHM.getUnpackedValueOrDefault("UIName", OUString() ); + const OUString aDefUIName = aDefFiltPropsHM.getUnpackedValueOrDefault("UIName", OUString() ); + const OUString aPreusedFilterName = GetDocProps().getUnpackedValueOrDefault("PreusedFilterName", OUString() ); + const OUString aDefType = aDefFiltPropsHM.getUnpackedValueOrDefault( "Type", OUString() ); + const OUString aDefExtension = GetRecommendedExtension( aDefType ); + + if ( aPreusedFilterName != aFilterName && aUIName != aDefUIName ) + { + if ( !SfxStoringHelper::WarnUnacceptableFormat( GetModel(), aUIName, aDefExtension, + static_cast<bool>( nDefFiltFlags & SfxFilterFlags::ALIEN ) ) ) + return STATUS_SAVEAS_STANDARDNAME; + } + } + + return STATUS_SAVE; +} + + +bool ModelData_Impl::CheckFilterOptionsDialogExistence() +{ + uno::Sequence< beans::NamedValue > aSearchRequest { { "DocumentService", css::uno::Any(GetDocServiceName()) } }; + + uno::Reference< container::XEnumeration > xFilterEnum = + m_pOwner->GetFilterQuery()->createSubSetEnumerationByProperties( aSearchRequest ); + + while ( xFilterEnum->hasMoreElements() ) + { + uno::Sequence< beans::PropertyValue > aProps; + if ( xFilterEnum->nextElement() >>= aProps ) + { + ::comphelper::SequenceAsHashMap aPropsHM( aProps ); + if ( !aPropsHM.getUnpackedValueOrDefault("UIComponent", OUString()).isEmpty() ) + return true; + } + } + + return false; +} + + +bool ModelData_Impl::OutputFileDialog( sal_Int16 nStoreMode, + const ::comphelper::SequenceAsHashMap& aPreselectedFilterPropsHM, + bool bSetStandardName, + OUString& aSuggestedName, + bool bPreselectPassword, + OUString& aSuggestedDir, + sal_Int16 nDialog, + const OUString& rStandardDir, + const css::uno::Sequence< OUString >& rDenyList) +{ + if ( nStoreMode == SAVEASREMOTE_REQUESTED ) + nStoreMode = SAVEAS_REQUESTED; + + bool bUseFilterOptions = false; + + ::comphelper::SequenceAsHashMap::const_iterator aOverwriteIter = + GetMediaDescr().find( OUString("Overwrite") ); + + // the file name must be specified if overwrite option is set + if ( aOverwriteIter != GetMediaDescr().end() ) + throw task::ErrorCodeIOException( + "ModelData_Impl::OutputFileDialog: ERRCODE_IO_INVALIDPARAMETER", + uno::Reference< uno::XInterface >(), + sal_uInt32(ERRCODE_IO_INVALIDPARAMETER)); + + // no target file name is specified + // we need to show the file dialog + + // check if we have a filter which allows for filter options, so we need a corresponding checkbox in the dialog + bool bAllowOptions = false; + + // in case of Export, filter options dialog is used if available + if( !( nStoreMode & EXPORT_REQUESTED ) || ( nStoreMode & WIDEEXPORT_REQUESTED ) ) + bAllowOptions = CheckFilterOptionsDialogExistence(); + + // get the filename by dialog ... + // create the file dialog + sal_Int16 aDialogMode = bAllowOptions + ? css::ui::dialogs::TemplateDescription::FILESAVE_AUTOEXTENSION_PASSWORD_FILTEROPTIONS + : css::ui::dialogs::TemplateDescription::FILESAVE_AUTOEXTENSION_PASSWORD; + FileDialogFlags aDialogFlags = FileDialogFlags::NONE; + + if( ( nStoreMode & EXPORT_REQUESTED ) && !( nStoreMode & WIDEEXPORT_REQUESTED ) ) + { + if ( (nStoreMode & PDFEXPORT_REQUESTED) || (nStoreMode & EPUBEXPORT_REQUESTED) ) + aDialogMode = css::ui::dialogs::TemplateDescription:: + FILESAVE_AUTOEXTENSION; + else + aDialogMode = css::ui::dialogs::TemplateDescription:: + FILESAVE_AUTOEXTENSION_SELECTION; + aDialogFlags = FileDialogFlags::Export; + } + + if( ( nStoreMode & EXPORT_REQUESTED ) && ( nStoreMode & SAVEACOPY_REQUESTED ) && ( nStoreMode & WIDEEXPORT_REQUESTED ) ) + { + aDialogFlags = FileDialogFlags::SaveACopy; + } + + std::unique_ptr<sfx2::FileDialogHelper> pFileDlg; + + const OUString aDocServiceName {GetDocServiceName()}; + DBG_ASSERT( !aDocServiceName.isEmpty(), "No document service for this module set!" ); + + SfxFilterFlags nMust = getMustFlags( nStoreMode ); + SfxFilterFlags nDont = getDontFlags( nStoreMode ); + weld::Window* pFrameWin = SfxStoringHelper::GetModelWindow(m_xModel); + if ( ( nStoreMode & EXPORT_REQUESTED ) && !( nStoreMode & WIDEEXPORT_REQUESTED ) ) + { + if ( ( nStoreMode & PDFEXPORT_REQUESTED ) && !aPreselectedFilterPropsHM.empty() ) + { + // this is a PDF export + // the filter options has been shown already + const OUString aFilterUIName = aPreselectedFilterPropsHM.getUnpackedValueOrDefault( "UIName", OUString() ); + pFileDlg.reset(new sfx2::FileDialogHelper( aDialogMode, aDialogFlags, aFilterUIName, u"pdf", rStandardDir, rDenyList, pFrameWin )); + pFileDlg->SetCurrentFilter( aFilterUIName ); + } + else if ((nStoreMode & EPUBEXPORT_REQUESTED) && !aPreselectedFilterPropsHM.empty()) + { + // This is an EPUB export, the filter options has been shown already. + const OUString aFilterUIName = aPreselectedFilterPropsHM.getUnpackedValueOrDefault( "UIName", OUString() ); + pFileDlg.reset(new sfx2::FileDialogHelper(aDialogMode, aDialogFlags, aFilterUIName, u"epub", rStandardDir, rDenyList, pFrameWin)); + pFileDlg->SetCurrentFilter(aFilterUIName); + } + else + { + // This is the normal dialog + pFileDlg.reset(new sfx2::FileDialogHelper( aDialogMode, aDialogFlags, aDocServiceName, nDialog, nMust, nDont, rStandardDir, rDenyList, pFrameWin )); + } + + sfx2::FileDialogHelper::Context eCtxt = sfx2::FileDialogHelper::UnknownContext; + if ( aDocServiceName == "com.sun.star.drawing.DrawingDocument" ) + eCtxt = sfx2::FileDialogHelper::DrawExport; + else if ( aDocServiceName == "com.sun.star.presentation.PresentationDocument" ) + eCtxt = sfx2::FileDialogHelper::ImpressExport; + else if ( aDocServiceName == "com.sun.star.text.TextDocument" ) + eCtxt = sfx2::FileDialogHelper::WriterExport; + else if ( aDocServiceName == "com.sun.star.sheet.SpreadsheetDocument" ) + eCtxt = sfx2::FileDialogHelper::CalcExport; + + if ( eCtxt != sfx2::FileDialogHelper::UnknownContext ) + pFileDlg->SetContext( eCtxt ); + + pFileDlg->CreateMatcher( aDocServiceName ); + + uno::Reference< ui::dialogs::XFilePicker3 > xFilePicker = pFileDlg->GetFilePicker(); + uno::Reference< ui::dialogs::XFilePickerControlAccess > xControlAccess( xFilePicker, uno::UNO_QUERY ); + + if ( xControlAccess.is() ) + { + xControlAccess->setLabel( ui::dialogs::CommonFilePickerElementIds::PUSHBUTTON_OK, SfxResId(STR_EXPORTBUTTON) ); + xControlAccess->setLabel( ui::dialogs::CommonFilePickerElementIds::LISTBOX_FILTER_LABEL, SfxResId(STR_LABEL_FILEFORMAT) ); + } + } + else + { + // This is the normal save as dialog + pFileDlg.reset(new sfx2::FileDialogHelper( aDialogMode, aDialogFlags, aDocServiceName, nDialog, + nMust, nDont, rStandardDir, rDenyList, pFrameWin )); + pFileDlg->CreateMatcher( aDocServiceName ); + + sfx2::FileDialogHelper::Context eCtxt = sfx2::FileDialogHelper::UnknownContext; + if ( aDocServiceName == "com.sun.star.drawing.DrawingDocument" ) + eCtxt = sfx2::FileDialogHelper::DrawSaveAs; + else if ( aDocServiceName == "com.sun.star.presentation.PresentationDocument" ) + eCtxt = sfx2::FileDialogHelper::ImpressSaveAs; + else if ( aDocServiceName == "com.sun.star.text.TextDocument" ) + eCtxt = sfx2::FileDialogHelper::WriterSaveAs; + else if ( aDocServiceName == "com.sun.star.sheet.SpreadsheetDocument" ) + eCtxt = sfx2::FileDialogHelper::CalcSaveAs; + + if ( eCtxt != sfx2::FileDialogHelper::UnknownContext ) + pFileDlg->SetContext( eCtxt ); + } + + OUString aAdjustToType; + + const OUString sFilterNameString(aFilterNameString); + + if ( ( nStoreMode & EXPORT_REQUESTED ) && !( nStoreMode & WIDEEXPORT_REQUESTED ) ) + { + // it is export, set the preselected filter + pFileDlg->SetCurrentFilter( aPreselectedFilterPropsHM.getUnpackedValueOrDefault( "UIName", OUString() ) ); + aAdjustToType = aPreselectedFilterPropsHM.getUnpackedValueOrDefault( "Type", OUString() ); + } + // it is no export, bSetStandardName == true means that user agreed to store document in the default (default default ;-)) format + else if ( bSetStandardName || GetStorable()->hasLocation() ) + { + uno::Sequence< beans::PropertyValue > aOldFilterProps; + const OUString aOldFilterName = GetDocProps().getUnpackedValueOrDefault( sFilterNameString, OUString() ); + + if ( !aOldFilterName.isEmpty() ) + m_pOwner->GetFilterConfiguration()->getByName( aOldFilterName ) >>= aOldFilterProps; + + ::comphelper::SequenceAsHashMap aOldFiltPropsHM( aOldFilterProps ); + SfxFilterFlags nOldFiltFlags = static_cast<SfxFilterFlags>(aOldFiltPropsHM.getUnpackedValueOrDefault("Flags", sal_Int32(0) )); + + if ( bSetStandardName || ( nOldFiltFlags & nMust ) != nMust || bool(nOldFiltFlags & nDont) ) + { + // the suggested type will be changed, the extension should be adjusted + aAdjustToType = aPreselectedFilterPropsHM.getUnpackedValueOrDefault( "Type", OUString() ); + pFileDlg->SetCurrentFilter( aPreselectedFilterPropsHM.getUnpackedValueOrDefault( "UIName", OUString() ) ); + } + else + { + pFileDlg->SetCurrentFilter( aOldFiltPropsHM.getUnpackedValueOrDefault( + "UIName", + OUString() ) ); + } + } + + const OUString aRecommendedDir {GetRecommendedDir( aSuggestedDir )}; + if ( !aRecommendedDir.isEmpty() ) + pFileDlg->SetDisplayFolder( aRecommendedDir ); + const OUString aRecommendedName {GetRecommendedName( aSuggestedName, aAdjustToType )}; + if ( !aRecommendedName.isEmpty() ) + pFileDlg->SetFileName( aRecommendedName ); + + uno::Reference < view::XSelectionSupplier > xSel( GetModel()->getCurrentController(), uno::UNO_QUERY ); + if ( xSel.is() && xSel->getSelection().hasValue() ) + GetMediaDescr()[OUString("SelectionOnly")] <<= true; + + // This is a temporary hardcoded solution must be removed when + // dialogs do not need parameters in SidSet representation any more + sal_uInt16 nSlotID = getSlotIDFromMode( nStoreMode ); + if ( !nSlotID ) + throw lang::IllegalArgumentException(); // TODO: + + // generate SidSet from MediaDescriptor and provide it into FileDialog + // than merge changed SidSet back + std::optional<SfxAllItemSet> pDialogParams( SfxGetpApp()->GetPool() ); + TransformParameters( nSlotID, + GetMediaDescr().getAsConstPropertyValueList(), + *pDialogParams ); + + if ( bPreselectPassword && !pDialogParams->HasItem( SID_ENCRYPTIONDATA ) ) + { + // the file dialog preselects the password checkbox if the provided mediadescriptor has encryption data entry + // after dialog execution the password interaction flag will be either removed or not + pDialogParams->Put( SfxBoolItem( SID_PASSWORDINTERACTION, true ) ); + } + + // aFilterName is a pure output parameter, pDialogParams is an in/out parameter + OUString aFilterName; + if ( pFileDlg->Execute( pDialogParams, aFilterName ) != ERRCODE_NONE ) + { + throw task::ErrorCodeIOException( + "ModelData_Impl::OutputFileDialog: ERRCODE_IO_ABORT", + uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_ABORT)); + } + + // the following two arguments can not be converted in MediaDescriptor, + // so they should be removed from the ItemSet after retrieving + const SfxBoolItem* pRecommendReadOnly = SfxItemSet::GetItem<SfxBoolItem>(&*pDialogParams, SID_RECOMMENDREADONLY, false); + m_bRecommendReadOnly = ( pRecommendReadOnly && pRecommendReadOnly->GetValue() ); + pDialogParams->ClearItem( SID_RECOMMENDREADONLY ); + + uno::Sequence< beans::PropertyValue > aPropsFromDialog; + TransformItems( nSlotID, *pDialogParams, aPropsFromDialog ); + GetMediaDescr() << aPropsFromDialog; + + // get the path from the dialog + INetURLObject aURL( pFileDlg->GetPath() ); + // the path should be provided outside since it might be used for further calls to the dialog + aSuggestedName = aURL.GetLastName(INetURLObject::DecodeMechanism::WithCharset); + aSuggestedDir = pFileDlg->GetDisplayDirectory(); + + // old filter options should be cleared in case different filter is used + + const OUString aFilterFromMediaDescr = GetMediaDescr().getUnpackedValueOrDefault( sFilterNameString, OUString() ); + const OUString aOldFilterName = GetDocProps().getUnpackedValueOrDefault( sFilterNameString, OUString() ); + + const OUString sFilterOptionsString(aFilterOptionsString); + const OUString sFilterDataString(aFilterDataString); + + if ( aFilterName == aFilterFromMediaDescr ) + { + // preserve current settings if any + // if there no current settings and the name is the same + // as old filter name use old filter settings + + if ( aFilterFromMediaDescr == aOldFilterName ) + { + ::comphelper::SequenceAsHashMap::const_iterator aIter = + GetDocProps().find( sFilterOptionsString ); + if ( aIter != GetDocProps().end() + && GetMediaDescr().find( sFilterOptionsString ) == GetMediaDescr().end() ) + GetMediaDescr()[aIter->first] = aIter->second; + + aIter = GetDocProps().find( sFilterDataString ); + if ( aIter != GetDocProps().end() + && GetMediaDescr().find( sFilterDataString ) == GetMediaDescr().end() ) + GetMediaDescr()[aIter->first] = aIter->second; + } + } + else + { + GetMediaDescr().erase( sFilterDataString ); + GetMediaDescr().erase( sFilterOptionsString ); + + if ( aFilterName == aOldFilterName ) + { + // merge filter option of the document filter + + ::comphelper::SequenceAsHashMap::const_iterator aIter = + GetDocProps().find( sFilterOptionsString ); + if ( aIter != GetDocProps().end() ) + GetMediaDescr()[aIter->first] = aIter->second; + + aIter = GetDocProps().find( sFilterDataString ); + if ( aIter != GetDocProps().end() ) + GetMediaDescr()[aIter->first] = aIter->second; + } + } + + uno::Reference< ui::dialogs::XFilePickerControlAccess > xExtFileDlg( pFileDlg->GetFilePicker(), uno::UNO_QUERY ); + if ( xExtFileDlg.is() ) + { + if ( SfxStoringHelper::CheckFilterOptionsAppearance( m_pOwner->GetFilterConfiguration(), aFilterName ) ) + bUseFilterOptions = true; + + if ( ( !( nStoreMode & EXPORT_REQUESTED ) || ( nStoreMode & WIDEEXPORT_REQUESTED ) ) && bUseFilterOptions ) + { + try + { + // for exporters: always show dialog if format uses options + // for save: show dialog if format uses options and no options given or if forced by user + uno::Any aVal = + xExtFileDlg->getValue( ui::dialogs::ExtendedFilePickerElementIds::CHECKBOX_FILTEROPTIONS, 0 ); + + aVal >>= bUseFilterOptions; + if ( !bUseFilterOptions ) + bUseFilterOptions = + ( GetMediaDescr().find( sFilterDataString ) == GetMediaDescr().end() + && GetMediaDescr().find( sFilterOptionsString ) == GetMediaDescr().end() ); + } + catch( const lang::IllegalArgumentException& ) + {} + } + } + + // merge in results of the dialog execution + GetMediaDescr()[OUString("URL")] <<= aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + GetMediaDescr()[sFilterNameString] <<= aFilterName; + + return bUseFilterOptions; +} + + +bool ModelData_Impl::ShowDocumentInfoDialog() +{ + bool bDialogUsed = false; + + try { + uno::Reference< frame::XController > xController = GetModel()->getCurrentController(); + if ( xController.is() ) + { + uno::Reference< frame::XDispatchProvider > xFrameDispatch( xController->getFrame(), uno::UNO_QUERY ); + if ( xFrameDispatch.is() ) + { + util::URL aURL; + aURL.Complete = ".uno:SetDocumentProperties"; + + uno::Reference < util::XURLTransformer > xTransformer( util::URLTransformer::create( comphelper::getProcessComponentContext() ) ); + if ( xTransformer->parseStrict( aURL ) ) + { + uno::Reference< frame::XDispatch > xDispatch = xFrameDispatch->queryDispatch( + aURL, + "_self", + 0 ); + if ( xDispatch.is() ) + { + // tdf#119206 use (abuse?) a SynchronMode of true, + // which will become SfxRequest::IsSynchronCall of true + // in SfxObjectShell::ExecFile_Impl to request that we + // do not want the properties dialog to be run async + uno::Sequence< beans::PropertyValue > aProperties{ + comphelper::makePropertyValue("SynchronMode", true) + }; + xDispatch->dispatch(aURL, aProperties); + bDialogUsed = true; + } + } + } + } + } + catch ( const uno::Exception& ) + { + } + + return bDialogUsed; +} + + +OUString ModelData_Impl::GetRecommendedExtension( const OUString& aTypeName ) +{ + if ( aTypeName.isEmpty() ) + return OUString(); + + uno::Reference< container::XNameAccess > xTypeDetection( + comphelper::getProcessServiceFactory()->createInstance("com.sun.star.document.TypeDetection"), + uno::UNO_QUERY ); + if ( xTypeDetection.is() ) + { + uno::Sequence< beans::PropertyValue > aTypeNameProps; + if ( ( xTypeDetection->getByName( aTypeName ) >>= aTypeNameProps ) && aTypeNameProps.hasElements() ) + { + ::comphelper::SequenceAsHashMap aTypeNamePropsHM( aTypeNameProps ); + uno::Sequence< OUString > aExtensions = aTypeNamePropsHM.getUnpackedValueOrDefault( + "Extensions", + ::uno::Sequence< OUString >() ); + if ( aExtensions.hasElements() ) + return aExtensions[0]; + } + } + + return OUString(); +} + + +OUString ModelData_Impl::GetRecommendedDir( const OUString& aSuggestedDir ) +{ + if ( ( !aSuggestedDir.isEmpty() || GetStorable()->hasLocation() ) + && !GetMediaDescr().getUnpackedValueOrDefault("RepairPackage", false ) ) + { + INetURLObject aLocation; + if ( !aSuggestedDir.isEmpty() ) + aLocation = INetURLObject( aSuggestedDir ); + else + { + const OUString aOldURL = GetStorable()->getLocation(); + if ( !aOldURL.isEmpty() ) + { + INetURLObject aTmp( aOldURL ); + if ( aTmp.removeSegment() ) + aLocation = aTmp; + } + + if ( aLocation.HasError() ) + aLocation = INetURLObject(); + } + + OUString sLocationURL( aLocation.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + bool bIsInTempPath( false ); + OUString sSysTempPath; + if( osl::FileBase::getTempDirURL( sSysTempPath ) == osl::FileBase::E_None ) + bIsInTempPath = !sSysTempPath.isEmpty() && sLocationURL.startsWith( sSysTempPath ); +#ifdef _WIN32 + if( !bIsInTempPath ) + { + wchar_t sPath[MAX_PATH+1]; + HRESULT hRes = SHGetFolderPathW( nullptr, CSIDL_INTERNET_CACHE, nullptr, SHGFP_TYPE_CURRENT, sPath ); + if( SUCCEEDED(hRes) ) + { + OUString sTempINetFiles; + if( osl::FileBase::getFileURLFromSystemPath(OUString(o3tl::toU(sPath)), sTempINetFiles) == osl::FileBase::E_None ) + bIsInTempPath = !sTempINetFiles.isEmpty() && sLocationURL.startsWith( sTempINetFiles ); + } + } +#endif + // Suggest somewhere other than the system's temp directory + if( bIsInTempPath ) + aLocation = INetURLObject(); + + aLocation.setFinalSlash(); + if ( !aLocation.HasError() ) + return aLocation.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + + return OUString(); + } + + return OUString(); +} + + +OUString ModelData_Impl::GetRecommendedName( const OUString& aSuggestedName, const OUString& aTypeName ) +{ + // the last used name might be provided by aSuggestedName from the old selection, or from the MediaDescriptor + if ( !aSuggestedName.isEmpty() ) + return aSuggestedName; + + OUString aRecommendedName{ INetURLObject(GetStorable()->getLocation()) + .GetLastName(INetURLObject::DecodeMechanism::WithCharset) }; + if ( aRecommendedName.isEmpty() ) + { + try { + uno::Reference< frame::XTitle > xTitle( GetModel(), uno::UNO_QUERY_THROW ); + aRecommendedName = xTitle->getTitle(); + } catch( const uno::Exception& ) {} + } + + if ( !aRecommendedName.isEmpty() && !aTypeName.isEmpty() ) + { + // adjust the extension to the type + uno::Reference< container::XNameAccess > xTypeDetection( + comphelper::getProcessServiceFactory()->createInstance("com.sun.star.document.TypeDetection"), + uno::UNO_QUERY ); + if ( xTypeDetection.is() ) + { + INetURLObject aObj( rtl::OUStringConcatenation("c:/" + aRecommendedName), INetProtocol::File, + INetURLObject::EncodeMechanism::All, RTL_TEXTENCODING_UTF8, FSysStyle::Dos ); + + const OUString aExtension = GetRecommendedExtension( aTypeName ); + if ( !aExtension.isEmpty() ) + aObj.SetExtension( aExtension ); + + aRecommendedName = aObj.GetLastName(INetURLObject::DecodeMechanism::WithCharset); + } + } + + return aRecommendedName; +} + + + + +SfxStoringHelper::SfxStoringHelper() +{ +} + + +uno::Reference< container::XNameAccess > const & SfxStoringHelper::GetFilterConfiguration() +{ + if ( !m_xFilterCFG.is() ) + { + m_xFilterCFG.set( comphelper::getProcessServiceFactory()->createInstance("com.sun.star.document.FilterFactory"), + uno::UNO_QUERY_THROW ); + } + + return m_xFilterCFG; +} + + +uno::Reference< container::XContainerQuery > const & SfxStoringHelper::GetFilterQuery() +{ + if ( !m_xFilterQuery.is() ) + { + m_xFilterQuery.set( GetFilterConfiguration(), uno::UNO_QUERY_THROW ); + } + + return m_xFilterQuery; +} + + +uno::Reference< css::frame::XModuleManager2 > const & SfxStoringHelper::GetModuleManager() +{ + if ( !m_xModuleManager.is() ) + { + m_xModuleManager = frame::ModuleManager::create( + comphelper::getProcessComponentContext() ); + } + + return m_xModuleManager; +} + +bool SfxStoringHelper::GUIStoreModel( const uno::Reference< frame::XModel >& xModel, + std::u16string_view aSlotName, + uno::Sequence< beans::PropertyValue >& aArgsSequence, + bool bPreselectPassword, + SignatureState nDocumentSignatureState ) +{ + ModelData_Impl aModelData( *this, xModel, aArgsSequence ); + + bool bDialogUsed = false; + + INetURLObject aURL; + + bool bSetStandardName = false; // can be set only for SaveAs + + // parse the slot name + bool bRemote = false; + sal_Int16 nStoreMode = getStoreModeFromSlotName( aSlotName ); + + if ( nStoreMode == SAVEASREMOTE_REQUESTED ) + { + nStoreMode = SAVEAS_REQUESTED; + bRemote = true; + } + + sal_Int8 nStatusSave = STATUS_NO_ACTION; + + ::comphelper::SequenceAsHashMap::const_iterator aSaveACopyIter = + aModelData.GetMediaDescr().find( OUString("SaveACopy") ); + if ( aSaveACopyIter != aModelData.GetMediaDescr().end() ) + { + bool bSaveACopy = false; + aSaveACopyIter->second >>= bSaveACopy; + if ( bSaveACopy ) + nStoreMode = EXPORT_REQUESTED | SAVEACOPY_REQUESTED | WIDEEXPORT_REQUESTED; + } + // handle the special cases + if ( nStoreMode & SAVEAS_REQUESTED ) + { + ::comphelper::SequenceAsHashMap::const_iterator aSaveToIter = + aModelData.GetMediaDescr().find( OUString("SaveTo") ); + if ( aSaveToIter != aModelData.GetMediaDescr().end() ) + { + bool bWideExport = false; + aSaveToIter->second >>= bWideExport; + if ( bWideExport ) + nStoreMode = EXPORT_REQUESTED | WIDEEXPORT_REQUESTED; + } + + // if saving is not acceptable the warning must be shown even in case of SaveAs operation + if ( ( nStoreMode & SAVEAS_REQUESTED ) && aModelData.CheckSaveAcceptable( STATUS_SAVEAS ) == STATUS_NO_ACTION ) + throw task::ErrorCodeIOException( + "SfxStoringHelper::GUIStoreModel: ERRCODE_IO_ABORT", + uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_ABORT)); + } + else if ( nStoreMode & SAVE_REQUESTED ) + { + // if saving is not acceptable by the configuration the warning must be shown + nStatusSave = aModelData.CheckSaveAcceptable( STATUS_SAVE ); + + if ( nStatusSave == STATUS_NO_ACTION ) + throw task::ErrorCodeIOException( + "SfxStoringHelper::GUIStoreModel: ERRCODE_IO_ABORT", + uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_ABORT)); + else if ( nStatusSave == STATUS_SAVE ) + { + // check whether it is possible to use save operation + nStatusSave = aModelData.CheckStateForSave(); + } + + if ( nStatusSave == STATUS_NO_ACTION ) + { + throw task::ErrorCodeIOException( + "SfxStoringHelper::GUIStoreModel: ERRCODE_IO_ABORT", + uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_ABORT)); + } + else if ( nStatusSave != STATUS_SAVE ) + { + // this should be a usual SaveAs operation + nStoreMode = SAVEAS_REQUESTED; + if ( nStatusSave == STATUS_SAVEAS_STANDARDNAME ) + bSetStandardName = true; + } + } + + if (!comphelper::LibreOfficeKit::isActive() && !( nStoreMode & EXPORT_REQUESTED ) ) + { + // if it is no export, warn user that the signature will be removed + if ( SignatureState::OK == nDocumentSignatureState + || SignatureState::INVALID == nDocumentSignatureState + || SignatureState::NOTVALIDATED == nDocumentSignatureState + || SignatureState::PARTIAL_OK == nDocumentSignatureState) + { + std::unique_ptr<weld::MessageDialog> xMessageBox(Application::CreateMessageDialog(SfxStoringHelper::GetModelWindow(xModel), + VclMessageType::Question, VclButtonsType::YesNo, SfxResId(RID_SVXSTR_XMLSEC_QUERY_LOSINGSIGNATURE))); + if (xMessageBox->run() != RET_YES) + { + // the user has decided not to store the document + throw task::ErrorCodeIOException( + "SfxStoringHelper::GUIStoreModel: ERRCODE_IO_ABORT (Preserve Signature)", + uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_ABORT)); + } + } + } + + if ( nStoreMode & SAVE_REQUESTED && nStatusSave == STATUS_SAVE ) + { + // Document properties can contain streams that should be freed before storing + aModelData.FreeDocumentProps(); + + if ( aModelData.GetStorable2().is() ) + { + try + { + aModelData.GetStorable2()->storeSelf( aModelData.GetMediaDescr().getAsConstPropertyValueList() ); + } + catch (const lang::IllegalArgumentException&) + { + TOOLS_WARN_EXCEPTION("sfx.doc", "Ignoring parameters! ModelData considers this illegal"); + aModelData.GetStorable()->store(); + } + } + else + { + OSL_FAIL( "XStorable2 is not supported by the model!" ); + aModelData.GetStorable()->store(); + } + + return false; + } + + // preselect a filter for the storing process + uno::Sequence< beans::PropertyValue > aFilterProps = aModelData.GetPreselectedFilter_Impl( nStoreMode ); + + DBG_ASSERT( aFilterProps.hasElements(), "No filter for storing!\n" ); + if ( !aFilterProps.hasElements() ) + throw task::ErrorCodeIOException( + "SfxStoringHelper::GUIStoreModel: ERRCODE_IO_INVALIDPARAMETER", + uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_INVALIDPARAMETER)); + + ::comphelper::SequenceAsHashMap aFilterPropsHM( aFilterProps ); + OUString aFilterName = aFilterPropsHM.getUnpackedValueOrDefault( "Name", OUString() ); + + const OUString sFilterNameString(aFilterNameString); + + const OUString aFilterFromMediaDescr = aModelData.GetMediaDescr().getUnpackedValueOrDefault( sFilterNameString, OUString() ); + const OUString aOldFilterName = aModelData.GetDocProps().getUnpackedValueOrDefault( sFilterNameString, OUString() ); + + bool bUseFilterOptions = false; + ::comphelper::SequenceAsHashMap::const_iterator aFileNameIter = aModelData.GetMediaDescr().find( OUString("URL") ); + + const OUString sFilterOptionsString(aFilterOptionsString); + const OUString sFilterDataString(aFilterDataString); + + bool bPDFOptions = (nStoreMode & PDFEXPORT_REQUESTED) && !(nStoreMode & PDFDIRECTEXPORT_REQUESTED); + bool bEPUBOptions = (nStoreMode & EPUBEXPORT_REQUESTED) && !(nStoreMode & EPUBDIRECTEXPORT_REQUESTED); + if ( ( nStoreMode & EXPORT_REQUESTED ) && (bPDFOptions || bEPUBOptions) ) + { + // this is PDF or EPUB export, the filter options dialog should be shown before the export + aModelData.GetMediaDescr()[sFilterNameString] <<= aFilterName; + if ( aModelData.GetMediaDescr().find( "FilterFlags" ) == aModelData.GetMediaDescr().end() + && aModelData.GetMediaDescr().find( sFilterOptionsString ) == aModelData.GetMediaDescr().end() + && aModelData.GetMediaDescr().find( sFilterDataString ) == aModelData.GetMediaDescr().end() ) + { + // execute filter options dialog since no options are set in the media descriptor + if ( aModelData.ExecuteFilterDialog_Impl( aFilterName ) ) + bDialogUsed = true; + } + } + + if ( aFileNameIter == aModelData.GetMediaDescr().end() ) + { + sal_Int16 nDialog = SFX2_IMPL_DIALOG_CONFIG; + + if( bRemote ) + { + nDialog = SFX2_IMPL_DIALOG_REMOTE; + } + else + { + ::comphelper::SequenceAsHashMap::const_iterator aDlgIter = + aModelData.GetMediaDescr().find( OUString("UseSystemDialog") ); + if ( aDlgIter != aModelData.GetMediaDescr().end() ) + { + bool bUseSystemDialog = true; + if ( aDlgIter->second >>= bUseSystemDialog ) + { + if ( bUseSystemDialog ) + nDialog = SFX2_IMPL_DIALOG_SYSTEM; + else + nDialog = SFX2_IMPL_DIALOG_OOO; + } + } + } + + // The Dispatch supports parameter FolderName that overwrites SuggestedSaveAsDir + OUString aSuggestedDir = aModelData.GetMediaDescr().getUnpackedValueOrDefault("FolderName", OUString() ); + if ( aSuggestedDir.isEmpty() ) + { + aSuggestedDir = aModelData.GetMediaDescr().getUnpackedValueOrDefault("SuggestedSaveAsDir", OUString() ); + if ( aSuggestedDir.isEmpty() ) + aSuggestedDir = aModelData.GetDocProps().getUnpackedValueOrDefault("SuggestedSaveAsDir", OUString() ); + } + + OUString aSuggestedName = aModelData.GetMediaDescr().getUnpackedValueOrDefault("SuggestedSaveAsName", OUString() ); + if ( aSuggestedName.isEmpty() ) + aSuggestedName = aModelData.GetDocProps().getUnpackedValueOrDefault("SuggestedSaveAsName", OUString() ); + + OUString sStandardDir; + ::comphelper::SequenceAsHashMap::const_iterator aStdDirIter = + aModelData.GetMediaDescr().find( OUString("StandardDir") ); + if ( aStdDirIter != aModelData.GetMediaDescr().end() ) + aStdDirIter->second >>= sStandardDir; + + css::uno::Sequence< OUString > aDenyList; + + ::comphelper::SequenceAsHashMap::const_iterator aDenyListIter = + aModelData.GetMediaDescr().find( OUString("DenyList") ); + if ( aDenyListIter != aModelData.GetMediaDescr().end() ) + aDenyListIter->second >>= aDenyList; + + for (;;) + { + // in case the dialog is opened a second time the folder should be the same as previously navigated to by the user, not what was handed over by initial parameters + bUseFilterOptions = aModelData.OutputFileDialog( nStoreMode, aFilterProps, bSetStandardName, aSuggestedName, bPreselectPassword, aSuggestedDir, nDialog, sStandardDir, aDenyList ); + if ( nStoreMode == SAVEAS_REQUESTED ) + { + // in case of saving check filter for possible alien warning + const OUString aSelFilterName = aModelData.GetMediaDescr().getUnpackedValueOrDefault( sFilterNameString, OUString() ); + sal_Int8 nStatusFilterSave = aModelData.CheckFilter( aSelFilterName ); + if ( nStatusFilterSave == STATUS_SAVEAS_STANDARDNAME ) + { + // switch to best filter + bSetStandardName = true; + } + else if ( nStatusFilterSave == STATUS_SAVE ) + { + // user confirmed alien filter or "good" filter is used + break; + } + } + else + break; + } + + bDialogUsed = true; + aFileNameIter = aModelData.GetMediaDescr().find( OUString("URL") ); + } + else + { + // the target file name is provided so check if new filter options + // are provided or old options can be used + if ( aFilterFromMediaDescr == aOldFilterName ) + { + ::comphelper::SequenceAsHashMap::const_iterator aIter = + aModelData.GetDocProps().find( sFilterOptionsString ); + if ( aIter != aModelData.GetDocProps().end() + && aModelData.GetMediaDescr().find( sFilterOptionsString ) == aModelData.GetMediaDescr().end() ) + aModelData.GetMediaDescr()[aIter->first] = aIter->second; + + aIter = aModelData.GetDocProps().find( sFilterDataString ); + if ( aIter != aModelData.GetDocProps().end() + && aModelData.GetMediaDescr().find( sFilterDataString ) == aModelData.GetMediaDescr().end() ) + aModelData.GetMediaDescr()[aIter->first] = aIter->second; + } + } + + if ( aFileNameIter != aModelData.GetMediaDescr().end() ) + { + OUString aFileName; + aFileNameIter->second >>= aFileName; + aURL.SetURL( aFileName ); + DBG_ASSERT( aURL.GetProtocol() != INetProtocol::NotValid, "Illegal URL!" ); + + ::comphelper::SequenceAsHashMap::const_iterator aIter = + aModelData.GetMediaDescr().find( sFilterNameString ); + + if ( aIter != aModelData.GetMediaDescr().end() ) + aIter->second >>= aFilterName; + else + aModelData.GetMediaDescr()[sFilterNameString] <<= aFilterName; + + DBG_ASSERT( !aFilterName.isEmpty(), "Illegal filter!" ); + } + else + { + SAL_WARN( "sfx.doc", "This code must be unreachable!" ); + throw task::ErrorCodeIOException( + "SfxStoringHelper::GUIStoreModel: ERRCODE_IO_INVALIDPARAMETER", + uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_INVALIDPARAMETER)); + } + + ::comphelper::SequenceAsHashMap::const_iterator aIter = + aModelData.GetMediaDescr().find( OUString("FilterFlags") ); + bool bFilterFlagsSet = ( aIter != aModelData.GetMediaDescr().end() ); + + // check if the filter Dialog has not been called before + if( !( nStoreMode & PDFEXPORT_REQUESTED ) && !( nStoreMode & EPUBEXPORT_REQUESTED ) && !bFilterFlagsSet + && ( ( nStoreMode & EXPORT_REQUESTED ) || bUseFilterOptions ) ) + { + // execute filter options dialog + if ( aModelData.ExecuteFilterDialog_Impl( aFilterName ) ) + { + bDialogUsed = true; + // check if the file is a pdf or not and change the storing mode at convenience + if (aFilterName.endsWith("pdf_Export")) + nStoreMode = EXPORT_REQUESTED | PDFEXPORT_REQUESTED; + } + } + + // so the arguments will not change any more and can be stored to the main location + aArgsSequence = aModelData.GetMediaDescr().getAsConstPropertyValueList(); + + // store the document and handle it's docinfo + + DocumentSettingsGuard aSettingsGuard( aModelData.GetModel(), aModelData.IsRecommendReadOnly(), nStoreMode & EXPORT_REQUESTED ); + + OSL_ENSURE( aModelData.GetMediaDescr().find( OUString( "Password" ) ) == aModelData.GetMediaDescr().end(), "The Password property of MediaDescriptor should not be used here!" ); + if ( officecfg::Office::Common::Save::Document::EditProperty::get() + && ( !aModelData.GetStorable()->hasLocation() + || INetURLObject( aModelData.GetStorable()->getLocation() ) != aURL ) ) + { + // this is definitely not a Save operation + // so the document info can be updated + + // on export document info must be preserved + uno::Reference<document::XDocumentPropertiesSupplier> xDPS( + aModelData.GetModel(), uno::UNO_QUERY_THROW); + uno::Reference<util::XCloneable> xCloneable( + xDPS->getDocumentProperties(), uno::UNO_QUERY_THROW); + uno::Reference<document::XDocumentProperties> xOldDocProps( + xCloneable->createClone(), uno::UNO_QUERY_THROW); + + // use dispatch API to show document info dialog + if ( aModelData.ShowDocumentInfoDialog() ) + bDialogUsed = true; + else + { + OSL_FAIL( "Can't execute document info dialog!" ); + } + + try { + // Document properties can contain streams that should be freed before storing + aModelData.FreeDocumentProps(); + if ( nStoreMode & EXPORT_REQUESTED ) + aModelData.GetStorable()->storeToURL( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), aArgsSequence ); + else + aModelData.GetStorable()->storeAsURL( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), aArgsSequence ); + } + catch( const uno::Exception& ) + { + if ( nStoreMode & EXPORT_REQUESTED ) + { + SetDocInfoState(aModelData.GetModel(), xOldDocProps); + } + throw; + } + + if ( nStoreMode & EXPORT_REQUESTED ) + { + SetDocInfoState(aModelData.GetModel(), xOldDocProps); + } + } + else + { + // Document properties can contain streams that should be freed before storing + aModelData.FreeDocumentProps(); + + // this is actually a save operation with different parameters + // so storeTo or storeAs without DocInfo operations are used + if ( nStoreMode & EXPORT_REQUESTED ) + aModelData.GetStorable()->storeToURL( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), aArgsSequence ); + else + aModelData.GetStorable()->storeAsURL( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), aArgsSequence ); + } + + // Launch PDF viewer + if ( nStoreMode & PDFEXPORT_REQUESTED ) + { + FilterConfigItem aItem(u"Office.Common/Filter/PDF/Export/"); + bool aViewPDF = aItem.ReadBool( "ViewPDFAfterExport", false ); + + if ( aViewPDF ) + { + uno::Reference<XSystemShellExecute> xSystemShellExecute(SystemShellExecute::create( ::comphelper::getProcessComponentContext() ) ); + xSystemShellExecute->execute( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), "", SystemShellExecuteFlags::URIS_ONLY ); + } + } + + return bDialogUsed; +} + + +// static +bool SfxStoringHelper::CheckFilterOptionsAppearance( + const uno::Reference< container::XNameAccess >& xFilterCFG, + const OUString& aFilterName ) +{ + bool bUseFilterOptions = false; + + DBG_ASSERT( xFilterCFG.is(), "No filter configuration!\n" ); + if( xFilterCFG.is() ) + { + try { + uno::Sequence < beans::PropertyValue > aProps; + uno::Any aAny = xFilterCFG->getByName( aFilterName ); + if ( aAny >>= aProps ) + { + ::comphelper::SequenceAsHashMap aPropsHM( aProps ); + if( !aPropsHM.getUnpackedValueOrDefault( "UIComponent", OUString() ).isEmpty() ) + bUseFilterOptions = true; + } + } + catch( const uno::Exception& ) + { + } + } + + return bUseFilterOptions; +} + + +// static +void SfxStoringHelper::SetDocInfoState( + const uno::Reference< frame::XModel >& xModel, + const uno::Reference< 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... wonder why + // SfxObjectShell doesn't handle this internally, should be easier + 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()); + // other attributes e.g. DocumentStatistics are not editable from dialog + } + catch (const uno::Exception&) + { + TOOLS_INFO_EXCEPTION("sfx.doc", "SetDocInfoState"); + } + + // set the modified flag back if required + if ( bIsModified != bool(xModifiable->isModified()) ) + xModifiable->setModified( bIsModified ); +} + + +// static +bool SfxStoringHelper::WarnUnacceptableFormat( const uno::Reference< frame::XModel >& xModel, + std::u16string_view aOldUIName, + const OUString& aDefExtension, + bool bDefIsAlien ) +{ + if ( !officecfg::Office::Common::Save::Document::WarnAlienFormat::get() ) + return true; + + weld::Window* pWin = SfxStoringHelper::GetModelWindow(xModel); + SfxAlienWarningDialog aDlg(pWin, aOldUIName, aDefExtension, bDefIsAlien); + + return aDlg.run() == RET_OK; +} + +uno::Reference<awt::XWindow> SfxStoringHelper::GetModelXWindow(const uno::Reference<frame::XModel>& xModel) +{ + try { + if ( xModel.is() ) + { + uno::Reference< frame::XController > xController = xModel->getCurrentController(); + if ( xController.is() ) + { + uno::Reference< frame::XFrame > xFrame = xController->getFrame(); + if ( xFrame.is() ) + { + return xFrame->getContainerWindow(); + } + } + } + } + catch ( const uno::Exception& ) + { + } + + return uno::Reference<awt::XWindow>(); +} + +weld::Window* SfxStoringHelper::GetModelWindow( const uno::Reference< frame::XModel >& xModel ) +{ + weld::Window* pWin = nullptr; + + try + { + pWin = Application::GetFrameWeld(GetModelXWindow(xModel)); + } + catch (const uno::Exception&) + { + } + + return pWin; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/iframe.cxx b/sfx2/source/doc/iframe.cxx new file mode 100644 index 000000000..52962c4be --- /dev/null +++ b/sfx2/source/doc/iframe.cxx @@ -0,0 +1,444 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <sal/config.h> + +#include <com/sun/star/awt/XWindowPeer.hpp> +#include <com/sun/star/frame/XDispatch.hpp> +#include <com/sun/star/frame/Frame.hpp> +#include <com/sun/star/frame/XFrame2.hpp> +#include <com/sun/star/frame/XSynchronousFrameLoader.hpp> +#include <com/sun/star/util/URLTransformer.hpp> +#include <com/sun/star/util/XURLTransformer.hpp> +#include <com/sun/star/util/XCloseable.hpp> +#include <com/sun/star/lang/XEventListener.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/ui/dialogs/XExecutableDialog.hpp> +#include <com/sun/star/embed/XEmbeddedObject.hpp> + +#include <comphelper/propertyvalue.hxx> +#include <cppuhelper/implbase.hxx> +#include <cppuhelper/supportsservice.hxx> +#include <officecfg/Office/Common.hxx> +#include <svl/itemprop.hxx> +#include <sfx2/docfile.hxx> +#include <sfx2/frmdescr.hxx> +#include <sfx2/objsh.hxx> +#include <sfx2/sfxdlg.hxx> +#include <toolkit/helper/vclunohelper.hxx> +#include <vcl/window.hxx> +#include <tools/debug.hxx> +#include <macroloader.hxx> +#include <eventsupplier.hxx> + +using namespace ::com::sun::star; + +namespace { + +class IFrameObject : public ::cppu::WeakImplHelper < + css::util::XCloseable, + css::lang::XEventListener, + css::frame::XSynchronousFrameLoader, + css::ui::dialogs::XExecutableDialog, + css::lang::XServiceInfo, + css::beans::XPropertySet > +{ + css::uno::Reference < css::uno::XComponentContext > mxContext; + css::uno::Reference < css::frame::XFrame2 > mxFrame; + css::uno::Reference < css::embed::XEmbeddedObject > mxObj; + SfxItemPropertyMap maPropMap; + SfxFrameDescriptor maFrmDescr; + +public: + /// @throws css::uno::Exception + /// @throws css::uno::RuntimeException + IFrameObject(const css::uno::Reference < css::uno::XComponentContext>& rxContext, const css::uno::Sequence< css::uno::Any >& aArguments); + + virtual OUString SAL_CALL getImplementationName() override + { + return "com.sun.star.comp.sfx2.IFrameObject"; + } + + virtual sal_Bool SAL_CALL supportsService(OUString const & ServiceName) override + { + return cppu::supportsService(this, ServiceName); + } + + virtual css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override + { + css::uno::Sequence< OUString > aSeq { "com.sun.star.frame.SpecialEmbeddedObject" }; + return aSeq; + } + + virtual sal_Bool SAL_CALL load( const css::uno::Sequence < css::beans::PropertyValue >& lDescriptor, + const css::uno::Reference < css::frame::XFrame >& xFrame ) override; + virtual void SAL_CALL cancel() override; + virtual void SAL_CALL close( sal_Bool bDeliverOwnership ) override; + virtual void SAL_CALL addCloseListener( const css::uno::Reference < css::util::XCloseListener >& xListener ) override; + virtual void SAL_CALL removeCloseListener( const css::uno::Reference < css::util::XCloseListener >& xListener ) override; + virtual void SAL_CALL disposing( const css::lang::EventObject& aEvent ) override ; + virtual void SAL_CALL setTitle( const OUString& aTitle ) override; + virtual ::sal_Int16 SAL_CALL execute( ) override; + virtual css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL getPropertySetInfo() override; + virtual void SAL_CALL addPropertyChangeListener(const OUString& aPropertyName, const css::uno::Reference< css::beans::XPropertyChangeListener > & aListener) override; + virtual void SAL_CALL removePropertyChangeListener(const OUString& aPropertyName, const css::uno::Reference< css::beans::XPropertyChangeListener > & aListener) override; + virtual void SAL_CALL addVetoableChangeListener(const OUString& aPropertyName, const css::uno::Reference< css::beans::XVetoableChangeListener > & aListener) override; + virtual void SAL_CALL removeVetoableChangeListener(const OUString& aPropertyName, const css::uno::Reference< css::beans::XVetoableChangeListener > & aListener) override; + virtual void SAL_CALL setPropertyValue( const OUString& aPropertyName, const css::uno::Any& aValue ) override; + virtual css::uno::Any SAL_CALL getPropertyValue( const OUString& PropertyName ) override; +}; + +class IFrameWindow_Impl : public vcl::Window +{ +public: + IFrameWindow_Impl( vcl::Window *pParent, bool bHasBorder ); +}; + +IFrameWindow_Impl::IFrameWindow_Impl( vcl::Window *pParent, bool bHasBorder ) + : Window( pParent, WB_CLIPCHILDREN | WB_NODIALOGCONTROL ) +{ + if ( !bHasBorder ) + SetBorderStyle( WindowBorderStyle::NOBORDER ); + else + SetBorderStyle( WindowBorderStyle::NORMAL ); +} + +#define PROPERTY_UNBOUND 0 + +#define WID_FRAME_URL 1 +#define WID_FRAME_NAME 2 +#define WID_FRAME_IS_AUTO_SCROLL 3 +#define WID_FRAME_IS_SCROLLING_MODE 4 +#define WID_FRAME_IS_BORDER 5 +#define WID_FRAME_IS_AUTO_BORDER 6 +#define WID_FRAME_MARGIN_WIDTH 7 +#define WID_FRAME_MARGIN_HEIGHT 8 + +const SfxItemPropertyMapEntry* lcl_GetIFramePropertyMap_Impl() +{ + static const SfxItemPropertyMapEntry aIFramePropertyMap_Impl[] = + { + { u"FrameIsAutoBorder", WID_FRAME_IS_AUTO_BORDER, cppu::UnoType<bool>::get(), PROPERTY_UNBOUND, 0 }, + { u"FrameIsAutoScroll", WID_FRAME_IS_AUTO_SCROLL, cppu::UnoType<bool>::get(), PROPERTY_UNBOUND, 0 }, + { u"FrameIsBorder", WID_FRAME_IS_BORDER, cppu::UnoType<bool>::get(), PROPERTY_UNBOUND, 0 }, + { u"FrameIsScrollingMode", WID_FRAME_IS_SCROLLING_MODE,cppu::UnoType<bool>::get(), PROPERTY_UNBOUND, 0 }, + { u"FrameMarginHeight", WID_FRAME_MARGIN_HEIGHT, cppu::UnoType<sal_Int32>::get(), PROPERTY_UNBOUND, 0 }, + { u"FrameMarginWidth", WID_FRAME_MARGIN_WIDTH, cppu::UnoType<sal_Int32>::get(), PROPERTY_UNBOUND, 0 }, + { u"FrameName", WID_FRAME_NAME, cppu::UnoType<OUString>::get(), PROPERTY_UNBOUND, 0 }, + { u"FrameURL", WID_FRAME_URL, cppu::UnoType<OUString>::get(), PROPERTY_UNBOUND, 0 }, + { u"", 0, css::uno::Type(), 0, 0 } + }; + return aIFramePropertyMap_Impl; +} + +IFrameObject::IFrameObject(const uno::Reference < uno::XComponentContext >& rxContext, const css::uno::Sequence< css::uno::Any >& aArguments) + : mxContext( rxContext ) + , maPropMap( lcl_GetIFramePropertyMap_Impl() ) +{ + if ( aArguments.hasElements() ) + aArguments[0] >>= mxObj; +} + +sal_Bool SAL_CALL IFrameObject::load( + const uno::Sequence < css::beans::PropertyValue >& /*lDescriptor*/, + const uno::Reference < frame::XFrame >& xFrame ) +{ + if ( officecfg::Office::Common::Misc::PluginsEnabled::get() ) + { + util::URL aTargetURL; + aTargetURL.Complete = maFrmDescr.GetURL().GetMainURL( INetURLObject::DecodeMechanism::NONE ); + uno::Reference < util::XURLTransformer > xTrans( util::URLTransformer::create( mxContext ) ); + xTrans->parseStrict( aTargetURL ); + + INetURLObject aURLObject(aTargetURL.Complete); + if (aURLObject.GetProtocol() == INetProtocol::Macro || aURLObject.isSchemeEqualTo(u"vnd.sun.star.script")) + return false; + + uno::Reference<frame::XFramesSupplier> xParentFrame = xFrame->getCreator(); + SfxObjectShell* pDoc = SfxMacroLoader::GetObjectShell(xParentFrame); + + bool bUpdateAllowed(true); + if (pDoc) + { + comphelper::EmbeddedObjectContainer& rEmbeddedObjectContainer = pDoc->getEmbeddedObjectContainer(); + bUpdateAllowed = rEmbeddedObjectContainer.getUserAllowsLinkUpdate(); + } + if (!bUpdateAllowed) + return false; + + OUString sReferer; + if (pDoc && pDoc->HasName()) + sReferer = pDoc->GetMedium()->GetName(); + + uno::Reference<css::awt::XWindow> xParentWindow(xFrame->getContainerWindow()); + + if (!mxFrame.is()) + { + VclPtr<vcl::Window> pParent = VCLUnoHelper::GetWindow(xParentWindow); + VclPtr<IFrameWindow_Impl> pWin = VclPtr<IFrameWindow_Impl>::Create( pParent, maFrmDescr.IsFrameBorderOn() ); + pWin->SetSizePixel( pParent->GetOutputSizePixel() ); + pWin->SetBackground(); + pWin->Show(); + + uno::Reference < awt::XWindow > xWindow( pWin->GetComponentInterface(), uno::UNO_QUERY ); + xFrame->setComponent( xWindow, uno::Reference < frame::XController >() ); + + // we must destroy the IFrame before the parent is destroyed + xWindow->addEventListener( this ); + + mxFrame = frame::Frame::create( mxContext ); + uno::Reference < awt::XWindow > xWin( pWin->GetComponentInterface(), uno::UNO_QUERY ); + mxFrame->initialize( xWin ); + mxFrame->setName( maFrmDescr.GetName() ); + + uno::Reference < frame::XFramesSupplier > xFramesSupplier( xFrame, uno::UNO_QUERY ); + if ( xFramesSupplier.is() ) + mxFrame->setCreator( xFramesSupplier ); + } + + uno::Sequence < beans::PropertyValue > aProps{ + comphelper::makePropertyValue("PluginMode", sal_Int16(2)), + comphelper::makePropertyValue("ReadOnly", true), + comphelper::makePropertyValue("Referer", sReferer) + }; + uno::Reference < frame::XDispatch > xDisp = mxFrame->queryDispatch( aTargetURL, "_self", 0 ); + if ( xDisp.is() ) + xDisp->dispatch( aTargetURL, aProps ); + + return true; + } + + return false; +} + +void SAL_CALL IFrameObject::cancel() +{ + try + { + uno::Reference < util::XCloseable > xClose( mxFrame, uno::UNO_QUERY ); + if ( xClose.is() ) + xClose->close( true ); + mxFrame = nullptr; + } + catch (const uno::Exception&) + { + } +} + +void SAL_CALL IFrameObject::close( sal_Bool /*bDeliverOwnership*/ ) +{ +} + +void SAL_CALL IFrameObject::addCloseListener( const css::uno::Reference < css::util::XCloseListener >& ) +{ +} + +void SAL_CALL IFrameObject::removeCloseListener( const css::uno::Reference < css::util::XCloseListener >& ) +{ +} + +void SAL_CALL IFrameObject::disposing( const css::lang::EventObject& ) +{ + cancel(); +} + +uno::Reference< beans::XPropertySetInfo > SAL_CALL IFrameObject::getPropertySetInfo() +{ + static uno::Reference< beans::XPropertySetInfo > xInfo = new SfxItemPropertySetInfo( maPropMap ); + return xInfo; +} + +void SAL_CALL IFrameObject::setPropertyValue(const OUString& aPropertyName, const uno::Any& aAny) +{ + const SfxItemPropertyMapEntry* pEntry = maPropMap.getByName( aPropertyName ); + if( !pEntry ) + throw beans::UnknownPropertyException(aPropertyName); + switch( pEntry->nWID ) + { + case WID_FRAME_URL: + { + OUString aURL; + aAny >>= aURL; + maFrmDescr.SetURL( aURL ); + } + break; + case WID_FRAME_NAME: + { + OUString aName; + if ( aAny >>= aName ) + maFrmDescr.SetName( aName ); + } + break; + case WID_FRAME_IS_AUTO_SCROLL: + { + bool bIsAutoScroll; + if ( (aAny >>= bIsAutoScroll) && bIsAutoScroll ) + maFrmDescr.SetScrollingMode( ScrollingMode::Auto ); + } + break; + case WID_FRAME_IS_SCROLLING_MODE: + { + bool bIsScroll; + if ( aAny >>= bIsScroll ) + maFrmDescr.SetScrollingMode( bIsScroll ? ScrollingMode::Yes : ScrollingMode::No ); + } + break; + case WID_FRAME_IS_BORDER: + { + bool bIsBorder; + if ( aAny >>= bIsBorder ) + maFrmDescr.SetFrameBorder( bIsBorder ); + } + break; + case WID_FRAME_IS_AUTO_BORDER: + { + bool bIsAutoBorder; + if ( aAny >>= bIsAutoBorder ) + { + bool bBorder = maFrmDescr.IsFrameBorderOn(); + maFrmDescr.ResetBorder(); + if ( bIsAutoBorder ) + maFrmDescr.SetFrameBorder( bBorder ); + } + } + break; + case WID_FRAME_MARGIN_WIDTH: + { + sal_Int32 nMargin = 0; + Size aSize = maFrmDescr.GetMargin(); + if ( aAny >>= nMargin ) + { + aSize.setWidth( nMargin ); + maFrmDescr.SetMargin( aSize ); + } + } + break; + case WID_FRAME_MARGIN_HEIGHT: + { + sal_Int32 nMargin = 0; + Size aSize = maFrmDescr.GetMargin(); + if ( aAny >>= nMargin ) + { + aSize.setHeight( nMargin ); + maFrmDescr.SetMargin( aSize ); + } + } + break; + default: ; + } +} + +uno::Any SAL_CALL IFrameObject::getPropertyValue(const OUString& aPropertyName) +{ + const SfxItemPropertyMapEntry* pEntry = maPropMap.getByName( aPropertyName ); + if( !pEntry ) + throw beans::UnknownPropertyException(aPropertyName); + uno::Any aAny; + switch( pEntry->nWID ) + { + case WID_FRAME_URL: + { + aAny <<= maFrmDescr.GetURL().GetMainURL( INetURLObject::DecodeMechanism::NONE ); + } + break; + case WID_FRAME_NAME: + { + aAny <<= maFrmDescr.GetName(); + } + break; + case WID_FRAME_IS_AUTO_SCROLL: + { + bool bIsAutoScroll = ( maFrmDescr.GetScrollingMode() == ScrollingMode::Auto ); + aAny <<= bIsAutoScroll; + } + break; + case WID_FRAME_IS_SCROLLING_MODE: + { + bool bIsScroll = ( maFrmDescr.GetScrollingMode() == ScrollingMode::Yes ); + aAny <<= bIsScroll; + } + break; + case WID_FRAME_IS_BORDER: + { + bool bIsBorder = maFrmDescr.IsFrameBorderOn(); + aAny <<= bIsBorder; + } + break; + case WID_FRAME_IS_AUTO_BORDER: + { + bool bIsAutoBorder = !maFrmDescr.IsFrameBorderSet(); + aAny <<= bIsAutoBorder; + } + break; + case WID_FRAME_MARGIN_WIDTH: + { + aAny <<= static_cast<sal_Int32>(maFrmDescr.GetMargin().Width()); + } + break; + case WID_FRAME_MARGIN_HEIGHT: + { + aAny <<= static_cast<sal_Int32>(maFrmDescr.GetMargin().Height()); + } + break; + default: ; + } + return aAny; +} + +void SAL_CALL IFrameObject::addPropertyChangeListener(const OUString&, const css::uno::Reference< css::beans::XPropertyChangeListener > & ) +{ +} + +void SAL_CALL IFrameObject::removePropertyChangeListener(const OUString&, const css::uno::Reference< css::beans::XPropertyChangeListener > & ) +{ +} + +void SAL_CALL IFrameObject::addVetoableChangeListener(const OUString&, const css::uno::Reference< css::beans::XVetoableChangeListener > & ) +{ +} + +void SAL_CALL IFrameObject::removeVetoableChangeListener(const OUString&, const css::uno::Reference< css::beans::XVetoableChangeListener > & ) +{ +} + +::sal_Int16 SAL_CALL IFrameObject::execute() +{ + SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create(); + //we really should set a parent here + ScopedVclPtr<VclAbstractDialog> pDlg(pFact->CreateEditObjectDialog(nullptr, ".uno:InsertObjectFloatingFrame", mxObj)); + pDlg->Execute(); + return 0; +} + +void SAL_CALL IFrameObject::setTitle( const OUString& ) +{ +} + +} + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * +com_sun_star_comp_sfx2_IFrameObject_get_implementation( + css::uno::XComponentContext *context, + css::uno::Sequence<css::uno::Any> const &arguments) +{ + return cppu::acquire(new IFrameObject(context, arguments)); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/new.cxx b/sfx2/source/doc/new.cxx new file mode 100644 index 000000000..a6922befc --- /dev/null +++ b/sfx2/source/doc/new.cxx @@ -0,0 +1,350 @@ +/* -*- 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 <osl/file.hxx> +#include <sfx2/new.hxx> +#include <vcl/idle.hxx> +#include <vcl/gdimtf.hxx> +#include <vcl/outdev.hxx> +#include <svl/itemset.hxx> +#include <svl/eitem.hxx> +#include <svtools/sfxecode.hxx> +#include <svtools/ehdl.hxx> +#include <tools/urlobj.hxx> +#include <tools/debug.hxx> + +#include <sfx2/strings.hrc> +#include <sfx2/sfxsids.hrc> +#include <sfx2/app.hxx> +#include <sfx2/objsh.hxx> +#include <sfx2/sfxresid.hxx> +#include <sfx2/docfile.hxx> +#include <preview.hxx> +#include <unotools/viewoptions.hxx> + +void SfxPreviewWin_Impl::SetObjectShell(SfxObjectShell const * pObj) +{ + std::shared_ptr<GDIMetaFile> xFile = pObj + ? pObj->GetPreviewMetaFile() + : std::shared_ptr<GDIMetaFile>(); + xMetaFile = xFile; + Invalidate(); +} + +SfxPreviewWin_Impl::SfxPreviewWin_Impl() +{ +} + +void SfxPreviewWin_Impl::ImpPaint(vcl::RenderContext& rRenderContext, GDIMetaFile* pFile) +{ + rRenderContext.SetLineColor(); + rRenderContext.SetFillColor(COL_LIGHTGRAY); + rRenderContext.DrawRect(tools::Rectangle(Point(0,0), rRenderContext.GetOutputSize())); + + Size aTmpSize = pFile ? pFile->GetPrefSize() : Size(1, 1); + DBG_ASSERT(!aTmpSize.IsEmpty(), "size of first page is 0, override GetFirstPageSize or set visible-area!"); + +#define FRAME 4 + + tools::Long nWidth = rRenderContext.GetOutputSize().Width() - 2 * FRAME; + tools::Long nHeight = rRenderContext.GetOutputSize().Height() - 2 * FRAME; + if (nWidth <= 0 || nHeight <= 0) + return; + + double dRatio = aTmpSize.Height() ? (double(aTmpSize.Width()) / aTmpSize.Height()) : 1; + double dRatioPreV = double(nWidth) / nHeight; + Size aSize; + Point aPoint; + if (dRatio > dRatioPreV) + { + aSize = Size(nWidth, sal_uInt16(nWidth / dRatio)); + aPoint = Point(0, sal_uInt16((nHeight - aSize.Height()) / 2)); + } + else + { + aSize = Size(sal_uInt16(nHeight * dRatio), nHeight); + aPoint = Point(sal_uInt16((nWidth - aSize.Width()) / 2), 0); + } + Point bPoint = Point(nWidth, nHeight) - aPoint; + + if (pFile) + { + rRenderContext.SetLineColor(COL_BLACK); + rRenderContext.SetFillColor(COL_WHITE); + rRenderContext.DrawRect(tools::Rectangle(aPoint + Point(FRAME, FRAME), bPoint + Point(FRAME, FRAME))); + pFile->WindStart(); + pFile->Play(rRenderContext, aPoint + Point(FRAME, FRAME), aSize); + } +} + +void SfxPreviewWin_Impl::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) +{ + ImpPaint(rRenderContext, xMetaFile.get()); +} + +IMPL_LINK_NOARG(SfxNewFileDialog, Update, Timer*, void) +{ + if (m_xDocShell.Is()) + { + if (m_xDocShell->GetProgress()) + return; + m_xDocShell.Clear(); + } + + const sal_uInt16 nEntry = GetSelectedTemplatePos(); + if (!nEntry) + { + m_xPreviewController->Invalidate(); + m_xPreviewController->SetObjectShell(nullptr); + return; + } + + if (!m_xMoreBt->get_expanded() || (m_nFlags != SfxNewFileDialogMode::Preview)) + return; + + OUString aFileName = m_aTemplates.GetPath(m_xRegionLb->get_selected_index(), nEntry - 1); + INetURLObject aTestObj(aFileName); + if (aTestObj.GetProtocol() == INetProtocol::NotValid) + { + // temp. fix until Templates are managed by UCB compatible service + // does NOT work with locally cached components ! + OUString aTemp; + osl::FileBase::getFileURLFromSystemPath( aFileName, aTemp ); + aFileName = aTemp; + } + + INetURLObject aObj(aFileName); + for (SfxObjectShell* pTmp = SfxObjectShell::GetFirst(); pTmp; pTmp = SfxObjectShell::GetNext(*pTmp)) + { + //! fsys bug op== + if (pTmp->GetMedium()) + // ??? HasName() MM + if (INetURLObject( pTmp->GetMedium()->GetName() ) == aObj) + { + m_xDocShell = pTmp; + break; + } + } + + if (!m_xDocShell.Is()) + { + SfxErrorContext eEC(ERRCTX_SFX_LOADTEMPLATE, m_xDialog.get()); + SfxApplication *pSfxApp = SfxGetpApp(); + std::unique_ptr<SfxItemSet> pSet(new SfxAllItemSet(pSfxApp->GetPool())); + pSet->Put(SfxBoolItem(SID_TEMPLATE, true)); + pSet->Put(SfxBoolItem(SID_PREVIEW, true)); + ErrCode lErr = pSfxApp->LoadTemplate(m_xDocShell, aFileName, std::move(pSet)); + if (lErr) + ErrorHandler::HandleError(lErr); + if (!m_xDocShell.Is()) + { + m_xPreviewController->SetObjectShell(nullptr); + return; + } + } + + m_xPreviewController->SetObjectShell(m_xDocShell); +} + +IMPL_LINK( SfxNewFileDialog, RegionSelect, weld::TreeView&, rBox, void ) +{ + if (m_xDocShell.Is() && m_xDocShell->GetProgress()) + return; + + const sal_uInt16 nRegion = rBox.get_selected_index(); + const sal_uInt16 nCount = m_aTemplates.GetRegionCount() ? m_aTemplates.GetCount(nRegion): 0; + m_xTemplateLb->freeze(); + m_xTemplateLb->clear(); + OUString aSel = m_xRegionLb->get_selected_text(); + sal_Int32 nc = aSel.indexOf('('); + if (nc != -1 && nc != 0) + aSel = aSel.replaceAt(nc-1, 1, u""); + if ( aSel.compareToIgnoreAsciiCase( SfxResId(STR_STANDARD) ) == 0 ) + m_xTemplateLb->append_text(SfxResId(STR_NONE)); + for (sal_uInt16 i = 0; i < nCount; ++i) + m_xTemplateLb->append_text(m_aTemplates.GetName(nRegion, i)); + m_xTemplateLb->thaw(); + if (nCount) + m_xTemplateLb->select(0); + TemplateSelect(*m_xTemplateLb); +} + +IMPL_LINK_NOARG(SfxNewFileDialog, Expand, weld::Expander&, void) +{ + TemplateSelect(*m_xTemplateLb); +} + +IMPL_LINK_NOARG(SfxNewFileDialog, TemplateSelect, weld::TreeView&, void) +{ + // Still loading + if (m_xDocShell && m_xDocShell->GetProgress()) + return; + + if (!m_xMoreBt->get_expanded()) + { + // Dialog is not opened + return; + } + + m_aPrevIdle.Start(); +} + +IMPL_LINK_NOARG( SfxNewFileDialog, DoubleClick, weld::TreeView&, bool ) +{ + // Still loading + if (!m_xDocShell.Is() || !m_xDocShell->GetProgress()) + m_xDialog->response(RET_OK); + return true; +} + +sal_uInt16 SfxNewFileDialog::GetSelectedTemplatePos() const +{ + int nEntry = m_xTemplateLb->get_selected_index(); + if (nEntry == -1) + return 0; + OUString aSel = m_xRegionLb->get_selected_text(); + sal_Int32 nc = aSel.indexOf('('); + if (nc != -1 && nc != 0) + aSel = aSel.replaceAt(nc-1, 1, u""); + if ( aSel.compareToIgnoreAsciiCase(SfxResId(STR_STANDARD)) != 0 ) + nEntry++; + return nEntry; +} + +SfxNewFileDialog::SfxNewFileDialog(weld::Window *pParent, SfxNewFileDialogMode nFlags) + : SfxDialogController(pParent, "sfx/ui/loadtemplatedialog.ui", "LoadTemplateDialog") + , m_aPrevIdle("SfxNewFileDialog m_aPrevIdle") + , m_nFlags(nFlags) + , m_xPreviewController(new SfxPreviewWin_Impl) + , m_xRegionLb(m_xBuilder->weld_tree_view("categories")) + , m_xTemplateLb(m_xBuilder->weld_tree_view("templates")) + , m_xTextStyleCB(m_xBuilder->weld_check_button("text")) + , m_xFrameStyleCB(m_xBuilder->weld_check_button("frame")) + , m_xPageStyleCB(m_xBuilder->weld_check_button("pages")) + , m_xNumStyleCB(m_xBuilder->weld_check_button("numbering")) + , m_xMergeStyleCB(m_xBuilder->weld_check_button("overwrite")) + , m_xLoadFilePB(m_xBuilder->weld_button("fromfile")) + , m_xMoreBt(m_xBuilder->weld_expander("expander")) + , m_xPreviewWin(new weld::CustomWeld(*m_xBuilder, "image", *m_xPreviewController)) + , m_xAltTitleFt(m_xBuilder->weld_label("alttitle")) +{ + const int nWidth = m_xRegionLb->get_approximate_digit_width() * 32; + const int nHeight = m_xRegionLb->get_height_rows(8); + m_xRegionLb->set_size_request(nWidth, nHeight); + m_xTemplateLb->set_size_request(nWidth, nHeight); + m_xPreviewWin->set_size_request(nWidth, nWidth); + + if (nFlags == SfxNewFileDialogMode::NONE) + m_xMoreBt->hide(); + else if(SfxNewFileDialogMode::LoadTemplate == nFlags) + { + m_xLoadFilePB->show(); + m_xTextStyleCB->show(); + m_xFrameStyleCB->show(); + m_xPageStyleCB->show(); + m_xNumStyleCB->show(); + m_xMergeStyleCB->show(); + m_xMoreBt->hide(); + m_xTextStyleCB->set_active(true); + m_xDialog->set_title(m_xAltTitleFt->get_label()); + } + else + { + m_xMoreBt->connect_expanded(LINK(this, SfxNewFileDialog, Expand)); + m_xPreviewWin->show(); + } + + OUString sExtraData; + SvtViewOptions aDlgOpt(EViewType::Dialog, OStringToOUString(m_xDialog->get_help_id(), RTL_TEXTENCODING_UTF8)); + if (aDlgOpt.Exists()) + { + css::uno::Any aUserItem = aDlgOpt.GetUserItem("UserItem"); + aUserItem >>= sExtraData; + } + + bool bExpand = !sExtraData.isEmpty() && sExtraData[0] == 'Y'; + m_xMoreBt->set_expanded(bExpand && (nFlags != SfxNewFileDialogMode::NONE)); + + m_xTemplateLb->connect_changed(LINK(this, SfxNewFileDialog, TemplateSelect)); + m_xTemplateLb->connect_row_activated(LINK(this, SfxNewFileDialog, DoubleClick)); + + // update the template configuration if necessary + { + weld::WaitObject aWaitCursor(m_xDialog.get()); + m_aTemplates.Update(); + } + // fill the list boxes + const sal_uInt16 nCount = m_aTemplates.GetRegionCount(); + if (nCount) + { + for(sal_uInt16 i = 0; i < nCount; ++i) + m_xRegionLb->append_text(m_aTemplates.GetFullRegionName(i)); + m_xRegionLb->connect_changed(LINK(this, SfxNewFileDialog, RegionSelect)); + } + + m_aPrevIdle.SetPriority( TaskPriority::LOWEST ); + m_aPrevIdle.SetInvokeHandler( LINK( this, SfxNewFileDialog, Update)); + + m_xRegionLb->select(0); + RegionSelect(*m_xRegionLb); +} + +SfxNewFileDialog::~SfxNewFileDialog() +{ + SvtViewOptions aDlgOpt(EViewType::Dialog, OStringToOUString(m_xDialog->get_help_id(), RTL_TEXTENCODING_UTF8)); + aDlgOpt.SetUserItem("UserItem", css::uno::Any(m_xMoreBt->get_expanded() ? OUString("Y") : OUString("N"))); +} + +bool SfxNewFileDialog::IsTemplate() const +{ + return GetSelectedTemplatePos()!=0; +} + +OUString SfxNewFileDialog::GetTemplateFileName() const +{ + if (!IsTemplate() || !m_aTemplates.GetRegionCount()) + return OUString(); + return m_aTemplates.GetPath(m_xRegionLb->get_selected_index(), + GetSelectedTemplatePos()-1); +} + +SfxTemplateFlags SfxNewFileDialog::GetTemplateFlags()const +{ + SfxTemplateFlags nRet = m_xTextStyleCB->get_active() ? SfxTemplateFlags::LOAD_TEXT_STYLES : SfxTemplateFlags::NONE; + if(m_xFrameStyleCB->get_active()) + nRet |= SfxTemplateFlags::LOAD_FRAME_STYLES; + if(m_xPageStyleCB->get_active()) + nRet |= SfxTemplateFlags::LOAD_PAGE_STYLES; + if(m_xNumStyleCB->get_active()) + nRet |= SfxTemplateFlags::LOAD_NUM_STYLES; + if(m_xMergeStyleCB->get_active()) + nRet |= SfxTemplateFlags::MERGE_STYLES; + return nRet; +} + +void SfxNewFileDialog::SetTemplateFlags(SfxTemplateFlags nSet) +{ + m_xTextStyleCB->set_active( bool(nSet & SfxTemplateFlags::LOAD_TEXT_STYLES )); + m_xFrameStyleCB->set_active( bool(nSet & SfxTemplateFlags::LOAD_FRAME_STYLES)); + m_xPageStyleCB->set_active( bool(nSet & SfxTemplateFlags::LOAD_PAGE_STYLES )); + m_xNumStyleCB->set_active( bool(nSet & SfxTemplateFlags::LOAD_NUM_STYLES )); + m_xMergeStyleCB->set_active( bool(nSet & SfxTemplateFlags::MERGE_STYLES )); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/objcont.cxx b/sfx2/source/doc/objcont.cxx new file mode 100644 index 000000000..8313cfc3d --- /dev/null +++ b/sfx2/source/doc/objcont.cxx @@ -0,0 +1,712 @@ +/* -*- 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 <com/sun/star/uno/Reference.hxx> + +#include <com/sun/star/document/DocumentProperties.hpp> +#include <com/sun/star/document/XDocumentProperties.hpp> +#include <com/sun/star/document/UpdateDocMode.hpp> +#include <comphelper/fileurl.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> +#include <svl/style.hxx> + +#include <svl/intitem.hxx> +#include <svl/ctloptions.hxx> +#include <comphelper/processfactory.hxx> +#include <unotools/securityoptions.hxx> +#include <tools/datetime.hxx> +#include <tools/diagnose_ex.h> +#include <tools/helpers.hxx> +#include <rtl/uri.hxx> + +#include <unotools/useroptions.hxx> +#include <vcl/virdev.hxx> +#include <vcl/settings.hxx> +#include <vcl/gdimtf.hxx> + +#include <sfx2/app.hxx> +#include <sfx2/dinfdlg.hxx> +#include <sfx2/sfxresid.hxx> +#include <appdata.hxx> +#include <sfx2/docfac.hxx> +#include <sfx2/viewsh.hxx> +#include <sfx2/objsh.hxx> +#include <objshimp.hxx> +#include <sfx2/printer.hxx> +#include <sfx2/viewfrm.hxx> +#include <sfx2/doctempl.hxx> +#include <sfx2/sfxsids.hrc> +#include <sfx2/strings.hrc> +#include <sfx2/docfile.hxx> +#include <sfx2/docfilt.hxx> +#include <memory> +#include <helpids.h> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; + + +static +bool operator> (const util::DateTime& i_rLeft, const util::DateTime& i_rRight) +{ + if ( i_rLeft.Year != i_rRight.Year ) + return i_rLeft.Year > i_rRight.Year; + + if ( i_rLeft.Month != i_rRight.Month ) + return i_rLeft.Month > i_rRight.Month; + + if ( i_rLeft.Day != i_rRight.Day ) + return i_rLeft.Day > i_rRight.Day; + + if ( i_rLeft.Hours != i_rRight.Hours ) + return i_rLeft.Hours > i_rRight.Hours; + + if ( i_rLeft.Minutes != i_rRight.Minutes ) + return i_rLeft.Minutes > i_rRight.Minutes; + + if ( i_rLeft.Seconds != i_rRight.Seconds ) + return i_rLeft.Seconds > i_rRight.Seconds; + + if ( i_rLeft.NanoSeconds != i_rRight.NanoSeconds ) + return i_rLeft.NanoSeconds > i_rRight.NanoSeconds; + + return false; +} + +std::shared_ptr<GDIMetaFile> +SfxObjectShell::GetPreviewMetaFile( bool bFullContent ) const +{ + auto xFile = std::make_shared<GDIMetaFile>(); + ScopedVclPtrInstance< VirtualDevice > pDevice; + pDevice->EnableOutput( false ); + if(!CreatePreview_Impl(bFullContent, pDevice, xFile.get())) + return std::shared_ptr<GDIMetaFile>(); + return xFile; +} + +BitmapEx SfxObjectShell::GetPreviewBitmap() const +{ + ScopedVclPtrInstance< VirtualDevice > pDevice; + pDevice->SetAntialiasing(AntialiasingFlags::Enable | pDevice->GetAntialiasing()); + if(!CreatePreview_Impl(/*bFullContent*/false, pDevice, nullptr)) + return BitmapEx(); + Size size = pDevice->GetOutputSizePixel(); + BitmapEx aBitmap = pDevice->GetBitmapEx( Point(), size); + // Scale down the image to the desired size from the 4*size from CreatePreview_Impl(). + size = Size( size.Width() / 4, size.Height() / 4 ); + aBitmap.Scale(size, BmpScaleFlag::BestQuality); + if (!aBitmap.IsEmpty()) + aBitmap.Convert(BmpConversion::N24Bit); + return aBitmap; +} + +bool SfxObjectShell::CreatePreview_Impl( bool bFullContent, VirtualDevice* pDevice, GDIMetaFile* pFile) const +{ + // DoDraw can only be called when no printing is done, otherwise + // the printer may be turned off + SfxViewFrame *pFrame = SfxViewFrame::GetFirst( this ); + if ( pFrame && pFrame->GetViewShell() && + pFrame->GetViewShell()->GetPrinter() && + pFrame->GetViewShell()->GetPrinter()->IsPrinting() ) + return false; + + MapMode aMode( GetMapUnit() ); + Size aTmpSize; + sal_Int8 nAspect; + if ( bFullContent ) + { + nAspect = ASPECT_CONTENT; + aTmpSize = GetVisArea( nAspect ).GetSize(); + } + else + { + nAspect = ASPECT_THUMBNAIL; + aTmpSize = GetFirstPageSize(); + } + + DBG_ASSERT( !aTmpSize.IsEmpty(), + "size of first page is 0, override GetFirstPageSize or set visible-area!" ); + + if(pFile) + { + pDevice->SetMapMode( aMode ); + pFile->SetPrefMapMode( aMode ); + pFile->SetPrefSize( aTmpSize ); + pFile->Record( pDevice ); + } + else + { + // Use pixel size, that's also what DoDraw() requires in this case, + // despite the metafile case (needlessly?) setting mapmode. + Size aSizePix = pDevice->LogicToPixel( aTmpSize, aMode ); + // Code based on GDIMetaFile::CreateThumbnail(). + sal_uInt32 nMaximumExtent = 512; + // determine size that has the same aspect ratio as image size and + // fits into the rectangle determined by nMaximumExtent + if ( aSizePix.Width() && aSizePix.Height() + && ( sal::static_int_cast< tools::ULong >(aSizePix.Width()) > + nMaximumExtent || + sal::static_int_cast< tools::ULong >(aSizePix.Height()) > + nMaximumExtent ) ) + { + double fWH = static_cast< double >( aSizePix.Width() ) / aSizePix.Height(); + if ( fWH <= 1.0 ) + { + aSizePix.setWidth( FRound( nMaximumExtent * fWH ) ); + aSizePix.setHeight( nMaximumExtent ); + } + else + { + aSizePix.setWidth( nMaximumExtent ); + aSizePix.setHeight( FRound( nMaximumExtent / fWH ) ); + } + } + // do it 4x larger to be able to scale it down & get beautiful antialias + aTmpSize = Size( aSizePix.Width() * 4, aSizePix.Height() * 4 ); + pDevice->SetOutputSizePixel( aTmpSize ); + } + + LanguageType eLang; + SvtCTLOptions aCTLOptions; + if ( SvtCTLOptions::NUMERALS_HINDI == aCTLOptions.GetCTLTextNumerals() ) + eLang = LANGUAGE_ARABIC_SAUDI_ARABIA; + else if ( SvtCTLOptions::NUMERALS_ARABIC == aCTLOptions.GetCTLTextNumerals() ) + eLang = LANGUAGE_ENGLISH; + else + eLang = Application::GetSettings().GetLanguageTag().getLanguageType(); + + pDevice->SetDigitLanguage( eLang ); + + const_cast<SfxObjectShell*>(this)->DoDraw( pDevice, Point(0,0), aTmpSize, JobSetup(), nAspect ); + + if(pFile) + pFile->Stop(); + + return true; +} + + +void SfxObjectShell::UpdateDocInfoForSave() +{ + uno::Reference<document::XDocumentProperties> xDocProps(getDocProperties()); + + // clear user data if recommend (see 'Tools - Options - LibreOffice - Security') + if ( SvtSecurityOptions::IsOptionSet( + SvtSecurityOptions::EOption::DocWarnRemovePersonalInfo ) ) + { + xDocProps->resetUserData( OUString() ); + } + else if ( IsModified() ) + { + const OUString aUserName = SvtUserOptions().GetFullName(); + if ( !IsUseUserData() ) + { + // remove all data pointing to the current user + if (xDocProps->getAuthor() == aUserName) { + xDocProps->setAuthor( OUString() ); + } + xDocProps->setModifiedBy( OUString() ); + if (xDocProps->getPrintedBy() == aUserName) { + xDocProps->setPrintedBy( OUString() ); + } + } + else + { + // update ModificationAuthor, revision and editing time + ::DateTime now( ::DateTime::SYSTEM ); + xDocProps->setModificationDate( now.GetUNODateTime() ); + xDocProps->setModifiedBy( aUserName ); + UpdateTime_Impl( xDocProps ); + } + } +} + + +static void +lcl_add(util::Duration & rDur, tools::Time const& rTime) +{ + // here we don't care about overflow: rDur is converted back to seconds + // anyway, and tools::Time cannot store more than ~4000 hours + rDur.Hours += rTime.GetHour(); + rDur.Minutes += rTime.GetMin(); + rDur.Seconds += rTime.GetSec(); +} + +// Update the processing time +void SfxObjectShell::UpdateTime_Impl( + const uno::Reference<document::XDocumentProperties> & i_xDocProps) +{ + // Get old time from documentinfo + const sal_Int32 secs = i_xDocProps->getEditingDuration(); + util::Duration editDuration(false, 0, 0, 0, + secs/3600, (secs%3600)/60, secs%60, 0); + + // Initialize some local member! It's necessary for follow operations! + DateTime aNow( DateTime::SYSTEM ); // Date and time at current moment + tools::Time n24Time (24,0,0,0) ; // Time-value for 24 hours - see follow calculation + tools::Time nAddTime (0) ; // Value to add on aOldTime + + // Save impossible cases! + // User has changed time to the past between last editing and now... it's not possible!!! + DBG_ASSERT( !(aNow.GetDate()<pImpl->nTime.GetDate()), "Timestamp of last change is in the past!?..." ); + + // Do the follow only, if user has NOT changed time to the past. + // Else add a time of 0 to aOldTime... !!! + if (aNow.GetDate()>=pImpl->nTime.GetDate()) + { + // Count of days between now and last editing + sal_Int32 nDays = aNow.GetSecFromDateTime(Date(pImpl->nTime.GetDate()))/86400 ; + + if (nDays==0) + { + // If no day between now and last editing - calculate time directly. + nAddTime = static_cast<const tools::Time&>(aNow) - static_cast<const tools::Time&>(pImpl->nTime); + } + else if (nDays<=31) + { + // If time of working without save greater than 1 month (!)... + // we add 0 to aOldTime! + + // If 1 or up to 31 days between now and last editing - calculate time indirectly. + // nAddTime = (24h - nTime) + (nDays * 24h) + aNow + --nDays; + nAddTime = tools::Time( nDays * n24Time.GetTime()); + nAddTime += n24Time-static_cast<const tools::Time&>(pImpl->nTime); + nAddTime += aNow ; + } + + lcl_add(editDuration, nAddTime); + } + + pImpl->nTime = aNow; + try { + const sal_Int32 newSecs( (editDuration.Hours*3600) + + (editDuration.Minutes*60) + editDuration.Seconds); + i_xDocProps->setEditingDuration(newSecs); + i_xDocProps->setEditingCycles(i_xDocProps->getEditingCycles() + 1); + } + catch (const lang::IllegalArgumentException &) + { + // ignore overflow + } +} + +std::shared_ptr<SfxDocumentInfoDialog> SfxObjectShell::CreateDocumentInfoDialog(weld::Window* pParent, + const SfxItemSet& rSet) +{ + return std::make_shared<SfxDocumentInfoDialog>(pParent, rSet); +} + +std::set<Color> SfxObjectShell::GetDocColors() +{ + std::set<Color> empty; + return empty; +} + +std::vector<Color> SfxObjectShell::GetThemeColors() { return std::vector<Color>(); } + +sfx::AccessibilityIssueCollection SfxObjectShell::runAccessibilityCheck() +{ + sfx::AccessibilityIssueCollection aCollection; + return aCollection; +} + +SfxStyleSheetBasePool* SfxObjectShell::GetStyleSheetPool() +{ + return nullptr; +} + +namespace { + +struct Styles_Impl +{ + SfxStyleSheetBase *pSource; + SfxStyleSheetBase *pDest; +}; + +} + +void SfxObjectShell::LoadStyles +( + SfxObjectShell &rSource /* the document template from which + the styles are to be loaded */ +) + +/* [Description] + + This method is called by the SFx if styles are to be loaded from a template. + Existing styles are in this case overwritten. The document must then be + re-formatted. Therefore, applications usually override this method + and call the implementation in the base class. +*/ + +{ + SfxStyleSheetBasePool *pSourcePool = rSource.GetStyleSheetPool(); + DBG_ASSERT(pSourcePool, "Source-DocumentShell without StyleSheetPool"); + SfxStyleSheetBasePool *pMyPool = GetStyleSheetPool(); + DBG_ASSERT(pMyPool, "Dest-DocumentShell without StyleSheetPool"); + auto xIter = pSourcePool->CreateIterator(SfxStyleFamily::All); + std::unique_ptr<Styles_Impl[]> pFound(new Styles_Impl[xIter->Count()]); + sal_uInt16 nFound = 0; + + SfxStyleSheetBase *pSource = xIter->First(); + while ( pSource ) + { + SfxStyleSheetBase *pDest = + pMyPool->Find( pSource->GetName(), pSource->GetFamily() ); + if ( !pDest ) + { + pDest = &pMyPool->Make( pSource->GetName(), + pSource->GetFamily(), pSource->GetMask()); + // Setting of parents, the next style + } + pFound[nFound].pSource = pSource; + pFound[nFound].pDest = pDest; + ++nFound; + pSource = xIter->Next(); + } + + for ( sal_uInt16 i = 0; i < nFound; ++i ) + { + pFound[i].pDest->GetItemSet().PutExtended(pFound[i].pSource->GetItemSet(), SfxItemState::DONTCARE, SfxItemState::DEFAULT); + if(pFound[i].pSource->HasParentSupport()) + pFound[i].pDest->SetParent(pFound[i].pSource->GetParent()); + if(pFound[i].pSource->HasFollowSupport()) + pFound[i].pDest->SetFollow(pFound[i].pSource->GetParent()); + } +} + +sfx2::StyleManager* SfxObjectShell::GetStyleManager() +{ + return nullptr; +} + +namespace +{ + class QueryTemplateBox + { + private: + std::unique_ptr<weld::MessageDialog> m_xQueryBox; + public: + QueryTemplateBox(weld::Window* pParent, const OUString& rMessage) + : m_xQueryBox(Application::CreateMessageDialog(pParent, VclMessageType::Question, VclButtonsType::NONE, rMessage)) + { + m_xQueryBox->add_button(SfxResId(STR_QRYTEMPL_UPDATE_BTN), RET_YES); + m_xQueryBox->add_button(SfxResId(STR_QRYTEMPL_KEEP_BTN), RET_NO); + m_xQueryBox->set_default_response(RET_YES); + m_xQueryBox->set_help_id(HID_QUERY_LOAD_TEMPLATE); + } + short run() { return m_xQueryBox->run(); } + }; +} + +void SfxObjectShell::UpdateFromTemplate_Impl( ) + +/* [Description] + + This internal method checks whether the document was created from a + template, and if this is newer than the document. If this is the case, + the user is asked if the Templates (StyleSheets) should be updated. + If this is answered positively, the StyleSheets are updated. +*/ + +{ + // Storage-medium? + SfxMedium *pFile = GetMedium(); + DBG_ASSERT( pFile, "cannot UpdateFromTemplate without medium" ); + if ( !pFile ) + return; + + if ( !comphelper::isFileUrl( pFile->GetName() ) ) + // update only for documents loaded from the local file system + return; + + // tdf#113935 - do not remove this line - somehow, it makes the process + // of switching from viewing a read-only document to opening it in writable + // mode much faster. + uno::Reference< embed::XStorage > xDocStor = pFile->GetStorage(false); + + // only for own storage formats + if ( !pFile->GetFilter() || !pFile->GetFilter()->IsOwnFormat() ) + return; + + const SfxUInt16Item* pUpdateDocItem = SfxItemSet::GetItem<SfxUInt16Item>(pFile->GetItemSet(), SID_UPDATEDOCMODE, false); + sal_Int16 bCanUpdateFromTemplate = pUpdateDocItem ? pUpdateDocItem->GetValue() : document::UpdateDocMode::NO_UPDATE; + + // created from template? + uno::Reference<document::XDocumentProperties> xDocProps(getDocProperties()); + const OUString aTemplName( xDocProps->getTemplateName() ); + OUString aTemplURL( xDocProps->getTemplateURL() ); + OUString aFoundName; + + if ( !aTemplName.isEmpty() || (!aTemplURL.isEmpty() && !IsReadOnly()) ) + { + // try to locate template, first using filename this must be done + // because writer global document uses this "great" idea to manage + // the templates of all parts in the master document but it is NOT + // an error if the template filename points not to a valid file + SfxDocumentTemplates aTempl; + if (!aTemplURL.isEmpty()) + { + try { + aFoundName = ::rtl::Uri::convertRelToAbs(GetMedium()->GetName(), + aTemplURL); + } catch (::rtl::MalformedUriException const&) { + assert(false); // don't think that's supposed to happen? + } + } + + if( aFoundName.isEmpty() && !aTemplName.isEmpty() ) + // if the template filename did not lead to success, + // try to get a file name for the logical template name + aTempl.GetFull( u"", aTemplName, aFoundName ); + } + + if ( aFoundName.isEmpty() ) + return; + + // check existence of template storage + aTemplURL = aFoundName; + + // should the document checked against changes in the template ? + if ( !IsQueryLoadTemplate() ) + return; + + bool bLoad = false; + + // load document properties of template + bool bOK = false; + util::DateTime aTemplDate; + try + { + Reference<document::XDocumentProperties> const + xTemplateDocProps( document::DocumentProperties::create( + ::comphelper::getProcessComponentContext())); + xTemplateDocProps->loadFromMedium(aTemplURL, + Sequence<beans::PropertyValue>()); + aTemplDate = xTemplateDocProps->getModificationDate(); + bOK = true; + } + catch (const Exception&) + { + TOOLS_INFO_EXCEPTION("sfx.doc", ""); + } + + // if modify date was read successfully + if ( bOK ) + { + // compare modify data of template with the last check date of the document + const util::DateTime aInfoDate( xDocProps->getTemplateDate() ); + if ( aTemplDate > aInfoDate ) + { + // ask user + if( bCanUpdateFromTemplate == document::UpdateDocMode::QUIET_UPDATE + || bCanUpdateFromTemplate == document::UpdateDocMode::FULL_UPDATE ) + bLoad = true; + else if ( bCanUpdateFromTemplate == document::UpdateDocMode::ACCORDING_TO_CONFIG ) + { + const OUString sMessage( SfxResId(STR_QRYTEMPL_MESSAGE).replaceAll( "$(ARG1)", aTemplName ) ); + QueryTemplateBox aBox(Application::GetFrameWeld(GetDialogParent()), sMessage); + if (RET_YES == aBox.run()) + bLoad = true; + } + + if( !bLoad ) + { + // user refuses, so don't ask again for this document + SetQueryLoadTemplate(false); + SetModified(); + } + } + } + + if ( !bLoad ) + return; + + // styles should be updated, create document in organizer mode to read in the styles + //TODO: testen! + SfxObjectShellLock xTemplDoc = CreateObjectByFactoryName( GetFactory().GetFactoryName(), SfxObjectCreateMode::ORGANIZER ); + xTemplDoc->DoInitNew(); + + // TODO/MBA: do we need a BaseURL? Then LoadFrom must be extended! + //xTemplDoc->SetBaseURL( aFoundName ); + + // TODO/LATER: make sure that we don't use binary templates! + SfxMedium aMedium( aFoundName, StreamMode::STD_READ ); + if ( xTemplDoc->LoadFrom( aMedium ) ) + { + // transfer styles from xTemplDoc to this document + // TODO/MBA: make sure that no BaseURL is needed in *this* document + LoadStyles(*xTemplDoc); + + // remember date/time of check + xDocProps->setTemplateDate(aTemplDate); + // TODO/LATER: new functionality to store document info is required ( didn't work for SO7 XML format ) + } +} + +bool SfxObjectShell::IsHelpDocument() const +{ + std::shared_ptr<const SfxFilter> pFilter = GetMedium()->GetFilter(); + return (pFilter && pFilter->GetFilterName() == "writer_web_HTML_help"); +} + +void SfxObjectShell::ResetFromTemplate( const OUString& rTemplateName, const OUString& rFileName ) +{ + // only care about resetting this data for LibreOffice formats otherwise + if ( !IsOwnStorageFormat( *GetMedium()) ) + return; + + uno::Reference<document::XDocumentProperties> xDocProps(getDocProperties()); + xDocProps->setTemplateURL( OUString() ); + xDocProps->setTemplateName( OUString() ); + xDocProps->setTemplateDate( util::DateTime() ); + xDocProps->resetUserData( OUString() ); + + // TODO/REFACTOR: + // Title? + + if( !comphelper::isFileUrl( rFileName ) ) + return; + + OUString aFoundName; + if( SfxGetpApp()->Get_Impl()->GetDocumentTemplates()->GetFull( u"", rTemplateName, aFoundName ) ) + { + INetURLObject aObj( rFileName ); + xDocProps->setTemplateURL( aObj.GetMainURL(INetURLObject::DecodeMechanism::ToIUri) ); + xDocProps->setTemplateName( rTemplateName ); + + ::DateTime now( ::DateTime::SYSTEM ); + xDocProps->setTemplateDate( now.GetUNODateTime() ); + + SetQueryLoadTemplate( true ); + } +} + +bool SfxObjectShell::IsQueryLoadTemplate() const +{ + return pImpl->bQueryLoadTemplate; +} + +bool SfxObjectShell::IsUseUserData() const +{ + return pImpl->bUseUserData; +} + +bool SfxObjectShell::IsUseThumbnailSave() const +{ + return pImpl->bUseThumbnailSave; +} + +void SfxObjectShell::SetQueryLoadTemplate( bool bNew ) +{ + if ( pImpl->bQueryLoadTemplate != bNew ) + SetModified(); + pImpl->bQueryLoadTemplate = bNew; +} + +void SfxObjectShell::SetUseUserData( bool bNew ) +{ + if ( pImpl->bUseUserData != bNew ) + SetModified(); + pImpl->bUseUserData = bNew; +} + +void SfxObjectShell::SetUseThumbnailSave( bool _bNew ) +{ + if ( pImpl->bUseThumbnailSave != _bNew ) + SetModified(); + pImpl->bUseThumbnailSave = _bNew; +} + +bool SfxObjectShell::IsLoadReadonly() const +{ + return pImpl->bLoadReadonly; +} + +bool SfxObjectShell::IsSaveVersionOnClose() const +{ + return pImpl->bSaveVersionOnClose; +} + +void SfxObjectShell::SetLoadReadonly( bool bNew ) +{ + if ( pImpl->bLoadReadonly != bNew ) + SetModified(); + pImpl->bLoadReadonly = bNew; +} + +void SfxObjectShell::SetSaveVersionOnClose( bool bNew ) +{ + if ( pImpl->bSaveVersionOnClose != bNew ) + SetModified(); + pImpl->bSaveVersionOnClose = bNew; +} + +sal_uInt32 SfxObjectShell::GetModifyPasswordHash() const +{ + return pImpl->m_nModifyPasswordHash; +} + +bool SfxObjectShell::SetModifyPasswordHash( sal_uInt32 nHash ) +{ + if ( ( !IsReadOnly() && !IsReadOnlyUI() ) + || !(pImpl->nFlagsInProgress & SfxLoadedFlags::MAINDOCUMENT ) ) + { + // the hash can be changed only in editable documents, + // or during loading of document + pImpl->m_nModifyPasswordHash = nHash; + return true; + } + + return false; +} + +const uno::Sequence< beans::PropertyValue >& SfxObjectShell::GetModifyPasswordInfo() const +{ + return pImpl->m_aModifyPasswordInfo; +} + +bool SfxObjectShell::SetModifyPasswordInfo( const uno::Sequence< beans::PropertyValue >& aInfo ) +{ + if ( ( !IsReadOnly() && !IsReadOnlyUI() ) + || !(pImpl->nFlagsInProgress & SfxLoadedFlags::MAINDOCUMENT ) ) + { + // the hash can be changed only in editable documents, + // or during loading of document + pImpl->m_aModifyPasswordInfo = aInfo; + return true; + } + + return false; +} + +void SfxObjectShell::SetModifyPasswordEntered( bool bEntered ) +{ + pImpl->m_bModifyPasswordEntered = bEntered; +} + +bool SfxObjectShell::IsModifyPasswordEntered() const +{ + return pImpl->m_bModifyPasswordEntered; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/objembed.cxx b/sfx2/source/doc/objembed.cxx new file mode 100644 index 000000000..91e886c8a --- /dev/null +++ b/sfx2/source/doc/objembed.cxx @@ -0,0 +1,217 @@ +/* -*- 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 <sfx2/objsh.hxx> +#include <sfx2/app.hxx> +#include <objshimp.hxx> +#include <sfx2/event.hxx> + +#include <comphelper/fileformat.h> +#include <tools/fract.hxx> +#include <vcl/transfer.hxx> +#include <vcl/outdev.hxx> +#include <vcl/gdimtf.hxx> + +using namespace ::com::sun::star; + + +Printer* SfxObjectShell::GetDocumentPrinter() +{ + SfxObjectShell* pParent = GetParentShell(GetModel()); + if ( pParent ) + return pParent->GetDocumentPrinter(); + return nullptr; +} + + +OutputDevice* SfxObjectShell::GetDocumentRefDev() +{ + SfxObjectShell* pParent = GetParentShell(GetModel()); + if ( pParent ) + return pParent->GetDocumentRefDev(); + return nullptr; +} + + +void SfxObjectShell::OnDocumentPrinterChanged( Printer* /*pNewPrinter*/ ) +{ + // virtual method +} + + +tools::Rectangle SfxObjectShell::GetVisArea( sal_uInt16 nAspect ) const +{ + if( nAspect == ASPECT_CONTENT ) + return pImpl->m_aVisArea; + else if( nAspect == ASPECT_THUMBNAIL ) + { + tools::Rectangle aRect; + aRect.SetSize( OutputDevice::LogicToLogic( Size( 5000, 5000 ), + MapMode(MapUnit::Map100thMM), MapMode(GetMapUnit()))); + return aRect; + } + return tools::Rectangle(); +} + + +const tools::Rectangle& SfxObjectShell::GetVisArea() const +{ + pImpl->m_aVisArea = GetVisArea( ASPECT_CONTENT ); + return pImpl->m_aVisArea; +} + + +void SfxObjectShell::SetVisArea( const tools::Rectangle & rVisArea ) +{ + if( pImpl->m_aVisArea != rVisArea ) + { + pImpl->m_aVisArea = rVisArea; + if ( GetCreateMode() == SfxObjectCreateMode::EMBEDDED ) + { + if ( IsEnableSetModified() ) + SetModified(); + + SfxGetpApp()->NotifyEvent(SfxEventHint( SfxEventHintId::VisAreaChanged, GlobalEventConfig::GetEventName(GlobalEventId::VISAREACHANGED), this)); + } + } +} + + +void SfxObjectShell::SetVisAreaSize( const Size & rVisSize ) +{ + SetVisArea( tools::Rectangle( GetVisArea().TopLeft(), rVisSize ) ); +} + + +MapUnit SfxObjectShell::GetMapUnit() const +{ + return pImpl->m_nMapUnit; +} + + +void SfxObjectShell::SetMapUnit( MapUnit nMapUnit ) +{ + pImpl->m_nMapUnit = nMapUnit; +} + + +void SfxObjectShell::FillTransferableObjectDescriptor( TransferableObjectDescriptor& rDesc ) const +{ + SotClipboardFormatId nClipFormat; + FillClass( &rDesc.maClassName, &nClipFormat, &rDesc.maTypeName, SOFFICE_FILEFORMAT_CURRENT ); + + rDesc.mnViewAspect = ASPECT_CONTENT; + rDesc.maSize = OutputDevice::LogicToLogic(GetVisArea().GetSize(), MapMode(GetMapUnit()), MapMode(MapUnit::Map100thMM)); + rDesc.maDragStartPos = Point(); + rDesc.maDisplayName.clear(); +} + + +void SfxObjectShell::DoDraw( OutputDevice* pDev, + const Point & rObjPos, + const Size & rSize, + const JobSetup & rSetup, + sal_uInt16 nAspect ) +{ + if (!rSize.Width() || !rSize.Height()) + return; + + MapMode aMod = pDev->GetMapMode(); + Size aSize = GetVisArea( nAspect ).GetSize(); + MapMode aWilliMode( GetMapUnit() ); + aSize = pDev->LogicToLogic( aSize, &aWilliMode, &aMod ); + if( aSize.Width() && aSize.Height() ) + { + Fraction aXF( rSize.Width(), aSize.Width() ); + Fraction aYF( rSize.Height(), aSize.Height() ); + + DoDraw_Impl( pDev, rObjPos, aXF, aYF, rSetup, nAspect ); + } +} + + +void SfxObjectShell::DoDraw_Impl( OutputDevice* pDev, + const Point & rViewPos, + const Fraction & rScaleX, + const Fraction & rScaleY, + const JobSetup & rSetup, + sal_uInt16 nAspect ) +{ + tools::Rectangle aVisArea = GetVisArea( nAspect ); + // MapUnit of the target + MapMode aMapMode( GetMapUnit() ); + aMapMode.SetScaleX( rScaleX ); + aMapMode.SetScaleY( rScaleY ); + + // Target in Pixels + Point aOrg = pDev->LogicToLogic( rViewPos, nullptr, &aMapMode ); + Point aDelta = aOrg - aVisArea.TopLeft(); + + // Origin moved according to the viewable area + // Origin set with Scale + aMapMode.SetOrigin( aDelta ); + + // Secure the Device settings + pDev->Push(); + + vcl::Region aRegion; + if( pDev->IsClipRegion() && pDev->GetOutDevType() != OUTDEV_PRINTER ) + { + aRegion = pDev->GetClipRegion(); + aRegion = pDev->LogicToPixel( aRegion ); + } + pDev->SetRelativeMapMode( aMapMode ); + + GDIMetaFile * pMtf = pDev->GetConnectMetaFile(); + if( pMtf ) + { + if( pMtf->IsRecord() && pDev->GetOutDevType() != OUTDEV_PRINTER ) + pMtf->Stop(); + else + pMtf = nullptr; + } + if( pDev->IsClipRegion() && pDev->GetOutDevType() != OUTDEV_PRINTER ) + { + aRegion = pDev->PixelToLogic( aRegion ); + pDev->SetClipRegion( aRegion ); + } + if( pMtf ) + pMtf->Record( pDev ); + + Draw( pDev, rSetup, nAspect ); + + // Restore Device settings + pDev->Pop(); + +} + +comphelper::EmbeddedObjectContainer& SfxObjectShell::GetEmbeddedObjectContainer() const +{ + if ( !pImpl->mxObjectContainer ) + pImpl->mxObjectContainer.reset(new comphelper::EmbeddedObjectContainer( const_cast<SfxObjectShell*>(this)->GetStorage(), GetModel() )); + return *pImpl->mxObjectContainer; +} + +void SfxObjectShell::ClearEmbeddedObjects() +{ + // frees all space taken by embedded objects + pImpl->mxObjectContainer.reset(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/objitem.cxx b/sfx2/source/doc/objitem.cxx new file mode 100644 index 000000000..e776e6608 --- /dev/null +++ b/sfx2/source/doc/objitem.cxx @@ -0,0 +1,97 @@ +/* -*- 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 <sfx2/objsh.hxx> +#include <sfx2/objitem.hxx> +#include <com/sun/star/frame/XModel.hpp> + + +SfxPoolItem* SfxObjectShellItem::CreateDefault() { return new SfxObjectShellItem; } + +SfxPoolItem* SfxObjectItem::CreateDefault() { return new SfxObjectItem; } + +bool SfxObjectShellItem::operator==( const SfxPoolItem &rItem ) const +{ + return SfxPoolItem::operator==(rItem) && + static_cast<const SfxObjectShellItem&>(rItem).pObjSh == pObjSh; +} + +SfxObjectShellItem* SfxObjectShellItem::Clone( SfxItemPool *) const +{ + return new SfxObjectShellItem( *this ); +} + +bool SfxObjectShellItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const +{ + if ( pObjSh ) + { + // This item MUST provide a model. Please don't change this, there are UNO-based + // implementations which need it!! + rVal <<= pObjSh->GetModel(); + } + else + { + rVal <<= css::uno::Reference< css::frame::XModel >(); + } + return true; +} + +bool SfxObjectShellItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) +{ + // This item MUST have a model. Please don't change this, there are UNO-based + // implementations which need it!! + css::uno::Reference< css::frame::XModel > xModel; + + if ( rVal >>= xModel ) + { + pObjSh = SfxObjectShell::GetShellFromComponent(xModel); + return true; + } + + return true; +} + +SfxObjectItem::SfxObjectItem( sal_uInt16 nWhichId, SfxShell *pSh ) +: SfxPoolItem( nWhichId ), + _pSh( pSh ) +{} + +bool SfxObjectItem::operator==( const SfxPoolItem &rItem ) const +{ + return SfxPoolItem::operator==(rItem) && + static_cast<const SfxObjectItem&>(rItem)._pSh == _pSh; +} + +SfxObjectItem* SfxObjectItem::Clone( SfxItemPool *) const +{ + return new SfxObjectItem( *this ); +} + +bool SfxObjectItem::QueryValue(css::uno::Any&, sal_uInt8) const +{ + return false; +} + +bool SfxObjectItem::PutValue(const css::uno::Any&, sal_uInt8) +{ + return false; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/objmisc.cxx b/sfx2/source/doc/objmisc.cxx new file mode 100644 index 000000000..873ab8b9b --- /dev/null +++ b/sfx2/source/doc/objmisc.cxx @@ -0,0 +1,1920 @@ +/* -*- 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 <config_features.h> + +#include <tools/inetmsg.hxx> +#include <tools/diagnose_ex.h> +#include <svl/eitem.hxx> +#include <svl/stritem.hxx> +#include <svl/intitem.hxx> +#include <svtools/svparser.hxx> +#include <cppuhelper/exc_hlp.hxx> +#include <sal/log.hxx> +#include <o3tl/string_view.hxx> + +#include <com/sun/star/awt/XTopWindow.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/container/XChild.hpp> +#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp> +#include <com/sun/star/document/XDocumentProperties.hpp> +#include <com/sun/star/document/MacroExecMode.hpp> +#include <com/sun/star/document/XScriptInvocationContext.hpp> +#include <com/sun/star/embed/EmbedStates.hpp> +#include <com/sun/star/embed/XEmbeddedObject.hpp> +#include <com/sun/star/script/provider/theMasterScriptProviderFactory.hpp> +#include <com/sun/star/script/provider/XScript.hpp> +#include <com/sun/star/script/provider/XScriptProvider.hpp> +#include <com/sun/star/script/provider/XScriptProviderSupplier.hpp> +#include <com/sun/star/uri/UriReferenceFactory.hpp> +#include <com/sun/star/uri/XVndSunStarScriptUrl.hpp> +#include <com/sun/star/util/XModifiable.hpp> + +#include <com/sun/star/uno/Reference.h> +#include <com/sun/star/uno/Any.h> +#include <com/sun/star/task/ErrorCodeRequest.hpp> + +#include <comphelper/processfactory.hxx> +#include <comphelper/string.hxx> + +#include <com/sun/star/security/DocumentDigitalSignatures.hpp> +#include <com/sun/star/task/DocumentMacroConfirmationRequest.hpp> +#include <com/sun/star/task/InteractionClassification.hpp> +#include <com/sun/star/task/XInteractionHandler.hpp> +#include <com/sun/star/frame/XModel.hpp> + +#include <basic/basmgr.hxx> +#include <basic/sberrors.hxx> +#include <vcl/weld.hxx> +#include <basic/sbx.hxx> +#include <svtools/sfxecode.hxx> + +#include <unotools/ucbhelper.hxx> +#include <tools/urlobj.hxx> +#include <svl/sharecontrolfile.hxx> +#include <rtl/uri.hxx> +#include <vcl/svapp.hxx> +#include <framework/interaction.hxx> +#include <framework/documentundoguard.hxx> +#include <comphelper/interaction.hxx> +#include <comphelper/storagehelper.hxx> +#include <comphelper/documentconstants.hxx> +#include <comphelper/namedvaluecollection.hxx> +#include <officecfg/Office/Common.hxx> + +#include <sfx2/signaturestate.hxx> +#include <sfx2/app.hxx> +#include <appdata.hxx> +#include <sfx2/request.hxx> +#include <sfx2/bindings.hxx> +#include <sfx2/sfxresid.hxx> +#include <sfx2/docfile.hxx> +#include <sfx2/objsh.hxx> +#include <objshimp.hxx> +#include <sfx2/event.hxx> +#include <sfx2/viewfrm.hxx> +#include <sfx2/sfxuno.hxx> +#include <sfx2/module.hxx> +#include <sfx2/docfac.hxx> +#include <sfx2/sfxsids.hrc> +#include <sfx2/strings.hrc> +#include <workwin.hxx> +#include <sfx2/sfxdlg.hxx> +#include <sfx2/infobar.hxx> +#include <sfx2/sfxbasemodel.hxx> +#include <openflag.hxx> +#include "objstor.hxx" +#include <appopen.hxx> + +#include <memory> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::ucb; +using namespace ::com::sun::star::document; +using namespace ::com::sun::star::frame; +using namespace ::com::sun::star::script; +using namespace ::com::sun::star::script::provider; +using namespace ::com::sun::star::container; + +// class SfxHeaderAttributes_Impl ---------------------------------------- + +namespace { + +class SfxHeaderAttributes_Impl : public SvKeyValueIterator +{ +private: + SfxObjectShell* pDoc; + SvKeyValueIteratorRef xIter; + bool bAlert; + +public: + explicit SfxHeaderAttributes_Impl( SfxObjectShell* pSh ) : + pDoc( pSh ), + xIter( pSh->GetMedium()->GetHeaderAttributes_Impl() ), + bAlert( false ) {} + + virtual bool GetFirst( SvKeyValue& rKV ) override { return xIter->GetFirst( rKV ); } + virtual bool GetNext( SvKeyValue& rKV ) override { return xIter->GetNext( rKV ); } + virtual void Append( const SvKeyValue& rKV ) override; + + void ClearForSourceView() { xIter = new SvKeyValueIterator; bAlert = false; } + void SetAttributes(); + void SetAttribute( const SvKeyValue& rKV ); +}; + +} + +sal_uInt16 const aTitleMap_Impl[3][2] = +{ + // local remote + /* SFX_TITLE_CAPTION */ { SFX_TITLE_FILENAME, SFX_TITLE_TITLE }, + /* SFX_TITLE_PICKLIST */ { 32, SFX_TITLE_FULLNAME }, + /* SFX_TITLE_HISTORY */ { 32, SFX_TITLE_FULLNAME } +}; + + +bool SfxObjectShell::IsAbortingImport() const +{ + return pImpl->bIsAbortingImport; +} + + +uno::Reference<document::XDocumentProperties> +SfxObjectShell::getDocProperties() const +{ + uno::Reference<document::XDocumentPropertiesSupplier> xDPS( + GetModel(), uno::UNO_QUERY_THROW); + uno::Reference<document::XDocumentProperties> xDocProps( + xDPS->getDocumentProperties()); + DBG_ASSERT(xDocProps.is(), + "SfxObjectShell: model has no DocumentProperties"); + return xDocProps; +} + + +void SfxObjectShell::DoFlushDocInfo() +{ +} + + +// Note: the only thing that calls this is the modification event handler +// that is installed at the XDocumentProperties +void SfxObjectShell::FlushDocInfo() +{ + if ( IsLoading() ) + return; + + SetModified(); + uno::Reference<document::XDocumentProperties> xDocProps(getDocProperties()); + DoFlushDocInfo(); // call template method + const OUString url(xDocProps->getAutoloadURL()); + sal_Int32 delay(xDocProps->getAutoloadSecs()); + SetAutoLoad( INetURLObject(url), delay * 1000, + (delay > 0) || !url.isEmpty() ); +} + +void SfxObjectShell::AppendInfoBarWhenReady(const OUString& sId, const OUString& sPrimaryMessage, + const OUString& sSecondaryMessage, + InfobarType aInfobarType, bool bShowCloseButton) +{ + InfobarData aInfobarData; + aInfobarData.msId = sId; + aInfobarData.msPrimaryMessage = sPrimaryMessage; + aInfobarData.msSecondaryMessage = sSecondaryMessage; + aInfobarData.maInfobarType = aInfobarType; + aInfobarData.mbShowCloseButton = bShowCloseButton; + Get_Impl()->m_aPendingInfobars.emplace_back(aInfobarData); +} + +std::vector<InfobarData>& SfxObjectShell::getPendingInfobars() +{ + return Get_Impl()->m_aPendingInfobars; +} + +void SfxObjectShell::SetError(ErrCode lErr) +{ + if (pImpl->lErr==ERRCODE_NONE) + { + pImpl->lErr=lErr; + } +} + +ErrCode SfxObjectShell::GetError() const +{ + return GetErrorCode().IgnoreWarning(); +} + +ErrCode SfxObjectShell::GetErrorCode() const +{ + ErrCode lError=pImpl->lErr; + if(!lError && GetMedium()) + lError=GetMedium()->GetErrorCode(); + return lError; +} + +void SfxObjectShell::ResetError() +{ + pImpl->lErr=ERRCODE_NONE; + SfxMedium * pMed = GetMedium(); + if( pMed ) + pMed->ResetError(); +} + +void SfxObjectShell::EnableSetModified( bool bEnable ) +{ + SAL_INFO_IF( bEnable == pImpl->m_bEnableSetModified, "sfx", "SFX_PERSIST: EnableSetModified 2x called with the same value" ); + pImpl->m_bEnableSetModified = bEnable; +} + + +bool SfxObjectShell::IsEnableSetModified() const +{ + return pImpl->m_bEnableSetModified && !IsReadOnly(); +} + + +bool SfxObjectShell::IsModified() const +{ + if ( pImpl->m_bIsModified ) + return true; + + if ( !pImpl->m_xDocStorage.is() || IsReadOnly() ) + { + // if the document still has no storage and is not set to be modified explicitly it is not modified + // a readonly document is also not modified + + return false; + } + + if (pImpl->mxObjectContainer) + { + const uno::Sequence < OUString > aNames = GetEmbeddedObjectContainer().GetObjectNames(); + for ( const auto& rName : aNames ) + { + uno::Reference < embed::XEmbeddedObject > xObj = GetEmbeddedObjectContainer().GetEmbeddedObject( rName ); + OSL_ENSURE( xObj.is(), "An empty entry in the embedded objects list!" ); + if ( xObj.is() ) + { + try + { + sal_Int32 nState = xObj->getCurrentState(); + if ( nState != embed::EmbedStates::LOADED ) + { + uno::Reference< util::XModifiable > xModifiable( xObj->getComponent(), uno::UNO_QUERY ); + if ( xModifiable.is() && xModifiable->isModified() ) + return true; + } + } + catch( uno::Exception& ) + {} + } + } + } + + return false; +} + + +void SfxObjectShell::SetModified( bool bModifiedP ) +{ + SAL_INFO_IF( !bModifiedP && !IsEnableSetModified(), "sfx", + "SFX_PERSIST: SetModified( sal_False ), although IsEnableSetModified() == sal_False" ); + + if( !IsEnableSetModified() ) + return; + + if( pImpl->m_bIsModified != bModifiedP ) + { + pImpl->m_bIsModified = bModifiedP; + ModifyChanged(); + } +} + + +void SfxObjectShell::ModifyChanged() +{ + if ( pImpl->bClosing ) + // SetModified dispose of the models! + return; + + + SfxViewFrame* pViewFrame = SfxViewFrame::Current(); + if ( pViewFrame ) + pViewFrame->GetBindings().Invalidate( SID_SAVEDOCS ); + + Invalidate( SID_SIGNATURE ); + Invalidate( SID_MACRO_SIGNATURE ); + Broadcast( SfxHint( SfxHintId::TitleChanged ) ); // xmlsec05, signed state might change in title... + + SfxGetpApp()->NotifyEvent( SfxEventHint( SfxEventHintId::ModifyChanged, GlobalEventConfig::GetEventName(GlobalEventId::MODIFYCHANGED), this ) ); +} + + +bool SfxObjectShell::IsReadOnlyUI() const + +/* [Description] + + Returns sal_True if the document for the UI is treated as r/o. This is + regardless of the actual r/o, which can be checked with <IsReadOnly()>. +*/ + +{ + return pImpl->bReadOnlyUI; +} + + +bool SfxObjectShell::IsReadOnlyMedium() const + +/* [Description] + + Returns sal_True when the medium is r/o, for instance when opened as r/o. +*/ + +{ + if ( !pMedium ) + return true; + return pMedium->IsReadOnly(); +} + +bool SfxObjectShell::IsOriginallyReadOnlyMedium() const +{ + return pMedium == nullptr || pMedium->IsOriginallyReadOnly(); +} + +bool SfxObjectShell::IsOriginallyLoadedReadOnlyMedium() const +{ + return pMedium != nullptr && pMedium->IsOriginallyLoadedReadOnly(); +} + + +void SfxObjectShell::SetReadOnlyUI( bool bReadOnly ) + +/* [Description] + + Turns the document in a r/o and r/w state respectively without reloading + it and without changing the open mode of the medium. +*/ + +{ + if ( bReadOnly != pImpl->bReadOnlyUI ) + { + pImpl->bReadOnlyUI = bReadOnly; + Broadcast( SfxHint(SfxHintId::ModeChanged) ); + } +} + + +void SfxObjectShell::SetReadOnly() +{ + // Let the document be completely readonly, means that the + // medium open mode is adjusted accordingly, and the write lock + // on the file is removed. + + if ( !pMedium || IsReadOnlyMedium() ) + return; + + bool bWasROUI = IsReadOnly(); + + pMedium->UnlockFile( false ); + + // the storage-based mediums are already based on the temporary file + // so UnlockFile has already closed the locking stream + if ( !pMedium->HasStorage_Impl() && IsLoadingFinished() ) + pMedium->CloseInStream(); + + pMedium->SetOpenMode( SFX_STREAM_READONLY, true ); + pMedium->GetItemSet()->Put( SfxBoolItem( SID_DOC_READONLY, true ) ); + + if ( !bWasROUI ) + Broadcast( SfxHint(SfxHintId::ModeChanged) ); +} + + +bool SfxObjectShell::IsReadOnly() const +{ + return pImpl->bReadOnlyUI || pMedium == nullptr; +} + + +bool SfxObjectShell::IsInModalMode() const +{ + return pImpl->bModalMode || pImpl->bRunningMacro; +} + +bool SfxObjectShell::AcceptStateUpdate() const +{ + return !IsInModalMode(); +} + + +void SfxObjectShell::SetMacroMode_Impl( bool bModal ) +{ + if ( !pImpl->bRunningMacro != !bModal ) + { + pImpl->bRunningMacro = bModal; + Broadcast( SfxHint( SfxHintId::ModeChanged ) ); + } +} + + +void SfxObjectShell::SetModalMode_Impl( bool bModal ) +{ + // Broadcast only if modified, or otherwise it will possibly go into + // an endless loop + if ( pImpl->bModalMode == bModal ) + return; + + // Central count + sal_uInt16 &rDocModalCount = SfxGetpApp()->Get_Impl()->nDocModalMode; + if ( bModal ) + ++rDocModalCount; + else + --rDocModalCount; + + // Switch + pImpl->bModalMode = bModal; + Broadcast( SfxHint( SfxHintId::ModeChanged ) ); +} + +#if HAVE_FEATURE_MULTIUSER_ENVIRONMENT + +bool SfxObjectShell::SwitchToShared( bool bShared, bool bSave ) +{ + bool bResult = true; + + if ( bShared != IsDocShared() ) + { + OUString aOrigURL = GetMedium()->GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ); + + if ( aOrigURL.isEmpty() && bSave ) + { + // this is a new document, let it be stored before switching to the shared mode; + // the storing should be done without shared flag, since it is possible that the + // target location does not allow to create sharing control file; + // the shared flag will be set later after creation of sharing control file + SfxViewFrame* pViewFrame = SfxViewFrame::GetFirst( this ); + + if ( pViewFrame ) + { + // TODO/LATER: currently the application guards against the reentrance problem + const SfxPoolItem* pItem = pViewFrame->GetBindings().ExecuteSynchron( HasName() ? SID_SAVEDOC : SID_SAVEASDOC ); + const SfxBoolItem* pResult = dynamic_cast<const SfxBoolItem*>( pItem ); + bResult = ( pResult && pResult->GetValue() ); + if ( bResult ) + aOrigURL = GetMedium()->GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ); + } + } + + bool bOldValue = HasSharedXMLFlagSet(); + SetSharedXMLFlag( bShared ); + + bool bRemoveEntryOnError = false; + if ( bResult && bShared ) + { + try + { + ::svt::ShareControlFile aControlFile( aOrigURL ); + aControlFile.InsertOwnEntry(); + bRemoveEntryOnError = true; + } + catch( uno::Exception& ) + { + bResult = false; + } + } + + if ( bResult && bSave ) + { + SfxViewFrame* pViewFrame = SfxViewFrame::GetFirst( this ); + + if ( pViewFrame ) + { + // TODO/LATER: currently the application guards against the reentrance problem + SetModified(); // the modified flag has to be set to let the document be stored with the shared flag + try + { + // Do *not* use dispatch mechanism in this place - we don't want others (extensions etc.) to intercept this. + pImpl->pBaseModel->store(); + bResult = true; + } + catch (...) + { + bResult = false; + } + } + } + + if ( bResult ) + { + // TODO/LATER: Is it possible that the following calls fail? + if ( bShared ) + { + pImpl->m_aSharedFileURL = aOrigURL; + GetMedium()->SwitchDocumentToTempFile(); + } + else + { + const OUString aTempFileURL = pMedium->GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ); + GetMedium()->SwitchDocumentToFile( GetSharedFileURL() ); + pImpl->m_aSharedFileURL.clear(); + + // now remove the temporary file the document was based on + ::utl::UCBContentHelper::Kill( aTempFileURL ); + + try + { + // aOrigURL can not be used since it contains an old value + ::svt::ShareControlFile aControlFile( GetMedium()->GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + aControlFile.RemoveFile(); + } + catch( uno::Exception& ) + { + } + } + } + else + { + // the saving has failed! + if ( bRemoveEntryOnError ) + { + try + { + ::svt::ShareControlFile aControlFile( aOrigURL ); + aControlFile.RemoveEntry(); + } + catch( uno::Exception& ) + {} + } + + SetSharedXMLFlag( bOldValue ); + } + } + else + bResult = false; // the second switch to the same mode + + if ( bResult ) + SetTitle( "" ); + + return bResult; +} + + +void SfxObjectShell::FreeSharedFile( const OUString& aTempFileURL ) +{ + SetSharedXMLFlag( false ); + + if ( !IsDocShared() || aTempFileURL.isEmpty() + || ::utl::UCBContentHelper::EqualURLs( aTempFileURL, GetSharedFileURL() ) ) + return; + + if ( pImpl->m_bAllowShareControlFileClean ) + { + try + { + ::svt::ShareControlFile aControlFile( GetSharedFileURL() ); + aControlFile.RemoveEntry(); + } + catch( uno::Exception& ) + { + } + } + + // the cleaning is forbidden only once + pImpl->m_bAllowShareControlFileClean = true; + + // now remove the temporary file the document is based currently on + ::utl::UCBContentHelper::Kill( aTempFileURL ); + + pImpl->m_aSharedFileURL.clear(); +} + + +void SfxObjectShell::DoNotCleanShareControlFile() +{ + pImpl->m_bAllowShareControlFileClean = false; +} + + +void SfxObjectShell::SetSharedXMLFlag( bool bFlag ) const +{ + pImpl->m_bSharedXMLFlag = bFlag; +} + + +bool SfxObjectShell::HasSharedXMLFlagSet() const +{ + return pImpl->m_bSharedXMLFlag; +} + +#endif + +bool SfxObjectShell::IsDocShared() const +{ +#if HAVE_FEATURE_MULTIUSER_ENVIRONMENT + return ( !pImpl->m_aSharedFileURL.isEmpty() ); +#else + return false; +#endif +} + + +OUString SfxObjectShell::GetSharedFileURL() const +{ +#if HAVE_FEATURE_MULTIUSER_ENVIRONMENT + return pImpl->m_aSharedFileURL; +#else + return OUString(); +#endif +} + +Size SfxObjectShell::GetFirstPageSize() const +{ + return GetVisArea(ASPECT_THUMBNAIL).GetSize(); +} + + +IndexBitSet& SfxObjectShell::GetNoSet_Impl() +{ + return pImpl->aBitSet; +} + + +// changes the title of the document + +void SfxObjectShell::SetTitle +( + const OUString& rTitle // the new Document Title +) + +/* [Description] + + With this method, the title of the document can be set. + This corresponds initially to the full file name. A setting of the + title does not affect the file name, but it will be shown in the + Caption-Bars of the MDI-window. +*/ + +{ + + // Nothing to do? + if ( ( ( HasName() && pImpl->aTitle == rTitle ) + || ( !HasName() && GetTitle() == rTitle ) ) + && !IsDocShared() ) + return; + + SfxApplication *pSfxApp = SfxGetpApp(); + + // If possible release the unnamed number. + if ( pImpl->bIsNamedVisible && USHRT_MAX != pImpl->nVisualDocumentNumber ) + { + pSfxApp->ReleaseIndex(pImpl->nVisualDocumentNumber); + pImpl->bIsNamedVisible = false; + } + + // Set Title + pImpl->aTitle = rTitle; + + // Notification + if ( GetMedium() ) + { + SfxShell::SetName( GetTitle(SFX_TITLE_APINAME) ); + Broadcast( SfxHint(SfxHintId::TitleChanged) ); + } +} + + + +OUString SfxObjectShell::GetTitle( sal_uInt16 nMaxLength ) const + +/* [Description] + + Returns the title or logical file name of the document, depending on the + 'nMaxLength'. + + If the file name with path is used, the Name shortened by replacing one or + more directory names with "...", URLs are currently always returned + in complete form. +*/ + +{ + SfxMedium *pMed = GetMedium(); + if ( IsLoading() ) + return OUString(); + + // Create Title? + if ( SFX_TITLE_DETECT == nMaxLength && pImpl->aTitle.isEmpty() ) + { + static bool bRecur = false; + if ( bRecur ) + return "-not available-"; + bRecur = true; + + OUString aTitle; + + if ( pMed ) + { + const SfxStringItem* pNameItem = SfxItemSet::GetItem<SfxStringItem>(pMed->GetItemSet(), SID_DOCINFO_TITLE, false); + if ( pNameItem ) + aTitle = pNameItem->GetValue(); + } + + if ( aTitle.isEmpty() ) + aTitle = GetTitle( SFX_TITLE_FILENAME ); + + bRecur = false; + return aTitle; + } + + if (SFX_TITLE_APINAME == nMaxLength ) + return GetAPIName(); + + // Picklist/Caption is mapped + if ( pMed && ( nMaxLength == SFX_TITLE_CAPTION || nMaxLength == SFX_TITLE_PICKLIST ) ) + { + // If a specific title was given at open: + // important for URLs: use INetProtocol::File for which the set title is not + // considered. (See below, analysis of aTitleMap_Impl) + const SfxStringItem* pNameItem = SfxItemSet::GetItem<SfxStringItem>(pMed->GetItemSet(), SID_DOCINFO_TITLE, false); + if ( pNameItem ) + return pNameItem->GetValue(); + } + + // Still unnamed? + DBG_ASSERT( !HasName() || pMed, "HasName() but no Medium?!?" ); + if ( !HasName() || !pMed ) + { + // Title already set? + if ( !pImpl->aTitle.isEmpty() ) + return pImpl->aTitle; + + // must it be numbered? + const OUString aNoName(SfxResId(STR_NONAME)); + if (pImpl->bIsNamedVisible) + { + // Append number + return aNoName + " " + OUString::number(pImpl->nVisualDocumentNumber); + } + + // Document called "Untitled" for the time being + return aNoName; + } + assert(pMed); + + const INetURLObject aURL( IsDocShared() ? GetSharedFileURL() : GetMedium()->GetName() ); + if ( nMaxLength > SFX_TITLE_CAPTION && nMaxLength <= SFX_TITLE_HISTORY ) + { + sal_uInt16 nRemote; + if (aURL.GetProtocol() == INetProtocol::File) + nRemote = 0; + else + nRemote = 1; + nMaxLength = aTitleMap_Impl[nMaxLength-SFX_TITLE_CAPTION][nRemote]; + } + + // Local file? + if ( aURL.GetProtocol() == INetProtocol::File ) + { + if ( nMaxLength == SFX_TITLE_FULLNAME ) + return aURL.HasMark() ? INetURLObject( aURL.GetURLNoMark() ).PathToFileName() : aURL.PathToFileName(); + if ( nMaxLength == SFX_TITLE_FILENAME ) + return aURL.getName(INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset); + if ( pImpl->aTitle.isEmpty() ) + pImpl->aTitle = aURL.getBase( INetURLObject::LAST_SEGMENT, + true, INetURLObject::DecodeMechanism::WithCharset ); + } + else + { + if ( nMaxLength >= SFX_TITLE_MAXLEN ) + { + const OUString aComplete( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + if( aComplete.getLength() > nMaxLength ) + return OUString::Concat("...") + aComplete.subView( aComplete.getLength() - nMaxLength + 3, nMaxLength - 3 ); + return aComplete; + } + if ( nMaxLength == SFX_TITLE_FILENAME ) + { + const OUString aName = INetURLObject::decode( aURL.GetBase(), INetURLObject::DecodeMechanism::WithCharset ); + return aName.isEmpty() ? aURL.GetURLNoPass() : aName; + } + if ( nMaxLength == SFX_TITLE_FULLNAME ) + return aURL.GetMainURL( INetURLObject::DecodeMechanism::ToIUri ); + + // Generate Title from file name if possible + if ( pImpl->aTitle.isEmpty() ) + pImpl->aTitle = aURL.GetBase(); + + // workaround for the case when the name can not be retrieved from URL by INetURLObject + if ( pImpl->aTitle.isEmpty() ) + pImpl->aTitle = aURL.GetMainURL( INetURLObject::DecodeMechanism::WithCharset ); + } + + // Complete Title + return pImpl->aTitle; +} + + +void SfxObjectShell::InvalidateName() + +/* [Description] + + Returns the title of the new document, DocInfo-Title or + File name. Is required for loading from template or SaveAs. +*/ + +{ + pImpl->aTitle.clear(); + SetName( GetTitle( SFX_TITLE_APINAME ) ); + + Broadcast( SfxHint(SfxHintId::TitleChanged) ); +} + + +void SfxObjectShell::SetNamedVisibility_Impl() +{ + if ( !pImpl->bIsNamedVisible ) + { + pImpl->bIsNamedVisible = true; + if ( !HasName() && USHRT_MAX == pImpl->nVisualDocumentNumber && pImpl->aTitle.isEmpty() ) + { + pImpl->nVisualDocumentNumber = SfxGetpApp()->GetFreeIndex(); + Broadcast( SfxHint(SfxHintId::TitleChanged) ); + } + } + + SetName( GetTitle(SFX_TITLE_APINAME) ); +} + +void SfxObjectShell::SetNoName() +{ + bHasName = false; + GetModel()->attachResource( OUString(), GetModel()->getArgs() ); +} + + +SfxProgress* SfxObjectShell::GetProgress() const +{ + return pImpl->pProgress; +} + + +void SfxObjectShell::SetProgress_Impl +( + SfxProgress *pProgress /* to started <SfxProgress> or 0, + if the progress is to be reset */ +) + +/* [Description] + + Internal method to set or reset the Progress modes for + SfxObjectShell. +*/ + +{ + DBG_ASSERT( ( !pImpl->pProgress && pProgress ) || + ( pImpl->pProgress && !pProgress ), + "Progress activation/deactivation mismatch" ); + pImpl->pProgress = pProgress; +} + + +void SfxObjectShell::PostActivateEvent_Impl( SfxViewFrame const * pFrame ) +{ + SfxApplication* pSfxApp = SfxGetpApp(); + if ( pSfxApp->IsDowning() || IsLoading() || !pFrame || pFrame->GetFrame().IsClosing_Impl() ) + return; + + const SfxBoolItem* pHiddenItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_HIDDEN, false); + if ( !pHiddenItem || !pHiddenItem->GetValue() ) + { + SfxEventHintId nId = pImpl->nEventId; + pImpl->nEventId = SfxEventHintId::NONE; + if ( nId == SfxEventHintId::OpenDoc ) + pSfxApp->NotifyEvent(SfxViewEventHint( nId, GlobalEventConfig::GetEventName(GlobalEventId::OPENDOC), this, pFrame->GetFrame().GetController() ), false); + else if (nId == SfxEventHintId::CreateDoc ) + pSfxApp->NotifyEvent(SfxViewEventHint( nId, GlobalEventConfig::GetEventName(GlobalEventId::CREATEDOC), this, pFrame->GetFrame().GetController() ), false); + } +} + + +void SfxObjectShell::SetActivateEvent_Impl(SfxEventHintId nId ) +{ + pImpl->nEventId = nId; +} + +bool SfxObjectShell::IsAutoLoadLocked() const + +/* Returns whether an Autoload is allowed to be executed. Before the + surrounding FrameSet of the AutoLoad is also taken into account as well. +*/ + +{ + return !IsReadOnly(); +} + + +void SfxObjectShell::BreakMacroSign_Impl( bool bBreakMacroSign ) +{ + pImpl->m_bMacroSignBroken = bBreakMacroSign; +} + + +void SfxObjectShell::CheckSecurityOnLoading_Impl() +{ + // make sure LO evaluates the macro signatures, so it can be preserved + GetScriptingSignatureState(); + + uno::Reference< task::XInteractionHandler > xInteraction; + if ( GetMedium() ) + xInteraction = GetMedium()->GetInteractionHandler(); + + // check if there is a broken signature... + CheckForBrokenDocSignatures_Impl(); + + CheckEncryption_Impl( xInteraction ); + + // check macro security + const bool bHasValidContentSignature = HasValidSignatures(); + pImpl->aMacroMode.checkMacrosOnLoading( xInteraction, bHasValidContentSignature ); +} + + +void SfxObjectShell::CheckEncryption_Impl( const uno::Reference< task::XInteractionHandler >& xHandler ) +{ + OUString aVersion; + bool bIsEncrypted = false; + bool bHasNonEncrypted = false; + + try + { + uno::Reference < beans::XPropertySet > xPropSet( GetStorage(), uno::UNO_QUERY_THROW ); + xPropSet->getPropertyValue("Version") >>= aVersion; + xPropSet->getPropertyValue("HasEncryptedEntries") >>= bIsEncrypted; + xPropSet->getPropertyValue("HasNonEncryptedEntries") >>= bHasNonEncrypted; + } + catch( uno::Exception& ) + { + } + + if ( aVersion.compareTo( ODFVER_012_TEXT ) < 0 ) + return; + + // this is ODF1.2 or later + if ( !(bIsEncrypted && bHasNonEncrypted) ) + return; + + if ( !pImpl->m_bIncomplEncrWarnShown ) + { + // this is an encrypted document with nonencrypted streams inside, show the warning + css::task::ErrorCodeRequest aErrorCode; + aErrorCode.ErrCode = sal_uInt32(ERRCODE_SFX_INCOMPLETE_ENCRYPTION); + + SfxMedium::CallApproveHandler( xHandler, uno::Any( aErrorCode ), false ); + pImpl->m_bIncomplEncrWarnShown = true; + } + + // broken signatures imply no macro execution at all + pImpl->aMacroMode.disallowMacroExecution(); +} + + +void SfxObjectShell::CheckForBrokenDocSignatures_Impl() +{ + SignatureState nSignatureState = GetDocumentSignatureState(); + bool bSignatureBroken = ( nSignatureState == SignatureState::BROKEN ); + if ( !bSignatureBroken ) + return; + + // broken signatures imply no macro execution at all + pImpl->aMacroMode.disallowMacroExecution(); +} + + +void SfxObjectShell::SetAutoLoad( + const INetURLObject& rUrl, sal_uInt32 nTime, bool bReload ) +{ + pImpl->pReloadTimer.reset(); + if ( bReload ) + { + pImpl->pReloadTimer.reset(new AutoReloadTimer_Impl( + rUrl.GetMainURL( INetURLObject::DecodeMechanism::ToIUri ), + nTime, this )); + pImpl->pReloadTimer->Start(); + } +} + +void SfxObjectShell::SetLoading(SfxLoadedFlags nFlags) +{ + pImpl->nLoadedFlags = nFlags; +} + +bool SfxObjectShell::IsLoadingFinished() const +{ + return ( pImpl->nLoadedFlags == SfxLoadedFlags::ALL ); +} + +void SfxObjectShell::InitOwnModel_Impl() +{ + if ( pImpl->bModelInitialized ) + return; + + const SfxStringItem* pSalvageItem = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_DOC_SALVAGE, false); + if ( pSalvageItem ) + { + pImpl->aTempName = pMedium->GetPhysicalName(); + pMedium->GetItemSet()->ClearItem( SID_DOC_SALVAGE ); + pMedium->GetItemSet()->ClearItem( SID_FILE_NAME ); + pMedium->GetItemSet()->Put( SfxStringItem( SID_FILE_NAME, pMedium->GetOrigURL() ) ); + } + else + { + pMedium->GetItemSet()->ClearItem( SID_PROGRESS_STATUSBAR_CONTROL ); + pMedium->GetItemSet()->ClearItem( SID_DOCUMENT ); + } + + pMedium->GetItemSet()->ClearItem( SID_REFERER ); + uno::Reference< frame::XModel > xModel = GetModel(); + if ( xModel.is() ) + { + SfxItemSet *pSet = GetMedium()->GetItemSet(); + if ( !GetMedium()->IsReadOnly() ) + pSet->ClearItem( SID_INPUTSTREAM ); + uno::Sequence< beans::PropertyValue > aArgs; + TransformItems( SID_OPENDOC, *pSet, aArgs ); + xModel->attachResource( GetMedium()->GetOrigURL(), aArgs ); + impl_addToModelCollection(xModel); + } + + pImpl->bModelInitialized = true; +} + +void SfxObjectShell::FinishedLoading( SfxLoadedFlags nFlags ) +{ + bool bSetModifiedTRUE = false; + const SfxStringItem* pSalvageItem = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_DOC_SALVAGE, false); + if( ( nFlags & SfxLoadedFlags::MAINDOCUMENT ) && !(pImpl->nLoadedFlags & SfxLoadedFlags::MAINDOCUMENT ) + && !(pImpl->nFlagsInProgress & SfxLoadedFlags::MAINDOCUMENT )) + { + pImpl->nFlagsInProgress |= SfxLoadedFlags::MAINDOCUMENT; + static_cast<SfxHeaderAttributes_Impl*>(GetHeaderAttributes())->SetAttributes(); + + if ( ( GetModifyPasswordHash() || GetModifyPasswordInfo().hasElements() ) && !IsModifyPasswordEntered() ) + SetReadOnly(); + + // Salvage + if ( pSalvageItem ) + bSetModifiedTRUE = true; + + if ( !IsEnableSetModified() ) + EnableSetModified(); + + if( !bSetModifiedTRUE && IsEnableSetModified() ) + SetModified( false ); + + CheckSecurityOnLoading_Impl(); + + bHasName = true; // the document is loaded, so the name should already available + GetTitle( SFX_TITLE_DETECT ); + InitOwnModel_Impl(); + pImpl->nFlagsInProgress &= ~SfxLoadedFlags::MAINDOCUMENT; + } + + if( ( nFlags & SfxLoadedFlags::IMAGES ) && !(pImpl->nLoadedFlags & SfxLoadedFlags::IMAGES ) + && !(pImpl->nFlagsInProgress & SfxLoadedFlags::IMAGES )) + { + pImpl->nFlagsInProgress |= SfxLoadedFlags::IMAGES; + uno::Reference<document::XDocumentProperties> xDocProps( + getDocProperties()); + const OUString url(xDocProps->getAutoloadURL()); + sal_Int32 delay(xDocProps->getAutoloadSecs()); + SetAutoLoad( INetURLObject(url), delay * 1000, + (delay > 0) || !url.isEmpty() ); + if( !bSetModifiedTRUE && IsEnableSetModified() ) + SetModified( false ); + Invalidate( SID_SAVEASDOC ); + pImpl->nFlagsInProgress &= ~SfxLoadedFlags::IMAGES; + } + + pImpl->nLoadedFlags |= nFlags; + + if ( pImpl->nFlagsInProgress != SfxLoadedFlags::NONE ) + return; + + // in case of reentrance calls the first called FinishedLoading() call on the stack + // should do the notification, in result the notification is done when all the FinishedLoading() calls are finished + + if ( bSetModifiedTRUE ) + SetModified(); + else + SetModified( false ); + + if ( (pImpl->nLoadedFlags & SfxLoadedFlags::MAINDOCUMENT ) && (pImpl->nLoadedFlags & SfxLoadedFlags::IMAGES ) ) + { + const SfxBoolItem* pTemplateItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_TEMPLATE, false); + bool bTemplate = pTemplateItem && pTemplateItem->GetValue(); + + // closing the streams on loading should be under control of SFX! + DBG_ASSERT( pMedium->IsOpen(), "Don't close the medium when loading documents!" ); + + if ( bTemplate ) + { + TemplateDisconnectionAfterLoad(); + } + else + { + // if a readonly medium has storage then it's stream is already based on temporary file + if( !(pMedium->GetOpenMode() & StreamMode::WRITE) && !pMedium->HasStorage_Impl() ) + // don't lock file opened read only + pMedium->CloseInStream(); + } + } + + SetInitialized_Impl( false ); + + // Title is not available until loading has finished + Broadcast( SfxHint( SfxHintId::TitleChanged ) ); + if ( pImpl->nEventId != SfxEventHintId::NONE ) + PostActivateEvent_Impl(SfxViewFrame::GetFirst(this)); +} + +void SfxObjectShell::TemplateDisconnectionAfterLoad() +{ + // document is created from a template + //TODO/LATER: should the templates always be XML docs! + + SfxMedium* pTmpMedium = pMedium; + if ( !pTmpMedium ) + return; + + const OUString aName( pTmpMedium->GetName() ); + const SfxStringItem* pTemplNamItem = SfxItemSet::GetItem<SfxStringItem>(pTmpMedium->GetItemSet(), SID_TEMPLATE_NAME, false); + OUString aTemplateName; + if ( pTemplNamItem ) + aTemplateName = pTemplNamItem->GetValue(); + else + { + // !TODO/LATER: what's this?! + // Interactive ( DClick, Contextmenu ) no long name is included + aTemplateName = getDocProperties()->getTitle(); + if ( aTemplateName.isEmpty() ) + { + INetURLObject aURL( aName ); + aURL.CutExtension(); + aTemplateName = aURL.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset ); + } + } + + // set medium to noname + pTmpMedium->SetName( OUString(), true ); + pTmpMedium->Init_Impl(); + + // drop resource + SetNoName(); + InvalidateName(); + + if( IsPackageStorageFormat_Impl( *pTmpMedium ) ) + { + // untitled document must be based on temporary storage + // the medium should not dispose the storage in this case + uno::Reference < embed::XStorage > xTmpStor = ::comphelper::OStorageHelper::GetTemporaryStorage(); + GetStorage()->copyToStorage( xTmpStor ); + + // the medium should disconnect from the original location + // the storage should not be disposed since the document is still + // based on it, but in DoSaveCompleted it will be disposed + pTmpMedium->CanDisposeStorage_Impl( false ); + pTmpMedium->Close(); + + // setting the new storage the medium will be based on + pTmpMedium->SetStorage_Impl( xTmpStor ); + + pMedium = nullptr; + bool ok = DoSaveCompleted( pTmpMedium ); + assert(pMedium != nullptr); + if( ok ) + { + const SfxStringItem* pSalvageItem = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_DOC_SALVAGE, false); + bool bSalvage = pSalvageItem != nullptr; + + if ( !bSalvage ) + { + // some further initializations for templates + SetTemplate_Impl( aName, aTemplateName, this ); + } + + // the medium should not dispose the storage, DoSaveCompleted() has let it to do so + pTmpMedium->CanDisposeStorage_Impl( false ); + } + else + { + SetError(ERRCODE_IO_GENERAL); + } + } + else + { + // some further initializations for templates + SetTemplate_Impl( aName, aTemplateName, this ); + pTmpMedium->CreateTempFile(); + } + + // templates are never readonly + pTmpMedium->GetItemSet()->ClearItem( SID_DOC_READONLY ); + pTmpMedium->SetOpenMode( SFX_STREAM_READWRITE, true ); + + // notifications about possible changes in readonly state and document info + Broadcast( SfxHint(SfxHintId::ModeChanged) ); + + // created untitled document can't be modified + SetModified( false ); +} + + +bool SfxObjectShell::IsLoading() const +/* [Description] + + Has FinishedLoading been called? +*/ +{ + return !( pImpl->nLoadedFlags & SfxLoadedFlags::MAINDOCUMENT ); +} + + +void SfxObjectShell::CancelTransfers() +/* [Description] + + Here can Transfers get canceled, which were not registered + by RegisterTransfer. +*/ +{ + if( ( pImpl->nLoadedFlags & SfxLoadedFlags::ALL ) != SfxLoadedFlags::ALL ) + { + pImpl->bIsAbortingImport = true; + if( IsLoading() ) + FinishedLoading(); + } +} + + +AutoReloadTimer_Impl::AutoReloadTimer_Impl( + const OUString& rURL, sal_uInt32 nTime, SfxObjectShell* pSh ) + : Timer("sfx2 AutoReloadTimer_Impl"), aUrl( rURL ), pObjSh( pSh ) +{ + SetTimeout( nTime ); +} + + +void AutoReloadTimer_Impl::Invoke() +{ + SfxViewFrame *pFrame = SfxViewFrame::GetFirst( pObjSh ); + + if ( pFrame ) + { + // Not possible/meaningful at the moment? + if ( !pObjSh->CanReload_Impl() || pObjSh->IsAutoLoadLocked() || Application::IsUICaptured() ) + { + // Allow a retry + Start(); + return; + } + + SfxAllItemSet aSet( SfxGetpApp()->GetPool() ); + aSet.Put( SfxBoolItem( SID_AUTOLOAD, true ) ); + if ( !aUrl.isEmpty() ) + aSet.Put( SfxStringItem( SID_FILE_NAME, aUrl ) ); + if (pObjSh->HasName()) { + aSet.Put( + SfxStringItem(SID_REFERER, pObjSh->GetMedium()->GetName())); + } + SfxRequest aReq( SID_RELOAD, SfxCallMode::SLOT, aSet ); + // this will delete this + pObjSh->Get_Impl()->pReloadTimer.reset(); + pFrame->ExecReload_Impl( aReq ); + return; + } + + // this will delete this + pObjSh->Get_Impl()->pReloadTimer.reset(); +} + +SfxModule* SfxObjectShell::GetModule() const +{ + return GetFactory().GetModule(); +} + +ErrCode SfxObjectShell::CallBasic( std::u16string_view rMacro, + std::u16string_view rBasic, SbxArray* pArgs, + SbxValue* pRet ) +{ + SfxApplication* pApp = SfxGetpApp(); + if( pApp->GetName() != rBasic ) + { + if ( !AdjustMacroMode() ) + return ERRCODE_IO_ACCESSDENIED; + } + + BasicManager *pMgr = GetBasicManager(); + if( pApp->GetName() == rBasic ) + pMgr = SfxApplication::GetBasicManager(); + ErrCode nRet = SfxApplication::CallBasic( OUString(rMacro), pMgr, pArgs, pRet ); + return nRet; +} + +bool SfxObjectShell::isScriptAccessAllowed( const Reference< XInterface >& _rxScriptContext ) +{ + try + { + Reference< XEmbeddedScripts > xScripts( _rxScriptContext, UNO_QUERY ); + if ( !xScripts.is() ) + { + Reference< XScriptInvocationContext > xContext( _rxScriptContext, UNO_QUERY_THROW ); + xScripts.set( xContext->getScriptContainer(), UNO_SET_THROW ); + } + + return xScripts->getAllowMacroExecution(); + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("sfx.doc"); + } + return false; +} + +// don't allow LibreLogo to be used with our mouseover/etc dom-alike events +bool SfxObjectShell::UnTrustedScript(const OUString& rScriptURL) +{ + if (!rScriptURL.startsWith("vnd.sun.star.script:")) + return false; + + // ensure URL Escape Codes are decoded + css::uno::Reference<css::uri::XUriReference> uri( + css::uri::UriReferenceFactory::create(comphelper::getProcessComponentContext())->parse(rScriptURL)); + css::uno::Reference<css::uri::XVndSunStarScriptUrl> sfUri(uri, css::uno::UNO_QUERY); + + if (!sfUri.is()) + return false; + + // pyuno encodes path separator as | + OUString sScript = sfUri->getName().replace('|', '/'); + + // check if any path portion matches LibreLogo and ban it if it does + sal_Int32 nIndex = 0; + do + { + OUString aToken = sScript.getToken(0, '/', nIndex); + if (aToken.startsWithIgnoreAsciiCase("LibreLogo") || aToken.indexOf('~') != -1) + { + return true; + } + } + while (nIndex >= 0); + + return false; +} + +ErrCode SfxObjectShell::CallXScript( const Reference< XInterface >& _rxScriptContext, const OUString& _rScriptURL, + const Sequence< Any >& aParams, Any& aRet, Sequence< sal_Int16 >& aOutParamIndex, Sequence< Any >& aOutParam, bool bRaiseError, const css::uno::Any* pCaller ) +{ + SAL_INFO("sfx", "in CallXScript" ); + ErrCode nErr = ERRCODE_NONE; + + bool bCaughtException = false; + Any aException; + try + { + if (!isScriptAccessAllowed(_rxScriptContext)) + return ERRCODE_IO_ACCESSDENIED; + + if ( UnTrustedScript(_rScriptURL) ) + return ERRCODE_IO_ACCESSDENIED; + + // obtain/create a script provider + Reference< provider::XScriptProvider > xScriptProvider; + Reference< provider::XScriptProviderSupplier > xSPS( _rxScriptContext, UNO_QUERY ); + if ( xSPS.is() ) + xScriptProvider.set( xSPS->getScriptProvider() ); + + if ( !xScriptProvider.is() ) + { + Reference< provider::XScriptProviderFactory > xScriptProviderFactory = + provider::theMasterScriptProviderFactory::get( ::comphelper::getProcessComponentContext() ); + xScriptProvider.set( xScriptProviderFactory->createScriptProvider( Any( _rxScriptContext ) ), UNO_SET_THROW ); + } + + // ry to protect the invocation context's undo manager (if present), just in case the script tampers with it + ::framework::DocumentUndoGuard aUndoGuard( _rxScriptContext ); + + // obtain the script, and execute it + Reference< provider::XScript > xScript( xScriptProvider->getScript( _rScriptURL ), UNO_SET_THROW ); + if ( pCaller && pCaller->hasValue() ) + { + Reference< beans::XPropertySet > xProps( xScript, uno::UNO_QUERY ); + if ( xProps.is() ) + { + Sequence< uno::Any > aArgs{ *pCaller }; + xProps->setPropertyValue("Caller", uno::Any( aArgs ) ); + } + } + aRet = xScript->invoke( aParams, aOutParamIndex, aOutParam ); + } + catch ( const uno::Exception& ) + { + aException = ::cppu::getCaughtException(); + bCaughtException = true; + nErr = ERRCODE_BASIC_INTERNAL_ERROR; + } + + if ( bCaughtException && bRaiseError ) + { + SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create(); + pFact->ShowAsyncScriptErrorDialog( nullptr, aException ); + } + + SAL_INFO("sfx", "leaving CallXScript" ); + return nErr; +} + +// perhaps rename to CallScript once we get rid of the existing CallScript +// and Call, CallBasic, CallStarBasic methods +ErrCode SfxObjectShell::CallXScript( const OUString& rScriptURL, + const css::uno::Sequence< css::uno::Any >& aParams, + css::uno::Any& aRet, + css::uno::Sequence< sal_Int16 >& aOutParamIndex, + css::uno::Sequence< css::uno::Any >& aOutParam, + bool bRaiseError, + const css::uno::Any* pCaller ) +{ + return CallXScript( GetModel(), rScriptURL, aParams, aRet, aOutParamIndex, aOutParam, bRaiseError, pCaller ); +} + +void SfxHeaderAttributes_Impl::SetAttributes() +{ + bAlert = true; + SvKeyValue aPair; + for( bool bCont = xIter->GetFirst( aPair ); bCont; + bCont = xIter->GetNext( aPair ) ) + SetAttribute( aPair ); +} + +void SfxHeaderAttributes_Impl::SetAttribute( const SvKeyValue& rKV ) +{ + const OUString& aValue = rKV.GetValue(); + if( rKV.GetKey().equalsIgnoreAsciiCase("refresh") && !rKV.GetValue().isEmpty() ) + { + sal_Int32 nIdx{ 0 }; + const sal_Int32 nTime{ o3tl::toInt32(o3tl::getToken(aValue, 0, ';', nIdx )) }; + const OUString aURL{ comphelper::string::strip(o3tl::getToken(aValue, 0, ';', nIdx ), ' ') }; + uno::Reference<document::XDocumentProperties> xDocProps( + pDoc->getDocProperties()); + if( aURL.startsWithIgnoreAsciiCase( "url=" ) ) + { + try { + xDocProps->setAutoloadURL( + rtl::Uri::convertRelToAbs(pDoc->GetMedium()->GetName(), aURL.copy( 4 )) ); + } catch (rtl::MalformedUriException &) { + TOOLS_WARN_EXCEPTION("sfx", ""); + } + } + try + { + xDocProps->setAutoloadSecs( nTime ); + } + catch (lang::IllegalArgumentException &) + { + // ignore + } + } + else if( rKV.GetKey().equalsIgnoreAsciiCase( "expires" ) ) + { + DateTime aDateTime( DateTime::EMPTY ); + if( INetMIMEMessage::ParseDateField( rKV.GetValue(), aDateTime ) ) + { + aDateTime.ConvertToLocalTime(); + pDoc->GetMedium()->SetExpired_Impl( aDateTime ); + } + else + { + pDoc->GetMedium()->SetExpired_Impl( Date( 1, 1, 1970 ) ); + } + } +} + +void SfxHeaderAttributes_Impl::Append( const SvKeyValue& rKV ) +{ + xIter->Append( rKV ); + if( bAlert ) SetAttribute( rKV ); +} + +SvKeyValueIterator* SfxObjectShell::GetHeaderAttributes() +{ + if( !pImpl->xHeaderAttributes.is() ) + { + DBG_ASSERT( pMedium, "No Medium" ); + pImpl->xHeaderAttributes = new SfxHeaderAttributes_Impl( this ); + } + return static_cast<SvKeyValueIterator*>( pImpl->xHeaderAttributes.get() ); +} + +void SfxObjectShell::ClearHeaderAttributesForSourceViewHack() +{ + static_cast<SfxHeaderAttributes_Impl*>(GetHeaderAttributes()) + ->ClearForSourceView(); +} + + +void SfxObjectShell::SetHeaderAttributesForSourceViewHack() +{ + static_cast<SfxHeaderAttributes_Impl*>(GetHeaderAttributes()) + ->SetAttributes(); +} + +bool SfxObjectShell::IsPreview() const +{ + if ( !pMedium ) + return false; + + bool bPreview = false; + const SfxStringItem* pFlags = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_OPTIONS, false); + if ( pFlags ) + { + // Distributed values among individual items + const OUString aFileFlags = pFlags->GetValue().toAsciiUpperCase(); + if ( -1 != aFileFlags.indexOf( 'B' ) ) + bPreview = true; + } + + if ( !bPreview ) + { + const SfxBoolItem* pItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_PREVIEW, false); + if ( pItem ) + bPreview = pItem->GetValue(); + } + + return bPreview; +} + +void SfxObjectShell::SetWaitCursor( bool bSet ) const +{ + for( SfxViewFrame* pFrame = SfxViewFrame::GetFirst( this ); pFrame; pFrame = SfxViewFrame::GetNext( *pFrame, this ) ) + { + if ( bSet ) + pFrame->GetFrame().GetWindow().EnterWait(); + else + pFrame->GetFrame().GetWindow().LeaveWait(); + } +} + +OUString SfxObjectShell::GetAPIName() const +{ + INetURLObject aURL( IsDocShared() ? GetSharedFileURL() : GetMedium()->GetName() ); + OUString aName( aURL.GetBase() ); + if( aName.isEmpty() ) + aName = aURL.GetURLNoPass(); + if ( aName.isEmpty() ) + aName = GetTitle( SFX_TITLE_DETECT ); + return aName; +} + +void SfxObjectShell::Invalidate( sal_uInt16 nId ) +{ + for( SfxViewFrame* pFrame = SfxViewFrame::GetFirst( this ); pFrame; pFrame = SfxViewFrame::GetNext( *pFrame, this ) ) + Invalidate_Impl( pFrame->GetBindings(), nId ); +} + +bool SfxObjectShell::AdjustMacroMode() +{ + uno::Reference< task::XInteractionHandler > xInteraction; + if ( pMedium ) + xInteraction = pMedium->GetInteractionHandler(); + + CheckForBrokenDocSignatures_Impl(); + + CheckEncryption_Impl( xInteraction ); + + return pImpl->aMacroMode.adjustMacroMode( xInteraction ); +} + +css::uno::Reference<css::awt::XWindow> SfxObjectShell::GetDialogParent( SfxMedium const * pLoadingMedium ) +{ + css::uno::Reference<css::awt::XWindow> xWindow; + SfxItemSet* pSet = pLoadingMedium ? pLoadingMedium->GetItemSet() : GetMedium()->GetItemSet(); + const SfxUnoFrameItem* pUnoItem = SfxItemSet::GetItem<SfxUnoFrameItem>(pSet, SID_FILLFRAME, false); + if ( pUnoItem ) + { + const uno::Reference < frame::XFrame >& xFrame( pUnoItem->GetFrame() ); + xWindow = xFrame->getContainerWindow(); + } + + if (!xWindow) + { + SfxFrame* pFrame = nullptr; + const SfxFrameItem* pFrameItem = SfxItemSet::GetItem<SfxFrameItem>(pSet, SID_DOCFRAME, false); + if( pFrameItem && pFrameItem->GetFrame() ) + // get target frame from ItemSet + pFrame = pFrameItem->GetFrame(); + else + { + // try the current frame + SfxViewFrame* pView = SfxViewFrame::Current(); + if ( !pView || pView->GetObjectShell() != this ) + // get any visible frame + pView = SfxViewFrame::GetFirst(this); + if ( pView ) + pFrame = &pView->GetFrame(); + } + + if ( pFrame ) + { + // get topmost window + xWindow = pFrame->GetFrameInterface()->getContainerWindow(); + } + } + + if (xWindow) + { + // this frame may be invisible, show it if it is allowed + const SfxBoolItem* pHiddenItem = SfxItemSet::GetItem<SfxBoolItem>(pSet, SID_HIDDEN, false); + if ( !pHiddenItem || !pHiddenItem->GetValue() ) + { + xWindow->setVisible(true); + css::uno::Reference<css::awt::XTopWindow> xTopWindow(xWindow, uno::UNO_QUERY); + SAL_WARN_IF(!xTopWindow, "sfx.appl", "XTopWindow not available from XWindow"); + if (xTopWindow) + xTopWindow->toFront(); + } + } + + return xWindow; +} + +void SfxObjectShell::SetCreateMode_Impl( SfxObjectCreateMode nMode ) +{ + eCreateMode = nMode; +} + +bool SfxObjectShell::IsInPlaceActive() const +{ + if ( eCreateMode != SfxObjectCreateMode::EMBEDDED ) + return false; + + SfxViewFrame* pFrame = SfxViewFrame::GetFirst( this ); + return pFrame && pFrame->GetFrame().IsInPlace(); +} + +bool SfxObjectShell::IsUIActive() const +{ + if ( eCreateMode != SfxObjectCreateMode::EMBEDDED ) + return false; + + SfxViewFrame* pFrame = SfxViewFrame::GetFirst( this ); + return pFrame && pFrame->GetFrame().IsInPlace() && pFrame->GetFrame().GetWorkWindow_Impl()->IsVisible_Impl(); +} + +bool SfxObjectShell::UseInteractionToHandleError( + const uno::Reference< task::XInteractionHandler >& xHandler, + ErrCode nError ) +{ + bool bResult = false; + + if ( xHandler.is() ) + { + try + { + uno::Any aInteraction; + rtl::Reference<::comphelper::OInteractionAbort> pAbort = new ::comphelper::OInteractionAbort(); + rtl::Reference<::comphelper::OInteractionApprove> pApprove = new ::comphelper::OInteractionApprove(); + uno::Sequence< uno::Reference< task::XInteractionContinuation > > lContinuations{ + pAbort, pApprove + }; + + task::ErrorCodeRequest aErrorCode; + aErrorCode.ErrCode = sal_uInt32(nError); + aInteraction <<= aErrorCode; + xHandler->handle(::framework::InteractionRequest::CreateRequest (aInteraction,lContinuations)); + bResult = pAbort->wasSelected(); + } + catch( uno::Exception& ) + {} + } + + return bResult; +} + +sal_Int16 SfxObjectShell_Impl::getCurrentMacroExecMode() const +{ + sal_Int16 nImposedExecMode( MacroExecMode::NEVER_EXECUTE ); + + const SfxMedium* pMedium( rDocShell.GetMedium() ); + OSL_PRECOND( pMedium, "SfxObjectShell_Impl::getCurrentMacroExecMode: no medium!" ); + if ( pMedium ) + { + const SfxUInt16Item* pMacroModeItem = SfxItemSet::GetItem<SfxUInt16Item>(pMedium->GetItemSet(), SID_MACROEXECMODE, false); + if ( pMacroModeItem ) + nImposedExecMode = pMacroModeItem->GetValue(); + } + return nImposedExecMode; +} + +void SfxObjectShell_Impl::setCurrentMacroExecMode( sal_uInt16 nMacroMode ) +{ + const SfxMedium* pMedium( rDocShell.GetMedium() ); + OSL_PRECOND( pMedium, "SfxObjectShell_Impl::getCurrentMacroExecMode: no medium!" ); + if ( pMedium ) + { + pMedium->GetItemSet()->Put( SfxUInt16Item( SID_MACROEXECMODE, nMacroMode ) ); + } +} + +OUString SfxObjectShell_Impl::getDocumentLocation() const +{ + OUString sLocation; + + const SfxMedium* pMedium( rDocShell.GetMedium() ); + OSL_PRECOND( pMedium, "SfxObjectShell_Impl::getDocumentLocation: no medium!" ); + if ( pMedium ) + { + sLocation = pMedium->GetName(); + if ( sLocation.isEmpty() ) + { + // for documents made from a template: get the name of the template + sLocation = rDocShell.getDocProperties()->getTemplateURL(); + } + + // tdf#128006 take document base url as location + if (sLocation.isEmpty()) + sLocation = rDocShell.getDocumentBaseURL(); + } + + return sLocation; +} + +bool SfxObjectShell_Impl::documentStorageHasMacros() const +{ + return ::sfx2::DocumentMacroMode::storageHasMacros( m_xDocStorage ); +} + +bool SfxObjectShell_Impl::macroCallsSeenWhileLoading() const +{ + return rDocShell.GetMacroCallsSeenWhileLoading(); +} + +Reference< XEmbeddedScripts > SfxObjectShell_Impl::getEmbeddedDocumentScripts() const +{ + return Reference< XEmbeddedScripts >( rDocShell.GetModel(), UNO_QUERY ); +} + +SignatureState SfxObjectShell_Impl::getScriptingSignatureState() +{ + SignatureState nSignatureState( rDocShell.GetScriptingSignatureState() ); + + if ( nSignatureState != SignatureState::NOSIGNATURES && m_bMacroSignBroken ) + { + // if there is a macro signature it must be handled as broken + nSignatureState = SignatureState::BROKEN; + } + + return nSignatureState; +} + +bool SfxObjectShell_Impl::hasTrustedScriptingSignature( bool bAllowUIToAddAuthor ) +{ + bool bResult = false; + + try + { + OUString aVersion; + try + { + uno::Reference < beans::XPropertySet > xPropSet( rDocShell.GetStorage(), uno::UNO_QUERY_THROW ); + xPropSet->getPropertyValue("Version") >>= aVersion; + } + catch( uno::Exception& ) + { + } + + uno::Reference< security::XDocumentDigitalSignatures > xSigner( security::DocumentDigitalSignatures::createWithVersion(comphelper::getProcessComponentContext(), aVersion) ); + + if ( nScriptingSignatureState == SignatureState::UNKNOWN + || nScriptingSignatureState == SignatureState::OK + || nScriptingSignatureState == SignatureState::NOTVALIDATED ) + { + const uno::Sequence< security::DocumentSignatureInformation > aInfo = rDocShell.GetDocumentSignatureInformation( true, xSigner ); + + if ( aInfo.hasElements() ) + { + if ( nScriptingSignatureState == SignatureState::UNKNOWN ) + nScriptingSignatureState = DocumentSignatures::getSignatureState(aInfo); + + if ( nScriptingSignatureState == SignatureState::OK + || nScriptingSignatureState == SignatureState::NOTVALIDATED ) + { + bResult = std::any_of(aInfo.begin(), aInfo.end(), + [&xSigner](const security::DocumentSignatureInformation& rInfo) { + return xSigner->isAuthorTrusted( rInfo.Signer ); }); + + if ( !bResult && bAllowUIToAddAuthor ) + { + uno::Reference< task::XInteractionHandler > xInteraction; + if ( rDocShell.GetMedium() ) + xInteraction = rDocShell.GetMedium()->GetInteractionHandler(); + + if ( xInteraction.is() ) + { + task::DocumentMacroConfirmationRequest aRequest; + aRequest.DocumentURL = getDocumentLocation(); + aRequest.DocumentStorage = rDocShell.GetMedium()->GetZipStorageToSign_Impl(); + aRequest.DocumentSignatureInformation = aInfo; + aRequest.DocumentVersion = aVersion; + aRequest.Classification = task::InteractionClassification_QUERY; + bResult = SfxMedium::CallApproveHandler( xInteraction, uno::Any( aRequest ), true ); + } + } + } + } + } + } + catch( uno::Exception& ) + {} + + return bResult; +} + +bool SfxObjectShell::IsContinueImportOnFilterExceptions(std::u16string_view aErrMessage) +{ + if (mbContinueImportOnFilterExceptions == undefined) + { + if (Application::GetDialogCancelMode() == DialogCancelMode::Off) + { + // Ask the user to try to continue or abort loading + OUString aMessage = SfxResId(STR_QMSG_ERROR_OPENING_FILE); + if (!aErrMessage.empty()) + aMessage += SfxResId(STR_QMSG_ERROR_OPENING_FILE_DETAILS) + aErrMessage; + aMessage += SfxResId(STR_QMSG_ERROR_OPENING_FILE_CONTINUE); + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(nullptr, + VclMessageType::Question, VclButtonsType::YesNo, aMessage)); + mbContinueImportOnFilterExceptions = (xBox->run() == RET_YES) ? yes : no; + } + else + mbContinueImportOnFilterExceptions = no; + } + return mbContinueImportOnFilterExceptions == yes; +} + +bool SfxObjectShell::isEditDocLocked() const +{ + Reference<XModel3> xModel = GetModel(); + if (!xModel.is()) + return false; + if (!officecfg::Office::Common::Misc::AllowEditReadonlyDocs::get()) + return true; + return comphelper::NamedValueCollection::getOrDefault(xModel->getArgs2( { "LockEditDoc" } ), u"LockEditDoc", false); +} + +bool SfxObjectShell::isContentExtractionLocked() const +{ + Reference<XModel3> xModel = GetModel(); + if (!xModel.is()) + return false; + return comphelper::NamedValueCollection::getOrDefault(xModel->getArgs2( { "LockContentExtraction" } ), u"LockContentExtraction", false); +} + +bool SfxObjectShell::isExportLocked() const +{ + Reference<XModel3> xModel = GetModel(); + if (!xModel.is()) + return false; + return comphelper::NamedValueCollection::getOrDefault(xModel->getArgs2( { "LockExport" } ), u"LockExport", false); +} + +bool SfxObjectShell::isPrintLocked() const +{ + Reference<XModel3> xModel = GetModel(); + if (!xModel.is()) + return false; + return comphelper::NamedValueCollection::getOrDefault(xModel->getArgs2( { "LockPrint" } ), u"LockPrint", false); +} + +bool SfxObjectShell::isSaveLocked() const +{ + Reference<XModel3> xModel = GetModel(); + if (!xModel.is()) + return false; + return comphelper::NamedValueCollection::getOrDefault(xModel->getArgs2( { "LockSave" } ), u"LockSave", false); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/objserv.cxx b/sfx2/source/doc/objserv.cxx new file mode 100644 index 000000000..3a6a0ceea --- /dev/null +++ b/sfx2/source/doc/objserv.cxx @@ -0,0 +1,2131 @@ +/* -*- 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 <config_features.h> + +#include <com/sun/star/style/XStyleFamiliesSupplier.hpp> +#include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp> +#include <com/sun/star/util/CloseVetoException.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/beans/PropertyValue.hpp> +#include <com/sun/star/document/XCmisDocument.hpp> +#include <com/sun/star/drawing/LineStyle.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/security/XCertificate.hpp> +#include <com/sun/star/task/ErrorCodeIOException.hpp> +#include <com/sun/star/task/InteractionHandler.hpp> +#include <com/sun/star/task/XStatusIndicator.hpp> +#include <com/sun/star/task/XStatusIndicatorFactory.hpp> +#include <comphelper/processfactory.hxx> +#include <comphelper/servicehelper.hxx> +#include <com/sun/star/drawing/XDrawView.hpp> + +#include <com/sun/star/security/DocumentSignatureInformation.hpp> +#include <com/sun/star/security/DocumentDigitalSignatures.hpp> +#include <tools/diagnose_ex.h> +#include <tools/urlobj.hxx> +#include <svl/whiter.hxx> +#include <svl/intitem.hxx> +#include <svl/eitem.hxx> +#include <svl/visitem.hxx> +#include <svtools/sfxecode.hxx> +#include <svtools/ehdl.hxx> +#include <sal/log.hxx> +#include <sfx2/app.hxx> + +#include <comphelper/string.hxx> +#include <basic/sbxcore.hxx> +#include <basic/sberrors.hxx> +#include <unotools/moduleoptions.hxx> +#include <unotools/saveopt.hxx> +#include <svtools/DocumentToGraphicRenderer.hxx> +#include <vcl/gdimtf.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> +#include <comphelper/documentconstants.hxx> +#include <comphelper/storagehelper.hxx> +#include <comphelper/lok.hxx> +#include <LibreOfficeKit/LibreOfficeKitEnums.h> +#include <tools/link.hxx> + +#include <sfx2/signaturestate.hxx> +#include <sfx2/sfxresid.hxx> +#include <sfx2/request.hxx> +#include <sfx2/printer.hxx> +#include <sfx2/viewsh.hxx> +#include <sfx2/dinfdlg.hxx> +#include <sfx2/docfilt.hxx> +#include <sfx2/docfile.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/objitem.hxx> +#include <sfx2/objsh.hxx> +#include <objshimp.hxx> +#include <sfx2/module.hxx> +#include <sfx2/viewfrm.hxx> +#include <versdlg.hxx> +#include <sfx2/strings.hrc> +#include <sfx2/docfac.hxx> +#include <sfx2/fcontnr.hxx> +#include <sfx2/msgpool.hxx> +#include <sfx2/objface.hxx> +#include <checkin.hxx> +#include <sfx2/infobar.hxx> +#include <sfx2/sfxuno.hxx> +#include <sfx2/sfxsids.hrc> +#include <SfxRedactionHelper.hxx> + +#include <com/sun/star/util/XCloseable.hpp> +#include <com/sun/star/document/XDocumentProperties.hpp> + +#include <com/sun/star/drawing/XDrawPagesSupplier.hpp> +#include <com/sun/star/frame/XDesktop2.hpp> +#include <com/sun/star/frame/Desktop.hpp> + +#include <guisaveas.hxx> +#include <saveastemplatedlg.hxx> +#include <memory> +#include <cppuhelper/implbase.hxx> +#include <unotools/ucbstreamhelper.hxx> +#include <unotools/streamwrap.hxx> +#include <comphelper/sequenceashashmap.hxx> +#include <editeng/unoprnms.hxx> + +#include <autoredactdialog.hxx> + +#include <boost/property_tree/json_parser.hpp> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::ui::dialogs; +using namespace ::com::sun::star::awt; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::document; +using namespace ::com::sun::star::security; +using namespace ::com::sun::star::task; +using namespace ::com::sun::star::graphic; + +#define ShellClass_SfxObjectShell +#include <sfxslots.hxx> + +SFX_IMPL_SUPERCLASS_INTERFACE(SfxObjectShell, SfxShell) + +void SfxObjectShell::InitInterface_Impl() +{ +} + +namespace { + +class SfxClosePreventer_Impl : public ::cppu::WeakImplHelper< css::util::XCloseListener > +{ + bool m_bGotOwnership; + bool m_bPreventClose; + +public: + SfxClosePreventer_Impl(); + + bool HasOwnership() const { return m_bGotOwnership; } + + void SetPreventClose( bool bPrevent ) { m_bPreventClose = bPrevent; } + + virtual void SAL_CALL queryClosing( const lang::EventObject& aEvent, sal_Bool bDeliverOwnership ) override; + + virtual void SAL_CALL notifyClosing( const lang::EventObject& aEvent ) override ; + + virtual void SAL_CALL disposing( const lang::EventObject& aEvent ) override ; + +} ; + +} + +SfxClosePreventer_Impl::SfxClosePreventer_Impl() +: m_bGotOwnership( false ) +, m_bPreventClose( true ) +{ +} + +void SAL_CALL SfxClosePreventer_Impl::queryClosing( const lang::EventObject&, sal_Bool bDeliverOwnership ) +{ + if ( m_bPreventClose ) + { + if ( !m_bGotOwnership ) + m_bGotOwnership = bDeliverOwnership; + + throw util::CloseVetoException(); + } +} + +void SAL_CALL SfxClosePreventer_Impl::notifyClosing( const lang::EventObject& ) +{} + +void SAL_CALL SfxClosePreventer_Impl::disposing( const lang::EventObject& ) +{} + +namespace { + +class SfxInstanceCloseGuard_Impl +{ + rtl::Reference<SfxClosePreventer_Impl> m_xPreventer; + uno::Reference< util::XCloseable > m_xCloseable; + +public: + SfxInstanceCloseGuard_Impl() {} + + ~SfxInstanceCloseGuard_Impl(); + + bool Init_Impl( const uno::Reference< util::XCloseable >& xCloseable ); +}; + +} + +bool SfxInstanceCloseGuard_Impl::Init_Impl( const uno::Reference< util::XCloseable >& xCloseable ) +{ + bool bResult = false; + + // do not allow reinit after the successful init + if ( xCloseable.is() && !m_xCloseable.is() ) + { + try + { + m_xPreventer = new SfxClosePreventer_Impl(); + xCloseable->addCloseListener( m_xPreventer ); + m_xCloseable = xCloseable; + bResult = true; + } + catch( uno::Exception& ) + { + OSL_FAIL( "Could not register close listener!" ); + } + } + + return bResult; +} + +SfxInstanceCloseGuard_Impl::~SfxInstanceCloseGuard_Impl() +{ + if ( !m_xCloseable.is() || !m_xPreventer.is() ) + return; + + try + { + m_xCloseable->removeCloseListener( m_xPreventer ); + } + catch( uno::Exception& ) + { + } + + try + { + if ( m_xPreventer.is() ) + { + m_xPreventer->SetPreventClose( false ); + + if ( m_xPreventer->HasOwnership() ) + m_xCloseable->close( true ); // TODO: do it asynchronously + } + } + catch( uno::Exception& ) + { + } +} + + +void SfxObjectShell::PrintExec_Impl(SfxRequest &rReq) +{ + SfxViewFrame *pFrame = SfxViewFrame::GetFirst(this); + if ( pFrame ) + { + rReq.SetSlot( SID_PRINTDOC ); + pFrame->GetViewShell()->ExecuteSlot(rReq); + } +} + + +void SfxObjectShell::PrintState_Impl(SfxItemSet &rSet) +{ + bool bPrinting = false; + SfxViewFrame* pFrame = SfxViewFrame::GetFirst( this ); + if ( pFrame ) + { + SfxPrinter *pPrinter = pFrame->GetViewShell()->GetPrinter(); + bPrinting = pPrinter && pPrinter->IsPrinting(); + } + rSet.Put( SfxBoolItem( SID_PRINTOUT, bPrinting ) ); +} + +bool SfxObjectShell::APISaveAs_Impl(std::u16string_view aFileName, SfxItemSet& rItemSet, + const css::uno::Sequence<css::beans::PropertyValue>& rArgs) +{ + bool bOk = false; + + if ( GetMedium() ) + { + OUString aFilterName; + const SfxStringItem* pFilterNameItem = rItemSet.GetItem<SfxStringItem>(SID_FILTER_NAME, false); + if( pFilterNameItem ) + { + aFilterName = pFilterNameItem->GetValue(); + } + else + { + const SfxStringItem* pContentTypeItem = rItemSet.GetItem<SfxStringItem>(SID_CONTENTTYPE, false); + if ( pContentTypeItem ) + { + std::shared_ptr<const SfxFilter> pFilter = SfxFilterMatcher( GetFactory().GetFactoryName() ).GetFilter4Mime( pContentTypeItem->GetValue(), SfxFilterFlags::EXPORT ); + if ( pFilter ) + aFilterName = pFilter->GetName(); + } + } + + // in case no filter defined use default one + if( aFilterName.isEmpty() ) + { + std::shared_ptr<const SfxFilter> pFilt = SfxFilter::GetDefaultFilterFromFactory(GetFactory().GetFactoryName()); + + DBG_ASSERT( pFilt, "No default filter!\n" ); + if( pFilt ) + aFilterName = pFilt->GetFilterName(); + + rItemSet.Put(SfxStringItem(SID_FILTER_NAME, aFilterName)); + } + + + { + SfxObjectShellRef xLock( this ); // ??? + + // use the title that is provided in the media descriptor + const SfxStringItem* pDocTitleItem = rItemSet.GetItem<SfxStringItem>(SID_DOCINFO_TITLE, false); + if ( pDocTitleItem ) + getDocProperties()->setTitle( pDocTitleItem->GetValue() ); + + bOk = CommonSaveAs_Impl(INetURLObject(aFileName), aFilterName, rItemSet, rArgs); + } + } + + return bOk; +} + +void SfxObjectShell::CheckOut( ) +{ + try + { + uno::Reference< document::XCmisDocument > xCmisDoc( GetModel(), uno::UNO_QUERY_THROW ); + xCmisDoc->checkOut( ); + + // Remove the info bar + SfxViewFrame* pViewFrame = GetFrame(); + pViewFrame->RemoveInfoBar( u"checkout" ); + } + catch ( const uno::RuntimeException& e ) + { + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(GetFrame()->GetFrameWeld(), + VclMessageType::Warning, VclButtonsType::Ok, e.Message)); + xBox->run(); + } +} + +void SfxObjectShell::CancelCheckOut( ) +{ + try + { + uno::Reference< document::XCmisDocument > xCmisDoc( GetModel(), uno::UNO_QUERY_THROW ); + xCmisDoc->cancelCheckOut( ); + + uno::Reference< util::XModifiable > xModifiable( GetModel( ), uno::UNO_QUERY ); + if ( xModifiable.is( ) ) + xModifiable->setModified( false ); + } + catch ( const uno::RuntimeException& e ) + { + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(GetFrame()->GetFrameWeld(), + VclMessageType::Warning, VclButtonsType::Ok, e.Message)); + xBox->run(); + } +} + +void SfxObjectShell::CheckIn( ) +{ + try + { + uno::Reference< document::XCmisDocument > xCmisDoc( GetModel(), uno::UNO_QUERY_THROW ); + // Pop up dialog to ask for comment and major + SfxCheckinDialog checkinDlg(GetFrame()->GetFrameWeld()); + if (checkinDlg.run() == RET_OK) + { + xCmisDoc->checkIn(checkinDlg.IsMajor(), checkinDlg.GetComment()); + uno::Reference< util::XModifiable > xModifiable( GetModel( ), uno::UNO_QUERY ); + if ( xModifiable.is( ) ) + xModifiable->setModified( false ); + } + } + catch ( const uno::RuntimeException& e ) + { + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(GetFrame()->GetFrameWeld(), + VclMessageType::Warning, VclButtonsType::Ok, e.Message)); + xBox->run(); + } +} + +uno::Sequence< document::CmisVersion > SfxObjectShell::GetCmisVersions( ) const +{ + try + { + uno::Reference< document::XCmisDocument > xCmisDoc( GetModel(), uno::UNO_QUERY_THROW ); + return xCmisDoc->getAllVersions( ); + } + catch ( const uno::RuntimeException& e ) + { + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(GetFrame()->GetFrameWeld(), + VclMessageType::Warning, VclButtonsType::Ok, e.Message)); + xBox->run(); + } + return uno::Sequence< document::CmisVersion > ( ); +} + +bool SfxObjectShell::IsSignPDF() const +{ + if (pMedium && !pMedium->IsOriginallyReadOnly()) + { + const std::shared_ptr<const SfxFilter>& pFilter = pMedium->GetFilter(); + if (pFilter && pFilter->GetName() == "draw_pdf_import") + return true; + } + + return false; +} + +uno::Reference<security::XCertificate> SfxObjectShell::GetSignPDFCertificate() const +{ + uno::Reference<frame::XModel> xModel = GetBaseModel(); + if (!xModel.is()) + { + return uno::Reference<security::XCertificate>(); + } + + uno::Reference<drawing::XShapes> xShapes(xModel->getCurrentSelection(), uno::UNO_QUERY); + if (!xShapes.is() || xShapes->getCount() < 1) + { + return uno::Reference<security::XCertificate>(); + } + + uno::Reference<beans::XPropertySet> xShapeProps(xShapes->getByIndex(0), uno::UNO_QUERY); + if (!xShapeProps.is()) + { + return uno::Reference<security::XCertificate>(); + } + + if (!xShapeProps->getPropertySetInfo()->hasPropertyByName("InteropGrabBag")) + { + return uno::Reference<security::XCertificate>(); + } + + comphelper::SequenceAsHashMap aMap(xShapeProps->getPropertyValue("InteropGrabBag")); + auto it = aMap.find("SignatureCertificate"); + if (it == aMap.end()) + { + return uno::Reference<security::XCertificate>(); + } + + return uno::Reference<security::XCertificate>(it->second, uno::UNO_QUERY); +} + +static void sendErrorToLOK(ErrCode error) +{ + if (error.GetClass() == ErrCodeClass::NONE) + return; + + boost::property_tree::ptree aTree; + aTree.put("code", error); + aTree.put("kind", ""); + aTree.put("cmd", ""); + + std::unique_ptr<ErrorInfo> pInfo = ErrorInfo::GetErrorInfo(error); + OUString aErr; + if (ErrorStringFactory::CreateString(pInfo.get(), aErr)) + aTree.put("message", aErr.toUtf8()); + + std::stringstream aStream; + boost::property_tree::write_json(aStream, aTree); + + SfxViewShell::Current()->libreOfficeKitViewCallback(LOK_CALLBACK_ERROR, aStream.str().c_str()); +} + +void SfxObjectShell::ExecFile_Impl(SfxRequest &rReq) +{ + weld::Window* pDialogParent = rReq.GetFrameWeld(); + if (!pDialogParent) + { + SfxViewFrame* pFrame = GetFrame(); + if (!pFrame) + pFrame = SfxViewFrame::GetFirst(this); + if (pFrame) + pDialogParent = pFrame->GetFrameWeld(); + } + + sal_uInt16 nId = rReq.GetSlot(); + + if( SID_SIGNATURE == nId || SID_MACRO_SIGNATURE == nId ) + { + if ( QueryHiddenInformation( HiddenWarningFact::WhenSigning, nullptr ) == RET_YES ) + { + if (SID_SIGNATURE == nId) + { + uno::Reference<security::XCertificate> xCertificate = GetSignPDFCertificate(); + if (xCertificate.is()) + { + SignDocumentContentUsingCertificate(xCertificate); + + // Reload to show how the PDF actually looks like after signing. This also + // changes "finish signing" on the infobar back to "sign document" as a side + // effect. + SfxViewFrame* pFrame = GetFrame(); + if (pFrame) + { + // Store current page before reload. + SfxAllItemSet aSet(SfxGetpApp()->GetPool()); + uno::Reference<drawing::XDrawView> xController( + GetBaseModel()->getCurrentController(), uno::UNO_QUERY); + uno::Reference<beans::XPropertySet> xPage(xController->getCurrentPage(), + uno::UNO_QUERY); + sal_Int32 nPage{}; + xPage->getPropertyValue("Number") >>= nPage; + if (nPage > 0) + { + // nPage is 1-based. + aSet.Put(SfxInt32Item(SID_PAGE_NUMBER, nPage - 1)); + } + SfxRequest aReq(SID_RELOAD, SfxCallMode::SLOT, aSet); + pFrame->ExecReload_Impl(aReq); + } + } + else + { + SignDocumentContent(pDialogParent); + } + } + else + { + SignScriptingContent(pDialogParent); + } + } + return; + } + + if ( !GetMedium() && nId != SID_CLOSEDOC ) + { + rReq.Ignore(); + return; + } + + // this guard is created here to have it destruction at the end of the method + SfxInstanceCloseGuard_Impl aModelGuard; + + bool bIsPDFExport = false; + bool bIsAutoRedact = false; + std::vector<std::pair<RedactionTarget, OUString>> aRedactionTargets; + switch(nId) + { + case SID_VERSION: + { + SfxViewFrame* pFrame = GetFrame(); + if ( !pFrame ) + pFrame = SfxViewFrame::GetFirst( this ); + if ( !pFrame ) + return; + + if ( !IsOwnStorageFormat( *GetMedium() ) ) + return; + + SfxVersionDialog aDlg(pDialogParent, pFrame, IsSaveVersionOnClose()); + aDlg.run(); + SetSaveVersionOnClose(aDlg.IsSaveVersionOnClose()); + rReq.Done(); + return; + } + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + case SID_DOCINFO: + { + const SfxDocumentInfoItem* pDocInfItem = rReq.GetArg<SfxDocumentInfoItem>(SID_DOCINFO); + if ( pDocInfItem ) + { + // parameter, e.g. from replayed macro + pDocInfItem->UpdateDocumentInfo(getDocProperties(), true); + SetUseUserData( pDocInfItem->IsUseUserData() ); + SetUseThumbnailSave( pDocInfItem->IsUseThumbnailSave() ); + } + else + { + // no argument containing DocInfo; check optional arguments + bool bReadOnly = IsReadOnly(); + const SfxBoolItem* pROItem = rReq.GetArg<SfxBoolItem>(SID_DOC_READONLY); + if ( pROItem ) + // override readonly attribute of document + // e.g. if a readonly document is saved elsewhere and user asks for editing DocInfo before + bReadOnly = pROItem->GetValue(); + + // URL for dialog + const OUString aURL( HasName() ? GetMedium()->GetName() : GetFactory().GetFactoryURL() ); + + Reference< XCmisDocument > xCmisDoc( GetModel(), uno::UNO_QUERY ); + uno::Sequence< document::CmisProperty> aCmisProperties = xCmisDoc->getCmisProperties(); + + SfxDocumentInfoItem aDocInfoItem( aURL, getDocProperties(), aCmisProperties, + IsUseUserData(), IsUseThumbnailSave() ); + if ( !GetSlotState( SID_DOCTEMPLATE ) ) + // templates not supported + aDocInfoItem.SetTemplate(false); + + SfxItemSetFixed<SID_DOCINFO, SID_DOCINFO, SID_DOC_READONLY, SID_DOC_READONLY, + SID_EXPLORER_PROPS_START, SID_EXPLORER_PROPS_START, SID_BASEURL, SID_BASEURL> + aSet(GetPool()); + aSet.Put( aDocInfoItem ); + aSet.Put( SfxBoolItem( SID_DOC_READONLY, bReadOnly ) ); + aSet.Put( SfxStringItem( SID_EXPLORER_PROPS_START, GetTitle() ) ); + aSet.Put( SfxStringItem( SID_BASEURL, GetMedium()->GetBaseURL() ) ); + + // creating dialog is done via virtual method; application will + // add its own statistics page + std::shared_ptr<SfxDocumentInfoDialog> xDlg(CreateDocumentInfoDialog(rReq.GetFrameWeld(), aSet)); + auto aFunc = [this, xDlg, xCmisDoc](sal_Int32 nResult, SfxRequest& rRequest) + { + if (RET_OK == nResult) + { + const SfxDocumentInfoItem* pDocInfoItem = SfxItemSet::GetItem(xDlg->GetOutputItemSet(), SID_DOCINFO, false); + if ( pDocInfoItem ) + { + // user has done some changes to DocumentInfo + pDocInfoItem->UpdateDocumentInfo(getDocProperties()); + const uno::Sequence< document::CmisProperty >& aNewCmisProperties = + pDocInfoItem->GetCmisProperties( ); + if ( aNewCmisProperties.hasElements( ) ) + xCmisDoc->updateCmisProperties( aNewCmisProperties ); + SetUseUserData( pDocInfoItem->IsUseUserData() ); + SetUseThumbnailSave( pDocInfoItem-> IsUseThumbnailSave() ); + // add data from dialog for possible recording purpose + rRequest.AppendItem( SfxDocumentInfoItem( GetTitle(), + getDocProperties(), aNewCmisProperties, IsUseUserData(), IsUseThumbnailSave() ) ); + } + rRequest.Done(); + } + else + { + // nothing done; no recording + rRequest.Ignore(); + } + }; + + if (!rReq.IsSynchronCall()) + { + std::shared_ptr<SfxRequest> pReq = std::make_shared<SfxRequest>(rReq); + SfxTabDialogController::runAsync(xDlg, [pReq, aFunc](sal_Int32 nResult) + { + aFunc(nResult, *pReq); + }); + rReq.Ignore(); + } + else + { + aFunc(xDlg->run(), rReq); + } + } + + return; + } + + case SID_AUTOREDACTDOC: + { + // Actual redaction takes place on a newly generated Draw document + if (!SvtModuleOptions().IsModuleInstalled(SvtModuleOptions::EModule::DRAW)) + { + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog( + pDialogParent, VclMessageType::Warning, VclButtonsType::Ok, + SfxResId(STR_REDACTION_NO_DRAW_WARNING))); + + xBox->run(); + + return; + } + + SfxAutoRedactDialog aDlg(pDialogParent); + sal_Int16 nResult = aDlg.run(); + + if (nResult != RET_OK || !aDlg.hasTargets() || !aDlg.isValidState()) + { + //Do nothing + return; + } + + // else continue with normal redaction + bIsAutoRedact = true; + aDlg.getTargets(aRedactionTargets); + + [[fallthrough]]; + } + + case SID_REDACTDOC: + { + css::uno::Reference<css::frame::XModel> xModel = GetModel(); + if(!xModel.is()) + return; + + uno::Reference< lang::XComponent > xSourceDoc( xModel ); + + // Actual redaction takes place on a newly generated Draw document + if (!SvtModuleOptions().IsModuleInstalled(SvtModuleOptions::EModule::DRAW)) + { + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog( + pDialogParent, VclMessageType::Warning, VclButtonsType::Ok, + SfxResId(STR_REDACTION_NO_DRAW_WARNING))); + + xBox->run(); + + return; + } + + DocumentToGraphicRenderer aRenderer(xSourceDoc, false); + + // Get the page margins of the original doc + PageMargins aPageMargins = {-1, -1, -1, -1}; + if (aRenderer.isWriter()) + aPageMargins = SfxRedactionHelper::getPageMarginsForWriter(xModel); + else if (aRenderer.isCalc()) + aPageMargins = SfxRedactionHelper::getPageMarginsForCalc(xModel); + + sal_Int32 nPages = aRenderer.getPageCount(); + std::vector< GDIMetaFile > aMetaFiles; + std::vector< ::Size > aPageSizes; + + // Convert the pages of the document to gdimetafiles + SfxRedactionHelper::getPageMetaFilesFromDoc(aMetaFiles, aPageSizes, nPages, aRenderer); + + // Create an empty Draw component. + uno::Reference<frame::XDesktop2> xDesktop = css::frame::Desktop::create(comphelper::getProcessComponentContext()); + uno::Reference<lang::XComponent> xComponent = xDesktop->loadComponentFromURL("private:factory/sdraw", "_default", 0, {}); + + if (!xComponent.is()) + { + SAL_WARN("sfx.doc", "SID_REDACTDOC: Failed to load new draw component. loadComponentFromURL returned an empty reference."); + + return; + } + + // Add the doc pages to the new draw document + SfxRedactionHelper::addPagesToDraw(xComponent, nPages, aMetaFiles, aPageSizes, aPageMargins, aRedactionTargets, bIsAutoRedact); + + // Show the Redaction toolbar + SfxViewFrame* pViewFrame = SfxViewFrame::Current(); + if (!pViewFrame) + return; + SfxRedactionHelper::showRedactionToolbar(pViewFrame); + + return; + } + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + case SID_DIRECTEXPORTDOCASPDF: + { + uno::Reference< lang::XComponent > xComponent( GetCurrentComponent(), uno::UNO_QUERY ); + if (!xComponent.is()) + return; + + uno::Reference< lang::XServiceInfo > xServiceInfo( xComponent, uno::UNO_QUERY); + + // Redaction finalization takes place in Draw + if ( xServiceInfo.is() && xServiceInfo->supportsService("com.sun.star.drawing.DrawingDocument") + && SfxRedactionHelper::isRedactMode(rReq) ) + { + OUString sRedactionStyle(SfxRedactionHelper::getStringParam(rReq, SID_REDACTION_STYLE)); + + // Access the draw pages + uno::Reference<drawing::XDrawPagesSupplier> xDrawPagesSupplier(xComponent, uno::UNO_QUERY); + uno::Reference<drawing::XDrawPages> xDrawPages = xDrawPagesSupplier->getDrawPages(); + + sal_Int32 nPageCount = xDrawPages->getCount(); + for (sal_Int32 nPageNum = 0; nPageNum < nPageCount; ++nPageNum) + { + // Get the page + uno::Reference< drawing::XDrawPage > xPage( xDrawPages->getByIndex( nPageNum ), uno::UNO_QUERY ); + + if (!xPage.is()) + continue; + + // Go through all shapes + sal_Int32 nShapeCount = xPage->getCount(); + for (sal_Int32 nShapeNum = 0; nShapeNum < nShapeCount; ++nShapeNum) + { + uno::Reference< drawing::XShape > xCurrShape(xPage->getByIndex(nShapeNum), uno::UNO_QUERY); + if (!xCurrShape.is()) + continue; + + uno::Reference< beans::XPropertySet > xPropSet(xCurrShape, uno::UNO_QUERY); + if (!xPropSet.is()) + continue; + + uno::Reference< beans::XPropertySetInfo> xInfo = xPropSet->getPropertySetInfo(); + if (!xInfo.is()) + continue; + + OUString sShapeName; + if (xInfo->hasPropertyByName("Name")) + { + uno::Any aAnyShapeName = xPropSet->getPropertyValue("Name"); + aAnyShapeName >>= sShapeName; + } + else + continue; + + // Rectangle redaction + if (sShapeName == "RectangleRedactionShape" + && xInfo->hasPropertyByName("FillTransparence") && xInfo->hasPropertyByName("FillColor")) + { + xPropSet->setPropertyValue("FillTransparence", css::uno::Any(static_cast<sal_Int16>(0))); + if (sRedactionStyle == "White") + { + xPropSet->setPropertyValue("FillColor", css::uno::Any(COL_WHITE)); + xPropSet->setPropertyValue("LineStyle", css::uno::Any(css::drawing::LineStyle::LineStyle_SOLID)); + xPropSet->setPropertyValue("LineColor", css::uno::Any(COL_BLACK)); + } + else + { + xPropSet->setPropertyValue("FillColor", css::uno::Any(COL_BLACK)); + xPropSet->setPropertyValue("LineStyle", css::uno::Any(css::drawing::LineStyle::LineStyle_NONE)); + } + } + // Freeform redaction + else if (sShapeName == "FreeformRedactionShape" + && xInfo->hasPropertyByName("LineTransparence") && xInfo->hasPropertyByName("LineColor")) + { + xPropSet->setPropertyValue("LineTransparence", css::uno::Any(static_cast<sal_Int16>(0))); + + if (sRedactionStyle == "White") + { + xPropSet->setPropertyValue("LineColor", css::uno::Any(COL_WHITE)); + } + else + { + xPropSet->setPropertyValue("LineColor", css::uno::Any(COL_BLACK)); + } + } + } + } + } + } + [[fallthrough]]; + case SID_EXPORTDOCASPDF: + bIsPDFExport = true; + [[fallthrough]]; + case SID_EXPORTDOCASEPUB: + case SID_DIRECTEXPORTDOCASEPUB: + case SID_EXPORTDOC: + case SID_SAVEASDOC: + case SID_SAVEASREMOTE: + case SID_SAVEDOC: + { + // derived class may decide to abort this + if( !QuerySlotExecutable( nId ) ) + { + rReq.SetReturnValue( SfxBoolItem( 0, false ) ); + return; + } + + //!! detailed analysis of an error code + SfxObjectShellRef xLock( this ); + + // the model can not be closed till the end of this method + // if somebody tries to close it during this time the model will be closed + // at the end of the method + aModelGuard.Init_Impl( uno::Reference< util::XCloseable >( GetModel(), uno::UNO_QUERY ) ); + + ErrCode nErrorCode = ERRCODE_NONE; + + // by default versions should be preserved always except in case of an explicit + // SaveAs via GUI, so the flag must be set accordingly + pImpl->bPreserveVersions = (nId == SID_SAVEDOC); + try + { + SfxErrorContext aEc( ERRCTX_SFX_SAVEASDOC, GetTitle() ); // ??? + + if ( nId == SID_SAVEASDOC || nId == SID_SAVEASREMOTE ) + { + // in case of plugin mode the SaveAs operation means SaveTo + const SfxBoolItem* pViewOnlyItem = SfxItemSet::GetItem<SfxBoolItem>(GetMedium()->GetItemSet(), SID_VIEWONLY, false); + if ( pViewOnlyItem && pViewOnlyItem->GetValue() ) + rReq.AppendItem( SfxBoolItem( SID_SAVETO, true ) ); + } + + // TODO/LATER: do the following GUI related actions in standalone method + + // Introduce a status indicator for GUI operation + const SfxUnoAnyItem* pStatusIndicatorItem = rReq.GetArg<SfxUnoAnyItem>(SID_PROGRESS_STATUSBAR_CONTROL); + if ( !pStatusIndicatorItem ) + { + // get statusindicator + uno::Reference< task::XStatusIndicator > xStatusIndicator; + uno::Reference < frame::XController > xCtrl( GetModel()->getCurrentController() ); + if ( xCtrl.is() ) + { + uno::Reference< task::XStatusIndicatorFactory > xStatFactory( xCtrl->getFrame(), uno::UNO_QUERY ); + if( xStatFactory.is() ) + xStatusIndicator = xStatFactory->createStatusIndicator(); + } + + OSL_ENSURE( xStatusIndicator.is(), "Can not retrieve default status indicator!" ); + + if ( xStatusIndicator.is() ) + { + SfxUnoAnyItem aStatIndItem( SID_PROGRESS_STATUSBAR_CONTROL, uno::Any( xStatusIndicator ) ); + + if ( nId == SID_SAVEDOC ) + { + // in case of saving it is not possible to transport the parameters from here + // but it is not clear here whether the saving will be done or saveAs operation + GetMedium()->GetItemSet()->Put( aStatIndItem ); + } + + rReq.AppendItem( aStatIndItem ); + } + } + else if ( nId == SID_SAVEDOC ) + { + // in case of saving it is not possible to transport the parameters from here + // but it is not clear here whether the saving will be done or saveAs operation + GetMedium()->GetItemSet()->Put( *pStatusIndicatorItem ); + } + + // Introduce an interaction handler for GUI operation + const SfxUnoAnyItem* pInteractionHandlerItem = rReq.GetArg<SfxUnoAnyItem>(SID_INTERACTIONHANDLER); + if ( !pInteractionHandlerItem ) + { + uno::Reference<css::awt::XWindow> xParentWindow; + uno::Reference<frame::XController> xCtrl(GetModel()->getCurrentController()); + if (xCtrl.is()) + xParentWindow = xCtrl->getFrame()->getContainerWindow(); + + uno::Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext(); + + uno::Reference< task::XInteractionHandler2 > xInteract( + task::InteractionHandler::createWithParent(xContext, xParentWindow) ); + + SfxUnoAnyItem aInteractionItem( SID_INTERACTIONHANDLER, uno::Any( xInteract ) ); + if ( nId == SID_SAVEDOC ) + { + // in case of saving it is not possible to transport the parameters from here + // but it is not clear here whether the saving will be done or saveAs operation + GetMedium()->GetItemSet()->Put( aInteractionItem ); + } + + rReq.AppendItem( aInteractionItem ); + } + else if ( nId == SID_SAVEDOC ) + { + // in case of saving it is not possible to transport the parameters from here + // but it is not clear here whether the saving will be done or saveAs operation + GetMedium()->GetItemSet()->Put( *pInteractionHandlerItem ); + } + + + const SfxStringItem* pOldPasswordItem = SfxItemSet::GetItem<SfxStringItem>(GetMedium()->GetItemSet(), SID_PASSWORD, false); + const SfxUnoAnyItem* pOldEncryptionDataItem = SfxItemSet::GetItem<SfxUnoAnyItem>(GetMedium()->GetItemSet(), SID_ENCRYPTIONDATA, false); + bool bPreselectPassword = (pOldPasswordItem && pOldEncryptionDataItem); + + uno::Sequence< beans::PropertyValue > aDispatchArgs; + if ( rReq.GetArgs() ) + TransformItems( nId, + *rReq.GetArgs(), + aDispatchArgs ); + + bool bForceSaveAs = nId == SID_SAVEDOC && IsReadOnlyMedium(); + const SfxSlot* pSlot = GetModule()->GetSlotPool()->GetSlot( bForceSaveAs ? SID_SAVEASDOC : nId ); + if ( !pSlot ) + throw uno::Exception("no slot", nullptr); + + SfxStoringHelper aHelper; + + if ( QueryHiddenInformation( bIsPDFExport ? HiddenWarningFact::WhenCreatingPDF : HiddenWarningFact::WhenSaving, nullptr ) != RET_YES ) + { + // the user has decided not to store the document + throw task::ErrorCodeIOException( + "SfxObjectShell::ExecFile_Impl: ERRCODE_IO_ABORT", + uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_IO_ABORT)); + } + + aHelper.GUIStoreModel( GetModel(), + OUString::createFromAscii( pSlot->GetUnoName() ), + aDispatchArgs, + bPreselectPassword, + GetDocumentSignatureState() ); + + + // merge aDispatchArgs to the request + SfxAllItemSet aResultParams( GetPool() ); + TransformParameters( nId, + aDispatchArgs, + aResultParams ); + rReq.SetArgs( aResultParams ); + + // the StoreAsURL/StoreToURL method have called this method with false + // so it has to be restored to true here since it is a call from GUI + GetMedium()->SetUpdatePickList( true ); + + // TODO: in future it must be done in following way + // if document is opened from GUI, it immediately appears in the picklist + // if the document is a new one then it appears in the picklist immediately + // after SaveAs operation triggered from GUI + } + catch( const task::ErrorCodeIOException& aErrorEx ) + { + TOOLS_WARN_EXCEPTION( "sfx.doc", "Fatal IO error during save"); + nErrorCode = ErrCode(aErrorEx.ErrCode); + } + catch( Exception& ) + { + nErrorCode = ERRCODE_IO_GENERAL; + } + + // by default versions should be preserved always except in case of an explicit + // SaveAs via GUI, so the flag must be reset to guarantee this + pImpl->bPreserveVersions = true; + ErrCode lErr=GetErrorCode(); + + if ( !lErr && nErrorCode ) + lErr = nErrorCode; + + if ( lErr && nErrorCode == ERRCODE_NONE ) + { + const SfxBoolItem* pWarnItem = rReq.GetArg<SfxBoolItem>(SID_FAIL_ON_WARNING); + if ( pWarnItem && pWarnItem->GetValue() ) + nErrorCode = lErr; + } + + // may be nErrorCode should be shown in future + if ( lErr != ERRCODE_IO_ABORT ) + { + if (comphelper::LibreOfficeKit::isActive()) + sendErrorToLOK(lErr); + else + { + SfxErrorContext aEc(ERRCTX_SFX_SAVEASDOC,GetTitle()); + ErrorHandler::HandleError(lErr, pDialogParent); + } + } + + if (nId == SID_DIRECTEXPORTDOCASPDF && + SfxRedactionHelper::isRedactMode(rReq)) + { + // Return the finalized redaction shapes back to normal (gray & transparent) + uno::Reference< lang::XComponent > xComponent( GetCurrentComponent(), uno::UNO_QUERY ); + if (!xComponent.is()) + return; + + uno::Reference< lang::XServiceInfo > xServiceInfo( xComponent, uno::UNO_QUERY); + + // Redaction finalization takes place in Draw + if ( xServiceInfo.is() && xServiceInfo->supportsService("com.sun.star.drawing.DrawingDocument") ) + { + // Access the draw pages + uno::Reference<drawing::XDrawPagesSupplier> xDrawPagesSupplier(xComponent, uno::UNO_QUERY); + uno::Reference<drawing::XDrawPages> xDrawPages = xDrawPagesSupplier->getDrawPages(); + + sal_Int32 nPageCount = xDrawPages->getCount(); + for (sal_Int32 nPageNum = 0; nPageNum < nPageCount; ++nPageNum) + { + // Get the page + uno::Reference< drawing::XDrawPage > xPage( xDrawPages->getByIndex( nPageNum ), uno::UNO_QUERY ); + + if (!xPage.is()) + continue; + + // Go through all shapes + sal_Int32 nShapeCount = xPage->getCount(); + for (sal_Int32 nShapeNum = 0; nShapeNum < nShapeCount; ++nShapeNum) + { + uno::Reference< drawing::XShape > xCurrShape(xPage->getByIndex(nShapeNum), uno::UNO_QUERY); + if (!xCurrShape.is()) + continue; + + uno::Reference< beans::XPropertySet > xPropSet(xCurrShape, uno::UNO_QUERY); + if (!xPropSet.is()) + continue; + + uno::Reference< beans::XPropertySetInfo> xInfo = xPropSet->getPropertySetInfo(); + if (!xInfo.is()) + continue; + + // Not a shape we converted? + if (!xInfo->hasPropertyByName("Name")) + continue; + + OUString sShapeName; + if (xInfo->hasPropertyByName("Name")) + { + uno::Any aAnyShapeName = xPropSet->getPropertyValue("Name"); + aAnyShapeName >>= sShapeName; + } + else + continue; + + // Rectangle redaction + if (sShapeName == "RectangleRedactionShape" + && xInfo->hasPropertyByName("FillTransparence") && xInfo->hasPropertyByName("FillColor")) + { + xPropSet->setPropertyValue("FillTransparence", css::uno::Any(static_cast<sal_Int16>(50))); + xPropSet->setPropertyValue("FillColor", css::uno::Any(COL_GRAY7)); + xPropSet->setPropertyValue("LineStyle", css::uno::Any(css::drawing::LineStyle::LineStyle_NONE)); + + } + // Freeform redaction + else if (sShapeName == "FreeformRedactionShape") + { + xPropSet->setPropertyValue("LineTransparence", css::uno::Any(static_cast<sal_Int16>(50))); + xPropSet->setPropertyValue("LineColor", css::uno::Any(COL_GRAY7)); + } + } + } + + + } + } + + if ( nId == SID_EXPORTDOCASPDF ) + { + // This function is used by the SendMail function that needs information if an export + // file was written or not. This could be due to cancellation of the export + // or due to an error. So IO abort must be handled like an error! + nErrorCode = ( lErr != ERRCODE_IO_ABORT ) && ( nErrorCode == ERRCODE_NONE ) ? nErrorCode : lErr; + } + + if ( ( nId == SID_SAVEASDOC || nId == SID_SAVEASREMOTE ) && nErrorCode == ERRCODE_NONE ) + { + const SfxBoolItem* saveTo = rReq.GetArg<SfxBoolItem>(SID_SAVETO); + if (saveTo == nullptr || !saveTo->GetValue()) + { + SfxViewFrame *pFrame = GetFrame(); + if (pFrame) + pFrame->RemoveInfoBar(u"readonly"); + SetReadOnlyUI(false); + } + } + + rReq.SetReturnValue( SfxBoolItem(0, nErrorCode == ERRCODE_NONE ) ); + + ResetError(); + + Invalidate(); + break; + } + + case SID_SAVEACOPY: + { + SfxAllItemSet aArgs( GetPool() ); + aArgs.Put( SfxBoolItem( SID_SAVEACOPYITEM, true ) ); + SfxRequest aSaveACopyReq( SID_EXPORTDOC, SfxCallMode::API, aArgs ); + ExecFile_Impl( aSaveACopyReq ); + if ( !aSaveACopyReq.IsDone() ) + { + rReq.Ignore(); + return; + } + break; + } + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + case SID_CLOSEDOC: + { + // Evaluate Parameter + const SfxBoolItem* pSaveItem = rReq.GetArg<SfxBoolItem>(SID_CLOSEDOC_SAVE); + const SfxStringItem* pNameItem = rReq.GetArg<SfxStringItem>(SID_CLOSEDOC_FILENAME); + if ( pSaveItem ) + { + if ( pSaveItem->GetValue() ) + { + if ( !pNameItem ) + { +#if HAVE_FEATURE_SCRIPTING + SbxBase::SetError( ERRCODE_BASIC_WRONG_ARGS ); +#endif + rReq.Ignore(); + return; + } + SfxAllItemSet aArgs( GetPool() ); + SfxStringItem aTmpItem( SID_FILE_NAME, pNameItem->GetValue() ); + aArgs.Put( aTmpItem, aTmpItem.Which() ); + SfxRequest aSaveAsReq( SID_SAVEASDOC, SfxCallMode::API, aArgs ); + ExecFile_Impl( aSaveAsReq ); + if ( !aSaveAsReq.IsDone() ) + { + rReq.Ignore(); + return; + } + } + else + SetModified(false); + } + + // Cancelled by the user? + if (!PrepareClose()) + { + rReq.SetReturnValue( SfxBoolItem(0, false) ); + rReq.Done(); + return; + } + + SetModified( false ); + ErrCode lErr = GetErrorCode(); + + if (comphelper::LibreOfficeKit::isActive()) + sendErrorToLOK(lErr); + else + ErrorHandler::HandleError(lErr, pDialogParent); + + rReq.SetReturnValue( SfxBoolItem(0, true) ); + rReq.Done(); + rReq.ReleaseArgs(); // because the pool is destroyed in Close + DoClose(); + return; + } + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + case SID_DOCTEMPLATE: + { + // save as document templates + SfxSaveAsTemplateDialog aDlg(pDialogParent, GetModel()); + (void)aDlg.run(); + break; + } + + case SID_CHECKOUT: + { + CheckOut( ); + break; + } + case SID_CANCELCHECKOUT: + { + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(nullptr, + VclMessageType::Question, VclButtonsType::YesNo, SfxResId(STR_QUERY_CANCELCHECKOUT))); + if (xBox->run() == RET_YES) + { + CancelCheckOut( ); + + // Reload the document as we may still have local changes + SfxViewFrame *pFrame = GetFrame(); + if ( pFrame ) + pFrame->GetDispatcher()->Execute(SID_RELOAD); + } + break; + } + case SID_CHECKIN: + { + CheckIn( ); + break; + } + } + + // Prevent entry in the Pick-lists + if ( rReq.IsAPI() ) + GetMedium()->SetUpdatePickList( false ); + + // Ignore()-branches have already returned + rReq.Done(); +} + + +void SfxObjectShell::GetState_Impl(SfxItemSet &rSet) +{ + SfxWhichIter aIter( rSet ); + + for ( sal_uInt16 nWhich = aIter.FirstWhich(); nWhich; nWhich = aIter.NextWhich() ) + { + switch ( nWhich ) + { + case SID_DOCTEMPLATE : + { + if ( isExportLocked()) + rSet.DisableItem( nWhich ); + break; + } + + case SID_CHECKOUT: + { + bool bShow = false; + Reference< XCmisDocument > xCmisDoc( GetModel(), uno::UNO_QUERY ); + const uno::Sequence< document::CmisProperty> aCmisProperties = xCmisDoc->getCmisProperties(); + + if ( xCmisDoc->isVersionable( ) && aCmisProperties.hasElements( ) ) + { + // Loop over the CMIS Properties to find cmis:isVersionSeriesCheckedOut + bool bIsGoogleFile = false; + bool bCheckedOut = false; + for ( const auto& rCmisProperty : aCmisProperties ) + { + if ( rCmisProperty.Id == "cmis:isVersionSeriesCheckedOut" ) + { + uno::Sequence< sal_Bool > bTmp; + rCmisProperty.Value >>= bTmp; + bCheckedOut = bTmp[0]; + } + // using title to know if it's a Google Drive file + // maybe there's a safer way. + if ( rCmisProperty.Name == "title" ) + bIsGoogleFile = true; + } + bShow = !bCheckedOut && !bIsGoogleFile; + } + + if ( !bShow ) + { + rSet.DisableItem( nWhich ); + rSet.Put( SfxVisibilityItem( nWhich, false ) ); + } + } + break; + + case SID_CANCELCHECKOUT: + case SID_CHECKIN: + { + bool bShow = false; + Reference< XCmisDocument > xCmisDoc( GetModel(), uno::UNO_QUERY ); + const uno::Sequence< document::CmisProperty> aCmisProperties = xCmisDoc->getCmisProperties( ); + + if ( xCmisDoc->isVersionable( ) && aCmisProperties.hasElements( ) ) + { + // Loop over the CMIS Properties to find cmis:isVersionSeriesCheckedOut + bool bCheckedOut = false; + auto pProp = std::find_if(aCmisProperties.begin(), aCmisProperties.end(), + [](const document::CmisProperty& rProp) { return rProp.Id == "cmis:isVersionSeriesCheckedOut"; }); + if (pProp != aCmisProperties.end()) + { + uno::Sequence< sal_Bool > bTmp; + pProp->Value >>= bTmp; + bCheckedOut = bTmp[0]; + } + bShow = bCheckedOut; + } + + if ( !bShow ) + { + rSet.DisableItem( nWhich ); + rSet.Put( SfxVisibilityItem( nWhich, false ) ); + } + } + break; + + case SID_VERSION: + { + SfxObjectShell *pDoc = this; + SfxViewFrame* pFrame = GetFrame(); + if ( !pFrame ) + pFrame = SfxViewFrame::GetFirst( this ); + + if ( !pFrame || !pDoc->HasName() || + !IsOwnStorageFormat( *pDoc->GetMedium() ) ) + rSet.DisableItem( nWhich ); + break; + } + case SID_SAVEDOC: + { + if ( IsReadOnly() || isSaveLocked()) + { + rSet.DisableItem(nWhich); + break; + } + rSet.Put(SfxStringItem(nWhich, SfxResId(STR_SAVEDOC))); + } + break; + + case SID_DOCINFO: + break; + + case SID_CLOSEDOC: + { + rSet.Put(SfxStringItem(nWhich, SfxResId(STR_CLOSEDOC))); + break; + } + + case SID_SAVEASDOC: + { + if (!(pImpl->nLoadedFlags & SfxLoadedFlags::MAINDOCUMENT) + || isExportLocked()) + { + rSet.DisableItem( nWhich ); + break; + } + if ( /*!pCombinedFilters ||*/ !GetMedium() ) + rSet.DisableItem( nWhich ); + else + rSet.Put( SfxStringItem( nWhich, SfxResId(STR_SAVEASDOC) ) ); + break; + } + + case SID_SAVEACOPY: + { + if (!(pImpl->nLoadedFlags & SfxLoadedFlags::MAINDOCUMENT) || isExportLocked()) + { + rSet.DisableItem( nWhich ); + break; + } + if ( /*!pCombinedFilters ||*/ !GetMedium() ) + rSet.DisableItem( nWhich ); + else + rSet.Put( SfxStringItem( nWhich, SfxResId(STR_SAVEACOPY) ) ); + break; + } + + case SID_EXPORTDOC: + case SID_EXPORTDOCASPDF: + case SID_DIRECTEXPORTDOCASPDF: + case SID_EXPORTDOCASEPUB: + case SID_DIRECTEXPORTDOCASEPUB: + case SID_REDACTDOC: + case SID_AUTOREDACTDOC: + case SID_SAVEASREMOTE: + { + if (isExportLocked()) + rSet.DisableItem( nWhich ); + break; + } + + case SID_DOC_MODIFIED: + { + rSet.Put( SfxBoolItem( SID_DOC_MODIFIED, IsModified() ) ); + break; + } + + case SID_MODIFIED: + { + rSet.Put( SfxBoolItem( SID_MODIFIED, IsModified() ) ); + break; + } + + case SID_DOCINFO_TITLE: + { + rSet.Put( SfxStringItem( + SID_DOCINFO_TITLE, getDocProperties()->getTitle() ) ); + break; + } + case SID_FILE_NAME: + { + if( GetMedium() && HasName() ) + rSet.Put( SfxStringItem( + SID_FILE_NAME, GetMedium()->GetName() ) ); + break; + } + case SID_SIGNATURE: + { + SfxViewFrame *pFrame = SfxViewFrame::GetFirst(this); + if ( pFrame ) + { + SignatureState eState = GetDocumentSignatureState(); + InfobarType aInfobarType(InfobarType::INFO); + OUString sMessage(""); + + switch (eState) + { + case SignatureState::BROKEN: + sMessage = SfxResId(STR_SIGNATURE_BROKEN); + aInfobarType = InfobarType::DANGER; + break; + case SignatureState::INVALID: + sMessage = SfxResId(STR_SIGNATURE_INVALID); + // Warning only, I've tried Danger and it looked too scary + aInfobarType = InfobarType::WARNING; + break; + case SignatureState::NOTVALIDATED: + sMessage = SfxResId(STR_SIGNATURE_NOTVALIDATED); + aInfobarType = InfobarType::WARNING; + break; + case SignatureState::PARTIAL_OK: + sMessage = SfxResId(STR_SIGNATURE_PARTIAL_OK); + aInfobarType = InfobarType::WARNING; + break; + case SignatureState::OK: + sMessage = SfxResId(STR_SIGNATURE_OK); + aInfobarType = InfobarType::INFO; + break; + case SignatureState::NOTVALIDATED_PARTIAL_OK: + sMessage = SfxResId(STR_SIGNATURE_NOTVALIDATED_PARTIAL_OK); + aInfobarType = InfobarType::WARNING; + break; + //FIXME SignatureState::Unknown, own message? + default: + break; + } + + // new info bar + if ( !pFrame->HasInfoBarWithID(u"signature") ) + { + if ( !sMessage.isEmpty() ) + { + auto pInfoBar = pFrame->AppendInfoBar("signature", "", sMessage, aInfobarType); + if (pInfoBar == nullptr || pInfoBar->isDisposed()) + return; + weld::Button& rBtn = pInfoBar->addButton(); + rBtn.set_label(SfxResId(STR_SIGNATURE_SHOW)); + rBtn.connect_clicked(LINK(this, SfxObjectShell, SignDocumentHandler)); + } + } + else // info bar exists already + { + if ( eState == SignatureState::NOSIGNATURES ) + pFrame->RemoveInfoBar(u"signature"); + else + pFrame->UpdateInfoBar(u"signature", "", sMessage, aInfobarType); + } + } + + rSet.Put( SfxUInt16Item( SID_SIGNATURE, static_cast<sal_uInt16>(GetDocumentSignatureState()) ) ); + break; + } + case SID_MACRO_SIGNATURE: + { + // the slot makes sense only if there is a macro in the document + if ( pImpl->documentStorageHasMacros() || pImpl->aMacroMode.hasMacroLibrary() ) + rSet.Put( SfxUInt16Item( SID_MACRO_SIGNATURE, static_cast<sal_uInt16>(GetScriptingSignatureState()) ) ); + else + rSet.DisableItem( nWhich ); + break; + } + case SID_DOC_REPAIR: + { + SfxUndoManager* pIUndoMgr = GetUndoManager(); + if (pIUndoMgr) + rSet.Put( SfxBoolItem(nWhich, pIUndoMgr->IsEmptyActions()) ); + else + rSet.DisableItem( nWhich ); + break; + } + } + } +} + +IMPL_LINK_NOARG(SfxObjectShell, SignDocumentHandler, weld::Button&, void) +{ + SfxViewFrame* pViewFrm = SfxViewFrame::GetFirst(this); + if (!pViewFrm) + { + SAL_WARN("sfx.appl", "There should be some SfxViewFrame associated here"); + return; + } + SfxUnoFrameItem aDocFrame(SID_FILLFRAME, pViewFrm->GetFrame().GetFrameInterface()); + pViewFrm->GetDispatcher()->ExecuteList(SID_SIGNATURE, SfxCallMode::SLOT, {}, { &aDocFrame }); +} + +void SfxObjectShell::ExecProps_Impl(SfxRequest &rReq) +{ + switch ( rReq.GetSlot() ) + { + case SID_MODIFIED: + { + SetModified( rReq.GetArgs()->Get(SID_MODIFIED).GetValue() ); + rReq.Done(); + break; + } + + case SID_DOCTITLE: + SetTitle( rReq.GetArgs()->Get(SID_DOCTITLE).GetValue() ); + rReq.Done(); + break; + + case SID_DOCINFO_AUTHOR : + getDocProperties()->setAuthor( static_cast<const SfxStringItem&>(rReq.GetArgs()->Get(rReq.GetSlot())).GetValue() ); + break; + + case SID_DOCINFO_COMMENTS : + getDocProperties()->setDescription( static_cast<const SfxStringItem&>(rReq.GetArgs()->Get(rReq.GetSlot())).GetValue() ); + break; + + case SID_DOCINFO_KEYWORDS : + { + const OUString aStr = static_cast<const SfxStringItem&>(rReq.GetArgs()->Get(rReq.GetSlot())).GetValue(); + getDocProperties()->setKeywords( + ::comphelper::string::convertCommaSeparated(aStr) ); + break; + } + } +} + + +void SfxObjectShell::StateProps_Impl(SfxItemSet &rSet) +{ + SfxWhichIter aIter(rSet); + for ( sal_uInt16 nSID = aIter.FirstWhich(); nSID; nSID = aIter.NextWhich() ) + { + switch ( nSID ) + { + case SID_DOCINFO_AUTHOR : + { + rSet.Put( SfxStringItem( nSID, + getDocProperties()->getAuthor() ) ); + break; + } + + case SID_DOCINFO_COMMENTS : + { + rSet.Put( SfxStringItem( nSID, + getDocProperties()->getDescription()) ); + break; + } + + case SID_DOCINFO_KEYWORDS : + { + rSet.Put( SfxStringItem( nSID, ::comphelper::string:: + convertCommaSeparated(getDocProperties()->getKeywords())) ); + break; + } + + case SID_DOCPATH: + { + OSL_FAIL( "Not supported anymore!" ); + break; + } + + case SID_DOCFULLNAME: + { + rSet.Put( SfxStringItem( SID_DOCFULLNAME, GetTitle(SFX_TITLE_FULLNAME) ) ); + break; + } + + case SID_DOCTITLE: + { + rSet.Put( SfxStringItem( SID_DOCTITLE, GetTitle() ) ); + break; + } + + case SID_DOC_READONLY: + { + rSet.Put( SfxBoolItem( SID_DOC_READONLY, IsReadOnly() ) ); + break; + } + + case SID_DOC_SAVED: + { + rSet.Put( SfxBoolItem( SID_DOC_SAVED, !IsModified() ) ); + break; + } + + case SID_CLOSING: + { + rSet.Put( SfxBoolItem( SID_CLOSING, false ) ); + break; + } + + case SID_DOC_LOADING: + rSet.Put( SfxBoolItem( nSID, ! ( pImpl->nLoadedFlags & SfxLoadedFlags::MAINDOCUMENT ) ) ); + break; + + case SID_IMG_LOADING: + rSet.Put( SfxBoolItem( nSID, ! ( pImpl->nLoadedFlags & SfxLoadedFlags::IMAGES ) ) ); + break; + } + } +} + + +void SfxObjectShell::ExecView_Impl(SfxRequest &rReq) +{ + switch ( rReq.GetSlot() ) + { + case SID_ACTIVATE: + { + SfxViewFrame *pFrame = SfxViewFrame::GetFirst( this ); + if ( pFrame ) + pFrame->GetFrame().Appear(); + rReq.SetReturnValue( SfxObjectItem( 0, pFrame ) ); + rReq.Done(); + break; + } + } +} + + +void SfxObjectShell::StateView_Impl(SfxItemSet& /*rSet*/) +{ +} + +/// Does this ZIP storage have a signature stream? +static bool HasSignatureStream(const uno::Reference<embed::XStorage>& xStorage) +{ + if (!xStorage.is()) + return false; + + if (xStorage->hasByName("META-INF")) + { + // ODF case. + try + { + uno::Reference<embed::XStorage> xMetaInf + = xStorage->openStorageElement("META-INF", embed::ElementModes::READ); + if (xMetaInf.is()) + { + return xMetaInf->hasByName("documentsignatures.xml") + || xMetaInf->hasByName("macrosignatures.xml") + || xMetaInf->hasByName("packagesignatures.xml"); + } + } + catch (const css::io::IOException&) + { + TOOLS_WARN_EXCEPTION("sfx.doc", "HasSignatureStream: failed to open META-INF"); + } + } + + // OOXML case. + return xStorage->hasByName("_xmlsignatures"); +} + +uno::Sequence< security::DocumentSignatureInformation > SfxObjectShell::GetDocumentSignatureInformation( bool bScriptingContent, const uno::Reference< security::XDocumentDigitalSignatures >& xSigner ) +{ + uno::Sequence< security::DocumentSignatureInformation > aResult; + uno::Reference< security::XDocumentDigitalSignatures > xLocSigner = xSigner; + + bool bSupportsSigning = GetMedium() && GetMedium()->GetFilter() && GetMedium()->GetFilter()->GetSupportsSigning(); + if (GetMedium() && !GetMedium()->GetName().isEmpty() && ((IsOwnStorageFormat(*GetMedium()) && GetMedium()->GetStorage().is()) || bSupportsSigning)) + { + try + { + if ( !xLocSigner.is() ) + { + OUString aVersion; + try + { + uno::Reference < beans::XPropertySet > xPropSet( GetStorage(), uno::UNO_QUERY_THROW ); + xPropSet->getPropertyValue("Version") >>= aVersion; + } + catch( uno::Exception& ) + { + } + + xLocSigner.set( security::DocumentDigitalSignatures::createWithVersion(comphelper::getProcessComponentContext(), aVersion) ); + + } + + if ( bScriptingContent ) + aResult = xLocSigner->verifyScriptingContentSignatures( GetMedium()->GetZipStorageToSign_Impl(), + uno::Reference< io::XInputStream >() ); + else + { + if (GetMedium()->GetStorage(false).is()) + { + // Something ZIP-based. + // Only call into xmlsecurity if we see a signature stream, + // as libxmlsec init is expensive. + if (HasSignatureStream(GetMedium()->GetZipStorageToSign_Impl())) + aResult = xLocSigner->verifyDocumentContentSignatures( GetMedium()->GetZipStorageToSign_Impl(), + uno::Reference< io::XInputStream >() ); + } + else + { + // Not ZIP-based, e.g. PDF. + + // Create temp file if needed. + GetMedium()->CreateTempFile(/*bReplace=*/false); + + std::unique_ptr<SvStream> pStream(utl::UcbStreamHelper::CreateStream(GetMedium()->GetName(), StreamMode::READ)); + uno::Reference<io::XStream> xStream(new utl::OStreamWrapper(*pStream)); + uno::Reference<io::XInputStream> xInputStream(xStream, uno::UNO_QUERY); + aResult = xLocSigner->verifyDocumentContentSignatures(uno::Reference<embed::XStorage>(), xInputStream); + } + } + } + catch( css::uno::Exception& ) + { + TOOLS_WARN_EXCEPTION("sfx.doc", "Failed to get document signature information"); + } + } + + return aResult; +} + +SignatureState SfxObjectShell::ImplGetSignatureState( bool bScriptingContent ) +{ + SignatureState* pState = bScriptingContent ? &pImpl->nScriptingSignatureState : &pImpl->nDocumentSignatureState; + + if ( *pState == SignatureState::UNKNOWN ) + { + *pState = SignatureState::NOSIGNATURES; + + uno::Sequence< security::DocumentSignatureInformation > aInfos = GetDocumentSignatureInformation( bScriptingContent ); + *pState = DocumentSignatures::getSignatureState(aInfos); + } + + if ( *pState == SignatureState::OK || *pState == SignatureState::NOTVALIDATED + || *pState == SignatureState::PARTIAL_OK) + { + if ( IsModified() ) + *pState = SignatureState::INVALID; + } + + return *pState; +} + +bool SfxObjectShell::PrepareForSigning(weld::Window* pDialogParent) +{ + // check whether the document is signed + ImplGetSignatureState(); // document signature + if (GetMedium() && GetMedium()->GetFilter() && GetMedium()->GetFilter()->IsOwnFormat()) + ImplGetSignatureState( true ); // script signature + bool bHasSign = ( pImpl->nScriptingSignatureState != SignatureState::NOSIGNATURES || pImpl->nDocumentSignatureState != SignatureState::NOSIGNATURES ); + + // the target ODF version on saving (only valid when signing ODF of course) + SvtSaveOptions::ODFSaneDefaultVersion nVersion = GetODFSaneDefaultVersion(); + + // the document is not new and is not modified + OUString aODFVersion(comphelper::OStorageHelper::GetODFVersionFromStorage(GetStorage())); + + if ( IsModified() || !GetMedium() || GetMedium()->GetName().isEmpty() + || (GetMedium()->GetFilter()->IsOwnFormat() && aODFVersion.compareTo(ODFVER_012_TEXT) < 0 && !bHasSign)) + { + // the document might need saving ( new, modified or in ODF1.1 format without signature ) + + if (nVersion >= SvtSaveOptions::ODFSVER_012) + { + OUString sQuestion(bHasSign ? SfxResId(STR_XMLSEC_QUERY_SAVESIGNEDBEFORESIGN) : SfxResId(RID_SVXSTR_XMLSEC_QUERY_SAVEBEFORESIGN)); + std::unique_ptr<weld::MessageDialog> xQuestion(Application::CreateMessageDialog(pDialogParent, + VclMessageType::Question, VclButtonsType::YesNo, sQuestion)); + + + if (xQuestion->run() == RET_YES) + { + sal_uInt16 nId = SID_SAVEDOC; + if ( !GetMedium() || GetMedium()->GetName().isEmpty() ) + nId = SID_SAVEASDOC; + SfxRequest aSaveRequest( nId, SfxCallMode::SLOT, GetPool() ); + //ToDo: Review. We needed to call SetModified, otherwise the document would not be saved. + SetModified(); + ExecFile_Impl( aSaveRequest ); + + // Check if it is stored a format which supports signing + if (GetMedium() && GetMedium()->GetFilter() && !GetMedium()->GetName().isEmpty() + && ((!GetMedium()->GetFilter()->IsOwnFormat() + && !GetMedium()->GetFilter()->GetSupportsSigning()) + || (GetMedium()->GetFilter()->IsOwnFormat() + && !GetMedium()->HasStorage_Impl()))) + { + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog( + pDialogParent, VclMessageType::Info, VclButtonsType::Ok, + SfxResId(STR_INFO_WRONGDOCFORMAT))); + + xBox->run(); + return false; + } + } + else + { + // When the document is modified then we must not show the + // digital signatures dialog + // If we have come here then the user denied to save. + if (!bHasSign) + return false; + } + } + else + { + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(pDialogParent, + VclMessageType::Warning, VclButtonsType::Ok, SfxResId(STR_XMLSEC_ODF12_EXPECTED))); + xBox->run(); + return false; + } + + if ( IsModified() || !GetMedium() || GetMedium()->GetName().isEmpty() ) + return false; + } + + // the document is not modified currently, so it can not become modified after signing + pImpl->m_bAllowModifiedBackAfterSigning = false; + if ( IsEnableSetModified() ) + { + EnableSetModified( false ); + pImpl->m_bAllowModifiedBackAfterSigning = true; + } + + // we have to store to the original document, the original medium should be closed for this time + if ( ConnectTmpStorage_Impl( pMedium->GetStorage(), pMedium ) ) + { + GetMedium()->CloseAndRelease(); + return true; + } + return false; +} + +void SfxObjectShell::RecheckSignature(bool bAlsoRecheckScriptingSignature) +{ + if (bAlsoRecheckScriptingSignature) + pImpl->nScriptingSignatureState = SignatureState::UNKNOWN; // Re-Check + + pImpl->nDocumentSignatureState = SignatureState::UNKNOWN; // Re-Check + + Invalidate(SID_SIGNATURE); + Invalidate(SID_MACRO_SIGNATURE); + Broadcast(SfxHint(SfxHintId::TitleChanged)); +} + +void SfxObjectShell::AfterSigning(bool bSignSuccess, bool bSignScriptingContent) +{ + pImpl->m_bSavingForSigning = true; + DoSaveCompleted( GetMedium() ); + pImpl->m_bSavingForSigning = false; + + if ( bSignSuccess ) + RecheckSignature(bSignScriptingContent); + + if ( pImpl->m_bAllowModifiedBackAfterSigning ) + EnableSetModified(); +} + +bool SfxObjectShell::CheckIsReadonly(bool bSignScriptingContent, weld::Window* pDialogParent) +{ + // in LOK case we support only viewer / readonly mode so far + if (GetMedium()->IsOriginallyReadOnly() || comphelper::LibreOfficeKit::isActive()) + { + // If the file is physically read-only, we just show the existing signatures + try + { + OUString aODFVersion( + comphelper::OStorageHelper::GetODFVersionFromStorage(GetStorage())); + uno::Reference<security::XDocumentDigitalSignatures> xSigner( + security::DocumentDigitalSignatures::createWithVersionAndValidSignature( + comphelper::getProcessComponentContext(), aODFVersion, HasValidSignatures())); + + if (pDialogParent) + xSigner->setParentWindow(pDialogParent->GetXWindow()); + + if (bSignScriptingContent) + xSigner->showScriptingContentSignatures(GetMedium()->GetZipStorageToSign_Impl(), + uno::Reference<io::XInputStream>()); + else + { + uno::Reference<embed::XStorage> xStorage = GetMedium()->GetZipStorageToSign_Impl(); + if (xStorage.is()) + xSigner->showDocumentContentSignatures(xStorage, + uno::Reference<io::XInputStream>()); + else + { + std::unique_ptr<SvStream> pStream( + utl::UcbStreamHelper::CreateStream(GetName(), StreamMode::READ)); + + if (!pStream) + { + pStream = utl::UcbStreamHelper::CreateStream(GetMedium()->GetName(), StreamMode::READ); + + if (!pStream) + { + SAL_WARN( "sfx.doc", "Couldn't use signing functionality!" ); + return true; + } + } + + uno::Reference<io::XInputStream> xStream(new utl::OStreamWrapper(*pStream)); + xSigner->showDocumentContentSignatures(uno::Reference<embed::XStorage>(), + xStream); + } + } + } + catch (const uno::Exception&) + { + SAL_WARN("sfx.doc", "Couldn't use signing functionality!"); + } + return true; + } + return false; +} + +bool SfxObjectShell::HasValidSignatures() const +{ + return pImpl->nDocumentSignatureState == SignatureState::OK + || pImpl->nDocumentSignatureState == SignatureState::NOTVALIDATED + || pImpl->nDocumentSignatureState == SignatureState::PARTIAL_OK; +} + +SignatureState SfxObjectShell::GetDocumentSignatureState() +{ + return ImplGetSignatureState(); +} + +void SfxObjectShell::SignDocumentContent(weld::Window* pDialogParent) +{ + if (!PrepareForSigning(pDialogParent)) + return; + + if (CheckIsReadonly(false, pDialogParent)) + return; + + bool bSignSuccess = GetMedium()->SignContents_Impl(pDialogParent, false, HasValidSignatures()); + + AfterSigning(bSignSuccess, false); +} + +bool SfxObjectShell::SignDocumentContentUsingCertificate(const Reference<XCertificate>& xCertificate) +{ + // 1. PrepareForSigning + + // check whether the document is signed + ImplGetSignatureState(false); // document signature + if (GetMedium() && GetMedium()->GetFilter() && GetMedium()->GetFilter()->IsOwnFormat()) + ImplGetSignatureState( true ); // script signature + bool bHasSign = ( pImpl->nScriptingSignatureState != SignatureState::NOSIGNATURES || pImpl->nDocumentSignatureState != SignatureState::NOSIGNATURES ); + + // the target ODF version on saving (only valid when signing ODF of course) + SvtSaveOptions::ODFSaneDefaultVersion nVersion = GetODFSaneDefaultVersion(); + + // the document is not new and is not modified + OUString aODFVersion(comphelper::OStorageHelper::GetODFVersionFromStorage(GetStorage())); + + if (IsModified() || !GetMedium() || GetMedium()->GetName().isEmpty() + || (GetMedium()->GetFilter()->IsOwnFormat() && aODFVersion.compareTo(ODFVER_012_TEXT) < 0 && !bHasSign)) + { + if (nVersion >= SvtSaveOptions::ODFSVER_012) + { + sal_uInt16 nId = SID_SAVEDOC; + if ( !GetMedium() || GetMedium()->GetName().isEmpty() ) + nId = SID_SAVEASDOC; + SfxRequest aSaveRequest( nId, SfxCallMode::SLOT, GetPool() ); + //ToDo: Review. We needed to call SetModified, otherwise the document would not be saved. + SetModified(); + ExecFile_Impl( aSaveRequest ); + + // Check if it is stored a format which supports signing + if (GetMedium() && GetMedium()->GetFilter() && !GetMedium()->GetName().isEmpty() + && ((!GetMedium()->GetFilter()->IsOwnFormat() + && !GetMedium()->GetFilter()->GetSupportsSigning()) + || (GetMedium()->GetFilter()->IsOwnFormat() + && !GetMedium()->HasStorage_Impl()))) + { + return false; + } + } + else + { + return false; + } + + if ( IsModified() || !GetMedium() || GetMedium()->GetName().isEmpty() ) + return false; + } + + // the document is not modified currently, so it can not become modified after signing + pImpl->m_bAllowModifiedBackAfterSigning = false; + if ( IsEnableSetModified() ) + { + EnableSetModified( false ); + pImpl->m_bAllowModifiedBackAfterSigning = true; + } + + // we have to store to the original document, the original medium should be closed for this time + bool bResult = ConnectTmpStorage_Impl( pMedium->GetStorage(), pMedium); + + if (!bResult) + return false; + + GetMedium()->CloseAndRelease(); + + // 2. Check Read-Only + if (GetMedium()->IsOriginallyReadOnly()) + return false; + + // 3. Sign + bool bSignSuccess = GetMedium()->SignDocumentContentUsingCertificate( + GetBaseModel(), HasValidSignatures(), xCertificate); + + // 4. AfterSigning + AfterSigning(bSignSuccess, false); + + return true; +} + +void SfxObjectShell::SignSignatureLine(weld::Window* pDialogParent, + const OUString& aSignatureLineId, + const Reference<XCertificate>& xCert, + const Reference<XGraphic>& xValidGraphic, + const Reference<XGraphic>& xInvalidGraphic, + const OUString& aComment) +{ + if (!PrepareForSigning(pDialogParent)) + return; + + if (CheckIsReadonly(false, pDialogParent)) + return; + + bool bSignSuccess = GetMedium()->SignContents_Impl(pDialogParent, + false, HasValidSignatures(), aSignatureLineId, xCert, xValidGraphic, xInvalidGraphic, aComment); + + AfterSigning(bSignSuccess, false); + + // Reload the document to get the updated graphic + // FIXME: Update just the signature line graphic instead of reloading the document + SfxViewFrame *pFrame = GetFrame(); + if (pFrame) + pFrame->GetDispatcher()->Execute(SID_RELOAD); +} + +SignatureState SfxObjectShell::GetScriptingSignatureState() +{ + return ImplGetSignatureState( true ); +} + +void SfxObjectShell::SignScriptingContent(weld::Window* pDialogParent) +{ + if (!PrepareForSigning(pDialogParent)) + return; + + if (CheckIsReadonly(true, pDialogParent)) + return; + + bool bSignSuccess = GetMedium()->SignContents_Impl(pDialogParent, true, HasValidSignatures()); + + AfterSigning(bSignSuccess, true); +} + +const uno::Sequence<sal_Int8>& SfxObjectShell::getUnoTunnelId() +{ + static const comphelper::UnoIdInit theSfxObjectShellUnoTunnelId; + return theSfxObjectShellUnoTunnelId.getSeq(); +} + +uno::Sequence< beans::PropertyValue > SfxObjectShell::GetDocumentProtectionFromGrabBag() const +{ + uno::Reference<frame::XModel> xModel = GetBaseModel(); + + if (!xModel.is()) + { + return uno::Sequence< beans::PropertyValue>(); + } + + uno::Reference< beans::XPropertySet > xPropSet( xModel, uno::UNO_QUERY_THROW ); + uno::Reference< beans::XPropertySetInfo > xPropSetInfo = xPropSet->getPropertySetInfo(); + const OUString aGrabBagName = UNO_NAME_MISC_OBJ_INTEROPGRABBAG; + if ( xPropSetInfo->hasPropertyByName( aGrabBagName ) ) + { + uno::Sequence< beans::PropertyValue > propList; + xPropSet->getPropertyValue( aGrabBagName ) >>= propList; + for( const auto& rProp : std::as_const(propList) ) + { + if (rProp.Name == "DocumentProtection") + { + uno::Sequence< beans::PropertyValue > rAttributeList; + rProp.Value >>= rAttributeList; + return rAttributeList; + } + } + } + + return uno::Sequence< beans::PropertyValue>(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/objstor.cxx b/sfx2/source/doc/objstor.cxx new file mode 100644 index 000000000..288b6a7ae --- /dev/null +++ b/sfx2/source/doc/objstor.cxx @@ -0,0 +1,3791 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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 <config_features.h> + +#include <sal/config.h> +#include <sal/log.hxx> + +#include <cassert> + +#include <svl/eitem.hxx> +#include <svl/stritem.hxx> +#include <svl/intitem.hxx> +#include <com/sun/star/frame/theGlobalEventBroadcaster.hpp> +#include <com/sun/star/frame/XModel.hpp> +#include <com/sun/star/frame/XModule.hpp> +#include <com/sun/star/document/XFilter.hpp> +#include <com/sun/star/document/XImporter.hpp> +#include <com/sun/star/document/XExporter.hpp> +#include <com/sun/star/packages/zip/ZipIOException.hpp> +#include <com/sun/star/task/XInteractionHandler.hpp> +#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp> +#include <com/sun/star/document/MacroExecMode.hpp> +#include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp> +#include <com/sun/star/beans/XPropertySetInfo.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/beans/PropertyValue.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/container/XNameAccess.hpp> +#include <com/sun/star/embed/ElementModes.hpp> +#include <com/sun/star/embed/EmbedStates.hpp> +#include <com/sun/star/embed/XTransactedObject.hpp> +#include <com/sun/star/embed/XEmbeddedObject.hpp> +#include <com/sun/star/embed/XEmbedPersist.hpp> +#include <com/sun/star/embed/XOptimizedStorage.hpp> +#include <com/sun/star/embed/XEncryptionProtectedStorage.hpp> +#include <com/sun/star/io/WrongFormatException.hpp> +#include <com/sun/star/io/XTruncate.hpp> +#include <com/sun/star/util/XModifiable.hpp> +#include <com/sun/star/util/RevisionTag.hpp> +#include <com/sun/star/security/DocumentDigitalSignatures.hpp> +#include <com/sun/star/text/XTextRange.hpp> +#include <com/sun/star/xml/crypto/CipherID.hpp> +#include <com/sun/star/xml/crypto/DigestID.hpp> + +#include <com/sun/star/document/XDocumentProperties.hpp> +#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp> +#include <comphelper/fileformat.h> +#include <comphelper/processfactory.hxx> +#include <svtools/langtab.hxx> +#include <svtools/sfxecode.hxx> +#include <unotools/configmgr.hxx> +#include <unotools/streamwrap.hxx> + +#include <unotools/saveopt.hxx> +#include <unotools/useroptions.hxx> +#include <unotools/securityoptions.hxx> +#include <tools/urlobj.hxx> +#include <tools/diagnose_ex.h> +#include <unotools/ucbhelper.hxx> +#include <unotools/tempfile.hxx> +#include <unotools/docinfohelper.hxx> +#include <unotools/mediadescriptor.hxx> +#include <ucbhelper/content.hxx> +#include <sot/storage.hxx> +#include <sot/exchange.hxx> +#include <sot/formats.hxx> +#include <comphelper/storagehelper.hxx> +#include <comphelper/documentconstants.hxx> +#include <comphelper/string.hxx> +#include <vcl/errinf.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> +#include <basic/modsizeexceeded.hxx> +#include <officecfg/Office/Common.hxx> +#include <osl/file.hxx> +#include <comphelper/scopeguard.hxx> +#include <comphelper/lok.hxx> + +#include <sfx2/signaturestate.hxx> +#include <sfx2/app.hxx> +#include <sfx2/objsh.hxx> +#include <sfx2/sfxresid.hxx> +#include <sfx2/docfile.hxx> +#include <sfx2/fcontnr.hxx> +#include <sfx2/docfilt.hxx> +#include <sfx2/docfac.hxx> +#include <appopen.hxx> +#include <objshimp.hxx> +#include <sfx2/strings.hrc> +#include <sfx2/sfxsids.hrc> +#include <sfx2/dispatch.hxx> +#include <sfx2/sfxuno.hxx> +#include <sfx2/event.hxx> +#include <fltoptint.hxx> +#include <sfx2/viewfrm.hxx> +#include "graphhelp.hxx" +#include <appbaslib.hxx> +#include "objstor.hxx" +#include "exoticfileloadexception.hxx" + +using namespace ::com::sun::star; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::ui::dialogs; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::ucb; +using namespace ::com::sun::star::task; +using namespace ::com::sun::star::document; +using namespace ::cppu; + + +void impl_addToModelCollection(const css::uno::Reference< css::frame::XModel >& xModel) +{ + if (!xModel.is()) + return; + + css::uno::Reference< css::uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext(); + css::uno::Reference< css::frame::XGlobalEventBroadcaster > xModelCollection = + css::frame::theGlobalEventBroadcaster::get(xContext); + try + { + xModelCollection->insert(css::uno::Any(xModel)); + } + catch ( uno::Exception& ) + { + SAL_WARN( "sfx.doc", "The document seems to be in the collection already!" ); + } +} + + +bool SfxObjectShell::Save() +{ + SaveChildren(); + return true; +} + + +bool SfxObjectShell::SaveAs( SfxMedium& rMedium ) +{ + return SaveAsChildren( rMedium ); +} + + +bool SfxObjectShell::QuerySlotExecutable( sal_uInt16 /*nSlotId*/ ) +{ + return true; +} + + +bool GetEncryptionData_Impl( const SfxItemSet* pSet, uno::Sequence< beans::NamedValue >& o_rEncryptionData ) +{ + bool bResult = false; + if ( pSet ) + { + const SfxUnoAnyItem* pEncryptionDataItem = SfxItemSet::GetItem<SfxUnoAnyItem>(pSet, SID_ENCRYPTIONDATA, false); + if ( pEncryptionDataItem ) + { + pEncryptionDataItem->GetValue() >>= o_rEncryptionData; + bResult = true; + } + else + { + const SfxStringItem* pPasswordItem = SfxItemSet::GetItem<SfxStringItem>(pSet, SID_PASSWORD, false); + if ( pPasswordItem ) + { + o_rEncryptionData = ::comphelper::OStorageHelper::CreatePackageEncryptionData( pPasswordItem->GetValue() ); + bResult = true; + } + } + } + + return bResult; +} + + +bool SfxObjectShell::PutURLContentsToVersionStream_Impl( + const OUString& aURL, + const uno::Reference< embed::XStorage >& xDocStorage, + const OUString& aStreamName ) +{ + bool bResult = false; + try + { + uno::Reference< embed::XStorage > xVersion = xDocStorage->openStorageElement( + "Versions", + embed::ElementModes::READWRITE ); + + DBG_ASSERT( xVersion.is(), + "The method must throw an exception if the storage can not be opened!" ); + if ( !xVersion.is() ) + throw uno::RuntimeException(); + + uno::Reference< io::XStream > xVerStream = xVersion->openStreamElement( + aStreamName, + embed::ElementModes::READWRITE ); + DBG_ASSERT( xVerStream.is(), "The method must throw an exception if the storage can not be opened!" ); + if ( !xVerStream.is() ) + throw uno::RuntimeException(); + + uno::Reference< io::XOutputStream > xOutStream = xVerStream->getOutputStream(); + uno::Reference< io::XTruncate > xTrunc( xOutStream, uno::UNO_QUERY_THROW ); + + uno::Reference< io::XInputStream > xTmpInStream = + ::comphelper::OStorageHelper::GetInputStreamFromURL( + aURL, comphelper::getProcessComponentContext() ); + assert( xTmpInStream.is() ); + + xTrunc->truncate(); + ::comphelper::OStorageHelper::CopyInputToOutput( xTmpInStream, xOutStream ); + xOutStream->closeOutput(); + + uno::Reference< embed::XTransactedObject > xTransact( xVersion, uno::UNO_QUERY ); + DBG_ASSERT( xTransact.is(), "The storage must implement XTransacted interface!\n" ); + if ( xTransact.is() ) + xTransact->commit(); + + bResult = true; + } + catch( uno::Exception& ) + { + // TODO/LATER: handle the error depending on exception + SetError(ERRCODE_IO_GENERAL); + } + + return bResult; +} + + +OUString SfxObjectShell::CreateTempCopyOfStorage_Impl( const uno::Reference< embed::XStorage >& xStorage ) +{ + OUString aTempURL = ::utl::TempFile().GetURL(); + + DBG_ASSERT( !aTempURL.isEmpty(), "Can't create a temporary file!\n" ); + if ( !aTempURL.isEmpty() ) + { + try + { + uno::Reference< embed::XStorage > xTempStorage = + ::comphelper::OStorageHelper::GetStorageFromURL( aTempURL, embed::ElementModes::READWRITE ); + + // the password will be transferred from the xStorage to xTempStorage by storage implementation + xStorage->copyToStorage( xTempStorage ); + + // the temporary storage was committed by the previous method and it will die by refcount + } + catch ( uno::Exception& ) + { + SAL_WARN( "sfx.doc", "Creation of a storage copy is failed!" ); + ::utl::UCBContentHelper::Kill( aTempURL ); + + aTempURL.clear(); + + // TODO/LATER: may need error code setting based on exception + SetError(ERRCODE_IO_GENERAL); + } + } + + return aTempURL; +} + + +SvGlobalName const & SfxObjectShell::GetClassName() const +{ + return GetFactory().GetClassId(); +} + + +void SfxObjectShell::SetupStorage( const uno::Reference< embed::XStorage >& xStorage, + sal_Int32 nVersion, bool bTemplate ) const +{ + uno::Reference< beans::XPropertySet > xProps( xStorage, uno::UNO_QUERY ); + + if ( !xProps.is() ) + return; + + SotClipboardFormatId nClipFormat = SotClipboardFormatId::NONE; + + SvGlobalName aName; + OUString aFullTypeName; + FillClass( &aName, &nClipFormat, &aFullTypeName, nVersion, bTemplate ); + + if ( nClipFormat == SotClipboardFormatId::NONE ) + return; + + // basic doesn't have a ClipFormat + // without MediaType the storage is not really usable, but currently the BasicIDE still + // is an SfxObjectShell and so we can't take this as an error + datatransfer::DataFlavor aDataFlavor; + SotExchange::GetFormatDataFlavor( nClipFormat, aDataFlavor ); + if ( aDataFlavor.MimeType.isEmpty() ) + return; + + try + { + xProps->setPropertyValue("MediaType", uno::Any( aDataFlavor.MimeType ) ); + } + catch( uno::Exception& ) + { + const_cast<SfxObjectShell*>( this )->SetError(ERRCODE_IO_GENERAL); + } + + SvtSaveOptions::ODFSaneDefaultVersion nDefVersion = SvtSaveOptions::ODFSVER_013; + if (!utl::ConfigManager::IsFuzzing()) + { + nDefVersion = GetODFSaneDefaultVersion(); + } + + // the default values, that should be used for ODF1.1 and older formats + uno::Sequence< beans::NamedValue > aEncryptionAlgs + { + { "StartKeyGenerationAlgorithm", css::uno::Any(xml::crypto::DigestID::SHA1) }, + { "EncryptionAlgorithm", css::uno::Any(xml::crypto::CipherID::BLOWFISH_CFB_8) }, + { "ChecksumAlgorithm", css::uno::Any(xml::crypto::DigestID::SHA1_1K) } + }; + + if (nDefVersion >= SvtSaveOptions::ODFSVER_012) + { + try + { + // older versions can not have this property set, it exists only starting from ODF1.2 + uno::Reference<frame::XModule> const xModule(GetModel(), uno::UNO_QUERY); + bool const isBaseForm(xModule.is() && + xModule->getIdentifier() == "com.sun.star.sdb.FormDesign"); + SAL_INFO_IF(isBaseForm, "sfx.doc", "tdf#138209 force form export to ODF 1.2"); + if (!isBaseForm && SvtSaveOptions::ODFSVER_013 <= nDefVersion) + { + xProps->setPropertyValue("Version", uno::Any(OUString(ODFVER_013_TEXT))); + } + else + { + xProps->setPropertyValue("Version", uno::Any(OUString(ODFVER_012_TEXT))); + } + } + catch( uno::Exception& ) + { + } + + auto pEncryptionAlgs = aEncryptionAlgs.getArray(); + pEncryptionAlgs[0].Value <<= xml::crypto::DigestID::SHA256; + pEncryptionAlgs[2].Value <<= xml::crypto::DigestID::SHA256_1K; + pEncryptionAlgs[1].Value <<= xml::crypto::CipherID::AES_CBC_W3C_PADDING; + } + + try + { + // set the encryption algorithms accordingly; + // the setting does not trigger encryption, + // it just provides the format for the case that contents should be encrypted + uno::Reference< embed::XEncryptionProtectedStorage > xEncr( xStorage, uno::UNO_QUERY_THROW ); + xEncr->setEncryptionAlgorithms( aEncryptionAlgs ); + } + catch( uno::Exception& ) + { + const_cast<SfxObjectShell*>( this )->SetError(ERRCODE_IO_GENERAL); + } +} + + +void SfxObjectShell::PrepareSecondTryLoad_Impl() +{ + // only for internal use + pImpl->m_xDocStorage.clear(); + pImpl->m_bIsInit = false; + ResetError(); +} + + +bool SfxObjectShell::GeneralInit_Impl( const uno::Reference< embed::XStorage >& xStorage, + bool bTypeMustBeSetAlready ) +{ + if ( pImpl->m_bIsInit ) + return false; + + pImpl->m_bIsInit = true; + if ( xStorage.is() ) + { + // no notification is required the storage is set the first time + pImpl->m_xDocStorage = xStorage; + + try { + uno::Reference < beans::XPropertySet > xPropSet( xStorage, uno::UNO_QUERY_THROW ); + Any a = xPropSet->getPropertyValue("MediaType"); + OUString aMediaType; + if ( !(a>>=aMediaType) || aMediaType.isEmpty() ) + { + if ( bTypeMustBeSetAlready ) + { + SetError(ERRCODE_IO_BROKENPACKAGE); + return false; + } + + SetupStorage( xStorage, SOFFICE_FILEFORMAT_CURRENT, false ); + } + } + catch ( uno::Exception& ) + { + SAL_WARN( "sfx.doc", "Can't check storage's mediatype!" ); + } + } + else + pImpl->m_bCreateTempStor = true; + + return true; +} + + +bool SfxObjectShell::InitNew( const uno::Reference< embed::XStorage >& xStorage ) +{ + return GeneralInit_Impl( xStorage, false ); +} + + +bool SfxObjectShell::Load( SfxMedium& rMedium ) +{ + return GeneralInit_Impl(rMedium.GetStorage(), true); +} + +void SfxObjectShell::DoInitUnitTest() +{ + pMedium = new SfxMedium; +} + +bool SfxObjectShell::DoInitNew() +/* [Description] + + This from SvPersist inherited virtual method is called to initialize + the SfxObjectShell instance from a storage (PStore! = 0) or (PStore == 0) + + Like with all Do...-methods there is a from a control, the actual + implementation is done by the virtual method in which also the + InitNew(SvStorate *) from the SfxObjectShell-Subclass is implemented. + + For pStore == 0 the SfxObjectShell-instance is connected to an empty + SfxMedium, otherwise a SfxMedium, which refers to the SotStorage + passed as a parameter. + + The object is only initialized correctly after InitNew() or Load(). + + [Return value] + true The object has been initialized. + false The object could not be initialized +*/ + +{ + ModifyBlocker_Impl aBlock( this ); + pMedium = new SfxMedium; + + pMedium->CanDisposeStorage_Impl( true ); + + if ( InitNew( nullptr ) ) + { + // empty documents always get their macros from the user, so there is no reason to restrict access + pImpl->aMacroMode.allowMacroExecution(); + if ( SfxObjectCreateMode::EMBEDDED == eCreateMode ) + SetTitle(SfxResId(STR_NONAME)); + + uno::Reference< frame::XModel > xModel = GetModel(); + if ( xModel.is() ) + { + SfxItemSet *pSet = GetMedium()->GetItemSet(); + uno::Sequence< beans::PropertyValue > aArgs; + TransformItems( SID_OPENDOC, *pSet, aArgs ); + sal_Int32 nLength = aArgs.getLength(); + aArgs.realloc( nLength + 1 ); + auto pArgs = aArgs.getArray(); + pArgs[nLength].Name = "Title"; + pArgs[nLength].Value <<= GetTitle( SFX_TITLE_DETECT ); + xModel->attachResource( OUString(), aArgs ); + if (!utl::ConfigManager::IsFuzzing()) + impl_addToModelCollection(xModel); + } + + SetInitialized_Impl( true ); + return true; + } + + return false; +} + +bool SfxObjectShell::ImportFromGeneratedStream_Impl( + const uno::Reference< io::XStream >& xStream, + const uno::Sequence< beans::PropertyValue >& rMediaDescr ) +{ + if ( !xStream.is() ) + return false; + + if ( pMedium && pMedium->HasStorage_Impl() ) + pMedium->CloseStorage(); + + bool bResult = false; + + try + { + uno::Reference< embed::XStorage > xStorage = + ::comphelper::OStorageHelper::GetStorageFromStream( xStream ); + + if ( !xStorage.is() ) + throw uno::RuntimeException(); + + if ( !pMedium ) + pMedium = new SfxMedium( xStorage, OUString() ); + else + pMedium->SetStorage_Impl( xStorage ); + + SfxAllItemSet aSet( SfxGetpApp()->GetPool() ); + TransformParameters( SID_OPENDOC, rMediaDescr, aSet ); + pMedium->GetItemSet()->Put( aSet ); + pMedium->CanDisposeStorage_Impl( false ); + uno::Reference<text::XTextRange> xInsertTextRange; + for (const auto& rProp : rMediaDescr) + { + if (rProp.Name == "TextInsertModeRange") + { + rProp.Value >>= xInsertTextRange; + } + } + + if (xInsertTextRange.is()) + { + bResult = InsertGeneratedStream(*pMedium, xInsertTextRange); + } + else + { + + // allow the subfilter to reinit the model + if ( pImpl->m_bIsInit ) + pImpl->m_bIsInit = false; + + if ( LoadOwnFormat( *pMedium ) ) + { + bHasName = true; + if ( !IsReadOnly() && IsLoadReadonly() ) + SetReadOnlyUI(); + + bResult = true; + OSL_ENSURE( pImpl->m_xDocStorage == xStorage, "Wrong storage is used!" ); + } + } + + // now the medium can be disconnected from the storage + // the medium is not allowed to dispose the storage so CloseStorage() can be used + pMedium->CloseStorage(); + } + catch( uno::Exception& ) + { + } + + return bResult; +} + + +bool SfxObjectShell::DoLoad( SfxMedium *pMed ) +{ + ModifyBlocker_Impl aBlock( this ); + + pMedium = pMed; + pMedium->CanDisposeStorage_Impl( true ); + + bool bOk = false; + std::shared_ptr<const SfxFilter> pFilter = pMed->GetFilter(); + SfxItemSet* pSet = pMedium->GetItemSet(); + if( pImpl->nEventId == SfxEventHintId::NONE ) + { + const SfxBoolItem* pTemplateItem = SfxItemSet::GetItem<SfxBoolItem>(pSet, SID_TEMPLATE, false); + SetActivateEvent_Impl( + ( pTemplateItem && pTemplateItem->GetValue() ) + ? SfxEventHintId::CreateDoc : SfxEventHintId::OpenDoc ); + } + + const SfxStringItem* pBaseItem = SfxItemSet::GetItem<SfxStringItem>(pSet, SID_BASEURL, false); + OUString aBaseURL; + const SfxStringItem* pSalvageItem = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_DOC_SALVAGE, false); + if( pBaseItem ) + aBaseURL = pBaseItem->GetValue(); + else + { + if ( pSalvageItem ) + { + osl::FileBase::getFileURLFromSystemPath( pMed->GetPhysicalName(), aBaseURL ); + } + else + aBaseURL = pMed->GetBaseURL(); + } + pMed->GetItemSet()->Put( SfxStringItem( SID_DOC_BASEURL, aBaseURL ) ); + + pImpl->nLoadedFlags = SfxLoadedFlags::NONE; + pImpl->bModelInitialized = false; + + if (pFilter && !pFilter->IsEnabled()) + { + SetError( ERRCODE_IO_FILTERDISABLED ); + } + + if ( pFilter && pFilter->IsExoticFormat() && !QueryAllowExoticFormat_Impl( getInteractionHandler(), aBaseURL, pMed->GetFilter()->GetUIName() ) ) + { + SetError( ERRCODE_IO_ABORT ); + } + + // initialize static language table so language-related extensions are learned before the document loads + (void)SvtLanguageTable::GetLanguageEntryCount(); + + //TODO/LATER: make a clear strategy how to handle "UsesStorage" etc. + bool bOwnStorageFormat = IsOwnStorageFormat( *pMedium ); + bool bHasStorage = IsPackageStorageFormat_Impl( *pMedium ); + if ( pMedium->GetFilter() ) + { + ErrCode nError = HandleFilter( pMedium, this ); + if ( nError != ERRCODE_NONE ) + SetError(nError); + + if (pMedium->GetFilter()->GetFilterFlags() & SfxFilterFlags::STARTPRESENTATION) + pSet->Put( SfxBoolItem( SID_DOC_STARTPRESENTATION, true) ); + } + + EnableSetModified( false ); + + pMedium->LockOrigFileOnDemand( true, false ); + if ( GetError() == ERRCODE_NONE && bOwnStorageFormat && ( !pFilter || !( pFilter->GetFilterFlags() & SfxFilterFlags::STARONEFILTER ) ) ) + { + uno::Reference< embed::XStorage > xStorage; + if ( pMedium->GetError() == ERRCODE_NONE ) + xStorage = pMedium->GetStorage(); + + if( xStorage.is() && pMedium->GetLastStorageCreationState() == ERRCODE_NONE ) + { + DBG_ASSERT( pFilter, "No filter for storage found!" ); + + try + { + bool bWarnMediaTypeFallback = false; + const SfxBoolItem* pRepairPackageItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_REPAIRPACKAGE, false); + + // treat the package as broken if the mediatype was retrieved as a fallback + uno::Reference< beans::XPropertySet > xStorProps( xStorage, uno::UNO_QUERY_THROW ); + xStorProps->getPropertyValue("MediaTypeFallbackUsed") + >>= bWarnMediaTypeFallback; + + if ( pRepairPackageItem && pRepairPackageItem->GetValue() ) + { + // the macros in repaired documents should be disabled + pMedium->GetItemSet()->Put( SfxUInt16Item( SID_MACROEXECMODE, document::MacroExecMode::NEVER_EXECUTE ) ); + + // the mediatype was retrieved by using fallback solution but this is a repairing mode + // so it is acceptable to open the document if there is no contents that required manifest.xml + bWarnMediaTypeFallback = false; + } + + if (bWarnMediaTypeFallback || !xStorage->getElementNames().hasElements()) + SetError(ERRCODE_IO_BROKENPACKAGE); + } + catch( uno::Exception& ) + { + // TODO/LATER: may need error code setting based on exception + SetError(ERRCODE_IO_GENERAL); + } + + // Load + if ( !GetError() ) + { + pImpl->nLoadedFlags = SfxLoadedFlags::NONE; + pImpl->bModelInitialized = false; + bOk = xStorage.is() && LoadOwnFormat( *pMed ); + if ( bOk ) + { + // the document loaded from template has no name + const SfxBoolItem* pTemplateItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_TEMPLATE, false); + if ( !pTemplateItem || !pTemplateItem->GetValue() ) + bHasName = true; + } + else + SetError(ERRCODE_ABORT); + } + } + else + SetError(pMed->GetLastStorageCreationState()); + } + else if ( GetError() == ERRCODE_NONE && InitNew(nullptr) ) + { + // set name before ConvertFrom, so that GetSbxObject() already works + bHasName = true; + SetName( SfxResId(STR_NONAME) ); + + if( !bHasStorage ) + pMedium->GetInStream(); + else + pMedium->GetStorage(); + + if ( GetError() == ERRCODE_NONE ) + { + // Experimental PDF importing using PDFium. This is currently enabled for LOK only and + // we handle it not via XmlFilterAdaptor but a new SdPdfFiler. +#if !HAVE_FEATURE_POPPLER + constexpr bool bUsePdfium = true; +#else + const bool bUsePdfium + = comphelper::LibreOfficeKit::isActive() || getenv("LO_IMPORT_USE_PDFIUM"); +#endif + const bool bPdfiumImport + = bUsePdfium && pMedium->GetFilter() + && (pMedium->GetFilter()->GetFilterName() == "draw_pdf_import"); + + pImpl->nLoadedFlags = SfxLoadedFlags::NONE; + pImpl->bModelInitialized = false; + if (pMedium->GetFilter() + && (pMedium->GetFilter()->GetFilterFlags() & SfxFilterFlags::STARONEFILTER) + && !bPdfiumImport) + { + uno::Reference < beans::XPropertySet > xSet( GetModel(), uno::UNO_QUERY ); + static const OUStringLiteral sLockUpdates(u"LockUpdates"); + bool bSetProperty = true; + try + { + xSet->setPropertyValue( sLockUpdates, Any( true ) ); + } + catch(const beans::UnknownPropertyException& ) + { + bSetProperty = false; + } + bOk = ImportFrom(*pMedium, nullptr); + if(bSetProperty) + { + try + { + xSet->setPropertyValue( sLockUpdates, Any( false ) ); + } + catch(const beans::UnknownPropertyException& ) + {} + } + UpdateLinks(); + FinishedLoading(); + } + else + { + if (tools::isEmptyFileUrl(pMedium->GetName())) + { + // The import filter would fail with empty input. + bOk = true; + } + else + { + bOk = ConvertFrom(*pMedium); + } + InitOwnModel_Impl(); + } + } + } + + if ( bOk ) + { + if ( IsReadOnlyMedium() || IsLoadReadonly() ) + SetReadOnlyUI(); + + try + { + ::ucbhelper::Content aContent( pMedium->GetName(), utl::UCBContentHelper::getDefaultCommandEnvironment(), comphelper::getProcessComponentContext() ); + css::uno::Reference < XPropertySetInfo > xProps = aContent.getProperties(); + if ( xProps.is() ) + { + static const OUStringLiteral aAuthor( u"Author" ); + static const OUStringLiteral aKeywords( u"Keywords" ); + static const OUStringLiteral aSubject( u"Subject" ); + Any aAny; + OUString aValue; + uno::Reference<document::XDocumentPropertiesSupplier> xDPS( + GetModel(), uno::UNO_QUERY_THROW); + uno::Reference<document::XDocumentProperties> xDocProps + = xDPS->getDocumentProperties(); + if ( xProps->hasPropertyByName( aAuthor ) ) + { + aAny = aContent.getPropertyValue( aAuthor ); + if ( aAny >>= aValue ) + xDocProps->setAuthor(aValue); + } + if ( xProps->hasPropertyByName( aKeywords ) ) + { + aAny = aContent.getPropertyValue( aKeywords ); + if ( aAny >>= aValue ) + xDocProps->setKeywords( + ::comphelper::string::convertCommaSeparated(aValue)); +; + } + if ( xProps->hasPropertyByName( aSubject ) ) + { + aAny = aContent.getPropertyValue( aSubject ); + if ( aAny >>= aValue ) { + xDocProps->setSubject(aValue); + } + } + } + } + catch( Exception& ) + { + } + + // If not loaded asynchronously call FinishedLoading + if ( !( pImpl->nLoadedFlags & SfxLoadedFlags::MAINDOCUMENT ) && + ( !pMedium->GetFilter() || pMedium->GetFilter()->UsesStorage() ) + ) + FinishedLoading( SfxLoadedFlags::MAINDOCUMENT ); + + Broadcast( SfxHint(SfxHintId::NameChanged) ); + + if ( SfxObjectCreateMode::EMBEDDED != eCreateMode ) + { + const SfxBoolItem* pAsTempItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_TEMPLATE, false); + const SfxBoolItem* pPreviewItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_PREVIEW, false); + const SfxBoolItem* pHiddenItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_HIDDEN, false); + if( bOk && !pMedium->GetOrigURL().isEmpty() + && !( pAsTempItem && pAsTempItem->GetValue() ) + && !( pPreviewItem && pPreviewItem->GetValue() ) + && !( pHiddenItem && pHiddenItem->GetValue() ) ) + { + AddToRecentlyUsedList(); + } + } + + const SfxBoolItem* pDdeReconnectItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_DDE_RECONNECT_ONLOAD, false); + + bool bReconnectDde = true; // by default, we try to auto-connect DDE connections. + if (pDdeReconnectItem) + bReconnectDde = pDdeReconnectItem->GetValue(); + + if (bReconnectDde) + ReconnectDdeLinks(*this); + } + + return bOk; +} + +bool SfxObjectShell::DoLoadExternal( SfxMedium *pMed ) +{ + pMedium = pMed; + return LoadExternal(*pMedium); +} + +ErrCode SfxObjectShell::HandleFilter( SfxMedium* pMedium, SfxObjectShell const * pDoc ) +{ + ErrCode nError = ERRCODE_NONE; + SfxItemSet* pSet = pMedium->GetItemSet(); + const SfxStringItem* pOptions = SfxItemSet::GetItem<SfxStringItem>(pSet, SID_FILE_FILTEROPTIONS, false); + const SfxUnoAnyItem* pData = SfxItemSet::GetItem<SfxUnoAnyItem>(pSet, SID_FILTER_DATA, false); + const bool bTiledRendering = comphelper::LibreOfficeKit::isActive(); + if ( !pData && (bTiledRendering || !pOptions) ) + { + css::uno::Reference< XMultiServiceFactory > xServiceManager = ::comphelper::getProcessServiceFactory(); + css::uno::Reference< XNameAccess > xFilterCFG; + if( xServiceManager.is() ) + { + xFilterCFG.set( xServiceManager->createInstance("com.sun.star.document.FilterFactory"), + UNO_QUERY ); + } + + if( xFilterCFG.is() ) + { + try { + bool bAbort = false; + std::shared_ptr<const SfxFilter> pFilter = pMedium->GetFilter(); + Sequence < PropertyValue > aProps; + Any aAny = xFilterCFG->getByName( pFilter->GetName() ); + if ( aAny >>= aProps ) + { + auto pProp = std::find_if(std::cbegin(aProps), std::cend(aProps), + [](const PropertyValue& rProp) { return rProp.Name == "UIComponent"; }); + if (pProp != std::cend(aProps)) + { + OUString aServiceName; + pProp->Value >>= aServiceName; + if( !aServiceName.isEmpty() ) + { + css::uno::Reference< XInteractionHandler > rHandler = pMedium->GetInteractionHandler(); + if( rHandler.is() ) + { + // we need some properties in the media descriptor, so we have to make sure that they are in + Any aStreamAny; + aStreamAny <<= pMedium->GetInputStream(); + if ( pSet->GetItemState( SID_INPUTSTREAM ) < SfxItemState::SET ) + pSet->Put( SfxUnoAnyItem( SID_INPUTSTREAM, aStreamAny ) ); + if ( pSet->GetItemState( SID_FILE_NAME ) < SfxItemState::SET ) + pSet->Put( SfxStringItem( SID_FILE_NAME, pMedium->GetName() ) ); + if ( pSet->GetItemState( SID_FILTER_NAME ) < SfxItemState::SET ) + pSet->Put( SfxStringItem( SID_FILTER_NAME, pFilter->GetName() ) ); + + Sequence< PropertyValue > rProperties; + TransformItems( SID_OPENDOC, *pSet, rProperties ); + rtl::Reference<RequestFilterOptions> pFORequest = new RequestFilterOptions( pDoc->GetModel(), rProperties ); + + rHandler->handle( pFORequest ); + + if ( !pFORequest->isAbort() ) + { + SfxAllItemSet aNewParams( pDoc->GetPool() ); + TransformParameters( SID_OPENDOC, + pFORequest->getFilterOptions(), + aNewParams ); + + const SfxStringItem* pFilterOptions = aNewParams.GetItem<SfxStringItem>(SID_FILE_FILTEROPTIONS, false); + if ( pFilterOptions ) + pSet->Put( *pFilterOptions ); + + const SfxUnoAnyItem* pFilterData = aNewParams.GetItem<SfxUnoAnyItem>(SID_FILTER_DATA, false); + if ( pFilterData ) + pSet->Put( *pFilterData ); + } + else + bAbort = true; + } + } + } + } + + if( bAbort ) + { + // filter options were not entered + nError = ERRCODE_ABORT; + } + } + catch( NoSuchElementException& ) + { + // the filter name is unknown + nError = ERRCODE_IO_INVALIDPARAMETER; + } + catch( Exception& ) + { + nError = ERRCODE_ABORT; + } + } + } + + return nError; +} + + +bool SfxObjectShell::IsOwnStorageFormat(const SfxMedium &rMedium) +{ + return !rMedium.GetFilter() || // Embedded + ( rMedium.GetFilter()->IsOwnFormat() && + rMedium.GetFilter()->UsesStorage() && + rMedium.GetFilter()->GetVersion() >= SOFFICE_FILEFORMAT_60 ); +} + + +bool SfxObjectShell::IsPackageStorageFormat_Impl(const SfxMedium &rMedium) +{ + return !rMedium.GetFilter() || // Embedded + ( rMedium.GetFilter()->UsesStorage() && + rMedium.GetFilter()->GetVersion() >= SOFFICE_FILEFORMAT_60 ); +} + + +bool SfxObjectShell::DoSave() +// DoSave is only invoked for OLE. Save your own documents in the SFX through +// DoSave_Impl order to allow for the creation of backups. +// Save in your own format again. +{ + bool bOk = false ; + { + ModifyBlocker_Impl aBlock( this ); + + pImpl->bIsSaving = true; + + if (IsOwnStorageFormat(*GetMedium())) + { + SvtSaveOptions::ODFSaneDefaultVersion nDefVersion = SvtSaveOptions::ODFSVER_013; + if (!utl::ConfigManager::IsFuzzing()) + { + nDefVersion = GetODFSaneDefaultVersion(); + } + uno::Reference<beans::XPropertySet> const xProps(GetMedium()->GetStorage(), uno::UNO_QUERY); + assert(xProps.is()); + if (nDefVersion >= SvtSaveOptions::ODFSVER_012) // property exists only since ODF 1.2 + { + try // tdf#134582 set Version on embedded objects as they + { // could have been loaded with a different/old version + uno::Reference<frame::XModule> const xModule(GetModel(), uno::UNO_QUERY); + bool const isBaseForm(xModule.is() && + xModule->getIdentifier() == "com.sun.star.sdb.FormDesign"); + SAL_INFO_IF(isBaseForm, "sfx.doc", "tdf#138209 force form export to ODF 1.2"); + if (!isBaseForm && SvtSaveOptions::ODFSVER_013 <= nDefVersion) + { + xProps->setPropertyValue("Version", uno::Any(OUString(ODFVER_013_TEXT))); + } + else + { + xProps->setPropertyValue("Version", uno::Any(OUString(ODFVER_012_TEXT))); + } + } + catch (uno::Exception&) + { + TOOLS_WARN_EXCEPTION("sfx.doc", "SfxObjectShell::DoSave"); + } + } + } + + uno::Sequence< beans::NamedValue > aEncryptionData; + if ( IsPackageStorageFormat_Impl( *GetMedium() ) ) + { + if ( GetEncryptionData_Impl( GetMedium()->GetItemSet(), aEncryptionData ) ) + { + try + { + //TODO/MBA: GetOutputStorage?! Special mode, because it's "Save"?! + ::comphelper::OStorageHelper::SetCommonStorageEncryptionData( GetMedium()->GetStorage(), aEncryptionData ); + bOk = true; + } + catch( uno::Exception& ) + { + SetError(ERRCODE_IO_GENERAL); + } + + DBG_ASSERT( bOk, "The root storage must allow to set common password!\n" ); + } + else + bOk = true; +#if HAVE_FEATURE_SCRIPTING + if ( HasBasic() ) + { + try + { + // The basic and dialogs related contents are still not able to proceed with save operation ( saveTo only ) + // so since the document storage is locked a workaround has to be used + + uno::Reference< embed::XStorage > xTmpStorage = ::comphelper::OStorageHelper::GetTemporaryStorage(); + DBG_ASSERT( xTmpStorage.is(), "If a storage can not be created an exception must be thrown!\n" ); + if ( !xTmpStorage.is() ) + throw uno::RuntimeException(); + + static const OUStringLiteral aBasicStorageName( u"Basic" ); + static const OUStringLiteral aDialogsStorageName( u"Dialogs" ); + if ( GetMedium()->GetStorage()->hasByName( aBasicStorageName ) ) + GetMedium()->GetStorage()->copyElementTo( aBasicStorageName, xTmpStorage, aBasicStorageName ); + if ( GetMedium()->GetStorage()->hasByName( aDialogsStorageName ) ) + GetMedium()->GetStorage()->copyElementTo( aDialogsStorageName, xTmpStorage, aDialogsStorageName ); + + GetBasicManager(); + + // disconnect from the current storage + pImpl->aBasicManager.setStorage( xTmpStorage ); + + // store to the current storage + pImpl->aBasicManager.storeLibrariesToStorage( GetMedium()->GetStorage() ); + + // connect to the current storage back + pImpl->aBasicManager.setStorage( GetMedium()->GetStorage() ); + } + catch( uno::Exception& ) + { + SetError(ERRCODE_IO_GENERAL); + bOk = false; + } + } +#endif + } + + if (bOk) + bOk = Save(); + + if (bOk) + bOk = pMedium->Commit(); + } + + return bOk; +} + +namespace +{ +class LockUIGuard +{ +public: + LockUIGuard(SfxObjectShell const* pDoc) + : m_pDoc(pDoc) + { + Lock_Impl(); + } + ~LockUIGuard() { Unlock(); } + + void Unlock() + { + if (m_bUnlock) + Lock_Impl(); + } + +private: + void Lock_Impl() + { + SfxViewFrame* pFrame = SfxViewFrame::GetFirst(m_pDoc); + while (pFrame) + { + pFrame->GetDispatcher()->Lock(!m_bUnlock); + pFrame->Enable(m_bUnlock); + pFrame = SfxViewFrame::GetNext(*pFrame, m_pDoc); + } + m_bUnlock = !m_bUnlock; + } + SfxObjectShell const* m_pDoc; + bool m_bUnlock = false; +}; +} + +static OUString lcl_strip_template(const OUString &aString) +{ + static constexpr OUStringLiteral sPostfix(u"_template"); + OUString sRes(aString); + if (sRes.endsWith(sPostfix)) + sRes = sRes.copy(0, sRes.getLength() - sPostfix.getLength()); + return sRes; +} + +bool SfxObjectShell::SaveTo_Impl +( + SfxMedium &rMedium, // Medium, in which it will be stored + const SfxItemSet* pSet +) + +/* [Description] + + Writes the current contents to the medium rMedium. If the target medium is + no storage, then saving to a temporary storage, or directly if the medium + is transacted, if we ourselves have opened it, and if we are a server + either the container a transacted storage provides or created a + temporary storage by one self. +*/ + +{ + SAL_INFO( "sfx.doc", "saving \"" << rMedium.GetName() << "\"" ); + + UpdateDocInfoForSave(); + + ModifyBlocker_Impl aMod(this); + // tdf#41063, tdf#135244: prevent jumping to cursor at any temporary modification + auto aViewGuard(LockAllViews()); + + std::shared_ptr<const SfxFilter> pFilter = rMedium.GetFilter(); + if ( !pFilter ) + { + // if no filter was set, use the default filter + // this should be changed in the feature, it should be an error! + SAL_WARN( "sfx.doc","No filter set!"); + pFilter = GetFactory().GetFilterContainer()->GetAnyFilter( SfxFilterFlags::IMPORT | SfxFilterFlags::EXPORT ); + rMedium.SetFilter(pFilter); + } + + bool bStorageBasedSource = IsPackageStorageFormat_Impl( *pMedium ); + bool bStorageBasedTarget = IsPackageStorageFormat_Impl( rMedium ); + bool bOwnSource = IsOwnStorageFormat( *pMedium ); + bool bOwnTarget = IsOwnStorageFormat( rMedium ); + + // Examine target format to determine whether to query if any password + // protected libraries exceed the size we can handler + if ( bOwnTarget && !QuerySaveSizeExceededModules_Impl( rMedium.GetInteractionHandler() ) ) + { + SetError(ERRCODE_IO_ABORT); + return false; + } + + bool bNeedsDisconnectionOnFail = false; + + bool bStoreToSameLocation = false; + + // the detection whether the script is changed should be done before saving + bool bTryToPreserveScriptSignature = false; + // no way to detect whether a filter is oasis format, have to wait for saving process + bool bNoPreserveForOasis = false; + if ( bOwnSource && bOwnTarget + && ( pImpl->nScriptingSignatureState == SignatureState::OK + || pImpl->nScriptingSignatureState == SignatureState::NOTVALIDATED + || pImpl->nScriptingSignatureState == SignatureState::INVALID ) ) + { + // the checking of the library modified state iterates over the libraries, should be done only when required + // currently the check is commented out since it is broken, we have to check the signature every time we save + // TODO/LATER: let isAnyContainerModified() work! + bTryToPreserveScriptSignature = true; // !pImpl->pBasicManager->isAnyContainerModified(); + if ( bTryToPreserveScriptSignature ) + { + // check that the storage format stays the same + SvtSaveOptions::ODFSaneDefaultVersion nVersion = GetODFSaneDefaultVersion(); + + OUString aODFVersion; + try + { + uno::Reference < beans::XPropertySet > xPropSet( GetStorage(), uno::UNO_QUERY_THROW ); + xPropSet->getPropertyValue("Version") >>= aODFVersion; + } + catch( uno::Exception& ) + {} + + // preserve only if the same filter has been used + // for templates, strip the _template from the filter name for comparison + const OUString aMediumFilter = lcl_strip_template(pMedium->GetFilter()->GetFilterName()); + bTryToPreserveScriptSignature = pMedium->GetFilter() && pFilter && aMediumFilter == lcl_strip_template(pFilter->GetFilterName()); + + // signatures were specified in ODF 1.2 but were used since much longer. + // LO will still correctly validate an old style signature on an ODF 1.2 + // document, but technically this is not correct, so this prevents old + // signatures to be copied over to a version 1.2 document + bNoPreserveForOasis = ( + (0 <= aODFVersion.compareTo(ODFVER_012_TEXT) && nVersion < SvtSaveOptions::ODFSVER_012) || + (aODFVersion.isEmpty() && nVersion >= SvtSaveOptions::ODFSVER_012) + ); + } + } + + // use UCB for case sensitive/insensitive file name comparison + if ( !pMedium->GetName().equalsIgnoreAsciiCase("private:stream") + && !rMedium.GetName().equalsIgnoreAsciiCase("private:stream") + && ::utl::UCBContentHelper::EqualURLs( pMedium->GetName(), rMedium.GetName() ) ) + { + // Do not unlock the file during saving. + // need to modify this for WebDAV if this method is called outside of + // the process of saving a file + pMedium->DisableUnlockWebDAV(); + bStoreToSameLocation = true; + + if ( pMedium->DocNeedsFileDateCheck() ) + rMedium.CheckFileDate( pMedium->GetInitFileDate( false ) ); + + // before we overwrite the original file, we will make a backup if there is a demand for that + // if the backup is not created here it will be created internally and will be removed in case of successful saving + const bool bDoBackup = officecfg::Office::Common::Save::Document::CreateBackup::get(); + if ( bDoBackup ) + { + rMedium.DoBackup_Impl(); + if ( rMedium.GetError() ) + { + SetError(rMedium.GetErrorCode()); + rMedium.ResetError(); + } + } + + if ( bStorageBasedSource && bStorageBasedTarget ) + { + // The active storage must be switched. The simple saving is not enough. + // The problem is that the target medium contains target MediaDescriptor. + + // In future the switch of the persistence could be done on stream level: + // a new wrapper service will be implemented that allows to exchange + // persistence on the fly. So the real persistence will be set + // to that stream only after successful commit of the storage. + // TODO/LATER: + // create wrapper stream based on the URL + // create a new storage based on this stream + // store to this new storage + // commit the new storage + // call saveCompleted based with this new storage ( get rid of old storage and "frees" URL ) + // commit the wrapper stream ( the stream will connect the URL only on commit, after that it will hold it ) + // if the last step is failed the stream should stay to be transacted and should be committed on any flush + // so we can forget the stream in any way and the next storage commit will flush it + + bNeedsDisconnectionOnFail = DisconnectStorage_Impl( + *pMedium, rMedium ); + if ( bNeedsDisconnectionOnFail + || ConnectTmpStorage_Impl( pMedium->GetStorage(), pMedium ) ) + { + pMedium->CloseAndRelease(); + + // TODO/LATER: for now the medium must be closed since it can already contain streams from old medium + // in future those streams should not be copied in case a valid target url is provided, + // if the url is not provided ( means the document is based on a stream ) this code is not + // reachable. + rMedium.CloseAndRelease(); + rMedium.SetHasEmbeddedObjects(GetEmbeddedObjectContainer().HasEmbeddedObjects()); + rMedium.GetOutputStorage(); + rMedium.SetHasEmbeddedObjects(false); + } + } + else if ( !bStorageBasedSource && !bStorageBasedTarget ) + { + // the source and the target formats are alien + // just disconnect the stream from the source format + // so that the target medium can use it + + pMedium->CloseAndRelease(); + rMedium.CloseAndRelease(); + rMedium.CreateTempFileNoCopy(); + rMedium.GetOutStream(); + } + else if ( !bStorageBasedSource && bStorageBasedTarget ) + { + // the source format is an alien one but the target + // format is an own one so just disconnect the source + // medium + + pMedium->CloseAndRelease(); + rMedium.CloseAndRelease(); + rMedium.GetOutputStorage(); + } + else // means if ( bStorageBasedSource && !bStorageBasedTarget ) + { + // the source format is an own one but the target is + // an alien format, just connect the source to temporary + // storage + + bNeedsDisconnectionOnFail = DisconnectStorage_Impl( + *pMedium, rMedium ); + if ( bNeedsDisconnectionOnFail + || ConnectTmpStorage_Impl( pMedium->GetStorage(), pMedium ) ) + { + pMedium->CloseAndRelease(); + rMedium.CloseAndRelease(); + rMedium.CreateTempFileNoCopy(); + rMedium.GetOutStream(); + } + } + pMedium->DisableUnlockWebDAV(false); + } + else + { + // This is SaveAs or export action, prepare the target medium + // the alien filters still might write directly to the file, that is of course a bug, + // but for now the framework has to be ready for it + // TODO/LATER: let the medium be prepared for alien formats as well + + rMedium.CloseAndRelease(); + if ( bStorageBasedTarget ) + { + rMedium.SetHasEmbeddedObjects(GetEmbeddedObjectContainer().HasEmbeddedObjects()); + rMedium.GetOutputStorage(); + rMedium.SetHasEmbeddedObjects(false); + } + } + + // TODO/LATER: error handling + if( rMedium.GetErrorCode() || pMedium->GetErrorCode() || GetErrorCode() ) + { + SAL_WARN("sfx.doc", "SfxObjectShell::SaveTo_Impl: very early error return"); + return false; + } + + rMedium.LockOrigFileOnDemand( false, false ); + + if ( bStorageBasedTarget ) + { + if ( rMedium.GetErrorCode() ) + return false; + + // If the filter is a "cross export" filter ( f.e. a filter for exporting an impress document from + // a draw document ), the ClassId of the destination storage is different from the ClassId of this + // document. It can be retrieved from the default filter for the desired target format + SotClipboardFormatId nFormat = rMedium.GetFilter()->GetFormat(); + SfxFilterMatcher& rMatcher = SfxGetpApp()->GetFilterMatcher(); + std::shared_ptr<const SfxFilter> pFilt = rMatcher.GetFilter4ClipBoardId( nFormat ); + if ( pFilt ) + { + if ( pFilt->GetServiceName() != rMedium.GetFilter()->GetServiceName() ) + { + datatransfer::DataFlavor aDataFlavor; + SotExchange::GetFormatDataFlavor( nFormat, aDataFlavor ); + + try + { + uno::Reference< beans::XPropertySet > xProps( rMedium.GetStorage(), uno::UNO_QUERY_THROW ); + xProps->setPropertyValue("MediaType", + uno::Any( aDataFlavor.MimeType ) ); + } + catch( uno::Exception& ) + { + } + } + } + } + + // TODO/LATER: error handling + if( rMedium.GetErrorCode() || pMedium->GetErrorCode() || GetErrorCode() ) + return false; + + bool bOldStat = pImpl->bForbidReload; + pImpl->bForbidReload = true; + + // lock user interface while saving the document + LockUIGuard aLockUIGuard(this); + + bool bCopyTo = false; + SfxItemSet *pMedSet = rMedium.GetItemSet(); + if( pMedSet ) + { + const SfxBoolItem* pSaveToItem = SfxItemSet::GetItem<SfxBoolItem>(pMedSet, SID_SAVETO, false); + bCopyTo = GetCreateMode() == SfxObjectCreateMode::EMBEDDED || + (pSaveToItem && pSaveToItem->GetValue()); + } + + bool bOk = false; + // TODO/LATER: get rid of bOk + if (bOwnTarget && pFilter && !(pFilter->GetFilterFlags() & SfxFilterFlags::STARONEFILTER)) + { + uno::Reference< embed::XStorage > xMedStorage = rMedium.GetStorage(); + if ( !xMedStorage.is() ) + { + // no saving without storage + pImpl->bForbidReload = bOldStat; + return false; + } + + // transfer password from the parameters to the storage + uno::Sequence< beans::NamedValue > aEncryptionData; + bool bPasswdProvided = false; + if ( GetEncryptionData_Impl( rMedium.GetItemSet(), aEncryptionData ) ) + { + bPasswdProvided = true; + try { + ::comphelper::OStorageHelper::SetCommonStorageEncryptionData( xMedStorage, aEncryptionData ); + bOk = true; + } + catch( uno::Exception& ) + { + SAL_WARN( "sfx.doc", "Setting of common encryption key failed!" ); + SetError(ERRCODE_IO_GENERAL); + } + } + else + bOk = true; + + pFilter = rMedium.GetFilter(); + + const SfxStringItem *pVersionItem = !rMedium.IsInCheckIn()? SfxItemSet::GetItem<SfxStringItem>(pSet, SID_DOCINFO_COMMENTS, false): nullptr; + OUString aTmpVersionURL; + + if ( bOk ) + { + bOk = false; + // currently the case that the storage is the same should be impossible + if ( xMedStorage == GetStorage() ) + { + OSL_ENSURE( !pVersionItem, "This scenario is impossible currently!" ); + // usual save procedure + bOk = Save(); + } + else + { + // save to target + bOk = SaveAsOwnFormat( rMedium ); + if ( bOk && pVersionItem ) + { + aTmpVersionURL = CreateTempCopyOfStorage_Impl( xMedStorage ); + bOk = !aTmpVersionURL.isEmpty(); + } + } + } + + //fdo#61320: only store thumbnail image if the corresponding option is enabled in the configuration + if ( bOk && officecfg::Office::Common::Save::Document::GenerateThumbnail::get() + && GetCreateMode() != SfxObjectCreateMode::EMBEDDED && !bPasswdProvided && IsUseThumbnailSave() ) + { + // store the thumbnail representation image + // the thumbnail is not stored in case of encrypted document + if ( !GenerateAndStoreThumbnail( bPasswdProvided, xMedStorage ) ) + { + // TODO: error handling + SAL_WARN( "sfx.doc", "Couldn't store thumbnail representation!" ); + } + } + + if ( bOk ) + { + if ( pImpl->bIsSaving || pImpl->bPreserveVersions ) + { + try + { + const Sequence < util::RevisionTag > aVersions = rMedium.GetVersionList(); + if ( aVersions.hasElements() ) + { + // copy the version streams + static const OUStringLiteral aVersionsName( u"Versions" ); + uno::Reference< embed::XStorage > xNewVerStor = xMedStorage->openStorageElement( + aVersionsName, + embed::ElementModes::READWRITE ); + uno::Reference< embed::XStorage > xOldVerStor = GetStorage()->openStorageElement( + aVersionsName, + embed::ElementModes::READ ); + if ( !xNewVerStor.is() || !xOldVerStor.is() ) + throw uno::RuntimeException(); + + for ( const auto& rVersion : aVersions ) + { + if ( xOldVerStor->hasByName( rVersion.Identifier ) ) + xOldVerStor->copyElementTo( rVersion.Identifier, xNewVerStor, rVersion.Identifier ); + } + + uno::Reference< embed::XTransactedObject > xTransact( xNewVerStor, uno::UNO_QUERY ); + if ( xTransact.is() ) + xTransact->commit(); + } + } + catch( uno::Exception& ) + { + SAL_WARN( "sfx.doc", "Couldn't copy versions!" ); + bOk = false; + // TODO/LATER: a specific error could be set + } + } + + if ( bOk && pVersionItem && !rMedium.IsInCheckIn() ) + { + // store a version also + const SfxStringItem *pAuthorItem = SfxItemSet::GetItem<SfxStringItem>(pSet, SID_DOCINFO_AUTHOR, false); + + // version comment + util::RevisionTag aInfo; + aInfo.Comment = pVersionItem->GetValue(); + + // version author + if ( pAuthorItem ) + aInfo.Author = pAuthorItem->GetValue(); + else + // if not transferred as a parameter, get it from user settings + aInfo.Author = SvtUserOptions().GetFullName(); + + DateTime aTime( DateTime::SYSTEM ); + aInfo.TimeStamp.Day = aTime.GetDay(); + aInfo.TimeStamp.Month = aTime.GetMonth(); + aInfo.TimeStamp.Year = aTime.GetYear(); + aInfo.TimeStamp.Hours = aTime.GetHour(); + aInfo.TimeStamp.Minutes = aTime.GetMin(); + aInfo.TimeStamp.Seconds = aTime.GetSec(); + + // add new version information into the versionlist and save the versionlist + // the version list must have been transferred from the "old" medium before + rMedium.AddVersion_Impl(aInfo); + rMedium.SaveVersionList_Impl(); + bOk = PutURLContentsToVersionStream_Impl(aTmpVersionURL, xMedStorage, + aInfo.Identifier); + } + else if ( bOk && ( pImpl->bIsSaving || pImpl->bPreserveVersions ) ) + { + rMedium.SaveVersionList_Impl(); + } + } + + if ( !aTmpVersionURL.isEmpty() ) + ::utl::UCBContentHelper::Kill( aTmpVersionURL ); + } + else + { + // it's a "SaveAs" in an alien format + if ( rMedium.GetFilter() && ( rMedium.GetFilter()->GetFilterFlags() & SfxFilterFlags::STARONEFILTER ) ) + bOk = ExportTo( rMedium ); + else + bOk = ConvertTo( rMedium ); + + // after saving the document, the temporary object storage must be updated + // if the old object storage was not a temporary one, it will be updated also, because it will be used + // as a source for copying the objects into the new temporary storage that will be created below + // updating means: all child objects must be stored into it + // ( same as on loading, where these objects are copied to the temporary storage ) + // but don't commit these changes, because in the case when the old object storage is not a temporary one, + // all changes will be written into the original file ! + + if( bOk && !bCopyTo ) + // we also don't touch any graphical replacements here + SaveChildren( true ); + } + + if ( bOk ) + { + // if ODF version of oasis format changes on saving the signature should not be preserved + if ( bTryToPreserveScriptSignature && bNoPreserveForOasis ) + bTryToPreserveScriptSignature = ( SotStorage::GetVersion( rMedium.GetStorage() ) == SOFFICE_FILEFORMAT_60 ); + + uno::Reference< security::XDocumentDigitalSignatures > xDDSigns; + if (bTryToPreserveScriptSignature) + { + // if the scripting code was not changed and it is signed the signature should be preserved + // unfortunately at this point we have only information whether the basic code has changed or not + // so the only way is to check the signature if the basic was not changed + try + { + // get the ODF version of the new medium + OUString aVersion; + try + { + uno::Reference < beans::XPropertySet > xPropSet( rMedium.GetStorage(), uno::UNO_QUERY_THROW ); + xPropSet->getPropertyValue("Version") >>= aVersion; + } + catch( uno::Exception& ) + { + } + + xDDSigns = security::DocumentDigitalSignatures::createWithVersion(comphelper::getProcessComponentContext(), aVersion); + + const OUString aScriptSignName = xDDSigns->getScriptingContentSignatureDefaultStreamName(); + + if ( !aScriptSignName.isEmpty() ) + { + // target medium is still not committed, it should not be closed + // commit the package storage and close it, but leave the streams open + rMedium.StorageCommit_Impl(); + rMedium.CloseStorage(); + + uno::Reference< embed::XStorage > xReadOrig = pMedium->GetZipStorageToSign_Impl(); + if ( !xReadOrig.is() ) + throw uno::RuntimeException(); + uno::Reference< embed::XStorage > xMetaInf = xReadOrig->openStorageElement( + "META-INF", + embed::ElementModes::READ ); + + uno::Reference< embed::XStorage > xTarget = rMedium.GetZipStorageToSign_Impl( false ); + if ( !xTarget.is() ) + throw uno::RuntimeException(); + uno::Reference< embed::XStorage > xTargetMetaInf = xTarget->openStorageElement( + "META-INF", + embed::ElementModes::READWRITE ); + + if ( xMetaInf.is() && xTargetMetaInf.is() ) + { + xMetaInf->copyElementTo( aScriptSignName, xTargetMetaInf, aScriptSignName ); + + uno::Reference< embed::XTransactedObject > xTransact( xTargetMetaInf, uno::UNO_QUERY ); + if ( xTransact.is() ) + xTransact->commit(); + + xTargetMetaInf->dispose(); + + // now check the copied signature + uno::Sequence< security::DocumentSignatureInformation > aInfos = + xDDSigns->verifyScriptingContentSignatures( xTarget, + uno::Reference< io::XInputStream >() ); + SignatureState nState = DocumentSignatures::getSignatureState(aInfos); + if ( nState == SignatureState::OK || nState == SignatureState::NOTVALIDATED + || nState == SignatureState::PARTIAL_OK) + { + rMedium.SetCachedSignatureState_Impl( nState ); + + // commit the ZipStorage from target medium + xTransact.set( xTarget, uno::UNO_QUERY ); + if ( xTransact.is() ) + xTransact->commit(); + } + else + { + // it should not happen, the copies signature is invalid! + // throw the changes away + SAL_WARN( "sfx.doc", "An invalid signature was copied!" ); + } + } + } + } + catch( uno::Exception& ) + { + } + + rMedium.CloseZipStorage_Impl(); + } + + const OUString sName( rMedium.GetName( ) ); + bOk = rMedium.Commit(); + const OUString sNewName( rMedium.GetName( ) ); + + if ( sName != sNewName ) + GetMedium( )->SwitchDocumentToFile( sNewName ); + + if ( bOk ) + { + // if the target medium is an alien format and the "old" medium was an own format and the "old" medium + // has a name, the object storage must be exchanged, because now we need a new temporary storage + // as object storage + if ( !bCopyTo && bStorageBasedSource && !bStorageBasedTarget ) + { + if ( bStoreToSameLocation ) + { + // if the old medium already disconnected from document storage, the storage still must + // be switched if backup file is used + if ( bNeedsDisconnectionOnFail ) + ConnectTmpStorage_Impl( pImpl->m_xDocStorage, nullptr ); + } + else if (!pMedium->GetName().isEmpty() + || ( pMedium->HasStorage_Impl() && pMedium->WillDisposeStorageOnClose_Impl() ) ) + { + OSL_ENSURE(!pMedium->GetName().isEmpty(), "Fallback is used, the medium without name should not dispose the storage!"); + // copy storage of old medium to new temporary storage and take this over + if( !ConnectTmpStorage_Impl( pMedium->GetStorage(), pMedium ) ) + { + SAL_WARN( "sfx.doc", "Process after storing has failed." ); + bOk = false; + } + } + } + } + else + { + SAL_WARN( "sfx.doc", "Storing has failed." ); + + // in case the document storage was connected to backup temporarily it must be disconnected now + if ( bNeedsDisconnectionOnFail ) + ConnectTmpStorage_Impl( pImpl->m_xDocStorage, nullptr ); + } + } + + // unlock user interface + aLockUIGuard.Unlock(); + pImpl->bForbidReload = bOldStat; + + if ( bOk ) + { + try + { + ::ucbhelper::Content aContent( rMedium.GetName(), utl::UCBContentHelper::getDefaultCommandEnvironment(), comphelper::getProcessComponentContext() ); + css::uno::Reference < XPropertySetInfo > xProps = aContent.getProperties(); + if ( xProps.is() ) + { + static const OUStringLiteral aAuthor( u"Author" ); + static const OUStringLiteral aKeywords( u"Keywords" ); + static const OUStringLiteral aSubject( u"Subject" ); + + uno::Reference<document::XDocumentPropertiesSupplier> xDPS( + GetModel(), uno::UNO_QUERY_THROW); + uno::Reference<document::XDocumentProperties> xDocProps + = xDPS->getDocumentProperties(); + + if ( xProps->hasPropertyByName( aAuthor ) ) + { + aContent.setPropertyValue( aAuthor, Any(xDocProps->getAuthor()) ); + } + if ( xProps->hasPropertyByName( aKeywords ) ) + { + Any aAny; + aAny <<= ::comphelper::string::convertCommaSeparated( + xDocProps->getKeywords()); + aContent.setPropertyValue( aKeywords, aAny ); + } + if ( xProps->hasPropertyByName( aSubject ) ) + { + aContent.setPropertyValue( aSubject, Any(xDocProps->getSubject()) ); + } + } + } + catch( Exception& ) + { + } + } + + return bOk; +} + +bool SfxObjectShell::DisconnectStorage_Impl( SfxMedium& rSrcMedium, SfxMedium& rTargetMedium ) +{ + // this method disconnects the storage from source medium, and attaches it to the backup created by the target medium + + uno::Reference< embed::XStorage > xStorage = rSrcMedium.GetStorage(); + + bool bResult = false; + if ( xStorage == pImpl->m_xDocStorage ) + { + try + { + uno::Reference< embed::XOptimizedStorage > xOptStorage( xStorage, uno::UNO_QUERY_THROW ); + const OUString aBackupURL = rTargetMedium.GetBackup_Impl(); + if ( aBackupURL.isEmpty() ) + { + // the backup could not be created, try to disconnect the storage and close the source SfxMedium + // in this case the optimization is not possible, connect storage to a temporary file + rTargetMedium.ResetError(); + xOptStorage->writeAndAttachToStream( uno::Reference< io::XStream >() ); + rSrcMedium.CanDisposeStorage_Impl( false ); + rSrcMedium.Close(); + + // now try to create the backup + rTargetMedium.GetBackup_Impl(); + } + else + { + // the following call will only compare stream sizes + // TODO/LATER: this is a very risky part, since if the URL contents are different from the storage + // contents, the storage will be broken + xOptStorage->attachToURL( aBackupURL, true ); + + // the storage is successfully attached to backup, thus it is owned by the document not by the medium + rSrcMedium.CanDisposeStorage_Impl( false ); + bResult = true; + } + } + catch ( uno::Exception& ) + {} + } + return bResult; +} + + +bool SfxObjectShell::ConnectTmpStorage_Impl( + const uno::Reference< embed::XStorage >& xStorage, + SfxMedium* pMediumArg ) + +/* [Description] + + If the application operates on a temporary storage, then it may not take + the temporary storage from the SaveCompleted. Therefore the new storage + is connected already here in this case and SaveCompleted then does nothing. +*/ + +{ + bool bResult = false; + + if ( xStorage.is() ) + { + try + { + // the empty argument means that the storage will create temporary stream itself + uno::Reference< embed::XOptimizedStorage > xOptStorage( xStorage, uno::UNO_QUERY_THROW ); + xOptStorage->writeAndAttachToStream( uno::Reference< io::XStream >() ); + + // the storage is successfully disconnected from the original sources, thus the medium must not dispose it + if ( pMediumArg ) + pMediumArg->CanDisposeStorage_Impl( false ); + + bResult = true; + } + catch( uno::Exception& ) + { + } + + // if switching of the storage does not work for any reason ( nonroot storage for example ) use the old method + if ( !bResult ) try + { + uno::Reference< embed::XStorage > xTmpStorage = ::comphelper::OStorageHelper::GetTemporaryStorage(); + + DBG_ASSERT( xTmpStorage.is(), "If a storage can not be created an exception must be thrown!\n" ); + if ( !xTmpStorage.is() ) + throw uno::RuntimeException(); + + // TODO/LATER: may be it should be done in SwitchPersistence also + // TODO/LATER: find faster way to copy storage; perhaps sharing with backup?! + xStorage->copyToStorage( xTmpStorage ); + bResult = SaveCompleted( xTmpStorage ); + + if ( bResult ) + { + pImpl->aBasicManager.setStorage( xTmpStorage ); + + // Get rid of this workaround after issue i113914 is fixed + try + { + uno::Reference< script::XStorageBasedLibraryContainer > xBasicLibraries( pImpl->xBasicLibraries, uno::UNO_QUERY_THROW ); + xBasicLibraries->setRootStorage( xTmpStorage ); + } + catch( uno::Exception& ) + {} + try + { + uno::Reference< script::XStorageBasedLibraryContainer > xDialogLibraries( pImpl->xDialogLibraries, uno::UNO_QUERY_THROW ); + xDialogLibraries->setRootStorage( xTmpStorage ); + } + catch( uno::Exception& ) + {} + } + } + catch( uno::Exception& ) + {} + + if ( !bResult ) + { + // TODO/LATER: may need error code setting based on exception + SetError(ERRCODE_IO_GENERAL); + } + } + else if (!GetMedium()->GetFilter()->IsOwnFormat()) + bResult = true; + + return bResult; +} + + +bool SfxObjectShell::DoSaveObjectAs( SfxMedium& rMedium, bool bCommit ) +{ + bool bOk = false; + + ModifyBlocker_Impl aBlock( this ); + + uno::Reference < embed::XStorage > xNewStor = rMedium.GetStorage(); + if ( !xNewStor.is() ) + return false; + + uno::Reference < beans::XPropertySet > xPropSet( xNewStor, uno::UNO_QUERY ); + if ( !xPropSet.is() ) + return false; + + Any a = xPropSet->getPropertyValue("MediaType"); + OUString aMediaType; + if ( !(a>>=aMediaType) || aMediaType.isEmpty() ) + { + SAL_WARN( "sfx.doc", "The mediatype must be set already!" ); + SetupStorage( xNewStor, SOFFICE_FILEFORMAT_CURRENT, false ); + } + + pImpl->bIsSaving = false; + bOk = SaveAsOwnFormat( rMedium ); + + if ( bCommit ) + { + try { + uno::Reference< embed::XTransactedObject > xTransact( xNewStor, uno::UNO_QUERY_THROW ); + xTransact->commit(); + } + catch( uno::Exception& ) + { + SAL_WARN( "sfx.doc", "The storage was not committed on DoSaveAs!" ); + } + } + + return bOk; +} + + +// TODO/LATER: may be the call must be removed completely +bool SfxObjectShell::DoSaveAs( SfxMedium& rMedium ) +{ + // here only root storages are included, which are stored via temp file + rMedium.CreateTempFileNoCopy(); + SetError(rMedium.GetErrorCode()); + if ( GetError() ) + return false; + + // copy version list from "old" medium to target medium, so it can be used on saving + if ( pImpl->bPreserveVersions ) + rMedium.TransferVersionList_Impl( *pMedium ); + + bool bRet = SaveTo_Impl( rMedium, nullptr ); + if ( !bRet ) + SetError(rMedium.GetErrorCode()); + return bRet; +} + + +bool SfxObjectShell::DoSaveCompleted( SfxMedium* pNewMed, bool bRegisterRecent ) +{ + bool bOk = true; + bool bMedChanged = pNewMed && pNewMed!=pMedium; + + DBG_ASSERT( !pNewMed || pNewMed->GetError() == ERRCODE_NONE, "DoSaveCompleted: Medium has error!" ); + + // delete Medium (and Storage!) after all notifications + SfxMedium* pOld = pMedium; + if ( bMedChanged ) + { + pMedium = pNewMed; + pMedium->CanDisposeStorage_Impl( true ); + } + + std::shared_ptr<const SfxFilter> pFilter = pMedium ? pMedium->GetFilter() : nullptr; + if ( pNewMed ) + { + if( bMedChanged ) + { + if (!pNewMed->GetName().isEmpty()) + bHasName = true; + Broadcast( SfxHint(SfxHintId::NameChanged) ); + EnableSetModified(false); + getDocProperties()->setGenerator( + ::utl::DocInfoHelper::GetGeneratorString() ); + EnableSetModified(); + } + + uno::Reference< embed::XStorage > xStorage; + if ( !pFilter || IsPackageStorageFormat_Impl( *pMedium ) ) + { + uno::Reference < embed::XStorage > xOld = GetStorage(); + + // when the package based medium is broken and has no storage or if the storage + // is the same as the document storage the current document storage should be preserved + xStorage = pMedium->GetStorage(); + bOk = SaveCompleted( xStorage ); + if ( bOk && xStorage.is() && xOld != xStorage + && (!pOld || !pOld->HasStorage_Impl() || xOld != pOld->GetStorage() ) ) + { + // old own storage was not controlled by old Medium -> dispose it + try { + xOld->dispose(); + } catch( uno::Exception& ) + { + // the storage is disposed already + // can happen during reload scenario when the medium has + // disposed it during the closing + // will be fixed in one of the next milestones + } + } + } + else + { + if (pImpl->m_bSavingForSigning && pFilter && pFilter->GetSupportsSigning()) + // So that pMedium->pImpl->xStream becomes a non-empty + // reference, and at the end we attempt locking again in + // SfxMedium::LockOrigFileOnDemand(). + pMedium->GetMedium_Impl(); + + if( pMedium->GetOpenMode() & StreamMode::WRITE ) + pMedium->GetInStream(); + xStorage = GetStorage(); + } + + // TODO/LATER: may be this code will be replaced, but not sure + // Set storage in document library containers + pImpl->aBasicManager.setStorage( xStorage ); + + // Get rid of this workaround after issue i113914 is fixed + try + { + uno::Reference< script::XStorageBasedLibraryContainer > xBasicLibraries( pImpl->xBasicLibraries, uno::UNO_QUERY_THROW ); + xBasicLibraries->setRootStorage( xStorage ); + } + catch( uno::Exception& ) + {} + try + { + uno::Reference< script::XStorageBasedLibraryContainer > xDialogLibraries( pImpl->xDialogLibraries, uno::UNO_QUERY_THROW ); + xDialogLibraries->setRootStorage( xStorage ); + } + catch( uno::Exception& ) + {} + } + else + { + if( pMedium ) + { + if( pFilter && !IsPackageStorageFormat_Impl( *pMedium ) && (pMedium->GetOpenMode() & StreamMode::WRITE )) + { + pMedium->ReOpen(); + bOk = SaveCompletedChildren(); + } + else + bOk = SaveCompleted( nullptr ); + } + // either Save or ConvertTo + else + bOk = SaveCompleted( nullptr ); + } + + if ( bOk && pNewMed ) + { + if( bMedChanged ) + { + delete pOld; + + uno::Reference< frame::XModel > xModel = GetModel(); + if ( xModel.is() ) + { + const OUString& aURL {pNewMed->GetOrigURL()}; + uno::Sequence< beans::PropertyValue > aMediaDescr; + TransformItems( SID_OPENDOC, *pNewMed->GetItemSet(), aMediaDescr ); + try + { + xModel->attachResource( aURL, aMediaDescr ); + } + catch( uno::Exception& ) + {} + } + + const SfxBoolItem* pTemplateItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_TEMPLATE, false); + bool bTemplate = pTemplateItem && pTemplateItem->GetValue(); + + // before the title regenerated the document must lose the signatures + pImpl->nDocumentSignatureState = SignatureState::NOSIGNATURES; + if (!bTemplate) + { + pImpl->nScriptingSignatureState = pNewMed->GetCachedSignatureState_Impl(); + OSL_ENSURE( pImpl->nScriptingSignatureState != SignatureState::BROKEN, "The signature must not be broken at this place" ); + + // TODO/LATER: in future the medium must control own signature state, not the document + pNewMed->SetCachedSignatureState_Impl( SignatureState::NOSIGNATURES ); // set the default value back + } + else + pNewMed->SetCachedSignatureState_Impl( pImpl->nScriptingSignatureState ); + + // Set new title + if (!pNewMed->GetName().isEmpty() && SfxObjectCreateMode::EMBEDDED != eCreateMode) + InvalidateName(); + SetModified(false); // reset only by set medium + Broadcast( SfxHint(SfxHintId::ModeChanged) ); + + // this is the end of the saving process, it is possible that + // the file was changed + // between medium commit and this step (attributes change and so on) + // so get the file date again + if ( pNewMed->DocNeedsFileDateCheck() ) + pNewMed->GetInitFileDate( true ); + } + } + + pMedium->ClearBackup_Impl(); + pMedium->LockOrigFileOnDemand( true, false ); + + if (bRegisterRecent) + AddToRecentlyUsedList(); + + return bOk; +} + +void SfxObjectShell::AddToRecentlyUsedList() +{ + INetURLObject aUrl( pMedium->GetOrigURL() ); + + if ( aUrl.GetProtocol() == INetProtocol::File ) + { + std::shared_ptr<const SfxFilter> pOrgFilter = pMedium->GetFilter(); + Application::AddToRecentDocumentList( aUrl.GetURLNoPass( INetURLObject::DecodeMechanism::NONE ), + pOrgFilter ? pOrgFilter->GetMimeType() : OUString(), + pOrgFilter ? pOrgFilter->GetServiceName() : OUString() ); + } +} + + +bool SfxObjectShell::ConvertFrom +( + SfxMedium& /*rMedium*/ /* <SfxMedium>, which describes the source file + (for example file name, <SfxFilter>, + Open-Modi and so on) */ +) + +/* [Description] + + This method is called for loading of documents over all filters which are + not SfxFilterFlags::OWN or for which no clipboard format has been registered + (thus no storage format that is used). In other words, with this method + it is imported. + + Files which are to be opened here should be opened through 'rMedium' + to guarantee the right open modes. Especially if the format is retained + (only possible with SfxFilterFlags::SIMULATE or SfxFilterFlags::OWN) file which must + be opened STREAM_SHARE_DENYWRITE. + + [Return value] + + bool true + The document could be loaded. + + false + The document could not be loaded, an error code + received through <SvMedium::GetError()const> + + [Example] + + bool DocSh::ConvertFrom( SfxMedium &rMedium ) + { + SvStreamRef xStream = rMedium.GetInStream(); + if( xStream.is() ) + { + xStream->SetBufferSize(4096); + *xStream >> ...; + + // Do not call 'rMedium.CloseInStream()'! Keep File locked! + return ERRCODE_NONE == rMedium.GetError(); + } + + return false; + } + + [Cross-references] + + <SfxObjectShell::ConvertTo(SfxMedium&)> + <SfxFilterFlags::REGISTRATION> +*/ +{ + return false; +} + +bool SfxObjectShell::ImportFrom(SfxMedium& rMedium, + css::uno::Reference<css::text::XTextRange> const& xInsertPosition) +{ + const OUString aFilterName( rMedium.GetFilter()->GetFilterName() ); + + uno::Reference< lang::XMultiServiceFactory > xMan = ::comphelper::getProcessServiceFactory(); + uno::Reference < lang::XMultiServiceFactory > xFilterFact ( + xMan->createInstance( "com.sun.star.document.FilterFactory" ), uno::UNO_QUERY ); + + uno::Sequence < beans::PropertyValue > aProps; + uno::Reference < container::XNameAccess > xFilters ( xFilterFact, uno::UNO_QUERY ); + if ( xFilters->hasByName( aFilterName ) ) + { + xFilters->getByName( aFilterName ) >>= aProps; + rMedium.GetItemSet()->Put( SfxStringItem( SID_FILTER_NAME, aFilterName ) ); + } + + OUString aFilterImplName; + auto pProp = std::find_if(std::cbegin(aProps), std::cend(aProps), + [](const beans::PropertyValue& rFilterProp) { return rFilterProp.Name == "FilterService"; }); + if (pProp != std::cend(aProps)) + pProp->Value >>= aFilterImplName; + + uno::Reference< document::XFilter > xLoader; + if ( !aFilterImplName.isEmpty() ) + { + try + { + xLoader.set( xFilterFact->createInstanceWithArguments( aFilterName, uno::Sequence < uno::Any >() ), uno::UNO_QUERY ); + } + catch(const uno::Exception&) + { + xLoader.clear(); + } + } + if ( xLoader.is() ) + { + // it happens that xLoader does not support xImporter! + try + { + uno::Reference< lang::XComponent > xComp( GetModel(), uno::UNO_QUERY_THROW ); + uno::Reference< document::XImporter > xImporter( xLoader, uno::UNO_QUERY_THROW ); + xImporter->setTargetDocument( xComp ); + + uno::Sequence < beans::PropertyValue > lDescriptor; + rMedium.GetItemSet()->Put( SfxStringItem( SID_FILE_NAME, rMedium.GetName() ) ); + TransformItems( SID_OPENDOC, *rMedium.GetItemSet(), lDescriptor ); + + css::uno::Sequence < css::beans::PropertyValue > aArgs ( lDescriptor.getLength() ); + css::beans::PropertyValue * pNewValue = aArgs.getArray(); + const css::beans::PropertyValue * pOldValue = lDescriptor.getConstArray(); + static const OUStringLiteral sInputStream ( u"InputStream" ); + + bool bHasInputStream = false; + bool bHasBaseURL = false; + sal_Int32 nEnd = lDescriptor.getLength(); + + for ( sal_Int32 i = 0; i < nEnd; i++ ) + { + pNewValue[i] = pOldValue[i]; + if ( pOldValue [i].Name == sInputStream ) + bHasInputStream = true; + else if ( pOldValue[i].Name == "DocumentBaseURL" ) + bHasBaseURL = true; + } + + if ( !bHasInputStream ) + { + aArgs.realloc ( ++nEnd ); + auto pArgs = aArgs.getArray(); + pArgs[nEnd-1].Name = sInputStream; + pArgs[nEnd-1].Value <<= css::uno::Reference < css::io::XInputStream > ( new utl::OSeekableInputStreamWrapper ( *rMedium.GetInStream() ) ); + } + + if ( !bHasBaseURL ) + { + aArgs.realloc ( ++nEnd ); + auto pArgs = aArgs.getArray(); + pArgs[nEnd-1].Name = "DocumentBaseURL"; + pArgs[nEnd-1].Value <<= rMedium.GetBaseURL(); + } + + if (xInsertPosition.is()) { + aArgs.realloc( nEnd += 2 ); + auto pArgs = aArgs.getArray(); + pArgs[nEnd-2].Name = "InsertMode"; + pArgs[nEnd-2].Value <<= true; + pArgs[nEnd-1].Name = "TextInsertModeRange"; + pArgs[nEnd-1].Value <<= xInsertPosition; + } + + // #i119492# During loading, some OLE objects like chart will be set + // modified flag, so needs to reset the flag to false after loading + bool bRtn = xLoader->filter(aArgs); + const uno::Sequence < OUString > aNames = GetEmbeddedObjectContainer().GetObjectNames(); + for ( const auto& rName : aNames ) + { + uno::Reference < embed::XEmbeddedObject > xObj = GetEmbeddedObjectContainer().GetEmbeddedObject( rName ); + OSL_ENSURE( xObj.is(), "An empty entry in the embedded objects list!" ); + if ( xObj.is() ) + { + sal_Int32 nState = xObj->getCurrentState(); + if ( nState == embed::EmbedStates::LOADED || nState == embed::EmbedStates::RUNNING ) // means that the object is not active + { + uno::Reference< util::XModifiable > xModifiable( xObj->getComponent(), uno::UNO_QUERY ); + if (xModifiable.is() && xModifiable->isModified()) + { + uno::Reference<embed::XEmbedPersist> const xPers(xObj, uno::UNO_QUERY); + assert(xPers.is() && "Modified object without persistence!"); + // store it before resetting modified! + xPers->storeOwn(); + xModifiable->setModified(false); + } + } + } + } + + // tdf#107690 import custom document property _MarkAsFinal as SecurityOptOpenReadonly + // (before this fix, LibreOffice opened read-only OOXML documents as editable, + // also saved and exported _MarkAsFinal=true silently, resulting unintended read-only + // warning info bar in MSO) + uno::Reference< document::XDocumentPropertiesSupplier > xPropSupplier(GetModel(), uno::UNO_QUERY_THROW); + uno::Reference<document::XDocumentProperties> xDocProps = xPropSupplier->getDocumentProperties() ; + uno::Reference<beans::XPropertyContainer> xPropertyContainer = xDocProps->getUserDefinedProperties(); + if (xPropertyContainer.is()) + { + uno::Reference<beans::XPropertySet> xPropertySet(xPropertyContainer, uno::UNO_QUERY); + if (xPropertySet.is()) + { + uno::Reference<beans::XPropertySetInfo> xPropertySetInfo = xPropertySet->getPropertySetInfo(); + if (xPropertySetInfo.is() && xPropertySetInfo->hasPropertyByName("_MarkAsFinal")) + { + if (xPropertySet->getPropertyValue("_MarkAsFinal").get<bool>()) + { + uno::Reference< lang::XMultiServiceFactory > xFactory(GetModel(), uno::UNO_QUERY); + uno::Reference< beans::XPropertySet > xSettings(xFactory->createInstance("com.sun.star.document.Settings"), uno::UNO_QUERY); + xSettings->setPropertyValue("LoadReadonly", uno::Any(true)); + } + xPropertyContainer->removeProperty("_MarkAsFinal"); + } + } + } + + return bRtn; + } + catch (const packages::zip::ZipIOException&) + { + SetError(ERRCODE_IO_BROKENPACKAGE); + } + catch (const lang::WrappedTargetRuntimeException& rWrapped) + { + io::WrongFormatException e; + if (rWrapped.TargetException >>= e) + { + SetError(*new StringErrorInfo(ERRCODE_SFX_FORMAT_ROWCOL, + e.Message, DialogMask::ButtonsOk | DialogMask::MessageError )); + } + } + catch (const css::io::IOException& e) + { + SetError(*new StringErrorInfo(ERRCODE_SFX_FORMAT_ROWCOL, + e.Message, DialogMask::ButtonsOk | DialogMask::MessageError )); + } + catch (const std::exception& e) + { + const char *msg = e.what(); + const OUString sError(msg, strlen(msg), RTL_TEXTENCODING_ASCII_US); + SetError(*new StringErrorInfo(ERRCODE_SFX_DOLOADFAILED, + sError, DialogMask::ButtonsOk | DialogMask::MessageError)); + } + catch (...) + { + std::abort(); // cannot happen + } + } + + return false; +} + +bool SfxObjectShell::ExportTo( SfxMedium& rMedium ) +{ + const OUString aFilterName( rMedium.GetFilter()->GetFilterName() ); + uno::Reference< document::XExporter > xExporter; + + { + uno::Reference< lang::XMultiServiceFactory > xMan = ::comphelper::getProcessServiceFactory(); + uno::Reference < lang::XMultiServiceFactory > xFilterFact ( + xMan->createInstance( "com.sun.star.document.FilterFactory" ), uno::UNO_QUERY ); + + uno::Sequence < beans::PropertyValue > aProps; + uno::Reference < container::XNameAccess > xFilters ( xFilterFact, uno::UNO_QUERY ); + if ( xFilters->hasByName( aFilterName ) ) + xFilters->getByName( aFilterName ) >>= aProps; + + OUString aFilterImplName; + auto pProp = std::find_if(std::cbegin(aProps), std::cend(aProps), + [](const beans::PropertyValue& rFilterProp) { return rFilterProp.Name == "FilterService"; }); + if (pProp != std::cend(aProps)) + pProp->Value >>= aFilterImplName; + + if ( !aFilterImplName.isEmpty() ) + { + try + { + xExporter.set( xFilterFact->createInstanceWithArguments( aFilterName, uno::Sequence < uno::Any >() ), uno::UNO_QUERY ); + } + catch(const uno::Exception&) + { + xExporter.clear(); + } + } + } + + if ( xExporter.is() ) + { + try{ + uno::Reference< lang::XComponent > xComp( GetModel(), uno::UNO_QUERY_THROW ); + uno::Reference< document::XFilter > xFilter( xExporter, uno::UNO_QUERY_THROW ); + xExporter->setSourceDocument( xComp ); + + css::uno::Sequence < css::beans::PropertyValue > aOldArgs; + SfxItemSet* pItems = rMedium.GetItemSet(); + TransformItems( SID_SAVEASDOC, *pItems, aOldArgs ); + + const css::beans::PropertyValue * pOldValue = aOldArgs.getConstArray(); + css::uno::Sequence < css::beans::PropertyValue > aArgs ( aOldArgs.getLength() ); + css::beans::PropertyValue * pNewValue = aArgs.getArray(); + + // put in the REAL file name, and copy all PropertyValues + static const OUStringLiteral sOutputStream ( u"OutputStream" ); + static const OUStringLiteral sStream ( u"StreamForOutput" ); + bool bHasOutputStream = false; + bool bHasStream = false; + bool bHasBaseURL = false; + bool bHasFilterName = false; + bool bIsRedactMode = false; + bool bIsPreview = false; + sal_Int32 nEnd = aOldArgs.getLength(); + + for ( sal_Int32 i = 0; i < nEnd; i++ ) + { + pNewValue[i] = pOldValue[i]; + if ( pOldValue[i].Name == "FileName" ) + pNewValue[i].Value <<= rMedium.GetName(); + else if ( pOldValue[i].Name == sOutputStream ) + bHasOutputStream = true; + else if ( pOldValue[i].Name == sStream ) + bHasStream = true; + else if ( pOldValue[i].Name == "DocumentBaseURL" ) + bHasBaseURL = true; + else if( pOldValue[i].Name == "FilterName" ) + bHasFilterName = true; + } + + const css::uno::Sequence<css::beans::PropertyValue>& rMediumArgs = rMedium.GetArgs(); + for ( sal_Int32 i = 0; i < rMediumArgs.getLength(); i++ ) + { + if( rMediumArgs[i].Name == "IsPreview" ) + rMediumArgs[i].Value >>= bIsPreview; + } + + // FIXME: Handle this inside TransformItems() + if (pItems->GetItemState(SID_IS_REDACT_MODE) == SfxItemState::SET) + bIsRedactMode = true; + + if ( !bHasOutputStream ) + { + aArgs.realloc ( ++nEnd ); + auto pArgs = aArgs.getArray(); + pArgs[nEnd-1].Name = sOutputStream; + pArgs[nEnd-1].Value <<= css::uno::Reference < css::io::XOutputStream > ( new utl::OOutputStreamWrapper ( *rMedium.GetOutStream() ) ); + } + + // add stream as well, for OOX export and maybe others + if ( !bHasStream ) + { + aArgs.realloc ( ++nEnd ); + auto pArgs = aArgs.getArray(); + pArgs[nEnd-1].Name = sStream; + pArgs[nEnd-1].Value <<= css::uno::Reference < css::io::XStream > ( new utl::OStreamWrapper ( *rMedium.GetOutStream() ) ); + } + + if ( !bHasBaseURL ) + { + aArgs.realloc ( ++nEnd ); + auto pArgs = aArgs.getArray(); + pArgs[nEnd-1].Name = "DocumentBaseURL"; + pArgs[nEnd-1].Value <<= rMedium.GetBaseURL( true ); + } + + if( !bHasFilterName ) + { + aArgs.realloc( ++nEnd ); + auto pArgs = aArgs.getArray(); + pArgs[nEnd-1].Name = "FilterName"; + pArgs[nEnd-1].Value <<= aFilterName; + } + + if (bIsRedactMode) + { + aArgs.realloc( ++nEnd ); + auto pArgs = aArgs.getArray(); + pArgs[nEnd-1].Name = "IsRedactMode"; + pArgs[nEnd-1].Value <<= bIsRedactMode; + } + + if (bIsPreview) + { + aArgs.realloc( ++nEnd ); + auto pArgs = aArgs.getArray(); + pArgs[nEnd-1].Name = "IsPreview"; + pArgs[nEnd-1].Value <<= bIsPreview; + } + + return xFilter->filter( aArgs ); + }catch(...) + {} + } + + return false; +} + + +bool SfxObjectShell::ConvertTo +( + SfxMedium& /*rMedium*/ /* <SfxMedium>, which describes the target file + (for example file name, <SfxFilter>, + Open-Modi and so on) */ +) + +/* [Description] + + This method is called for saving of documents over all filters which are + not SfxFilterFlags::OWN or for which no clipboard format has been registered + (thus no storage format that is used). In other words, with this method + it is exported. + + Files which are to be opened here should be opened through 'rMedium' + to guarantee the right open modes. Especially if the format is retained + (only possible with SfxFilterFlags::SIMULATE or SfxFilterFlags::OWN) file which must + be opened STREAM_SHARE_DENYWRITE. + + [Return value] + + bool true + The document could be saved. + + false + The document could not be saved, an error code is + received by <SvMedium::GetError()const> + + + [Example] + + bool DocSh::ConvertTo( SfxMedium &rMedium ) + { + SvStreamRef xStream = rMedium.GetOutStream(); + if ( xStream.is() ) + { + xStream->SetBufferSize(4096); + *xStream << ...; + + rMedium.CloseOutStream(); // opens the InStream automatically + return ERRCODE_NONE == rMedium.GetError(); + } + return false ; + } + + [Cross-references] + + <SfxObjectShell::ConvertFrom(SfxMedium&)> + <SfxFilterFlags::REGISTRATION> +*/ + +{ + return false; +} + + +bool SfxObjectShell::DoSave_Impl( const SfxItemSet* pArgs ) +{ + SfxMedium* pRetrMedium = GetMedium(); + std::shared_ptr<const SfxFilter> pFilter = pRetrMedium->GetFilter(); + + // copy the original itemset, but remove the "version" item, because pMediumTmp + // is a new medium "from scratch", so no version should be stored into it + std::shared_ptr<SfxItemSet> pSet = std::make_shared<SfxAllItemSet>(*pRetrMedium->GetItemSet()); + pSet->ClearItem( SID_VERSION ); + pSet->ClearItem( SID_DOC_BASEURL ); + + // copy the version comment and major items for the checkin only + if ( pRetrMedium->IsInCheckIn( ) ) + { + const SfxPoolItem* pMajor = pArgs->GetItem( SID_DOCINFO_MAJOR ); + if ( pMajor ) + pSet->Put( *pMajor ); + + const SfxPoolItem* pComments = pArgs->GetItem( SID_DOCINFO_COMMENTS ); + if ( pComments ) + pSet->Put( *pComments ); + } + + // create a medium as a copy; this medium is only for writing, because it + // uses the same name as the original one writing is done through a copy, + // that will be transferred to the target (of course after calling HandsOff) + SfxMedium* pMediumTmp = new SfxMedium( pRetrMedium->GetName(), pRetrMedium->GetOpenMode(), pFilter, std::move(pSet) ); + pMediumTmp->SetInCheckIn( pRetrMedium->IsInCheckIn( ) ); + pMediumTmp->SetLongName( pRetrMedium->GetLongName() ); + if ( pMediumTmp->GetErrorCode() != ERRCODE_NONE ) + { + SetError(pMediumTmp->GetError()); + delete pMediumTmp; + return false; + } + + // copy version list from "old" medium to target medium, so it can be used on saving + pMediumTmp->TransferVersionList_Impl( *pRetrMedium ); + + // an interaction handler here can acquire only in case of GUI Saving + // and should be removed after the saving is done + css::uno::Reference< XInteractionHandler > xInteract; + const SfxUnoAnyItem* pxInteractionItem = SfxItemSet::GetItem<SfxUnoAnyItem>(pArgs, SID_INTERACTIONHANDLER, false); + if ( pxInteractionItem && ( pxInteractionItem->GetValue() >>= xInteract ) && xInteract.is() ) + pMediumTmp->GetItemSet()->Put( SfxUnoAnyItem( SID_INTERACTIONHANDLER, Any( xInteract ) ) ); + + const SfxBoolItem* pNoFileSync = pArgs->GetItem<SfxBoolItem>(SID_NO_FILE_SYNC, false); + if (pNoFileSync && pNoFileSync->GetValue()) + pMediumTmp->DisableFileSync(true); + + bool bSaved = false; + if( !GetError() && SaveTo_Impl( *pMediumTmp, pArgs ) ) + { + bSaved = true; + + if( pMediumTmp->GetItemSet() ) + { + pMediumTmp->GetItemSet()->ClearItem( SID_INTERACTIONHANDLER ); + pMediumTmp->GetItemSet()->ClearItem( SID_PROGRESS_STATUSBAR_CONTROL ); + } + + SetError(pMediumTmp->GetErrorCode()); + + bool bOpen = DoSaveCompleted( pMediumTmp ); + + DBG_ASSERT(bOpen,"Error handling for DoSaveCompleted not implemented"); + } + else + { + // transfer error code from medium to objectshell + SetError(pMediumTmp->GetError()); + + // reconnect to object storage + DoSaveCompleted(); + + if( pRetrMedium->GetItemSet() ) + { + pRetrMedium->GetItemSet()->ClearItem( SID_INTERACTIONHANDLER ); + pRetrMedium->GetItemSet()->ClearItem( SID_PROGRESS_STATUSBAR_CONTROL ); + } + + delete pMediumTmp; + } + + SetModified( !bSaved ); + return bSaved; +} + + +bool SfxObjectShell::Save_Impl( const SfxItemSet* pSet ) +{ + if ( IsReadOnly() ) + { + SetError(ERRCODE_SFX_DOCUMENTREADONLY); + return false; + } + + pImpl->bIsSaving = true; + bool bSaved = false; + const SfxStringItem* pSalvageItem = SfxItemSet::GetItem<SfxStringItem>(GetMedium()->GetItemSet(), SID_DOC_SALVAGE, false); + if ( pSalvageItem ) + { + const SfxStringItem* pFilterItem = SfxItemSet::GetItem<SfxStringItem>(GetMedium()->GetItemSet(), SID_FILTER_NAME, false); + std::shared_ptr<const SfxFilter> pFilter; + if ( pFilterItem ) + pFilter = SfxFilterMatcher( GetFactory().GetFactoryName() ).GetFilter4FilterName( OUString() ); + + SfxMedium *pMed = new SfxMedium( + pSalvageItem->GetValue(), StreamMode::READWRITE | StreamMode::SHARE_DENYWRITE | StreamMode::TRUNC, pFilter ); + + const SfxStringItem* pPasswordItem = SfxItemSet::GetItem<SfxStringItem>(GetMedium()->GetItemSet(), SID_PASSWORD, false); + if ( pPasswordItem ) + pMed->GetItemSet()->Put( *pPasswordItem ); + + bSaved = DoSaveAs( *pMed ); + if ( bSaved ) + bSaved = DoSaveCompleted( pMed ); + else + delete pMed; + } + else + bSaved = DoSave_Impl( pSet ); + return bSaved; +} + +bool SfxObjectShell::CommonSaveAs_Impl(const INetURLObject& aURL, const OUString& aFilterName, + SfxItemSet& rItemSet, + const uno::Sequence<beans::PropertyValue>& rArgs) +{ + if( aURL.HasError() ) + { + SetError(ERRCODE_IO_INVALIDPARAMETER); + return false; + } + + if ( aURL != INetURLObject( u"private:stream" ) ) + { + // Is there already a Document with this name? + SfxObjectShell* pDoc = nullptr; + for ( SfxObjectShell* pTmp = SfxObjectShell::GetFirst(); + pTmp && !pDoc; + pTmp = SfxObjectShell::GetNext(*pTmp) ) + { + if( ( pTmp != this ) && pTmp->GetMedium() ) + { + INetURLObject aCompare( pTmp->GetMedium()->GetName() ); + if ( aCompare == aURL ) + pDoc = pTmp; + } + } + if ( pDoc ) + { + // Then error message: "already opened" + SetError(ERRCODE_SFX_ALREADYOPEN); + return false; + } + } + + DBG_ASSERT( aURL.GetProtocol() != INetProtocol::NotValid, "Illegal URL!" ); + DBG_ASSERT( rItemSet.Count() != 0, "Incorrect Parameter"); + + const SfxBoolItem* pSaveToItem = rItemSet.GetItem<SfxBoolItem>(SID_SAVETO, false); + bool bSaveTo = pSaveToItem && pSaveToItem->GetValue(); + + std::shared_ptr<const SfxFilter> pFilter = GetFactory().GetFilterContainer()->GetFilter4FilterName( aFilterName ); + if ( !pFilter + || !pFilter->CanExport() + || (!bSaveTo && !pFilter->CanImport()) ) + { + SetError(ERRCODE_IO_INVALIDPARAMETER); + return false; + } + + + const SfxBoolItem* pCopyStreamItem = rItemSet.GetItem(SID_COPY_STREAM_IF_POSSIBLE, false); + if ( bSaveTo && pCopyStreamItem && pCopyStreamItem->GetValue() && !IsModified() ) + { + if (pMedium->TryDirectTransfer(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE), rItemSet)) + return true; + } + rItemSet.ClearItem( SID_COPY_STREAM_IF_POSSIBLE ); + + SfxMedium *pActMed = GetMedium(); + const INetURLObject aActName(pActMed->GetName()); + + bool bWasReadonly = IsReadOnly(); + + if ( aURL == aActName && aURL != INetURLObject( u"private:stream" ) + && IsReadOnly() ) + { + SetError(ERRCODE_SFX_DOCUMENTREADONLY); + return false; + } + + if (SfxItemState::SET != rItemSet.GetItemState(SID_UNPACK) && officecfg::Office::Common::Save::Document::Unpacked::get()) + rItemSet.Put(SfxBoolItem(SID_UNPACK, false)); + +#if HAVE_FEATURE_MULTIUSER_ENVIRONMENT + OUString aTempFileURL; + if ( IsDocShared() ) + aTempFileURL = pMedium->GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ); +#endif + + if (PreDoSaveAs_Impl(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE), aFilterName, + rItemSet, rArgs)) + { + // Update Data on media + SfxItemSet *pSet = GetMedium()->GetItemSet(); + pSet->ClearItem( SID_INTERACTIONHANDLER ); + pSet->ClearItem( SID_PROGRESS_STATUSBAR_CONTROL ); + pSet->ClearItem( SID_STANDARD_DIR ); + pSet->ClearItem( SID_PATH ); + + if ( !bSaveTo ) + { + pSet->ClearItem( SID_REFERER ); + pSet->ClearItem( SID_POSTDATA ); + pSet->ClearItem( SID_TEMPLATE ); + pSet->ClearItem( SID_DOC_READONLY ); + pSet->ClearItem( SID_CONTENTTYPE ); + pSet->ClearItem( SID_CHARSET ); + pSet->ClearItem( SID_FILTER_NAME ); + pSet->ClearItem( SID_OPTIONS ); + pSet->ClearItem( SID_VERSION ); + pSet->ClearItem( SID_EDITDOC ); + pSet->ClearItem( SID_OVERWRITE ); + pSet->ClearItem( SID_DEFAULTFILEPATH ); + pSet->ClearItem( SID_DEFAULTFILENAME ); + + const SfxStringItem* pFilterItem = rItemSet.GetItem<SfxStringItem>(SID_FILTER_NAME, false); + if ( pFilterItem ) + pSet->Put( *pFilterItem ); + + const SfxStringItem* pOptionsItem = rItemSet.GetItem<SfxStringItem>(SID_OPTIONS, false); + if ( pOptionsItem ) + pSet->Put( *pOptionsItem ); + + const SfxStringItem* pFilterOptItem = rItemSet.GetItem<SfxStringItem>(SID_FILE_FILTEROPTIONS, false); + if ( pFilterOptItem ) + pSet->Put( *pFilterOptItem ); + +#if HAVE_FEATURE_MULTIUSER_ENVIRONMENT + if ( IsDocShared() && !aTempFileURL.isEmpty() ) + { + // this is a shared document that has to be disconnected from the old location + FreeSharedFile( aTempFileURL ); + + if ( pFilter->IsOwnFormat() + && pFilter->UsesStorage() + && pFilter->GetVersion() >= SOFFICE_FILEFORMAT_60 ) + { + // the target format is the own format + // the target document must be shared + SwitchToShared( true, false ); + } + } +#endif + } + + if ( bWasReadonly && !bSaveTo ) + Broadcast( SfxHint(SfxHintId::ModeChanged) ); + + return true; + } + else + return false; +} + +bool SfxObjectShell::PreDoSaveAs_Impl(const OUString& rFileName, const OUString& aFilterName, + SfxItemSet const& rItemSet, + const uno::Sequence<beans::PropertyValue>& rArgs) +{ + // copy all items stored in the itemset of the current medium + std::shared_ptr<SfxAllItemSet> xMergedParams = std::make_shared<SfxAllItemSet>( *pMedium->GetItemSet() ); + + // in "SaveAs" title and password will be cleared ( maybe the new itemset contains new values, otherwise they will be empty ) + // #i119366# - As the SID_ENCRYPTIONDATA and SID_PASSWORD are using for setting password together, we need to clear them both. + // Also, ( maybe the new itemset contains new values, otherwise they will be empty ) + if (xMergedParams->HasItem(SID_ENCRYPTIONDATA)) + { + bool bPasswordProtected = true; + const SfxUnoAnyItem* pEncryptionDataItem + = xMergedParams->GetItem<SfxUnoAnyItem>(SID_ENCRYPTIONDATA, false); + if (pEncryptionDataItem) + { + uno::Sequence<beans::NamedValue> aEncryptionData; + pEncryptionDataItem->GetValue() >>= aEncryptionData; + for (const auto& rItem : std::as_const(aEncryptionData)) + { + if (rItem.Name == "CryptoType") + { + OUString aValue; + rItem.Value >>= aValue; + if (aValue != "StrongEncryptionDataSpace") + { + // This is not just a password protected document. Let's keep encryption data as is. + bPasswordProtected = false; + } + break; + } + } + } + if (bPasswordProtected) + { + // For password protected documents remove encryption data during "Save as..." + xMergedParams->ClearItem(SID_PASSWORD); + xMergedParams->ClearItem(SID_ENCRYPTIONDATA); + } + } + + xMergedParams->ClearItem( SID_DOCINFO_TITLE ); + + xMergedParams->ClearItem( SID_INPUTSTREAM ); + xMergedParams->ClearItem( SID_STREAM ); + xMergedParams->ClearItem( SID_CONTENT ); + xMergedParams->ClearItem( SID_DOC_READONLY ); + xMergedParams->ClearItem( SID_DOC_BASEURL ); + + xMergedParams->ClearItem( SID_REPAIRPACKAGE ); + + // "SaveAs" will never store any version information - it's a complete new file ! + xMergedParams->ClearItem( SID_VERSION ); + + // merge the new parameters into the copy + // all values present in both itemsets will be overwritten by the new parameters + xMergedParams->Put(rItemSet); + + SAL_WARN_IF( xMergedParams->GetItemState( SID_DOC_SALVAGE) >= SfxItemState::SET, + "sfx.doc","Salvage item present in Itemset, check the parameters!"); + + // should be unnecessary - too hot to handle! + xMergedParams->ClearItem( SID_DOC_SALVAGE ); + + // create a medium for the target URL + SfxMedium *pNewFile = new SfxMedium( rFileName, StreamMode::READWRITE | StreamMode::SHARE_DENYWRITE | StreamMode::TRUNC, nullptr, xMergedParams ); + pNewFile->SetArgs(rArgs); + + const SfxBoolItem* pNoFileSync = xMergedParams->GetItem<SfxBoolItem>(SID_NO_FILE_SYNC, false); + if (pNoFileSync && pNoFileSync->GetValue()) + pNewFile->DisableFileSync(true); + + bool bUseThumbnailSave = IsUseThumbnailSave(); + comphelper::ScopeGuard aThumbnailGuard( + [this, bUseThumbnailSave] { this->SetUseThumbnailSave(bUseThumbnailSave); }); + const SfxBoolItem* pNoThumbnail = xMergedParams->GetItem<SfxBoolItem>(SID_NO_THUMBNAIL, false); + if (pNoThumbnail) + // Thumbnail generation should be avoided just for this save. + SetUseThumbnailSave(!pNoThumbnail->GetValue()); + else + aThumbnailGuard.dismiss(); + + // set filter; if no filter is given, take the default filter of the factory + if ( !aFilterName.isEmpty() ) + { + pNewFile->SetFilter( GetFactory().GetFilterContainer()->GetFilter4FilterName( aFilterName ) ); + + if(aFilterName == "writer_pdf_Export" && pNewFile->GetItemSet()) + { + uno::Sequence< beans::PropertyValue > aSaveToFilterDataOptions(2); + auto pSaveToFilterDataOptions = aSaveToFilterDataOptions.getArray(); + bool bRet = false; + + for(int i = 0 ; i< rArgs.getLength() ; ++i) + { + auto aProp = rArgs[i]; + if(aProp.Name == "EncryptFile") + { + pSaveToFilterDataOptions[0].Name = aProp.Name; + pSaveToFilterDataOptions[0].Value = aProp.Value; + bRet = true; + } + if(aProp.Name == "DocumentOpenPassword") + { + pSaveToFilterDataOptions[1].Name = aProp.Name; + pSaveToFilterDataOptions[1].Value = aProp.Value; + bRet = true; + } + } + + if( bRet ) + pNewFile->GetItemSet()->Put( SfxUnoAnyItem(SID_FILTER_DATA, uno::Any(aSaveToFilterDataOptions))); + } + } + else + pNewFile->SetFilter( GetFactory().GetFilterContainer()->GetAnyFilter( SfxFilterFlags::IMPORT | SfxFilterFlags::EXPORT ) ); + + if ( pNewFile->GetErrorCode() != ERRCODE_NONE ) + { + // creating temporary file failed ( f.e. floppy disk not inserted! ) + SetError(pNewFile->GetError()); + delete pNewFile; + return false; + } + + if (comphelper::LibreOfficeKit::isActive()) + { + // Before saving, commit in-flight changes. + TerminateEditing(); + } + + // check if a "SaveTo" is wanted, no "SaveAs" + const SfxBoolItem* pSaveToItem = xMergedParams->GetItem<SfxBoolItem>(SID_SAVETO, false); + bool bCopyTo = GetCreateMode() == SfxObjectCreateMode::EMBEDDED || (pSaveToItem && pSaveToItem->GetValue()); + + // distinguish between "Save" and "SaveAs" + pImpl->bIsSaving = false; + + // copy version list from "old" medium to target medium, so it can be used on saving + if ( pImpl->bPreserveVersions ) + pNewFile->TransferVersionList_Impl( *pMedium ); + + // Save the document ( first as temporary file, then transfer to the target URL by committing the medium ) + bool bOk = false; + if ( !pNewFile->GetErrorCode() && SaveTo_Impl( *pNewFile, nullptr ) ) + { + // transfer a possible error from the medium to the document + SetError(pNewFile->GetErrorCode()); + + // notify the document that saving was done successfully + if ( !bCopyTo ) + { + bOk = DoSaveCompleted( pNewFile ); + } + else + bOk = DoSaveCompleted(); + + if( bOk ) + { + if( !bCopyTo ) + SetModified( false ); + } + else + { + // TODO/LATER: the code below must be dead since the storage commit makes all the stuff + // and the DoSaveCompleted call should not be able to fail in general + + DBG_ASSERT( !bCopyTo, "Error while reconnecting to medium, can't be handled!"); + SetError(pNewFile->GetErrorCode()); + + if ( !bCopyTo ) + { + // reconnect to the old medium + bool bRet = DoSaveCompleted( pMedium ); + DBG_ASSERT( bRet, "Error in DoSaveCompleted, can't be handled!"); + } + + // TODO/LATER: disconnect the new file from the storage for the case when pure saving is done + // if storing has corrupted the file, probably it must be restored either here or + // by the storage + delete pNewFile; + pNewFile = nullptr; + } + } + else + { + SetError(pNewFile->GetErrorCode()); + + // reconnect to the old storage + DoSaveCompleted(); + + delete pNewFile; + pNewFile = nullptr; + } + + if ( bCopyTo ) + delete pNewFile; + else if( !bOk ) + SetModified(); + + return bOk; +} + + +bool SfxObjectShell::LoadFrom( SfxMedium& /*rMedium*/ ) +{ + SAL_WARN( "sfx.doc", "Base implementation, must not be called in general!" ); + return true; +} + + +bool SfxObjectShell::CanReload_Impl() + +/* [Description] + + Internal method for determining whether a reload of the document + (as RevertToSaved or last known version) is possible. +*/ + +{ + return pMedium && HasName() && !IsInModalMode() && !pImpl->bForbidReload; +} + + +HiddenInformation SfxObjectShell::GetHiddenInformationState( HiddenInformation nStates ) +{ + HiddenInformation nState = HiddenInformation::NONE; + if ( nStates & HiddenInformation::DOCUMENTVERSIONS ) + { + if ( GetMedium()->GetVersionList().hasElements() ) + nState |= HiddenInformation::DOCUMENTVERSIONS; + } + + return nState; +} + +sal_Int16 SfxObjectShell::QueryHiddenInformation(HiddenWarningFact eFact, weld::Window* pParent) +{ + sal_Int16 nRet = RET_YES; + TranslateId pResId; + SvtSecurityOptions::EOption eOption = SvtSecurityOptions::EOption(); + + switch ( eFact ) + { + case HiddenWarningFact::WhenSaving : + { + pResId = STR_HIDDENINFO_CONTINUE_SAVING; + eOption = SvtSecurityOptions::EOption::DocWarnSaveOrSend; + break; + } + case HiddenWarningFact::WhenPrinting : + { + pResId = STR_HIDDENINFO_CONTINUE_PRINTING; + eOption = SvtSecurityOptions::EOption::DocWarnPrint; + break; + } + case HiddenWarningFact::WhenSigning : + { + pResId = STR_HIDDENINFO_CONTINUE_SIGNING; + eOption = SvtSecurityOptions::EOption::DocWarnSigning; + break; + } + case HiddenWarningFact::WhenCreatingPDF : + { + pResId = STR_HIDDENINFO_CONTINUE_CREATEPDF; + eOption = SvtSecurityOptions::EOption::DocWarnCreatePdf; + break; + } + default: + assert(false); // this cannot happen + } + + if ( SvtSecurityOptions::IsOptionSet( eOption ) ) + { + OUString sMessage( SfxResId(STR_HIDDENINFO_CONTAINS) ); + HiddenInformation nWantedStates = HiddenInformation::RECORDEDCHANGES | HiddenInformation::NOTES; + if ( eFact != HiddenWarningFact::WhenPrinting ) + nWantedStates |= HiddenInformation::DOCUMENTVERSIONS; + HiddenInformation nStates = GetHiddenInformationState( nWantedStates ); + bool bWarning = false; + + if ( nStates & HiddenInformation::RECORDEDCHANGES ) + { + sMessage += SfxResId(STR_HIDDENINFO_RECORDCHANGES) + "\n"; + bWarning = true; + } + if ( nStates & HiddenInformation::NOTES ) + { + sMessage += SfxResId(STR_HIDDENINFO_NOTES) + "\n"; + bWarning = true; + } + if ( nStates & HiddenInformation::DOCUMENTVERSIONS ) + { + sMessage += SfxResId(STR_HIDDENINFO_DOCVERSIONS) + "\n"; + bWarning = true; + } + + if ( bWarning ) + { + sMessage += "\n" + SfxResId(pResId); + std::unique_ptr<weld::MessageDialog> xWarn(Application::CreateMessageDialog(pParent, + VclMessageType::Warning, VclButtonsType::YesNo, sMessage)); + xWarn->set_default_response(RET_NO); + nRet = xWarn->run(); + } + } + + return nRet; +} + +bool SfxObjectShell::IsSecurityOptOpenReadOnly() const +{ + return IsLoadReadonly(); +} + +void SfxObjectShell::SetSecurityOptOpenReadOnly( bool _b ) +{ + SetLoadReadonly( _b ); +} + +bool SfxObjectShell::LoadOwnFormat( SfxMedium& rMedium ) +{ + SAL_INFO( "sfx.doc", "loading \" " << rMedium.GetName() << "\"" ); + + uno::Reference< embed::XStorage > xStorage = rMedium.GetStorage(); + if ( xStorage.is() ) + { + // Password + const SfxStringItem* pPasswdItem = SfxItemSet::GetItem<SfxStringItem>(rMedium.GetItemSet(), SID_PASSWORD, false); + if ( pPasswdItem || ERRCODE_IO_ABORT != CheckPasswd_Impl( this, pMedium ) ) + { + uno::Sequence< beans::NamedValue > aEncryptionData; + if ( GetEncryptionData_Impl(pMedium->GetItemSet(), aEncryptionData) ) + { + try + { + // the following code must throw an exception in case of failure + ::comphelper::OStorageHelper::SetCommonStorageEncryptionData( xStorage, aEncryptionData ); + } + catch( uno::Exception& ) + { + // TODO/LATER: handle the error code + } + } + + // load document + return Load( rMedium ); + } + return false; + } + else + return false; +} + +bool SfxObjectShell::SaveAsOwnFormat( SfxMedium& rMedium ) +{ + uno::Reference< embed::XStorage > xStorage = rMedium.GetStorage(); + if( xStorage.is() ) + { + sal_Int32 nVersion = rMedium.GetFilter()->GetVersion(); + + // OASIS templates have own mediatypes (SO7 also actually, but it is too late to use them here) + const bool bTemplate = rMedium.GetFilter()->IsOwnTemplateFormat() + && nVersion > SOFFICE_FILEFORMAT_60; + + SetupStorage( xStorage, nVersion, bTemplate ); +#if HAVE_FEATURE_SCRIPTING + if ( HasBasic() ) + { + // Initialize Basic + GetBasicManager(); + + // Save dialog/script container + pImpl->aBasicManager.storeLibrariesToStorage( xStorage ); + } +#endif + return SaveAs( rMedium ); + } + else return false; +} + +uno::Reference< embed::XStorage > const & SfxObjectShell::GetStorage() +{ + if ( !pImpl->m_xDocStorage.is() ) + { + OSL_ENSURE( pImpl->m_bCreateTempStor, "The storage must exist already!" ); + try { + // no notification is required the storage is set the first time + pImpl->m_xDocStorage = ::comphelper::OStorageHelper::GetTemporaryStorage(); + OSL_ENSURE( pImpl->m_xDocStorage.is(), "The method must either return storage or throw exception!" ); + + SetupStorage( pImpl->m_xDocStorage, SOFFICE_FILEFORMAT_CURRENT, false ); + pImpl->m_bCreateTempStor = false; + if (!utl::ConfigManager::IsFuzzing()) + SfxGetpApp()->NotifyEvent( SfxEventHint( SfxEventHintId::StorageChanged, GlobalEventConfig::GetEventName(GlobalEventId::STORAGECHANGED), this ) ); + } + catch( uno::Exception& ) + { + // TODO/LATER: error handling? + TOOLS_WARN_EXCEPTION("sfx.doc", "SfxObjectShell::GetStorage"); + } + } + + OSL_ENSURE( pImpl->m_xDocStorage.is(), "The document storage must be created!" ); + return pImpl->m_xDocStorage; +} + + +void SfxObjectShell::SaveChildren( bool bObjectsOnly ) +{ + if ( pImpl->mxObjectContainer ) + { + bool bOasis = ( SotStorage::GetVersion( GetStorage() ) > SOFFICE_FILEFORMAT_60 ); + GetEmbeddedObjectContainer().StoreChildren(bOasis,bObjectsOnly); + } +} + +bool SfxObjectShell::SaveAsChildren( SfxMedium& rMedium ) +{ + uno::Reference < embed::XStorage > xStorage = rMedium.GetStorage(); + if ( !xStorage.is() ) + return false; + + if ( xStorage == GetStorage() ) + { + SaveChildren(); + return true; + } + + bool AutoSaveEvent = false; + utl::MediaDescriptor lArgs(rMedium.GetArgs()); + lArgs[utl::MediaDescriptor::PROP_AUTOSAVEEVENT] >>= AutoSaveEvent; + + if ( pImpl->mxObjectContainer ) + { + bool bOasis = ( SotStorage::GetVersion( xStorage ) > SOFFICE_FILEFORMAT_60 ); + GetEmbeddedObjectContainer().StoreAsChildren(bOasis,SfxObjectCreateMode::EMBEDDED == eCreateMode,AutoSaveEvent,xStorage); + } + + uno::Sequence<OUString> aExceptions; + if (const SfxBoolItem* pNoEmbDS + = SfxItemSet::GetItem(rMedium.GetItemSet(), SID_NO_EMBEDDED_DS, false)) + { + // Don't save data source in case a temporary is being saved for preview in MM wizard + if (pNoEmbDS->GetValue()) + aExceptions = uno::Sequence<OUString>{ "EmbeddedDatabase" }; + } + + return CopyStoragesOfUnknownMediaType(GetStorage(), xStorage, aExceptions); +} + +bool SfxObjectShell::SaveCompletedChildren() +{ + bool bResult = true; + + if ( pImpl->mxObjectContainer ) + { + const uno::Sequence < OUString > aNames = GetEmbeddedObjectContainer().GetObjectNames(); + for ( const auto& rName : aNames ) + { + uno::Reference < embed::XEmbeddedObject > xObj = GetEmbeddedObjectContainer().GetEmbeddedObject( rName ); + OSL_ENSURE( xObj.is(), "An empty entry in the embedded objects list!" ); + if ( xObj.is() ) + { + uno::Reference< embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY ); + if ( xPersist.is() ) + { + try + { + xPersist->saveCompleted( false/*bSuccess*/ ); + } + catch( uno::Exception& ) + { + // TODO/LATER: error handling + bResult = false; + break; + } + } + } + } + } + + return bResult; +} + +bool SfxObjectShell::SwitchChildrenPersistence( const uno::Reference< embed::XStorage >& xStorage, + bool bForceNonModified ) +{ + if ( !xStorage.is() ) + { + // TODO/LATER: error handling + return false; + } + + if ( pImpl->mxObjectContainer ) + pImpl->mxObjectContainer->SetPersistentEntries(xStorage,bForceNonModified); + + return true; +} + +// Never call this method directly, always use the DoSaveCompleted call +bool SfxObjectShell::SaveCompleted( const uno::Reference< embed::XStorage >& xStorage ) +{ + bool bResult = false; + bool bSendNotification = false; + uno::Reference< embed::XStorage > xOldStorageHolder; + + // check for wrong creation of object container + bool bHasContainer( pImpl->mxObjectContainer ); + + if ( !xStorage.is() || xStorage == GetStorage() ) + { + // no persistence change + bResult = SaveCompletedChildren(); + } + else + { + if ( pImpl->mxObjectContainer ) + GetEmbeddedObjectContainer().SwitchPersistence( xStorage ); + + bResult = SwitchChildrenPersistence( xStorage, true ); + } + + if ( bResult ) + { + if ( xStorage.is() && pImpl->m_xDocStorage != xStorage ) + { + // make sure that until the storage is assigned the object + // container is not created by accident! + DBG_ASSERT( bHasContainer == (pImpl->mxObjectContainer != nullptr), "Wrong storage in object container!" ); + xOldStorageHolder = pImpl->m_xDocStorage; + pImpl->m_xDocStorage = xStorage; + bSendNotification = true; + + if ( IsEnableSetModified() ) + SetModified( false ); + } + } + else + { + if ( pImpl->mxObjectContainer ) + GetEmbeddedObjectContainer().SwitchPersistence( pImpl->m_xDocStorage ); + + // let already successfully connected objects be switched back + SwitchChildrenPersistence( pImpl->m_xDocStorage, true ); + } + + if ( bSendNotification ) + { + SfxGetpApp()->NotifyEvent( SfxEventHint( SfxEventHintId::StorageChanged, GlobalEventConfig::GetEventName(GlobalEventId::STORAGECHANGED), this ) ); + } + + return bResult; +} + +static bool StoragesOfUnknownMediaTypeAreCopied_Impl( const uno::Reference< embed::XStorage >& xSource, + const uno::Reference< embed::XStorage >& xTarget ) +{ + OSL_ENSURE( xSource.is() && xTarget.is(), "Source and/or target storages are not available!" ); + if ( !xSource.is() || !xTarget.is() || xSource == xTarget ) + return true; + + try + { + const uno::Sequence< OUString > aSubElements = xSource->getElementNames(); + for ( const auto& rSubElement : aSubElements ) + { + if ( xSource->isStorageElement( rSubElement ) ) + { + OUString aMediaType; + static const OUStringLiteral aMediaTypePropName( u"MediaType" ); + bool bGotMediaType = false; + + try + { + uno::Reference< embed::XOptimizedStorage > xOptStorage( xSource, uno::UNO_QUERY_THROW ); + bGotMediaType = + ( xOptStorage->getElementPropertyValue( rSubElement, aMediaTypePropName ) >>= aMediaType ); + } + catch( uno::Exception& ) + {} + + if ( !bGotMediaType ) + { + uno::Reference< embed::XStorage > xSubStorage; + try { + xSubStorage = xSource->openStorageElement( rSubElement, embed::ElementModes::READ ); + } catch( uno::Exception& ) + {} + + if ( !xSubStorage.is() ) + { + xSubStorage = ::comphelper::OStorageHelper::GetTemporaryStorage(); + xSource->copyStorageElementLastCommitTo( rSubElement, xSubStorage ); + } + + uno::Reference< beans::XPropertySet > xProps( xSubStorage, uno::UNO_QUERY_THROW ); + xProps->getPropertyValue( aMediaTypePropName ) >>= aMediaType; + } + + // TODO/LATER: there should be a way to detect whether an object with such a MediaType can exist + // probably it should be placed in the MimeType-ClassID table or in standalone table + if ( !aMediaType.isEmpty() + && aMediaType != "application/vnd.sun.star.oleobject" ) + { + css::datatransfer::DataFlavor aDataFlavor; + aDataFlavor.MimeType = aMediaType; + SotClipboardFormatId nFormat = SotExchange::GetFormat( aDataFlavor ); + + switch ( nFormat ) + { + case SotClipboardFormatId::STARWRITER_60 : + case SotClipboardFormatId::STARWRITERWEB_60 : + case SotClipboardFormatId::STARWRITERGLOB_60 : + case SotClipboardFormatId::STARDRAW_60 : + case SotClipboardFormatId::STARIMPRESS_60 : + case SotClipboardFormatId::STARCALC_60 : + case SotClipboardFormatId::STARCHART_60 : + case SotClipboardFormatId::STARMATH_60 : + case SotClipboardFormatId::STARWRITER_8: + case SotClipboardFormatId::STARWRITERWEB_8: + case SotClipboardFormatId::STARWRITERGLOB_8: + case SotClipboardFormatId::STARDRAW_8: + case SotClipboardFormatId::STARIMPRESS_8: + case SotClipboardFormatId::STARCALC_8: + case SotClipboardFormatId::STARCHART_8: + case SotClipboardFormatId::STARMATH_8: + break; + + default: + { + if ( !xTarget->hasByName( rSubElement ) ) + return false; + } + } + } + } + } + } + catch( uno::Exception& ) + { + SAL_WARN( "sfx.doc", "Can not check storage consistency!" ); + } + + return true; +} + +bool SfxObjectShell::SwitchPersistence( const uno::Reference< embed::XStorage >& xStorage ) +{ + bool bResult = false; + // check for wrong creation of object container + bool bHasContainer( pImpl->mxObjectContainer ); + if ( xStorage.is() ) + { + if ( pImpl->mxObjectContainer ) + GetEmbeddedObjectContainer().SwitchPersistence( xStorage ); + bResult = SwitchChildrenPersistence( xStorage ); + + // TODO/LATER: substorages that have unknown mimetypes probably should be copied to the target storage here + OSL_ENSURE( StoragesOfUnknownMediaTypeAreCopied_Impl( pImpl->m_xDocStorage, xStorage ), + "Some of substorages with unknown mimetypes is lost!" ); + } + + if ( bResult ) + { + // make sure that until the storage is assigned the object container is not created by accident! + DBG_ASSERT( bHasContainer == (pImpl->mxObjectContainer != nullptr), "Wrong storage in object container!" ); + if ( pImpl->m_xDocStorage != xStorage ) + DoSaveCompleted( new SfxMedium( xStorage, GetMedium()->GetBaseURL() ) ); + + if ( IsEnableSetModified() ) + SetModified(); // ??? + } + + return bResult; +} + +bool SfxObjectShell::CopyStoragesOfUnknownMediaType(const uno::Reference< embed::XStorage >& xSource, + const uno::Reference< embed::XStorage >& xTarget, + const uno::Sequence<OUString>& rExceptions) +{ + // This method does not commit the target storage and should not do it + bool bResult = true; + + try + { + const css::uno::Sequence<OUString> aSubElementNames = xSource->getElementNames(); + for (const OUString& rSubElement : aSubElementNames) + { + if (std::find(rExceptions.begin(), rExceptions.end(), rSubElement) != rExceptions.end()) + continue; + + if (rSubElement == "Configurations") + { + // The workaround for compatibility with SO7, "Configurations" substorage must be preserved + if (xSource->isStorageElement(rSubElement)) + { + OSL_ENSURE(!xTarget->hasByName(rSubElement), "The target storage is an output " + "storage, the element should not " + "exist in the target!"); + + xSource->copyElementTo(rSubElement, xTarget, rSubElement); + } + } + else if (xSource->isStorageElement(rSubElement)) + { + OUString aMediaType; + static const OUStringLiteral aMediaTypePropName( u"MediaType" ); + bool bGotMediaType = false; + + try + { + uno::Reference< embed::XOptimizedStorage > xOptStorage( xSource, uno::UNO_QUERY_THROW ); + bGotMediaType = (xOptStorage->getElementPropertyValue(rSubElement, aMediaTypePropName) + >>= aMediaType); + } + catch( uno::Exception& ) + {} + + if ( !bGotMediaType ) + { + uno::Reference< embed::XStorage > xSubStorage; + try { + xSubStorage + = xSource->openStorageElement(rSubElement, embed::ElementModes::READ); + } catch( uno::Exception& ) + {} + + if ( !xSubStorage.is() ) + { + // TODO/LATER: as optimization in future a substorage of target storage could be used + // instead of the temporary storage; this substorage should be removed later + // if the MimeType is wrong + xSubStorage = ::comphelper::OStorageHelper::GetTemporaryStorage(); + xSource->copyStorageElementLastCommitTo(rSubElement, xSubStorage); + } + + uno::Reference< beans::XPropertySet > xProps( xSubStorage, uno::UNO_QUERY_THROW ); + xProps->getPropertyValue( aMediaTypePropName ) >>= aMediaType; + } + + // TODO/LATER: there should be a way to detect whether an object with such a MediaType can exist + // probably it should be placed in the MimeType-ClassID table or in standalone table + if ( !aMediaType.isEmpty() + && aMediaType != "application/vnd.sun.star.oleobject" ) + { + css::datatransfer::DataFlavor aDataFlavor; + aDataFlavor.MimeType = aMediaType; + SotClipboardFormatId nFormat = SotExchange::GetFormat( aDataFlavor ); + + switch ( nFormat ) + { + case SotClipboardFormatId::STARWRITER_60 : + case SotClipboardFormatId::STARWRITERWEB_60 : + case SotClipboardFormatId::STARWRITERGLOB_60 : + case SotClipboardFormatId::STARDRAW_60 : + case SotClipboardFormatId::STARIMPRESS_60 : + case SotClipboardFormatId::STARCALC_60 : + case SotClipboardFormatId::STARCHART_60 : + case SotClipboardFormatId::STARMATH_60 : + case SotClipboardFormatId::STARWRITER_8: + case SotClipboardFormatId::STARWRITERWEB_8: + case SotClipboardFormatId::STARWRITERGLOB_8: + case SotClipboardFormatId::STARDRAW_8: + case SotClipboardFormatId::STARIMPRESS_8: + case SotClipboardFormatId::STARCALC_8: + case SotClipboardFormatId::STARCHART_8: + case SotClipboardFormatId::STARMATH_8: + break; + + default: + { + OSL_ENSURE(rSubElement == "Configurations2" + || nFormat == SotClipboardFormatId::STARBASE_8 + || !xTarget->hasByName(rSubElement), + "The target storage is an output storage, the element " + "should not exist in the target!"); + + if (!xTarget->hasByName(rSubElement)) + { + xSource->copyElementTo(rSubElement, xTarget, rSubElement); + } + } + } + } + } + } + } + catch( uno::Exception& ) + { + bResult = false; + // TODO/LATER: a specific error could be provided + } + + return bResult; +} + +bool SfxObjectShell::GenerateAndStoreThumbnail(bool bEncrypted, const uno::Reference<embed::XStorage>& xStorage) +{ + //optimize thumbnail generate and store procedure to improve odt saving performance, i120030 + bIsInGenerateThumbnail = true; + + bool bResult = false; + + try + { + uno::Reference<embed::XStorage> xThumbnailStorage = xStorage->openStorageElement("Thumbnails", embed::ElementModes::READWRITE); + + if (xThumbnailStorage.is()) + { + uno::Reference<io::XStream> xStream = xThumbnailStorage->openStreamElement("thumbnail.png", embed::ElementModes::READWRITE); + + if (xStream.is() && WriteThumbnail(bEncrypted, xStream)) + { + uno::Reference<embed::XTransactedObject> xTransactedObject(xThumbnailStorage, uno::UNO_QUERY_THROW); + xTransactedObject->commit(); + bResult = true; + } + } + } + catch( uno::Exception& ) + { + } + + //optimize thumbnail generate and store procedure to improve odt saving performance, i120030 + bIsInGenerateThumbnail = false; + + return bResult; +} + +bool SfxObjectShell::WriteThumbnail(bool bEncrypted, const uno::Reference<io::XStream>& xStream) +{ + bool bResult = false; + + if (!xStream.is()) + return false; + + try + { + uno::Reference<io::XTruncate> xTruncate(xStream->getOutputStream(), uno::UNO_QUERY_THROW); + xTruncate->truncate(); + + uno::Reference <beans::XPropertySet> xSet(xStream, uno::UNO_QUERY); + if (xSet.is()) + xSet->setPropertyValue("MediaType", uno::Any(OUString("image/png"))); + if (bEncrypted) + { + const OUString sResID = GraphicHelper::getThumbnailReplacementIDByFactoryName_Impl( + GetFactory().GetFactoryName()); + if (!sResID.isEmpty()) + bResult = GraphicHelper::getThumbnailReplacement_Impl(sResID, xStream); + } + else + { + BitmapEx bitmap = GetPreviewBitmap(); + if (!bitmap.IsEmpty()) + { + bResult = GraphicHelper::getThumbnailFormatFromBitmap_Impl(bitmap, xStream); + } + } + } + catch(uno::Exception&) + {} + + return bResult; +} + +void SfxObjectShell::UpdateLinks() +{ +} + +bool SfxObjectShell::LoadExternal( SfxMedium& ) +{ + // Not implemented. It's an error if the code path ever comes here. + assert(false); + return false; +} + +bool SfxObjectShell::InsertGeneratedStream(SfxMedium&, + uno::Reference<text::XTextRange> const&) +{ + // Not implemented. It's an error if the code path ever comes here. + assert(false); + return false; +} + +bool SfxObjectShell::IsConfigOptionsChecked() const +{ + return pImpl->m_bConfigOptionsChecked; +} + +void SfxObjectShell::SetConfigOptionsChecked( bool bChecked ) +{ + pImpl->m_bConfigOptionsChecked = bChecked; +} + +void SfxObjectShell::SetMacroCallsSeenWhileLoading() +{ + pImpl->m_bMacroCallsSeenWhileLoading = true; +} + +bool SfxObjectShell::GetMacroCallsSeenWhileLoading() const +{ + if (officecfg::Office::Common::Security::Scripting::CheckDocumentEvents::get()) + return pImpl->m_bMacroCallsSeenWhileLoading; + return false; +} + +bool SfxObjectShell::QuerySaveSizeExceededModules_Impl( const uno::Reference< task::XInteractionHandler >& xHandler ) +{ +#if !HAVE_FEATURE_SCRIPTING + (void) xHandler; +#else + if ( !HasBasic() ) + return true; + + if ( !pImpl->aBasicManager.isValid() ) + GetBasicManager(); + std::vector< OUString > sModules; + if ( xHandler.is() ) + { + if( pImpl->aBasicManager.LegacyPsswdBinaryLimitExceeded( sModules ) ) + { + rtl::Reference<ModuleSizeExceeded> pReq = new ModuleSizeExceeded( sModules ); + xHandler->handle( pReq ); + return pReq->isApprove(); + } + } +#endif + // No interaction handler, default is to continue to save + return true; +} + +bool SfxObjectShell::QueryAllowExoticFormat_Impl( const uno::Reference< task::XInteractionHandler >& xHandler, const OUString& rURL, const OUString& rFilterUIName ) +{ + if ( SvtSecurityOptions::isTrustedLocationUri( rURL ) ) + { + // Always load from trusted location + return true; + } + if ( officecfg::Office::Common::Security::LoadExoticFileFormats::get() == 0 ) + { + // Refuse loading without question + return false; + } + else if ( officecfg::Office::Common::Security::LoadExoticFileFormats::get() == 2 ) + { + // Always load without question + return true; + } + else if ( officecfg::Office::Common::Security::LoadExoticFileFormats::get() == 1 && xHandler.is() ) + { + // Display a warning and let the user decide + rtl::Reference<ExoticFileLoadException> xException(new ExoticFileLoadException( rURL, rFilterUIName )); + xHandler->handle( xException ); + return xException->isApprove(); + } + // No interaction handler, default is to continue to load + return true; +} + +uno::Reference< task::XInteractionHandler > SfxObjectShell::getInteractionHandler() const +{ + uno::Reference< task::XInteractionHandler > xRet; + if ( GetMedium() ) + xRet = GetMedium()->GetInteractionHandler(); + return xRet; +} + +OUString SfxObjectShell::getDocumentBaseURL() const +{ + return GetMedium()->GetBaseURL(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/objstor.hxx b/sfx2/source/doc/objstor.hxx new file mode 100644 index 000000000..4692dbf71 --- /dev/null +++ b/sfx2/source/doc/objstor.hxx @@ -0,0 +1,29 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_SFX2_SOURCE_DOC_OBJSTOR_HXX +#define INCLUDED_SFX2_SOURCE_DOC_OBJSTOR_HXX + +#include <com/sun/star/frame/XModel.hpp> + +void impl_addToModelCollection(const css::uno::Reference<css::frame::XModel>& xModel); + +#endif // INCLUDED_SFX2_SOURCE_DOC_OBJSTOR_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/objxtor.cxx b/sfx2/source/doc/objxtor.cxx new file mode 100644 index 000000000..c83a446a8 --- /dev/null +++ b/sfx2/source/doc/objxtor.cxx @@ -0,0 +1,1118 @@ +/* -*- 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 <config_features.h> +#include <config_fuzzers.h> + +#include <map> + +#include <cppuhelper/implbase.hxx> +#include <cppuhelper/weakref.hxx> + +#include <com/sun/star/util/XCloseable.hpp> +#include <com/sun/star/frame/XComponentLoader.hpp> +#include <com/sun/star/frame/Desktop.hpp> +#include <com/sun/star/util/XCloseListener.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/frame/XTitle.hpp> +#include <osl/file.hxx> +#include <sal/log.hxx> +#include <vcl/weld.hxx> +#include <vcl/svapp.hxx> +#include <svl/eitem.hxx> +#include <basic/sbstar.hxx> +#include <svl/stritem.hxx> +#include <unotools/configmgr.hxx> +#include <unotools/eventcfg.hxx> + +#include <sfx2/objsh.hxx> +#include <sfx2/signaturestate.hxx> +#include <sfx2/sfxmodelfactory.hxx> + +#include <comphelper/processfactory.hxx> +#include <comphelper/servicehelper.hxx> + +#include <com/sun/star/document/XStorageBasedDocument.hpp> +#include <com/sun/star/script/DocumentDialogLibraryContainer.hpp> +#include <com/sun/star/script/DocumentScriptLibraryContainer.hpp> +#include <com/sun/star/document/XEmbeddedScripts.hpp> +#include <com/sun/star/document/XScriptInvocationContext.hpp> +#include <com/sun/star/ucb/ContentCreationException.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> + +#include <unotools/ucbhelper.hxx> +#include <tools/diagnose_ex.h> +#include <tools/globname.hxx> +#include <tools/debug.hxx> + +#include <sfx2/app.hxx> +#include <sfx2/bindings.hxx> +#include <sfx2/docfile.hxx> +#include <sfx2/event.hxx> +#include <sfx2/viewsh.hxx> +#include <sfx2/viewfrm.hxx> +#include <sfx2/sfxresid.hxx> +#include <objshimp.hxx> +#include <sfx2/strings.hrc> +#include <sfx2/sfxsids.hrc> +#include <basic/basmgr.hxx> +#include <sfx2/QuerySaveDocument.hxx> +#include <appbaslib.hxx> +#include <sfx2/sfxbasemodel.hxx> +#include <sfx2/sfxuno.hxx> +#include <sfx2/notebookbar/SfxNotebookBar.hxx> +#include <sfx2/infobar.hxx> + +#include <basic/basicmanagerrepository.hxx> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::script; +using namespace ::com::sun::star::frame; +using namespace ::com::sun::star::document; + +using ::basic::BasicManagerRepository; + +namespace { + +WeakReference< XInterface > theCurrentComponent; + +#if HAVE_FEATURE_SCRIPTING + +// remember all registered components for VBA compatibility, to be able to remove them on disposing the model +typedef ::std::map< XInterface*, OUString > VBAConstantNameMap; +VBAConstantNameMap s_aRegisteredVBAConstants; + +OUString lclGetVBAGlobalConstName( const Reference< XInterface >& rxComponent ) +{ + OSL_ENSURE( rxComponent.is(), "lclGetVBAGlobalConstName - missing component" ); + + VBAConstantNameMap::iterator aIt = s_aRegisteredVBAConstants.find( rxComponent.get() ); + if( aIt != s_aRegisteredVBAConstants.end() ) + return aIt->second; + + uno::Reference< beans::XPropertySet > xProps( rxComponent, uno::UNO_QUERY ); + if( xProps.is() ) try + { + OUString aConstName; + xProps->getPropertyValue("VBAGlobalConstantName") >>= aConstName; + return aConstName; + } + catch (const uno::Exception&) // not supported + { + } + return OUString(); +} + +#endif + +class SfxModelListener_Impl : public ::cppu::WeakImplHelper< css::util::XCloseListener > +{ + SfxObjectShell* mpDoc; +public: + explicit SfxModelListener_Impl( SfxObjectShell* pDoc ) : mpDoc(pDoc) {}; + virtual void SAL_CALL queryClosing( const css::lang::EventObject& aEvent, sal_Bool bDeliverOwnership ) override ; + virtual void SAL_CALL notifyClosing( const css::lang::EventObject& aEvent ) override ; + virtual void SAL_CALL disposing( const css::lang::EventObject& aEvent ) override ; + +}; + +} // namespace + +void SAL_CALL SfxModelListener_Impl::queryClosing( const css::lang::EventObject& , sal_Bool ) +{ +} + +void SAL_CALL SfxModelListener_Impl::notifyClosing( const css::lang::EventObject& ) +{ + SolarMutexGuard aSolarGuard; + mpDoc->Broadcast( SfxHint(SfxHintId::Deinitializing) ); +} + +void SAL_CALL SfxModelListener_Impl::disposing( const css::lang::EventObject& _rEvent ) +{ + // am I ThisComponent in AppBasic? + SolarMutexGuard aSolarGuard; + if ( SfxObjectShell::GetCurrentComponent() == _rEvent.Source ) + { + // remove ThisComponent reference from AppBasic + SfxObjectShell::SetCurrentComponent( Reference< XInterface >() ); + } + +#if HAVE_FEATURE_SCRIPTING + /* Remove VBA component from AppBasic. As every application registers its + own current component, the disposed component may not be the "current + component" of the SfxObjectShell. */ + if ( _rEvent.Source.is() ) + { + VBAConstantNameMap::iterator aIt = s_aRegisteredVBAConstants.find( _rEvent.Source.get() ); + if ( aIt != s_aRegisteredVBAConstants.end() ) + { + if ( BasicManager* pAppMgr = SfxApplication::GetBasicManager() ) + pAppMgr->SetGlobalUNOConstant( aIt->second, Any( Reference< XInterface >() ) ); + s_aRegisteredVBAConstants.erase( aIt ); + } + } +#endif + + if ( !mpDoc->Get_Impl()->bClosing ) + // GCC crashes when already in the destructor, so first query the Flag + mpDoc->DoClose(); +} + + +SfxObjectShell_Impl::SfxObjectShell_Impl( SfxObjectShell& _rDocShell ) + :rDocShell( _rDocShell ) + ,aMacroMode( *this ) + ,pProgress( nullptr) + ,nTime( DateTime::SYSTEM ) + ,nVisualDocumentNumber( USHRT_MAX) + ,nDocumentSignatureState( SignatureState::UNKNOWN ) + ,nScriptingSignatureState( SignatureState::UNKNOWN ) + ,bClosing( false) + ,bIsSaving( false) + ,bIsNamedVisible( false) + ,bIsAbortingImport ( false) + ,bInPrepareClose( false ) + ,bPreparedForClose( false ) + ,bForbidReload( false ) + ,bBasicInitialized( false ) + ,bIsPrintJobCancelable( true ) + ,bOwnsStorage( true ) + ,bInitialized( false ) + ,bModelInitialized( false ) + ,bPreserveVersions( true ) + ,m_bMacroSignBroken( false ) + ,m_bNoBasicCapabilities( false ) + ,m_bDocRecoverySupport( true ) + ,bQueryLoadTemplate( true ) + ,bLoadReadonly( false ) + ,bUseUserData( true ) + ,bUseThumbnailSave( true ) + ,bSaveVersionOnClose( false ) + ,m_bSharedXMLFlag( false ) + ,m_bAllowShareControlFileClean( true ) + ,m_bConfigOptionsChecked( false ) + ,m_bMacroCallsSeenWhileLoading( false ) + ,lErr(ERRCODE_NONE) + ,nEventId ( SfxEventHintId::NONE ) + ,nLoadedFlags ( SfxLoadedFlags::ALL ) + ,nFlagsInProgress( SfxLoadedFlags::NONE ) + ,bModalMode( false ) + ,bRunningMacro( false ) + ,bReadOnlyUI( false ) + ,nStyleFilter( 0 ) + ,m_bEnableSetModified( true ) + ,m_bIsModified( false ) + ,m_nMapUnit( MapUnit::Map100thMM ) + ,m_bCreateTempStor( false ) + ,m_bIsInit( false ) + ,m_bIncomplEncrWarnShown( false ) + ,m_nModifyPasswordHash( 0 ) + ,m_bModifyPasswordEntered( false ) + ,m_bSavingForSigning( false ) + ,m_bAllowModifiedBackAfterSigning( false ) +{ + SfxObjectShell* pDoc = &_rDocShell; + std::vector<SfxObjectShell*> &rArr = SfxGetpApp()->GetObjectShells_Impl(); + rArr.push_back( pDoc ); +} + + +SfxObjectShell_Impl::~SfxObjectShell_Impl() +{ +} + + +SfxObjectShell::SfxObjectShell( const SfxModelFlags i_nCreationFlags ) + : pImpl(new SfxObjectShell_Impl(*this)) + , pMedium(nullptr) + , eCreateMode(SfxObjectCreateMode::STANDARD) + , bHasName(false) + , bIsInGenerateThumbnail (false) + , mbAvoidRecentDocs(false) +{ + if (i_nCreationFlags & SfxModelFlags::EMBEDDED_OBJECT) + eCreateMode = SfxObjectCreateMode::EMBEDDED; + else if (i_nCreationFlags & SfxModelFlags::EXTERNAL_LINK) + eCreateMode = SfxObjectCreateMode::INTERNAL; + + const bool bScriptSupport = ( i_nCreationFlags & SfxModelFlags::DISABLE_EMBEDDED_SCRIPTS ) == SfxModelFlags::NONE; + if ( !bScriptSupport ) + pImpl->m_bNoBasicCapabilities = true; + + const bool bDocRecovery = ( i_nCreationFlags & SfxModelFlags::DISABLE_DOCUMENT_RECOVERY ) == SfxModelFlags::NONE; + if ( !bDocRecovery ) + pImpl->m_bDocRecoverySupport = false; +} + +/** Constructor of the class SfxObjectShell. + + @param eMode Purpose, to which the SfxObjectShell is created: + SfxObjectCreateMode::EMBEDDED (default) as SO-Server from within another Document + SfxObjectCreateMode::STANDARD, as a normal Document open stand-alone + SfxObjectCreateMode::ORGANIZER to be displayed in the Organizer, here nothing of the contents is used +*/ +SfxObjectShell::SfxObjectShell(SfxObjectCreateMode eMode) + : pImpl(new SfxObjectShell_Impl(*this)) + , pMedium(nullptr) + , eCreateMode(eMode) + , bHasName(false) + , bIsInGenerateThumbnail(false) + , mbAvoidRecentDocs(false) +{ +} + +SfxObjectShell::~SfxObjectShell() +{ + + if ( IsEnableSetModified() ) + EnableSetModified( false ); + + SfxObjectShell::CloseInternal(); + pImpl->pBaseModel.set( nullptr ); + + pImpl->pReloadTimer.reset(); + + SfxApplication *pSfxApp = SfxGetpApp(); + if ( USHRT_MAX != pImpl->nVisualDocumentNumber && pSfxApp ) + pSfxApp->ReleaseIndex(pImpl->nVisualDocumentNumber); + + // Destroy Basic-Manager + pImpl->aBasicManager.reset(nullptr); + + if ( pSfxApp && pSfxApp->GetDdeService() ) + pSfxApp->RemoveDdeTopic( this ); + + pImpl->pBaseModel.set( nullptr ); + + // don't call GetStorage() here, in case of Load Failure it's possible that a storage was never assigned! + if ( pMedium && pMedium->HasStorage_Impl() && pMedium->GetStorage( false ) == pImpl->m_xDocStorage ) + pMedium->CanDisposeStorage_Impl( false ); + + if ( pImpl->mxObjectContainer ) + { + pImpl->mxObjectContainer->CloseEmbeddedObjects(); + pImpl->mxObjectContainer.reset(); + } + + if ( pImpl->bOwnsStorage && pImpl->m_xDocStorage.is() ) + pImpl->m_xDocStorage->dispose(); + + if ( pMedium ) + { + pMedium->CloseAndReleaseStreams_Impl(); + +#if HAVE_FEATURE_MULTIUSER_ENVIRONMENT + if (IsDocShared()) + FreeSharedFile( pMedium->GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); +#endif + delete pMedium; + pMedium = nullptr; + } + + // The removing of the temporary file must be done as the latest step in the document destruction + if ( !pImpl->aTempName.isEmpty() ) + { + OUString aTmp; + osl::FileBase::getFileURLFromSystemPath( pImpl->aTempName, aTmp ); + ::utl::UCBContentHelper::Kill( aTmp ); + } +} + + +void SfxObjectShell::Stamp_SetPrintCancelState(bool bState) +{ + pImpl->bIsPrintJobCancelable = bState; +} + + +bool SfxObjectShell::Stamp_GetPrintCancelState() const +{ + return pImpl->bIsPrintJobCancelable; +} + + +// closes the Object and all its views + +bool SfxObjectShell::Close() +{ + SfxObjectShellRef xKeepAlive(this); + return CloseInternal(); +} + +// variant that does not take a reference to itself, so we can call it during object destruction +bool SfxObjectShell::CloseInternal() +{ + if ( !pImpl->bClosing ) + { + // Do not close if a progress is still running + if ( GetProgress() ) + return false; + + pImpl->bClosing = true; + Reference< util::XCloseable > xCloseable( GetBaseModel(), UNO_QUERY ); + + if ( xCloseable.is() ) + { + try + { + xCloseable->close( true ); + } + catch (const Exception&) + { + pImpl->bClosing = false; + } + } + + if ( pImpl->bClosing ) + { + // remove from Document list + // If there is no App, there is no document to remove + // no need to call GetOrCreate here + SfxApplication *pSfxApp = SfxApplication::Get(); + if(pSfxApp) + { + std::vector<SfxObjectShell*> &rDocs = pSfxApp->GetObjectShells_Impl(); + auto it = std::find( rDocs.begin(), rDocs.end(), this ); + if ( it != rDocs.end() ) + rDocs.erase( it ); + } + } + } + + return true; +} + +OUString SfxObjectShell::CreateShellID( const SfxObjectShell* pShell ) +{ + if (!pShell) + return OUString(); + + OUString aShellID; + + SfxMedium* pMedium = pShell->GetMedium(); + if (pMedium) + aShellID = pMedium->GetBaseURL(); + + if (!aShellID.isEmpty()) + return aShellID; + + sal_Int64 nShellID = reinterpret_cast<sal_Int64>(pShell); + aShellID = "0x" + OUString::number(nShellID, 16); + return aShellID; +} + +// returns a pointer the first SfxDocument of specified type + +SfxObjectShell* SfxObjectShell::GetFirst +( + const std::function<bool ( const SfxObjectShell* )>& isObjectShell, + bool bOnlyVisible +) +{ + std::vector<SfxObjectShell*> &rDocs = SfxGetpApp()->GetObjectShells_Impl(); + + // search for a SfxDocument of the specified type + for (SfxObjectShell* pSh : rDocs) + { + if ( bOnlyVisible && pSh->IsPreview() && pSh->IsReadOnly() ) + continue; + + if ( (!isObjectShell || isObjectShell( pSh)) && + ( !bOnlyVisible || SfxViewFrame::GetFirst( pSh ))) + return pSh; + } + + return nullptr; +} + + +// returns a pointer to the next SfxDocument of specified type behind *pDoc + +SfxObjectShell* SfxObjectShell::GetNext +( + const SfxObjectShell& rPrev, + const std::function<bool ( const SfxObjectShell* )>& isObjectShell, + bool bOnlyVisible +) +{ + std::vector<SfxObjectShell*> &rDocs = SfxGetpApp()->GetObjectShells_Impl(); + + // refind the specified predecessor + size_t nPos; + for ( nPos = 0; nPos < rDocs.size(); ++nPos ) + if ( rDocs[nPos] == &rPrev ) + break; + + // search for the next SfxDocument of the specified type + for ( ++nPos; nPos < rDocs.size(); ++nPos ) + { + SfxObjectShell* pSh = rDocs[ nPos ]; + if ( bOnlyVisible && pSh->IsPreview() && pSh->IsReadOnly() ) + continue; + + if ( (!isObjectShell || isObjectShell( pSh)) && + ( !bOnlyVisible || SfxViewFrame::GetFirst( pSh ))) + return pSh; + } + return nullptr; +} + + +SfxObjectShell* SfxObjectShell::Current() +{ + SfxViewFrame *pFrame = SfxViewFrame::Current(); + return pFrame ? pFrame->GetObjectShell() : nullptr; +} + + +bool SfxObjectShell::IsInPrepareClose() const +{ + return pImpl->bInPrepareClose; +} + +namespace { + +struct BoolEnv_Impl +{ + SfxObjectShell_Impl& rImpl; + explicit BoolEnv_Impl( SfxObjectShell_Impl& rImplP) : rImpl( rImplP ) + { rImplP.bInPrepareClose = true; } + ~BoolEnv_Impl() { rImpl.bInPrepareClose = false; } +}; + +} + +bool SfxObjectShell::PrepareClose +( + bool bUI // true: Dialog and so on is allowed + // false: silent-mode +) +{ + if( pImpl->bInPrepareClose || pImpl->bPreparedForClose ) + return true; + BoolEnv_Impl aBoolEnv( *pImpl ); + + // DocModalDialog? + if ( IsInModalMode() ) + return false; + + SfxViewFrame* pFirst = SfxViewFrame::GetFirst( this ); + if( pFirst && !pFirst->GetFrame().PrepareClose_Impl( bUI ) ) + return false; + + // prepare views for closing + for ( SfxViewFrame* pFrm = SfxViewFrame::GetFirst( this ); + pFrm; pFrm = SfxViewFrame::GetNext( *pFrm, this ) ) + { + DBG_ASSERT(pFrm->GetViewShell(),"No Shell"); + if ( pFrm->GetViewShell() ) + { + bool bRet = pFrm->GetViewShell()->PrepareClose( bUI ); + if ( !bRet ) + return bRet; + } + } + + SfxApplication *pSfxApp = SfxGetpApp(); + pSfxApp->NotifyEvent( SfxEventHint(SfxEventHintId::PrepareCloseDoc, GlobalEventConfig::GetEventName(GlobalEventId::PREPARECLOSEDOC), this) ); + + if( GetCreateMode() == SfxObjectCreateMode::EMBEDDED ) + { + pImpl->bPreparedForClose = true; + return true; + } + + // Ask if possible if it should be saved + // only ask for the Document in the visible window + SfxViewFrame *pFrame = SfxObjectShell::Current() == this + ? SfxViewFrame::Current() : SfxViewFrame::GetFirst( this ); + + if ( bUI && IsModified() && pFrame ) + { + // restore minimized + SfxFrame& rTop = pFrame->GetFrame(); + SfxViewFrame::SetViewFrame( rTop.GetCurrentViewFrame() ); + pFrame->GetFrame().Appear(); + + // Ask if to save + short nRet = RET_YES; + { + const Reference<XTitle> xTitle(*pImpl->pBaseModel, UNO_QUERY_THROW); + const OUString sTitle = xTitle->getTitle (); + nRet = ExecuteQuerySaveDocument(pFrame->GetFrameWeld(), sTitle); + } + /*HACK for plugin::destroy()*/ + + if ( RET_YES == nRet ) + { + // Save by each Dispatcher + const SfxPoolItem *pPoolItem; + if ( IsSaveVersionOnClose() ) + { + SfxStringItem aItem( SID_DOCINFO_COMMENTS, SfxResId(STR_AUTOMATICVERSION) ); + SfxBoolItem aWarnItem( SID_FAIL_ON_WARNING, bUI ); + const SfxPoolItem* ppArgs[] = { &aItem, &aWarnItem, nullptr }; + pPoolItem = pFrame->GetBindings().ExecuteSynchron( SID_SAVEDOC, ppArgs ); + } + else + { + SfxBoolItem aWarnItem( SID_FAIL_ON_WARNING, bUI ); + const SfxPoolItem* ppArgs[] = { &aWarnItem, nullptr }; + pPoolItem = pFrame->GetBindings().ExecuteSynchron( SID_SAVEDOC, ppArgs ); + } + + if ( !pPoolItem || pPoolItem->IsVoidItem() ) + return false; + if ( auto pBoolItem = dynamic_cast< const SfxBoolItem *>( pPoolItem ) ) + if ( !pBoolItem->GetValue() ) + return false; + } + else if ( RET_CANCEL == nRet ) + // Cancelled + return false; + } + + if ( pFrame ) + sfx2::SfxNotebookBar::CloseMethod(pFrame->GetBindings()); + pImpl->bPreparedForClose = true; + return true; +} + + +#if HAVE_FEATURE_SCRIPTING +namespace +{ + BasicManager* lcl_getBasicManagerForDocument( const SfxObjectShell& _rDocument ) + { + if ( !_rDocument.Get_Impl()->m_bNoBasicCapabilities ) + { + if ( !_rDocument.Get_Impl()->bBasicInitialized ) + const_cast< SfxObjectShell& >( _rDocument ).InitBasicManager_Impl(); + return _rDocument.Get_Impl()->aBasicManager.get(); + } + + // assume we do not have Basic ourself, but we can refer to another + // document which does (by our model's XScriptInvocationContext::getScriptContainer). + // In this case, we return the BasicManager of this other document. + + OSL_ENSURE( !Reference< XEmbeddedScripts >( _rDocument.GetModel(), UNO_QUERY ).is(), + "lcl_getBasicManagerForDocument: inconsistency: no Basic, but an XEmbeddedScripts?" ); + Reference< XModel > xForeignDocument; + Reference< XScriptInvocationContext > xContext( _rDocument.GetModel(), UNO_QUERY ); + if ( xContext.is() ) + { + xForeignDocument.set( xContext->getScriptContainer(), UNO_QUERY ); + OSL_ENSURE( xForeignDocument.is() && xForeignDocument != _rDocument.GetModel(), + "lcl_getBasicManagerForDocument: no Basic, but providing ourself as script container?" ); + } + + BasicManager* pBasMgr = nullptr; + if ( xForeignDocument.is() ) + pBasMgr = ::basic::BasicManagerRepository::getDocumentBasicManager( xForeignDocument ); + + return pBasMgr; + } +} +#endif + +BasicManager* SfxObjectShell::GetBasicManager() const +{ + BasicManager* pBasMgr = nullptr; +#if HAVE_FEATURE_SCRIPTING + try + { + pBasMgr = lcl_getBasicManagerForDocument( *this ); + if ( !pBasMgr ) + pBasMgr = SfxApplication::GetBasicManager(); + } + catch (const css::ucb::ContentCreationException&) + { + TOOLS_WARN_EXCEPTION("sfx.doc", ""); + } +#endif + return pBasMgr; +} + +bool SfxObjectShell::HasBasic() const +{ +#if !HAVE_FEATURE_SCRIPTING + return false; +#else + if ( pImpl->m_bNoBasicCapabilities ) + return false; + + if ( !pImpl->bBasicInitialized ) + const_cast< SfxObjectShell* >( this )->InitBasicManager_Impl(); + + return pImpl->aBasicManager.isValid(); +#endif +} + + +#if HAVE_FEATURE_SCRIPTING +namespace +{ + const Reference< XLibraryContainer >& + lcl_getOrCreateLibraryContainer( bool _bScript, Reference< XLibraryContainer >& _rxContainer, + const Reference< XModel >& _rxDocument ) + { + if ( !_rxContainer.is() ) + { + try + { + Reference< XStorageBasedDocument > xStorageDoc( _rxDocument, UNO_QUERY ); + const Reference< XComponentContext > xContext( + ::comphelper::getProcessComponentContext() ); + _rxContainer.set ( _bScript + ? DocumentScriptLibraryContainer::create( + xContext, xStorageDoc ) + : DocumentDialogLibraryContainer::create( + xContext, xStorageDoc ) + , UNO_QUERY_THROW ); + } + catch (const Exception&) + { + DBG_UNHANDLED_EXCEPTION("sfx.doc"); + } + } + return _rxContainer; + } +} +#endif + +Reference< XLibraryContainer > SfxObjectShell::GetDialogContainer() +{ +#if HAVE_FEATURE_SCRIPTING + try + { + if ( !pImpl->m_bNoBasicCapabilities ) + return lcl_getOrCreateLibraryContainer( false, pImpl->xDialogLibraries, GetModel() ); + + BasicManager* pBasMgr = lcl_getBasicManagerForDocument( *this ); + if ( pBasMgr ) + return pBasMgr->GetDialogLibraryContainer(); + } + catch (const css::ucb::ContentCreationException&) + { + TOOLS_WARN_EXCEPTION("sfx.doc", ""); + } + + SAL_WARN("sfx.doc", "SfxObjectShell::GetDialogContainer: falling back to the application - is this really expected here?"); +#endif + return SfxGetpApp()->GetDialogContainer(); +} + +Reference< XLibraryContainer > SfxObjectShell::GetBasicContainer() +{ +#if HAVE_FEATURE_SCRIPTING + if (!utl::ConfigManager::IsFuzzing()) + { + try + { + if ( !pImpl->m_bNoBasicCapabilities ) + return lcl_getOrCreateLibraryContainer( true, pImpl->xBasicLibraries, GetModel() ); + + BasicManager* pBasMgr = lcl_getBasicManagerForDocument( *this ); + if ( pBasMgr ) + return pBasMgr->GetScriptLibraryContainer(); + } + catch (const css::ucb::ContentCreationException&) + { + TOOLS_WARN_EXCEPTION("sfx.doc", ""); + } + } + SAL_WARN("sfx.doc", "SfxObjectShell::GetBasicContainer: falling back to the application - is this really expected here?"); +#endif + return SfxGetpApp()->GetBasicContainer(); +} + +StarBASIC* SfxObjectShell::GetBasic() const +{ +#if !HAVE_FEATURE_SCRIPTING + return nullptr; +#else + BasicManager * pMan = GetBasicManager(); + return pMan ? pMan->GetLib(0) : nullptr; +#endif +} + +void SfxObjectShell::InitBasicManager_Impl() +/* [Description] + + Creates a document's BasicManager and loads it, if we are already based on + a storage. + + [Note] + + This method has to be called by implementations of <SvPersist::Load()> + (with its pStor parameter) and by implementations of <SvPersist::InitNew()> + (with pStor = 0). +*/ + +{ + /* #163556# (DR) - Handling of recursive calls while creating the Basic + manager. + + It is possible that (while creating the Basic manager) the code that + imports the Basic storage wants to access the Basic manager again. + Especially in VBA compatibility mode, there is code that wants to + access the "VBA Globals" object which is stored as global UNO constant + in the Basic manager. + + To achieve correct handling of the recursive calls of this function + from lcl_getBasicManagerForDocument(), the implementation of the + function BasicManagerRepository::getDocumentBasicManager() has been + changed to return the Basic manager currently under construction, when + called repeatedly. + + The variable pImpl->bBasicInitialized will be set to sal_True after + construction now, to ensure that the recursive call of the function + lcl_getBasicManagerForDocument() will be routed into this function too. + + Calling BasicManagerHolder::reset() twice is not a big problem, as it + does not take ownership but stores only the raw pointer. Owner of all + Basic managers is the global BasicManagerRepository instance. + */ +#if HAVE_FEATURE_SCRIPTING + DBG_ASSERT( !pImpl->bBasicInitialized && !pImpl->aBasicManager.isValid(), "Local BasicManager already exists"); + try + { + pImpl->aBasicManager.reset( BasicManagerRepository::getDocumentBasicManager( GetModel() ) ); + } + catch (const css::ucb::ContentCreationException&) + { + TOOLS_WARN_EXCEPTION("sfx.doc", ""); + } + DBG_ASSERT( pImpl->aBasicManager.isValid(), "SfxObjectShell::InitBasicManager_Impl: did not get a BasicManager!" ); + pImpl->bBasicInitialized = true; +#endif +} + + +bool SfxObjectShell::DoClose() +{ + return Close(); +} + + +SfxObjectShell* SfxObjectShell::GetObjectShell() +{ + return this; +} + + +uno::Sequence< OUString > SfxObjectShell::GetEventNames() +{ + static uno::Sequence< OUString > s_EventNameContainer(rtl::Reference<GlobalEventConfig>(new GlobalEventConfig)->getElementNames()); + + return s_EventNameContainer; +} + + +css::uno::Reference< css::frame::XModel3 > SfxObjectShell::GetModel() const +{ + return GetBaseModel(); +} + +void SfxObjectShell::SetBaseModel( SfxBaseModel* pModel ) +{ + OSL_ENSURE( !pImpl->pBaseModel.is() || pModel == nullptr, "Model already set!" ); + pImpl->pBaseModel.set( pModel ); + if ( pImpl->pBaseModel.is() ) + { + pImpl->pBaseModel->addCloseListener( new SfxModelListener_Impl(this) ); + } +} + + +css::uno::Reference< css::frame::XModel3 > SfxObjectShell::GetBaseModel() const +{ + return pImpl->pBaseModel; +} + +void SfxObjectShell::SetAutoStyleFilterIndex(sal_uInt16 nSet) +{ + pImpl->nStyleFilter = nSet; +} + +sal_uInt16 SfxObjectShell::GetAutoStyleFilterIndex() const +{ + return pImpl->nStyleFilter; +} + + +void SfxObjectShell::SetCurrentComponent( const Reference< XInterface >& _rxComponent ) +{ + WeakReference< XInterface >& rTheCurrentComponent = theCurrentComponent; + + Reference< XInterface > xOldCurrentComp(rTheCurrentComponent); + if ( _rxComponent == xOldCurrentComp ) + // nothing to do + return; + // note that "_rxComponent.get() == s_xCurrentComponent.get().get()" is /sufficient/, but not + // /required/ for "_rxComponent == s_xCurrentComponent.get()". + // In other words, it's still possible that we here do something which is not necessary, + // but we should have filtered quite some unnecessary calls already. + +#if HAVE_FEATURE_SCRIPTING + BasicManager* pAppMgr = SfxApplication::GetBasicManager(); + rTheCurrentComponent = _rxComponent; + if ( !pAppMgr ) + return; + + // set "ThisComponent" for Basic + pAppMgr->SetGlobalUNOConstant( "ThisComponent", Any( _rxComponent ) ); + + // set new current component for VBA compatibility + if ( _rxComponent.is() ) + { + OUString aVBAConstName = lclGetVBAGlobalConstName( _rxComponent ); + if ( !aVBAConstName.isEmpty() ) + { + pAppMgr->SetGlobalUNOConstant( aVBAConstName, Any( _rxComponent ) ); + s_aRegisteredVBAConstants[ _rxComponent.get() ] = aVBAConstName; + } + } + // no new component passed -> remove last registered VBA component + else if ( xOldCurrentComp.is() ) + { + OUString aVBAConstName = lclGetVBAGlobalConstName( xOldCurrentComp ); + if ( !aVBAConstName.isEmpty() ) + { + pAppMgr->SetGlobalUNOConstant( aVBAConstName, Any( Reference< XInterface >() ) ); + s_aRegisteredVBAConstants.erase( xOldCurrentComp.get() ); + } + } +#endif +} + +Reference< XInterface > SfxObjectShell::GetCurrentComponent() +{ + return theCurrentComponent; +} + + +OUString SfxObjectShell::GetServiceNameFromFactory( const OUString& rFact ) +{ + //! Remove everything behind name! + OUString aFact( rFact ); + OUString aPrefix("private:factory/"); + if ( aFact.startsWith( aPrefix ) ) + aFact = aFact.copy( aPrefix.getLength() ); + sal_Int32 nPos = aFact.indexOf( '?' ); + if ( nPos != -1 ) + { + aFact = aFact.copy( 0, nPos ); + } + aFact = aFact.replaceAll("4", ""); + aFact = aFact.toAsciiLowerCase(); + + // HACK: sometimes a real document service name is given here instead of + // a factory short name. Set return value directly to this service name as fallback + // in case next lines of code does nothing ... + // use rFact instead of normed aFact value ! + OUString aServiceName = rFact; + + if ( aFact == "swriter" ) + { + aServiceName = "com.sun.star.text.TextDocument"; + } + else if ( aFact == "sweb" || aFact == "swriter/web" ) + { + aServiceName = "com.sun.star.text.WebDocument"; + } + else if ( aFact == "sglobal" || aFact == "swriter/globaldocument" ) + { + aServiceName = "com.sun.star.text.GlobalDocument"; + } + else if ( aFact == "scalc" ) + { + aServiceName = "com.sun.star.sheet.SpreadsheetDocument"; + } + else if ( aFact == "sdraw" ) + { + aServiceName = "com.sun.star.drawing.DrawingDocument"; + } + else if ( aFact == "simpress" ) + { + aServiceName = "com.sun.star.presentation.PresentationDocument"; + } + else if ( aFact == "schart" ) + { + aServiceName = "com.sun.star.chart.ChartDocument"; + } + else if ( aFact == "smath" ) + { + aServiceName = "com.sun.star.formula.FormulaProperties"; + } +#if HAVE_FEATURE_SCRIPTING + else if ( aFact == "sbasic" ) + { + aServiceName = "com.sun.star.script.BasicIDE"; + } +#endif +#if HAVE_FEATURE_DBCONNECTIVITY && !ENABLE_FUZZERS + else if ( aFact == "sdatabase" ) + { + aServiceName = "com.sun.star.sdb.OfficeDatabaseDocument"; + } +#endif + + return aServiceName; +} + +SfxObjectShell* SfxObjectShell::CreateObjectByFactoryName( const OUString& rFact, SfxObjectCreateMode eMode ) +{ + return CreateObject( GetServiceNameFromFactory( rFact ), eMode ); +} + + +SfxObjectShell* SfxObjectShell::CreateObject( const OUString& rServiceName, SfxObjectCreateMode eCreateMode ) +{ + if ( !rServiceName.isEmpty() ) + { + uno::Reference < frame::XModel > xDoc( ::comphelper::getProcessServiceFactory()->createInstance( rServiceName ), UNO_QUERY ); + if (SfxObjectShell* pRet = SfxObjectShell::GetShellFromComponent(xDoc)) + { + pRet->SetCreateMode_Impl(eCreateMode); + return pRet; + } + } + + return nullptr; +} + +Reference<lang::XComponent> SfxObjectShell::CreateAndLoadComponent( const SfxItemSet& rSet ) +{ + uno::Sequence < beans::PropertyValue > aProps; + TransformItems( SID_OPENDOC, rSet, aProps ); + const SfxStringItem* pFileNameItem = rSet.GetItem<SfxStringItem>(SID_FILE_NAME, false); + const SfxStringItem* pTargetItem = rSet.GetItem<SfxStringItem>(SID_TARGETNAME, false); + OUString aURL; + OUString aTarget("_blank"); + if ( pFileNameItem ) + aURL = pFileNameItem->GetValue(); + if ( pTargetItem ) + aTarget = pTargetItem->GetValue(); + + uno::Reference < frame::XComponentLoader > xLoader = + frame::Desktop::create(comphelper::getProcessComponentContext()); + + Reference <lang::XComponent> xComp; + try + { + xComp = xLoader->loadComponentFromURL(aURL, aTarget, 0, aProps); + } + catch (const uno::Exception&) + { + } + + return xComp; +} + +SfxObjectShell* SfxObjectShell::GetShellFromComponent(const Reference<uno::XInterface>& xComp) +{ + try + { + Reference<lang::XUnoTunnel> xTunnel(xComp, UNO_QUERY); + if (!xTunnel) + return nullptr; + static const Sequence <sal_Int8> aSeq( SvGlobalName( SFX_GLOBAL_CLASSID ).GetByteSequence() ); + return comphelper::getSomething_cast<SfxObjectShell>(xTunnel->getSomething(aSeq)); + } + catch (const Exception&) + { + } + + return nullptr; +} + +SfxObjectShell* SfxObjectShell::GetParentShell(const css::uno::Reference<css::uno::XInterface>& xChild) +{ + SfxObjectShell* pResult = nullptr; + + try + { + if (css::uno::Reference<css::container::XChild> xChildModel{ xChild, css::uno::UNO_QUERY }) + pResult = GetShellFromComponent(xChildModel->getParent()); + } + catch (const Exception&) + { + } + + return pResult; +} + +void SfxObjectShell::SetInitialized_Impl( const bool i_fromInitNew ) +{ + pImpl->bInitialized = true; + if (utl::ConfigManager::IsFuzzing()) + return; + if ( i_fromInitNew ) + { + SetActivateEvent_Impl( SfxEventHintId::CreateDoc ); + SfxGetpApp()->NotifyEvent( SfxEventHint( SfxEventHintId::DocCreated, GlobalEventConfig::GetEventName(GlobalEventId::DOCCREATED), this ) ); + } + else + { + SfxGetpApp()->NotifyEvent( SfxEventHint( SfxEventHintId::LoadFinished, GlobalEventConfig::GetEventName(GlobalEventId::LOADFINISHED), this ) ); + } +} + + +bool SfxObjectShell::IsChangeRecording() const +{ + // currently this function needs to be overwritten by Writer and Calc only + SAL_WARN( "sfx.doc", "function not implemented" ); + return false; +} + + +bool SfxObjectShell::HasChangeRecordProtection() const +{ + // currently this function needs to be overwritten by Writer and Calc only + SAL_WARN( "sfx.doc", "function not implemented" ); + return false; +} + + +void SfxObjectShell::SetChangeRecording( bool /*bActivate*/, bool /*bLockAllViews*/ ) +{ + // currently this function needs to be overwritten by Writer and Calc only + SAL_WARN( "sfx.doc", "function not implemented" ); +} + + +void SfxObjectShell::SetProtectionPassword( const OUString & /*rPassword*/ ) +{ + // currently this function needs to be overwritten by Writer and Calc only + SAL_WARN( "sfx.doc", "function not implemented" ); +} + + +bool SfxObjectShell::GetProtectionHash( /*out*/ css::uno::Sequence< sal_Int8 > & /*rPasswordHash*/ ) +{ + // currently this function needs to be overwritten by Writer and Calc only + SAL_WARN( "sfx.doc", "function not implemented" ); + return false; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/oleprops.cxx b/sfx2/source/doc/oleprops.cxx new file mode 100644 index 000000000..6de4aace5 --- /dev/null +++ b/sfx2/source/doc/oleprops.cxx @@ -0,0 +1,1240 @@ +/* -*- 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 "oleprops.hxx" + +#include <comphelper/types.hxx> +#include <o3tl/safeint.hxx> +#include <tools/datetime.hxx> +#include <rtl/tencinfo.h> +#include <sal/log.hxx> + + +#define STREAM_BUFFER_SIZE 2048 + +// usings +using ::com::sun::star::uno::Any; + +using namespace ::com::sun::star; + +#define TIMESTAMP_INVALID_DATETIME ( DateTime ( Date ( 1, 1, 1601 ), tools::Time ( 0, 0, 0 ) ) ) /// Invalid value for date and time to create invalid instance of TimeStamp. +/// Invalid value for date and time to create invalid instance of TimeStamp. +#define TIMESTAMP_INVALID_UTILDATETIME (util::DateTime(0, 0, 0, 0, 1, 1, 1601, false)) +/// Invalid value for date to create invalid instance of TimeStamp. +#define TIMESTAMP_INVALID_UTILDATE (util::Date(1, 1, 1601)) + +namespace { + +/** Property representing a signed 32-bit integer value. */ +class SfxOleInt32Property : public SfxOlePropertyBase +{ +public: + explicit SfxOleInt32Property( sal_Int32 nPropId, sal_Int32 nValue = 0 ); + + sal_Int32 GetValue() const { return mnValue; } + +private: + virtual void ImplLoad( SvStream& rStrm ) override; + virtual void ImplSave( SvStream& rStrm ) override; + +private: + sal_Int32 mnValue; +}; + + +/** Property representing a floating-point value. */ +class SfxOleDoubleProperty : public SfxOlePropertyBase +{ +public: + explicit SfxOleDoubleProperty( sal_Int32 nPropId, double fValue = 0.0 ); + + double GetValue() const { return mfValue; } + +private: + virtual void ImplLoad( SvStream& rStrm ) override; + virtual void ImplSave( SvStream& rStrm ) override; + +private: + double mfValue; +}; + + +/** Property representing a boolean value. */ +class SfxOleBoolProperty : public SfxOlePropertyBase +{ +public: + explicit SfxOleBoolProperty( sal_Int32 nPropId, bool bValue = false ); + + bool GetValue() const { return mbValue; } + +private: + virtual void ImplLoad( SvStream& rStrm ) override; + virtual void ImplSave( SvStream& rStrm ) override; + +private: + bool mbValue; +}; + + +/** Base class for properties that contain a single string value. */ +class SfxOleStringPropertyBase : public SfxOlePropertyBase, public SfxOleStringHelper +{ +public: + explicit SfxOleStringPropertyBase( + sal_Int32 nPropId, sal_Int32 nPropType, + const SfxOleTextEncoding& rTextEnc ); + explicit SfxOleStringPropertyBase( + sal_Int32 nPropId, sal_Int32 nPropType, + const SfxOleTextEncoding& rTextEnc, const OUString& rValue ); + explicit SfxOleStringPropertyBase( + sal_Int32 nPropId, sal_Int32 nPropType, + rtl_TextEncoding eTextEnc ); + + const OUString& GetValue() const { return maValue; } + void SetValue( const OUString& rValue ) { maValue = rValue; } + +private: + OUString maValue; +}; + + +/** Property representing a bytestring value. */ +class SfxOleString8Property : public SfxOleStringPropertyBase +{ +public: + explicit SfxOleString8Property( + sal_Int32 nPropId, const SfxOleTextEncoding& rTextEnc ); + explicit SfxOleString8Property( + sal_Int32 nPropId, const SfxOleTextEncoding& rTextEnc, + const OUString& rValue ); + +private: + virtual void ImplLoad( SvStream& rStrm ) override; + virtual void ImplSave( SvStream& rStrm ) override; +}; + + +/** Property representing a Unicode string value. */ +class SfxOleString16Property : public SfxOleStringPropertyBase +{ +public: + explicit SfxOleString16Property( sal_Int32 nPropId ); + +private: + virtual void ImplLoad( SvStream& rStrm ) override; + virtual void ImplSave( SvStream& rStrm ) override; +}; + + +/** Property representing a filetime value as defined by the Windows API. */ +class SfxOleFileTimeProperty : public SfxOlePropertyBase +{ +public: + explicit SfxOleFileTimeProperty( sal_Int32 nPropId ); + /** @param rDateTime Date and time as LOCAL time. */ + explicit SfxOleFileTimeProperty( sal_Int32 nPropId, const util::DateTime& rDateTime ); + + /** Returns the time value as LOCAL time. */ + const util::DateTime& GetValue() const { return maDateTime; } + +private: + virtual void ImplLoad( SvStream& rStrm ) override; + virtual void ImplSave( SvStream& rStrm ) override; + +private: + util::DateTime maDateTime; +}; + +/** Property representing a filetime value as defined by the Windows API. */ +class SfxOleDateProperty : public SfxOlePropertyBase +{ +public: + explicit SfxOleDateProperty( sal_Int32 nPropId ); + + /** Returns the date value as LOCAL time. */ + const util::Date& GetValue() const { return maDate; } + +private: + virtual void ImplLoad( SvStream& rStrm ) override; + virtual void ImplSave( SvStream& rStrm ) override; + +private: + util::Date maDate; +}; + + +/** Property representing a thumbnail picture. + + Currently, only saving this property is implemented. + */ +class SfxOleThumbnailProperty : public SfxOlePropertyBase +{ +public: + explicit SfxOleThumbnailProperty( sal_Int32 nPropId, + const uno::Sequence<sal_Int8> & i_rData); + + bool IsValid() const { return mData.hasElements(); } + +private: + virtual void ImplLoad( SvStream& rStrm ) override; + virtual void ImplSave( SvStream& rStrm ) override; + +private: + uno::Sequence<sal_Int8> mData; +}; + + +/** Property representing a BLOB (which presumably stands for binary large + object). + + Currently, only saving this property is implemented. + */ +class SfxOleBlobProperty : public SfxOlePropertyBase +{ +public: + explicit SfxOleBlobProperty( sal_Int32 nPropId, + const uno::Sequence<sal_Int8> & i_rData); + bool IsValid() const { return mData.hasElements(); } + +private: + virtual void ImplLoad( SvStream& rStrm ) override; + virtual void ImplSave( SvStream& rStrm ) override; + +private: + uno::Sequence<sal_Int8> mData; +}; + +} + +sal_uInt16 SfxOleTextEncoding::GetCodePage() const +{ + sal_uInt16 nCodePage = IsUnicode() ? CODEPAGE_UNICODE : + static_cast< sal_uInt16 >( rtl_getWindowsCodePageFromTextEncoding( *mxTextEnc ) ); + return (nCodePage == CODEPAGE_UNKNOWN) ? CODEPAGE_UTF8 : nCodePage; +} + +void SfxOleTextEncoding::SetCodePage( sal_uInt16 nCodePage ) +{ + if( nCodePage == CODEPAGE_UNICODE ) + SetUnicode(); + else + { + rtl_TextEncoding eTextEnc = rtl_getTextEncodingFromWindowsCodePage( nCodePage ); + if( eTextEnc != RTL_TEXTENCODING_DONTKNOW ) + *mxTextEnc = eTextEnc; + } +} + + +OUString SfxOleStringHelper::LoadString8( SvStream& rStrm ) const +{ + return IsUnicode() ? ImplLoadString16( rStrm ) : ImplLoadString8( rStrm ); +} + +void SfxOleStringHelper::SaveString8( SvStream& rStrm, const OUString& rValue ) const +{ + if( IsUnicode() ) + ImplSaveString16( rStrm, rValue ); + else + ImplSaveString8( rStrm, rValue ); +} + +OUString SfxOleStringHelper::LoadString16( SvStream& rStrm ) +{ + return ImplLoadString16( rStrm ); +} + +void SfxOleStringHelper::SaveString16( SvStream& rStrm, const OUString& rValue ) +{ + ImplSaveString16( rStrm, rValue ); +} + +OUString SfxOleStringHelper::ImplLoadString8( SvStream& rStrm ) const +{ + // read size field (signed 32-bit) + sal_Int32 nSize(0); + rStrm.ReadInt32( nSize ); + // size field includes trailing NUL character + SAL_WARN_IF(nSize < 1 || nSize > 0xFFFF, "sfx.doc", "SfxOleStringHelper::ImplLoadString8 - invalid string of len " << nSize); + if (nSize < 1 || nSize > 0xFFFF) + return OUString(); + // load character buffer + OString sValue(read_uInt8s_ToOString(rStrm, nSize - 1)); + if (rStrm.good() && rStrm.remainingSize()) + rStrm.SeekRel(1); // skip null-byte at end + return OStringToOUString(sValue, GetTextEncoding()); +} + +OUString SfxOleStringHelper::ImplLoadString16( SvStream& rStrm ) +{ + // read size field (signed 32-bit), may be buffer size or character count + sal_Int32 nSize(0); + rStrm.ReadInt32(nSize); + SAL_WARN_IF(nSize < 1 || nSize > 0xFFFF, "sfx.doc", "SfxOleStringHelper::ImplLoadString16 - invalid string of len " << nSize); + // size field includes trailing NUL character + if (nSize < 1 || nSize > 0xFFFF) + return OUString(); + // load character buffer + OUString aValue = read_uInt16s_ToOUString(rStrm, nSize - 1); + sal_Int32 nSkip(2); // skip null-byte at end + // stream is always padded to 32-bit boundary, skip 2 bytes on odd character count + if ((nSize & 1) == 1) + nSkip += 2; + nSkip = std::min<sal_uInt32>(nSkip, rStrm.remainingSize()); + if (rStrm.good() && nSkip) + rStrm.SeekRel(nSkip); + return aValue; +} + +void SfxOleStringHelper::ImplSaveString8( SvStream& rStrm, std::u16string_view rValue ) const +{ + // encode to byte string + OString aEncoded(OUStringToOString(rValue, GetTextEncoding())); + // write size field (including trailing NUL character) + sal_Int32 nSize = aEncoded.getLength() + 1; + rStrm.WriteInt32( nSize ); + // write character array with trailing NUL character + rStrm.WriteBytes(aEncoded.getStr(), aEncoded.getLength()); + rStrm.WriteUChar( 0 ); +} + +void SfxOleStringHelper::ImplSaveString16( SvStream& rStrm, const OUString& rValue ) +{ + // write size field (including trailing NUL character) + sal_Int32 nSize = static_cast< sal_Int32 >( rValue.getLength() + 1 ); + rStrm.WriteInt32( nSize ); + // write character array with trailing NUL character + for( sal_Int32 nIdx = 0; nIdx < rValue.getLength(); ++nIdx ) + rStrm.WriteUInt16( rValue[ nIdx ] ); + rStrm.WriteUInt16( 0 ); + // stream is always padded to 32-bit boundary, add 2 bytes on odd character count + if( (nSize & 1) == 1 ) + rStrm.WriteUInt16( 0 ); +} + + +SfxOleObjectBase::~SfxOleObjectBase() +{ +} + +ErrCode const & SfxOleObjectBase::Load( SvStream& rStrm ) +{ + mnErrCode = ERRCODE_NONE; + ImplLoad( rStrm ); + SetError( rStrm.GetErrorCode() ); + return GetError(); +} + +ErrCode const & SfxOleObjectBase::Save( SvStream& rStrm ) +{ + mnErrCode = ERRCODE_NONE; + ImplSave( rStrm ); + SetError( rStrm.GetErrorCode() ); + return GetError(); +} + +void SfxOleObjectBase::LoadObject( SvStream& rStrm, SfxOleObjectBase& rObj ) +{ + SetError( rObj.Load( rStrm ) ); +} + +void SfxOleObjectBase::SaveObject( SvStream& rStrm, SfxOleObjectBase& rObj ) +{ + SetError( rObj.Save( rStrm ) ); +} + + +SfxOleCodePageProperty::SfxOleCodePageProperty() : + SfxOlePropertyBase( PROPID_CODEPAGE, PROPTYPE_INT16 ) +{ +} + +void SfxOleCodePageProperty::ImplLoad(SvStream& rStrm) +{ + // property type is signed int16, but we use always unsigned int16 for codepages + sal_uInt16 nCodePage(0); + rStrm.ReadUInt16(nCodePage); + SetCodePage(nCodePage); +} + +void SfxOleCodePageProperty::ImplSave( SvStream& rStrm ) +{ + // property type is signed int16, but we use always unsigned int16 for codepages + rStrm.WriteUInt16( GetCodePage() ); +} + + +SfxOleInt32Property::SfxOleInt32Property( sal_Int32 nPropId, sal_Int32 nValue ) : + SfxOlePropertyBase( nPropId, PROPTYPE_INT32 ), + mnValue( nValue ) +{ +} + +void SfxOleInt32Property::ImplLoad( SvStream& rStrm ) +{ + rStrm.ReadInt32( mnValue ); +} + +void SfxOleInt32Property::ImplSave( SvStream& rStrm ) +{ + rStrm.WriteInt32( mnValue ); +} + + +SfxOleDoubleProperty::SfxOleDoubleProperty( sal_Int32 nPropId, double fValue ) : + SfxOlePropertyBase( nPropId, PROPTYPE_DOUBLE ), + mfValue( fValue ) +{ +} + +void SfxOleDoubleProperty::ImplLoad( SvStream& rStrm ) +{ + rStrm.ReadDouble( mfValue ); +} + +void SfxOleDoubleProperty::ImplSave( SvStream& rStrm ) +{ + rStrm.WriteDouble( mfValue ); +} + + +SfxOleBoolProperty::SfxOleBoolProperty( sal_Int32 nPropId, bool bValue ) : + SfxOlePropertyBase( nPropId, PROPTYPE_BOOL ), + mbValue( bValue ) +{ +} + +void SfxOleBoolProperty::ImplLoad( SvStream& rStrm ) +{ + sal_Int16 nValue(0); + rStrm.ReadInt16( nValue ); + mbValue = nValue != 0; +} + +void SfxOleBoolProperty::ImplSave( SvStream& rStrm ) +{ + rStrm.WriteInt16( mbValue ? -1 : 0 ); +} + + +SfxOleStringPropertyBase::SfxOleStringPropertyBase( + sal_Int32 nPropId, sal_Int32 nPropType, const SfxOleTextEncoding& rTextEnc ) : + SfxOlePropertyBase( nPropId, nPropType ), + SfxOleStringHelper( rTextEnc ) +{ +} + +SfxOleStringPropertyBase::SfxOleStringPropertyBase( + sal_Int32 nPropId, sal_Int32 nPropType, const SfxOleTextEncoding& rTextEnc, const OUString& rValue ) : + SfxOlePropertyBase( nPropId, nPropType ), + SfxOleStringHelper( rTextEnc ), + maValue( rValue ) +{ +} + +SfxOleStringPropertyBase::SfxOleStringPropertyBase( + sal_Int32 nPropId, sal_Int32 nPropType, rtl_TextEncoding eTextEnc ) : + SfxOlePropertyBase( nPropId, nPropType ), + SfxOleStringHelper( eTextEnc ) +{ +} + + +SfxOleString8Property::SfxOleString8Property( + sal_Int32 nPropId, const SfxOleTextEncoding& rTextEnc ) : + SfxOleStringPropertyBase( nPropId, PROPTYPE_STRING8, rTextEnc ) +{ +} + +SfxOleString8Property::SfxOleString8Property( + sal_Int32 nPropId, const SfxOleTextEncoding& rTextEnc, const OUString& rValue ) : + SfxOleStringPropertyBase( nPropId, PROPTYPE_STRING8, rTextEnc, rValue ) +{ +} + +void SfxOleString8Property::ImplLoad( SvStream& rStrm ) +{ + SetValue( LoadString8( rStrm ) ); +} + +void SfxOleString8Property::ImplSave( SvStream& rStrm ) +{ + SaveString8( rStrm, GetValue() ); +} + + +SfxOleString16Property::SfxOleString16Property( sal_Int32 nPropId ) : + SfxOleStringPropertyBase( nPropId, PROPTYPE_STRING16, RTL_TEXTENCODING_UCS2 ) +{ +} + +void SfxOleString16Property::ImplLoad( SvStream& rStrm ) +{ + SetValue( LoadString16( rStrm ) ); +} + +void SfxOleString16Property::ImplSave( SvStream& rStrm ) +{ + SaveString16( rStrm, GetValue() ); +} + + +SfxOleFileTimeProperty::SfxOleFileTimeProperty( sal_Int32 nPropId ) : + SfxOlePropertyBase( nPropId, PROPTYPE_FILETIME ) +{ +} + +SfxOleFileTimeProperty::SfxOleFileTimeProperty( sal_Int32 nPropId, const util::DateTime& rDateTime ) : + SfxOlePropertyBase( nPropId, PROPTYPE_FILETIME ), + maDateTime( rDateTime ) +{ +} + +void SfxOleFileTimeProperty::ImplLoad( SvStream& rStrm ) +{ + sal_uInt32 nLower(0), nUpper(0); + rStrm.ReadUInt32( nLower ).ReadUInt32( nUpper ); + ::DateTime aDateTime = DateTime::CreateFromWin32FileDateTime( nLower, nUpper ); + // note: editing duration is stored as offset to TIMESTAMP_INVALID_DATETIME + // of course we should not convert the time zone of a duration! + // heuristic to detect editing durations (which we assume to be < 1 year): + // check only the year, not the entire date + if ( aDateTime.GetYear() != TIMESTAMP_INVALID_DATETIME.GetYear() ) + aDateTime.ConvertToLocalTime(); + maDateTime.Year = aDateTime.GetYear(); + maDateTime.Month = aDateTime.GetMonth(); + maDateTime.Day = aDateTime.GetDay(); + maDateTime.Hours = aDateTime.GetHour(); + maDateTime.Minutes = aDateTime.GetMin(); + maDateTime.Seconds = aDateTime.GetSec(); + maDateTime.NanoSeconds = aDateTime.GetNanoSec(); + maDateTime.IsUTC = false; +} + +void SfxOleFileTimeProperty::ImplSave( SvStream& rStrm ) +{ + DateTime aDateTimeUtc( + Date( + maDateTime.Day, + maDateTime.Month, + static_cast< sal_uInt16 >( maDateTime.Year ) ), + tools::Time( + maDateTime.Hours, + maDateTime.Minutes, + maDateTime.Seconds, + maDateTime.NanoSeconds ) ); + // invalid time stamp is not converted to UTC + // heuristic to detect editing durations (which we assume to be < 1 year): + // check only the year, not the entire date + if( aDateTimeUtc.IsValidAndGregorian() + && aDateTimeUtc.GetYear() != TIMESTAMP_INVALID_DATETIME.GetYear() ) { + aDateTimeUtc.ConvertToUTC(); + } + sal_uInt32 nLower, nUpper; + aDateTimeUtc.GetWin32FileDateTime( nLower, nUpper ); + rStrm.WriteUInt32( nLower ).WriteUInt32( nUpper ); +} + +SfxOleDateProperty::SfxOleDateProperty( sal_Int32 nPropId ) : + SfxOlePropertyBase( nPropId, PROPTYPE_DATE ) +{ +} + +void SfxOleDateProperty::ImplLoad( SvStream& rStrm ) +{ + double fValue(0.0); + rStrm.ReadDouble( fValue ); + //stored as number of days (not seconds) since December 31, 1899 + sal_Int32 nDays = fValue; + sal_Int32 nStartDays = ::Date::DateToDays(31, 12, 1899); + if (o3tl::checked_add(nStartDays, nDays, nStartDays)) + SAL_WARN("sfx.doc", "SfxOleDateProperty::ImplLoad bad date, ignored"); + else + { + ::Date aDate(31, 12, 1899); + aDate.AddDays(nDays); + maDate.Day = aDate.GetDay(); + maDate.Month = aDate.GetMonth(); + maDate.Year = aDate.GetYear(); + } +} + +void SfxOleDateProperty::ImplSave( SvStream& rStrm ) +{ + sal_Int32 nDays = ::Date::DateToDays(maDate.Day, maDate.Month, maDate.Year); + //number of days (not seconds) since December 31, 1899 + sal_Int32 nStartDays = ::Date::DateToDays(31, 12, 1899); + double fValue = nDays-nStartDays; + rStrm.WriteDouble( fValue ); +} + + +SfxOleThumbnailProperty::SfxOleThumbnailProperty( + sal_Int32 nPropId, const uno::Sequence<sal_Int8> & i_rData) : + SfxOlePropertyBase( nPropId, PROPTYPE_CLIPFMT ), + mData(i_rData) +{ +} + +void SfxOleThumbnailProperty::ImplLoad( SvStream& ) +{ + SAL_WARN( "sfx.doc", "SfxOleThumbnailProperty::ImplLoad - not implemented" ); + SetError( SVSTREAM_INVALID_ACCESS ); +} + +void SfxOleThumbnailProperty::ImplSave( SvStream& rStrm ) +{ + /* Type Contents + ----------------------------------------------------------------------- + int32 size of following data + int32 clipboard format tag (see below) + byte[] clipboard data (see below) + + Clipboard format tag: + -1 = Windows clipboard format + -2 = Macintosh clipboard format + -3 = GUID that contains a format identifier (FMTID) + >0 = custom clipboard format name plus data (see msdn site below) + 0 = no data + + References: + http://msdn.microsoft.com/library/default.asp?url=/library/en-us/stg/stg/propvariant.asp + http://jakarta.apache.org/poi/hpsf/thumbnails.html + http://linux.com.hk/docs/poi/org/apache/poi/hpsf/Thumbnail.html + https://web.archive.org/web/20060126202945/http://sparks.discreet.com/knowledgebase/public/solutions/ExtractThumbnailImg.htm + */ + if( IsValid() ) + { + // clipboard size: clip_format_tag + data_format_tag + bitmap_len + sal_Int32 nClipSize = static_cast< sal_Int32 >( 4 + 4 + mData.getLength() ); + rStrm.WriteInt32( nClipSize ).WriteInt32( CLIPFMT_WIN ).WriteInt32( CLIPDATAFMT_DIB ); + rStrm.WriteBytes(mData.getConstArray(), mData.getLength()); + } + else + { + SAL_WARN( "sfx.doc", "SfxOleThumbnailProperty::ImplSave - invalid thumbnail property" ); + SetError( SVSTREAM_INVALID_ACCESS ); + } +} + + +SfxOleBlobProperty::SfxOleBlobProperty( sal_Int32 nPropId, + const uno::Sequence<sal_Int8> & i_rData) : + SfxOlePropertyBase( nPropId, PROPTYPE_BLOB ), + mData(i_rData) +{ +} + +void SfxOleBlobProperty::ImplLoad( SvStream& ) +{ + SAL_WARN( "sfx.doc", "SfxOleBlobProperty::ImplLoad - not implemented" ); + SetError( SVSTREAM_INVALID_ACCESS ); +} + +void SfxOleBlobProperty::ImplSave( SvStream& rStrm ) +{ + if (IsValid()) { + rStrm.WriteBytes(mData.getConstArray(), mData.getLength()); + } else { + SAL_WARN( "sfx.doc", "SfxOleBlobProperty::ImplSave - invalid BLOB property" ); + SetError( SVSTREAM_INVALID_ACCESS ); + } +} + + +SfxOleDictionaryProperty::SfxOleDictionaryProperty( const SfxOleTextEncoding& rTextEnc ) : + SfxOlePropertyBase( PROPID_DICTIONARY, 0 ), + SfxOleStringHelper( rTextEnc ) +{ +} + +OUString SfxOleDictionaryProperty::GetPropertyName( sal_Int32 nPropId ) const +{ + SfxOlePropNameMap::const_iterator aIt = maPropNameMap.find( nPropId ); + return (aIt == maPropNameMap.end()) ? OUString() : aIt->second; +} + +void SfxOleDictionaryProperty::SetPropertyName( sal_Int32 nPropId, const OUString& rPropName ) +{ + maPropNameMap[ nPropId ] = rPropName; + // dictionary property contains number of pairs in property type field + SetPropType( static_cast< sal_Int32 >( maPropNameMap.size() ) ); +} + +void SfxOleDictionaryProperty::ImplLoad( SvStream& rStrm ) +{ + // dictionary property contains number of pairs in property type field + sal_Int32 nNameCount = GetPropType(); + // read property ID/name pairs + maPropNameMap.clear(); + for (sal_Int32 nIdx = 0; nIdx < nNameCount && rStrm.good() && rStrm.remainingSize() >= 4; ++nIdx) + { + sal_Int32 nPropId(0); + rStrm.ReadInt32(nPropId); + // name always stored as byte string + maPropNameMap[nPropId] = LoadString8(rStrm); + } +} + +void SfxOleDictionaryProperty::ImplSave( SvStream& rStrm ) +{ + // write property ID/name pairs + for (auto const& propName : maPropNameMap) + { + rStrm.WriteInt32( propName.first ); + // name always stored as byte string + SaveString8( rStrm, propName.second ); + } +} + + +SfxOleSection::SfxOleSection( bool bSupportsDict ) : + maDictProp( maCodePageProp ), + mnStartPos( 0 ), + mbSupportsDict( bSupportsDict ) +{ +} + +SfxOlePropertyRef SfxOleSection::GetProperty( sal_Int32 nPropId ) const +{ + SfxOlePropertyRef xProp; + SfxOlePropMap::const_iterator aIt = maPropMap.find( nPropId ); + if( aIt != maPropMap.end() ) + xProp = aIt->second; + return xProp; +} + +bool SfxOleSection::GetInt32Value( sal_Int32& rnValue, sal_Int32 nPropId ) const +{ + SfxOlePropertyRef xProp = GetProperty( nPropId ); + const SfxOleInt32Property* pProp = + dynamic_cast< const SfxOleInt32Property* >( xProp.get() ); + if( pProp ) + rnValue = pProp->GetValue(); + return pProp != nullptr; +} + +bool SfxOleSection::GetDoubleValue( double& rfValue, sal_Int32 nPropId ) const +{ + SfxOlePropertyRef xProp = GetProperty( nPropId ); + const SfxOleDoubleProperty* pProp = + dynamic_cast< const SfxOleDoubleProperty* >( xProp.get() ); + if( pProp ) + rfValue = pProp->GetValue(); + return pProp != nullptr; +} + +bool SfxOleSection::GetBoolValue( bool& rbValue, sal_Int32 nPropId ) const +{ + SfxOlePropertyRef xProp = GetProperty( nPropId ); + const SfxOleBoolProperty* pProp = + dynamic_cast< const SfxOleBoolProperty* >( xProp.get() ); + if( pProp ) + rbValue = pProp->GetValue(); + return pProp != nullptr; +} + +bool SfxOleSection::GetStringValue( OUString& rValue, sal_Int32 nPropId ) const +{ + SfxOlePropertyRef xProp = GetProperty( nPropId ); + const SfxOleStringPropertyBase* pProp = + dynamic_cast< const SfxOleStringPropertyBase* >( xProp.get() ); + if( pProp ) + rValue = pProp->GetValue(); + return pProp != nullptr; +} + +bool SfxOleSection::GetFileTimeValue( util::DateTime& rValue, sal_Int32 nPropId ) const +{ + SfxOlePropertyRef xProp = GetProperty( nPropId ); + const SfxOleFileTimeProperty* pProp = + dynamic_cast< const SfxOleFileTimeProperty* >( xProp.get() ); + if( pProp ) + { + if ( pProp->GetValue() == TIMESTAMP_INVALID_UTILDATETIME ) + rValue = util::DateTime(); + else + rValue = pProp->GetValue(); + } + return pProp != nullptr; +} + +bool SfxOleSection::GetDateValue( util::Date& rValue, sal_Int32 nPropId ) const +{ + SfxOlePropertyRef xProp = GetProperty( nPropId ); + const SfxOleDateProperty* pProp = + dynamic_cast< const SfxOleDateProperty* >( xProp.get() ); + if( pProp ) + { + if ( pProp->GetValue() == TIMESTAMP_INVALID_UTILDATE ) + rValue = util::Date(); + else + rValue = pProp->GetValue(); + } + return pProp != nullptr; +} + +void SfxOleSection::SetProperty( const SfxOlePropertyRef& xProp ) +{ + if( xProp ) + maPropMap[ xProp->GetPropId() ] = xProp; +} + +void SfxOleSection::SetInt32Value( sal_Int32 nPropId, sal_Int32 nValue ) +{ + SetProperty( std::make_shared<SfxOleInt32Property>( nPropId, nValue ) ); +} + +void SfxOleSection::SetDoubleValue( sal_Int32 nPropId, double fValue ) +{ + SetProperty( std::make_shared<SfxOleDoubleProperty>( nPropId, fValue ) ); +} + +void SfxOleSection::SetBoolValue( sal_Int32 nPropId, bool bValue ) +{ + SetProperty( std::make_shared<SfxOleBoolProperty>( nPropId, bValue ) ); +} + +bool SfxOleSection::SetStringValue( sal_Int32 nPropId, const OUString& rValue ) +{ + bool bInserted = !rValue.isEmpty(); + if( bInserted ) + SetProperty( std::make_shared<SfxOleString8Property>( nPropId, maCodePageProp, rValue ) ); + return bInserted; +} + +void SfxOleSection::SetFileTimeValue( sal_Int32 nPropId, const util::DateTime& rValue ) +{ + if ( rValue.Year == 0 || rValue.Month == 0 || rValue.Day == 0 ) + SetProperty( std::make_shared<SfxOleFileTimeProperty>( nPropId, TIMESTAMP_INVALID_UTILDATETIME ) ); + else + SetProperty( std::make_shared<SfxOleFileTimeProperty>( nPropId, rValue ) ); +} + +void SfxOleSection::SetDateValue( sal_Int32 nPropId, const util::Date& rValue ) +{ + //Annoyingly MS2010 considers VT_DATE apparently as an invalid possibility, so here we use VT_FILETIME + //instead :-( + if ( rValue.Year == 0 || rValue.Month == 0 || rValue.Day == 0 ) + SetProperty( std::make_shared<SfxOleFileTimeProperty>( nPropId, TIMESTAMP_INVALID_UTILDATETIME ) ); + else + { + const util::DateTime aValue(0, 0, 0, 0, rValue.Day, rValue.Month, + rValue.Year, false ); + SetProperty( std::make_shared<SfxOleFileTimeProperty>( nPropId, aValue ) ); + } +} + +void SfxOleSection::SetThumbnailValue( sal_Int32 nPropId, + const uno::Sequence<sal_Int8> & i_rData) +{ + auto pThumbnail = std::make_shared<SfxOleThumbnailProperty>( nPropId, i_rData ); + if( pThumbnail->IsValid() ) + SetProperty( pThumbnail ); +} + +void SfxOleSection::SetBlobValue( sal_Int32 nPropId, + const uno::Sequence<sal_Int8> & i_rData) +{ + auto pBlob = std::make_shared<SfxOleBlobProperty>( nPropId, i_rData ); + if( pBlob->IsValid() ) + SetProperty( pBlob ); +} + +Any SfxOleSection::GetAnyValue( sal_Int32 nPropId ) const +{ + Any aValue; + sal_Int32 nInt32 = 0; + double fDouble = 0.0; + bool bBool = false; + OUString aString; + css::util::DateTime aApiDateTime; + css::util::Date aApiDate; + + if( GetInt32Value( nInt32, nPropId ) ) + aValue <<= nInt32; + else if( GetDoubleValue( fDouble, nPropId ) ) + aValue <<= fDouble; + else if( GetBoolValue( bBool, nPropId ) ) + aValue <<= bBool; + else if( GetStringValue( aString, nPropId ) ) + aValue <<= aString; + else if( GetFileTimeValue( aApiDateTime, nPropId ) ) + { + aValue <<= aApiDateTime; + } + else if( GetDateValue( aApiDate, nPropId ) ) + { + aValue <<= aApiDate; + } + return aValue; +} + +bool SfxOleSection::SetAnyValue( sal_Int32 nPropId, const Any& rValue ) +{ + bool bInserted = true; + sal_Int32 nInt32 = 0; + double fDouble = 0.0; + OUString aString; + css::util::DateTime aApiDateTime; + css::util::Date aApiDate; + + if( rValue.getValueType() == cppu::UnoType<bool>::get() ) + SetBoolValue( nPropId, ::comphelper::getBOOL( rValue ) ); + else if( rValue >>= nInt32 ) + SetInt32Value( nPropId, nInt32 ); + else if( rValue >>= fDouble ) + SetDoubleValue( nPropId, fDouble ); + else if( rValue >>= aString ) + bInserted = SetStringValue( nPropId, aString ); + else if( rValue >>= aApiDateTime ) + SetFileTimeValue( nPropId, aApiDateTime ); + else if( rValue >>= aApiDate ) + SetDateValue( nPropId, aApiDate ); + else + bInserted = false; + return bInserted; +} + +OUString SfxOleSection::GetPropertyName( sal_Int32 nPropId ) const +{ + return maDictProp.GetPropertyName( nPropId ); +} + +void SfxOleSection::SetPropertyName( sal_Int32 nPropId, const OUString& rPropName ) +{ + maDictProp.SetPropertyName( nPropId, rPropName ); +} + +void SfxOleSection::GetPropertyIds( ::std::vector< sal_Int32 >& rPropIds ) const +{ + rPropIds.clear(); + for (auto const& prop : maPropMap) + rPropIds.push_back(prop.first); +} + +sal_Int32 SfxOleSection::GetFreePropertyId() const +{ + return maPropMap.empty() ? PROPID_FIRSTCUSTOM : (maPropMap.rbegin()->first + 1); +} + +void SfxOleSection::ImplLoad( SvStream& rStrm ) +{ + // read section header + mnStartPos = rStrm.Tell(); + sal_uInt32 nSize(0); + sal_Int32 nPropCount(0); + rStrm.ReadUInt32( nSize ).ReadInt32( nPropCount ); + + // read property ID/position pairs + typedef ::std::map< sal_Int32, sal_uInt32 > SfxOlePropPosMap; + SfxOlePropPosMap aPropPosMap; + for (sal_Int32 nPropIdx = 0; nPropIdx < nPropCount && rStrm.good(); ++nPropIdx) + { + sal_Int32 nPropId(0); + sal_uInt32 nPropPos(0); + rStrm.ReadInt32( nPropId ).ReadUInt32( nPropPos ); + aPropPosMap[ nPropId ] = nPropPos; + } + + // read codepage property + SfxOlePropPosMap::iterator aCodePageIt = aPropPosMap.find( PROPID_CODEPAGE ); + if( (aCodePageIt != aPropPosMap.end()) && SeekToPropertyPos( rStrm, aCodePageIt->second ) ) + { + // codepage property must be of type signed int-16 + sal_Int32 nPropType(0); + rStrm.ReadInt32( nPropType ); + if( nPropType == PROPTYPE_INT16 ) + LoadObject( rStrm, maCodePageProp ); + // remove property position + aPropPosMap.erase( aCodePageIt ); + } + + // read dictionary property + SfxOlePropPosMap::iterator aDictIt = aPropPosMap.find( PROPID_DICTIONARY ); + if( (aDictIt != aPropPosMap.end()) && SeekToPropertyPos( rStrm, aDictIt->second ) ) + { + // #i66214# #i66428# applications may write broken dictionary properties in wrong sections + if( mbSupportsDict ) + { + // dictionary property contains number of pairs in property type field + sal_Int32 nNameCount(0); + rStrm.ReadInt32( nNameCount ); + maDictProp.SetNameCount( nNameCount ); + LoadObject( rStrm, maDictProp ); + } + // always remove position of dictionary property (do not try to read it again below) + aPropPosMap.erase( aDictIt ); + } + + // read other properties + maPropMap.clear(); + for (auto const& propPos : aPropPosMap) + if( SeekToPropertyPos( rStrm, propPos.second ) ) + LoadProperty( rStrm, propPos.first ); +} + +void SfxOleSection::ImplSave( SvStream& rStrm ) +{ + /* Always export with UTF-8 encoding. All dependent properties (bytestring + and dictionary) will be updated automatically. */ + maCodePageProp.SetTextEncoding( RTL_TEXTENCODING_UTF8 ); + + // write section header + mnStartPos = rStrm.Tell(); + sal_Int32 nPropCount = static_cast< sal_Int32 >( maPropMap.size() + 1 ); + if( maDictProp.HasPropertyNames() ) + ++nPropCount; + rStrm.WriteUInt32( 0 ).WriteInt32( nPropCount ); + + // write placeholders for property ID/position pairs + sal_uInt64 nPropPosPos = rStrm.Tell(); + rStrm.SeekRel( static_cast< sal_sSize >( 8 * nPropCount ) ); + + // write dictionary property + if( maDictProp.HasPropertyNames() ) + SaveProperty( rStrm, maDictProp, nPropPosPos ); + // write codepage property + SaveProperty( rStrm, maCodePageProp, nPropPosPos ); + // write other properties + for (auto const& prop : maPropMap) + SaveProperty( rStrm, *prop.second, nPropPosPos ); + + // write section size (first field in section header) + sal_uInt32 nSectSize = static_cast< sal_uInt32 >( rStrm.TellEnd() - mnStartPos ); + rStrm.Seek( mnStartPos ); + rStrm.WriteUInt32( nSectSize ); +} + +bool SfxOleSection::SeekToPropertyPos( SvStream& rStrm, sal_uInt32 nPropPos ) const +{ + return checkSeek(rStrm, static_cast<std::size_t>(mnStartPos + nPropPos)) && + rStrm.GetErrorCode() == ERRCODE_NONE; +} + +void SfxOleSection::LoadProperty( SvStream& rStrm, sal_Int32 nPropId ) +{ + // property data type + sal_Int32 nPropType(0); + rStrm.ReadInt32( nPropType ); + // create empty property object + SfxOlePropertyRef xProp; + switch( nPropType ) + { + case PROPTYPE_INT32: + xProp = std::make_shared<SfxOleInt32Property>( nPropId ); + break; + case PROPTYPE_DOUBLE: + xProp = std::make_shared<SfxOleDoubleProperty>( nPropId ); + break; + case PROPTYPE_BOOL: + xProp = std::make_shared<SfxOleBoolProperty>( nPropId ); + break; + case PROPTYPE_STRING8: + xProp = std::make_shared<SfxOleString8Property>( nPropId, maCodePageProp ); + break; + case PROPTYPE_STRING16: + xProp = std::make_shared<SfxOleString16Property>( nPropId ); + break; + case PROPTYPE_FILETIME: + xProp = std::make_shared<SfxOleFileTimeProperty>( nPropId ); + break; + case PROPTYPE_DATE: + xProp = std::make_shared<SfxOleDateProperty>( nPropId ); + break; + } + // load property contents + if( xProp ) + { + SetError( xProp->Load( rStrm ) ); + maPropMap[ nPropId ] = xProp; + } +} + +void SfxOleSection::SaveProperty( SvStream& rStrm, SfxOlePropertyBase& rProp, sal_uInt64 & rnPropPosPos ) +{ + rStrm.Seek( STREAM_SEEK_TO_END ); + sal_uInt32 nPropPos = static_cast< sal_uInt32 >( rStrm.Tell() - mnStartPos ); + // property data type + rStrm.WriteInt32( rProp.GetPropType() ); + // write property contents + SaveObject( rStrm, rProp ); + // align to 32-bit + while( (rStrm.Tell() & 3) != 0 ) + rStrm.WriteUChar( 0 ); + // write property ID/position pair + rStrm.Seek( rnPropPosPos ); + rStrm.WriteInt32( rProp.GetPropId() ).WriteUInt32( nPropPos ); + rnPropPosPos = rStrm.Tell(); +} + + +ErrCode const & SfxOlePropertySet::LoadPropertySet( SotStorage* pStrg, const OUString& rStrmName ) +{ + if( pStrg ) + { + tools::SvRef<SotStorageStream> xStrm = pStrg->OpenSotStream( rStrmName, StreamMode::STD_READ ); + if( xStrm.is() && (xStrm->GetError() == ERRCODE_NONE) ) + { + xStrm->SetBufferSize( STREAM_BUFFER_SIZE ); + Load( *xStrm ); + } + else + SetError( ERRCODE_IO_ACCESSDENIED ); + } + else + SetError( ERRCODE_IO_ACCESSDENIED ); + return GetError(); +} + +ErrCode const & SfxOlePropertySet::SavePropertySet( SotStorage* pStrg, const OUString& rStrmName ) +{ + if( pStrg ) + { + tools::SvRef<SotStorageStream> xStrm = pStrg->OpenSotStream( rStrmName, StreamMode::TRUNC | StreamMode::STD_WRITE ); + if( xStrm.is() ) + Save( *xStrm ); + else + SetError( ERRCODE_IO_ACCESSDENIED ); + } + else + SetError( ERRCODE_IO_ACCESSDENIED ); + return GetError(); +} + +SfxOleSectionRef SfxOlePropertySet::GetSection( SfxOleSectionType eSection ) const +{ + return GetSection( GetSectionGuid( eSection ) ); +} + +SfxOleSectionRef SfxOlePropertySet::GetSection( const SvGlobalName& rSectionGuid ) const +{ + SfxOleSectionRef xSection; + SfxOleSectionMap::const_iterator aIt = maSectionMap.find( rSectionGuid ); + if( aIt != maSectionMap.end() ) + xSection = aIt->second; + return xSection; +} + +SfxOleSection& SfxOlePropertySet::AddSection( SfxOleSectionType eSection ) +{ + return AddSection( GetSectionGuid( eSection ) ); +} + +SfxOleSection& SfxOlePropertySet::AddSection( const SvGlobalName& rSectionGuid ) +{ + SfxOleSectionRef xSection = GetSection( rSectionGuid ); + if( !xSection ) + { + // #i66214# #i66428# applications may write broken dictionary properties in wrong sections + bool bSupportsDict = rSectionGuid == GetSectionGuid( SECTION_CUSTOM ); + xSection = std::make_shared<SfxOleSection>( bSupportsDict ); + maSectionMap[ rSectionGuid ] = xSection; + } + return *xSection; +} + +void SfxOlePropertySet::ImplLoad( SvStream& rStrm ) +{ + // read property set header + sal_uInt16 nByteOrder; + sal_uInt16 nVersion; + sal_uInt16 nOsMinor; + sal_uInt16 nOsType; + SvGlobalName aGuid; + sal_Int32 nSectCount(0); + rStrm.ReadUInt16( nByteOrder ).ReadUInt16( nVersion ).ReadUInt16( nOsMinor ).ReadUInt16( nOsType ); + rStrm >> aGuid; + rStrm.ReadInt32( nSectCount ); + + // read sections + sal_uInt64 nSectPosPos = rStrm.Tell(); + for (sal_Int32 nSectIdx = 0; nSectIdx < nSectCount; ++nSectIdx) + { + // read section guid/position pair + rStrm.Seek(nSectPosPos); + SvGlobalName aSectGuid; + rStrm >> aSectGuid; + sal_uInt32 nSectPos(0); + rStrm.ReadUInt32(nSectPos); + if (!rStrm.good()) + break; + nSectPosPos = rStrm.Tell(); + // read section + if (!checkSeek(rStrm, nSectPos)) + break; + LoadObject(rStrm, AddSection(aSectGuid)); + if (!rStrm.good()) + break; + } +} + +void SfxOlePropertySet::ImplSave( SvStream& rStrm ) +{ + // write property set header + SvGlobalName aGuid; + sal_Int32 nSectCount = static_cast< sal_Int32 >( maSectionMap.size() ); + rStrm .WriteUInt16( 0xFFFE ) // byte order + .WriteUInt16( 0 ) // version + .WriteUInt16( 1 ) // OS minor version + .WriteUInt16( 2 ); // OS type always windows for text encoding + WriteSvGlobalName( rStrm, aGuid ); // unused guid + rStrm .WriteInt32( nSectCount ); // number of sections + + // write placeholders for section guid/position pairs + sal_uInt64 nSectPosPos = rStrm.Tell(); + rStrm.SeekRel( static_cast< sal_sSize >( 20 * nSectCount ) ); + + // write sections + for (auto const& section : maSectionMap) + { + SfxOleSection& rSection = *section.second; + rStrm.Seek( STREAM_SEEK_TO_END ); + sal_uInt32 nSectPos = static_cast< sal_uInt32 >( rStrm.Tell() ); + // write the section + SaveObject( rStrm, rSection ); + // write section guid/position pair + rStrm.Seek( nSectPosPos ); + WriteSvGlobalName( rStrm, section.first ); + rStrm.WriteUInt32( nSectPos ); + nSectPosPos = rStrm.Tell(); + } +} + +const SvGlobalName& SfxOlePropertySet::GetSectionGuid( SfxOleSectionType eSection ) +{ + static const SvGlobalName saGlobalGuid( 0xF29F85E0, 0x4FF9, 0x1068, 0xAB, 0x91, 0x08, 0x00, 0x2B, 0x27, 0xB3, 0xD9 ); + static const SvGlobalName saBuiltInGuid( 0xD5CDD502, 0x2E9C, 0x101B, 0x93, 0x97, 0x08, 0x00, 0x2B, 0x2C, 0xF9, 0xAE ); + static const SvGlobalName saCustomGuid( 0xD5CDD505, 0x2E9C, 0x101B, 0x93, 0x97, 0x08, 0x00, 0x2B, 0x2C, 0xF9, 0xAE ); + static const SvGlobalName saEmptyGuid; + switch( eSection ) + { + case SECTION_GLOBAL: return saGlobalGuid; + case SECTION_BUILTIN: return saBuiltInGuid; + case SECTION_CUSTOM: return saCustomGuid; + default: SAL_WARN( "sfx.doc", "SfxOlePropertySet::GetSectionGuid - unknown section type" ); + } + return saEmptyGuid; +} + + +//} // namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/oleprops.hxx b/sfx2/source/doc/oleprops.hxx new file mode 100644 index 000000000..81eb744ea --- /dev/null +++ b/sfx2/source/doc/oleprops.hxx @@ -0,0 +1,391 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_SFX2_SOURCE_DOC_OLEPROPS_HXX +#define INCLUDED_SFX2_SOURCE_DOC_OLEPROPS_HXX + +#include <map> +#include <memory> +#include <string_view> + +#include <osl/thread.h> +#include <rtl/ustring.hxx> +#include <sot/storage.hxx> + +#include <com/sun/star/util/DateTime.hpp> +#include <com/sun/star/util/Date.hpp> + + +//namespace { + + +// property type IDs +const sal_Int32 PROPTYPE_INT16 = 2; +const sal_Int32 PROPTYPE_INT32 = 3; +const sal_Int32 PROPTYPE_FLOAT = 4; +const sal_Int32 PROPTYPE_DOUBLE = 5; +const sal_Int32 PROPTYPE_DATE = 7; +const sal_Int32 PROPTYPE_STRING = 8; +const sal_Int32 PROPTYPE_STATUS = 10; +const sal_Int32 PROPTYPE_BOOL = 11; +const sal_Int32 PROPTYPE_VARIANT = 12; +const sal_Int32 PROPTYPE_INT8 = 16; +const sal_Int32 PROPTYPE_UINT8 = 17; +const sal_Int32 PROPTYPE_UINT16 = 18; +const sal_Int32 PROPTYPE_UINT32 = 19; +const sal_Int32 PROPTYPE_INT64 = 20; +const sal_Int32 PROPTYPE_UINT64 = 21; +const sal_Int32 PROPTYPE_STRING8 = 30; +const sal_Int32 PROPTYPE_STRING16 = 31; +const sal_Int32 PROPTYPE_FILETIME = 64; +const sal_Int32 PROPTYPE_BLOB = 65; +const sal_Int32 PROPTYPE_CLIPFMT = 71; + +// static property IDs +const sal_Int32 PROPID_DICTIONARY = 0; +const sal_Int32 PROPID_CODEPAGE = 1; +const sal_Int32 PROPID_FIRSTCUSTOM = 2; + +// property IDs for GlobalDocPropertySet +const sal_Int32 PROPID_TITLE = 2; +const sal_Int32 PROPID_SUBJECT = 3; +const sal_Int32 PROPID_AUTHOR = 4; +const sal_Int32 PROPID_KEYWORDS = 5; +const sal_Int32 PROPID_COMMENTS = 6; +const sal_Int32 PROPID_TEMPLATE = 7; +const sal_Int32 PROPID_LASTAUTHOR = 8; +const sal_Int32 PROPID_REVNUMBER = 9; +const sal_Int32 PROPID_EDITTIME = 10; +const sal_Int32 PROPID_LASTPRINTED = 11; +const sal_Int32 PROPID_CREATED = 12; +const sal_Int32 PROPID_LASTSAVED = 13; +const sal_Int32 PROPID_THUMBNAIL = 17; + +// some Builtin properties +const sal_Int32 PROPID_CATEGORY = 0x2; +const sal_Int32 PROPID_COMPANY = 0xf; +const sal_Int32 PROPID_MANAGER = 0xe; +// predefined codepages +const sal_uInt16 CODEPAGE_UNKNOWN = 0; +const sal_uInt16 CODEPAGE_UNICODE = 1200; +const sal_uInt16 CODEPAGE_UTF8 = 65001; + +// predefined clipboard format IDs +const sal_Int32 CLIPFMT_WIN = -1; + +// predefined clipboard data format IDs +const sal_Int32 CLIPDATAFMT_DIB = 8; + + +/** Helper for classes that need text encoding settings. + + Classes derived from this class will include functions to store and use + text encoding settings and to convert Windows codepage constants. + */ +class SfxOleTextEncoding +{ +public: + explicit SfxOleTextEncoding() : + mxTextEnc( std::make_shared<rtl_TextEncoding>( osl_getThreadTextEncoding() ) ) {} + explicit SfxOleTextEncoding( rtl_TextEncoding eTextEnc ) : + mxTextEnc( std::make_shared<rtl_TextEncoding>( eTextEnc ) ) {} + + /** Returns the current text encoding identifier. */ + rtl_TextEncoding GetTextEncoding() const { return *mxTextEnc; } + /** Sets the passed text encoding. */ + void SetTextEncoding( rtl_TextEncoding eTextEnc ) { *mxTextEnc = eTextEnc; } + + /** Returns true, if this object contains Unicode text encoding. */ + bool IsUnicode() const { return GetTextEncoding() == RTL_TEXTENCODING_UCS2; } + /** Sets Unicode text encoding to this object. */ + void SetUnicode() { SetTextEncoding( RTL_TEXTENCODING_UCS2 ); } + + /** Converts the current settings to a Windows codepage identifier. */ + sal_uInt16 GetCodePage() const; + /** Sets the current text encoding from a Windows codepage identifier. */ + void SetCodePage( sal_uInt16 nCodePage ); + +private: + std::shared_ptr< rtl_TextEncoding > mxTextEnc; +}; + + +/** Helper for classes that need to load or save string values. + + Classes derived from this class contain functions to load and save string + values with the text encoding passed in the constructor. + */ +class SfxOleStringHelper : public SfxOleTextEncoding +{ +public: + /** Creates a string helper object depending on an external text encoding. */ + explicit SfxOleStringHelper( const SfxOleTextEncoding& rTextEnc ) : + SfxOleTextEncoding( rTextEnc ) {} + /** Creates a string helper object with own text encoding. */ + explicit SfxOleStringHelper( rtl_TextEncoding eTextEnc ) : + SfxOleTextEncoding( eTextEnc ) {} + + /** Loads a string from the passed stream with current encoding (maybe Unicode). */ + OUString LoadString8( SvStream& rStrm ) const; + /** Saves a string to the passed stream with current encoding (maybe Unicode). */ + void SaveString8( SvStream& rStrm, const OUString& rValue ) const; + + /** Loads a Unicode string from the passed stream, ignores own encoding. */ + static OUString LoadString16( SvStream& rStrm ); + /** Saves a Unicode string to the passed stream, ignores own encoding. */ + static void SaveString16( SvStream& rStrm, const OUString& rValue ); + +private: + OUString ImplLoadString8( SvStream& rStrm ) const; + static OUString ImplLoadString16( SvStream& rStrm ); + void ImplSaveString8( SvStream& rStrm, std::u16string_view rValue ) const; + static void ImplSaveString16( SvStream& rStrm, const OUString& rValue ); +}; + + +/** Base class for all classes related to OLE property sets. + + Derived classes have to implement the pure virtual functions ImplLoad() and + ImplSave(). + */ +class SfxOleObjectBase +{ +public: + explicit SfxOleObjectBase() : mnErrCode( ERRCODE_NONE ) {} + virtual ~SfxOleObjectBase(); + + /** Returns the current error code. */ + ErrCode const & GetError() const { return mnErrCode; } + + /** Loads this object from the passed stream. Calls virtual ImplLoad(). */ + ErrCode const & Load( SvStream& rStrm ); + /** Saves this object to the passed stream. Calls virtual ImplSave(). */ + ErrCode const & Save( SvStream& rStrm ); + +protected: + /** Sets the passed error code. Will be returned by Load() and Save() functions. + Always the first error code is stored. Multiple calls have no effect. */ + void SetError( ErrCode nErrCode ) { if( mnErrCode == ERRCODE_NONE ) mnErrCode = nErrCode; } + /** Loads the passed object from the stream. Sets returned error code as own error. */ + void LoadObject( SvStream& rStrm, SfxOleObjectBase& rObj ); + /** Saves the passed object to the stream. Sets returned error code as own error. */ + void SaveObject( SvStream& rStrm, SfxOleObjectBase& rObj ); + +private: + /** Derived classes implement loading the object from the passed steam. */ + virtual void ImplLoad( SvStream& rStrm ) = 0; + /** Derived classes implement saving the object to the passed steam. */ + virtual void ImplSave( SvStream& rStrm ) = 0; + +private: + ErrCode mnErrCode; /// Current error code. +}; + + +/** Base class for all OLE property objects. */ +class SfxOlePropertyBase : public SfxOleObjectBase +{ +public: + explicit SfxOlePropertyBase( sal_Int32 nPropId, sal_Int32 nPropType ) : + mnPropId( nPropId ), mnPropType( nPropType ) {} + + sal_Int32 GetPropId() const { return mnPropId; } + sal_Int32 GetPropType() const { return mnPropType; } + +protected: + void SetPropType( sal_Int32 nPropType ) { mnPropType = nPropType; } + +private: + sal_Int32 mnPropId; + sal_Int32 mnPropType; +}; + +typedef std::shared_ptr< SfxOlePropertyBase > SfxOlePropertyRef; + + +/** Property representing the codepage used to encode bytestrings in the entire property set. */ +class SfxOleCodePageProperty : public SfxOlePropertyBase, public SfxOleTextEncoding +{ +public: + explicit SfxOleCodePageProperty(); + +private: + virtual void ImplLoad( SvStream& rStrm ) override; + virtual void ImplSave( SvStream& rStrm ) override; +}; + + +/** Property containing custom names for other properties in the property set. */ +class SfxOleDictionaryProperty : public SfxOlePropertyBase, public SfxOleStringHelper +{ +public: + explicit SfxOleDictionaryProperty( const SfxOleTextEncoding& rTextEnc ); + + /** Returns true, if the property contains at least one custom property name. */ + bool HasPropertyNames() const { return !maPropNameMap.empty(); } + /** Prepares the property for loading. Does not affect contained names for its own. */ + void SetNameCount( sal_Int32 nNameCount ) { SetPropType( nNameCount ); } + + /** Returns the custom name for the passed property ID, or an empty string, if name not found. */ + OUString GetPropertyName( sal_Int32 nPropId ) const; + /** Sets a custom name for the passed property ID. */ + void SetPropertyName( sal_Int32 nPropId, const OUString& rPropName ); + +private: + virtual void ImplLoad( SvStream& rStrm ) override; + virtual void ImplSave( SvStream& rStrm ) override; + +private: + typedef ::std::map< sal_Int32, OUString > SfxOlePropNameMap; + SfxOlePropNameMap maPropNameMap; +}; + + +/** A section in a property set. Contains properties with unique identifiers. */ +class SfxOleSection : public SfxOleObjectBase +{ +private: + typedef ::std::map< sal_Int32, SfxOlePropertyRef > SfxOlePropMap; + +public: + explicit SfxOleSection( bool bSupportsDict ); + + /** Returns the property with the passed ID, or an empty reference, if nothing found. */ + SfxOlePropertyRef GetProperty( sal_Int32 nPropId ) const; + /** Returns the value of a signed int32 property with the passed ID in rnValue. + @return true = Property found, rnValue is valid; false = Property not found. */ + bool GetInt32Value( sal_Int32& rnValue, sal_Int32 nPropId ) const; + /** Returns the value of a floating-point property with the passed ID in rfValue. + @return true = Property found, rfValue is valid; false = Property not found. */ + bool GetDoubleValue( double& rfValue, sal_Int32 nPropId ) const; + /** Returns the value of a boolean property with the passed ID in rbValue. + @return true = Property found, rbValue is valid; false = Property not found. */ + bool GetBoolValue( bool& rbValue, sal_Int32 nPropId ) const; + /** Returns the value of a string property with the passed ID in rValue. + @return true = Property found, rValue is valid; false = Property not found. */ + bool GetStringValue( OUString& rValue, sal_Int32 nPropId ) const; + /** Returns the value of a time stamp property with the passed ID in rValue. + @return true = Property found, rValue is valid; false = Property not found. */ + bool GetFileTimeValue( css::util::DateTime& rValue, sal_Int32 nPropId ) const; + /** Returns the value of a date property with the passed ID in rValue. + @return true = Property found, rValue is valid; false = Property not found. */ + bool GetDateValue( css::util::Date& rValue, sal_Int32 nPropId ) const; + + /** Adds the passed property to the property set. Drops an existing old property. */ + void SetProperty( const SfxOlePropertyRef& xProp ); + /** Inserts a signed int32 property with the passed value. */ + void SetInt32Value( sal_Int32 nPropId, sal_Int32 nValue ); + /** Inserts a floating-point property with the passed value. */ + void SetDoubleValue( sal_Int32 nPropId, double fValue ); + /** Inserts a boolean property with the passed value. */ + void SetBoolValue( sal_Int32 nPropId, bool bValue ); + /** Inserts a string property with the passed value. + @return true = Property inserted; false = String was empty, property not inserted. */ + bool SetStringValue( sal_Int32 nPropId, const OUString& rValue ); + /** Inserts a time stamp property with the passed value. */ + void SetFileTimeValue( sal_Int32 nPropId, const css::util::DateTime& rValue ); + /** Inserts a date property with the passed value. */ + void SetDateValue( sal_Int32 nPropId, const css::util::Date& rValue ); + /** Inserts a thumbnail property from the passed meta file. */ + void SetThumbnailValue( sal_Int32 nPropId, + const css::uno::Sequence<sal_Int8> & i_rData); + /** Inserts a BLOB property with the passed data. */ + void SetBlobValue( sal_Int32 nPropId, + const css::uno::Sequence<sal_Int8> & i_rData); + + /** Returns the value of the property with the passed ID in a UNO any. */ + css::uno::Any GetAnyValue( sal_Int32 nPropId ) const; + /** Inserts a property created from the passed any. + @return true = Property converted and inserted; false = Property type not supported. */ + bool SetAnyValue( sal_Int32 nPropId, const css::uno::Any& rValue ); + + /** Returns the custom name for the passed property ID, or an empty string, if name not found. */ + OUString GetPropertyName( sal_Int32 nPropId ) const; + /** Sets a custom name for the passed property ID. */ + void SetPropertyName( sal_Int32 nPropId, const OUString& rPropName ); + + /** Returns the identifiers of all existing properties in the passed vector. */ + void GetPropertyIds( ::std::vector< sal_Int32 >& rPropIds ) const; + /** Returns a property identifier not used in this section. */ + sal_Int32 GetFreePropertyId() const; + +private: + virtual void ImplLoad( SvStream& rStrm ) override; + virtual void ImplSave( SvStream& rStrm ) override; + + bool SeekToPropertyPos( SvStream& rStrm, sal_uInt32 nPropPos ) const; + void LoadProperty( SvStream& rStrm, sal_Int32 nPropId ); + void SaveProperty( SvStream& rStrm, SfxOlePropertyBase& rProp, sal_uInt64 & rnPropPosPos ); + +private: + SfxOlePropMap maPropMap; /// All properties in this section, by identifier. + SfxOleCodePageProperty maCodePageProp; /// The codepage property. + SfxOleDictionaryProperty maDictProp; /// The dictionary property. + sal_uInt64 mnStartPos; /// Start stream position of the section. + bool mbSupportsDict; /// true = section supports dictionary. +}; + +typedef std::shared_ptr< SfxOleSection > SfxOleSectionRef; + + +/** Enumerates different section types in OLE property sets. */ +enum SfxOleSectionType +{ + SECTION_GLOBAL, /// Globally defined properties. + SECTION_BUILTIN, /// Properties built into MS Office. + SECTION_CUSTOM /// Custom properties. +}; + + +/** Represents a complete property set, may consist of several property sections. */ +class SfxOlePropertySet : public SfxOleObjectBase +{ +public: + explicit SfxOlePropertySet() {} + + /** Loads this object from the passed storage. */ + ErrCode const & LoadPropertySet( SotStorage* pStrg, const OUString& rStrmName ); + /** Saves this object to the passed storage. */ + ErrCode const & SavePropertySet( SotStorage* pStrg, const OUString& rStrmName ); + + /** Returns the specified section, or an empty reference, if nothing found. */ + SfxOleSectionRef GetSection( SfxOleSectionType eSection ) const; + /** Returns the specified section, or an empty reference, if nothing found. */ + SfxOleSectionRef GetSection( const SvGlobalName& rSectionGuid ) const; + + /** Creates and returns the specified section, or just returns it if it already exists. */ + SfxOleSection& AddSection( SfxOleSectionType eSection ); + /** Creates and returns the specified section, or just returns it if it already exists. */ + SfxOleSection& AddSection( const SvGlobalName& rSectionGuid ); + +private: + virtual void ImplLoad( SvStream& rStrm ) override; + virtual void ImplSave( SvStream& rStrm ) override; + + /** Returns the GUID for the specified section. */ + static const SvGlobalName& GetSectionGuid( SfxOleSectionType eSection ); + +private: + typedef ::std::map< SvGlobalName, SfxOleSectionRef > SfxOleSectionMap; + SfxOleSectionMap maSectionMap; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/ownsubfilterservice.cxx b/sfx2/source/doc/ownsubfilterservice.cxx new file mode 100644 index 000000000..7e317cc29 --- /dev/null +++ b/sfx2/source/doc/ownsubfilterservice.cxx @@ -0,0 +1,115 @@ +/* -*- 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 <com/sun/star/frame/DoubleInitializationException.hpp> +#include <com/sun/star/document/XFilter.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/lang/IllegalArgumentException.hpp> +#include <com/sun/star/uno/XComponentContext.hpp> +#include <com/sun/star/frame/XModel.hpp> +#include <com/sun/star/io/XStream.hpp> + +#include <cppuhelper/implbase.hxx> +#include <cppuhelper/supportsservice.hxx> +#include <sfx2/objsh.hxx> + +using namespace css; + +namespace { + +class OwnSubFilterService : public cppu::WeakImplHelper < document::XFilter + ,lang::XServiceInfo > +{ + uno::Reference< frame::XModel > m_xModel; + uno::Reference< io::XStream > m_xStream; + SfxObjectShell* m_pObjectShell; + +public: + /// @throws css::uno::Exception + /// @throws css::uno::RuntimeException + explicit OwnSubFilterService(const css::uno::Sequence< css::uno::Any >& aArguments); + + // XFilter + virtual sal_Bool SAL_CALL filter( const uno::Sequence< beans::PropertyValue >& aDescriptor ) override; + virtual void SAL_CALL cancel() override; + + // XServiceInfo + virtual OUString SAL_CALL getImplementationName( ) override; + virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override; + virtual uno::Sequence< OUString > SAL_CALL getSupportedServiceNames( ) override; +}; + +OwnSubFilterService::OwnSubFilterService(const css::uno::Sequence< css::uno::Any >& aArguments) + : m_pObjectShell( nullptr ) +{ + if ( aArguments.getLength() != 2 ) + throw lang::IllegalArgumentException(); + + if ( m_pObjectShell ) + throw frame::DoubleInitializationException(); + + if ( ( aArguments[1] >>= m_xStream ) && m_xStream.is() + && ( aArguments[0] >>= m_xModel ) && m_xModel.is() ) + { + m_pObjectShell = SfxObjectShell::GetShellFromComponent(m_xModel); + } + + if ( !m_pObjectShell ) + throw lang::IllegalArgumentException(); +} + +sal_Bool SAL_CALL OwnSubFilterService::filter( const uno::Sequence< beans::PropertyValue >& aDescriptor ) +{ + if ( !m_pObjectShell ) + throw uno::RuntimeException(); + + return m_pObjectShell->ImportFromGeneratedStream_Impl( m_xStream, aDescriptor ); +} + +void SAL_CALL OwnSubFilterService::cancel() +{ + // not implemented +} + +OUString SAL_CALL OwnSubFilterService::getImplementationName() +{ + return "com.sun.star.comp.document.OwnSubFilter"; +} + +sal_Bool SAL_CALL OwnSubFilterService::supportsService( const OUString& ServiceName ) +{ + return cppu::supportsService(this, ServiceName); +} + +uno::Sequence< OUString > SAL_CALL OwnSubFilterService::getSupportedServiceNames() +{ + return { "com.sun.star.document.OwnSubFilter", "com.sun.star.comp.document.OwnSubFilter" }; +} + +} + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * +com_sun_star_comp_document_OwnSubFilter_get_implementation( + css::uno::XComponentContext *, + css::uno::Sequence<css::uno::Any> const &arguments) +{ + return cppu::acquire(new OwnSubFilterService(arguments)); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/printhelper.cxx b/sfx2/source/doc/printhelper.cxx new file mode 100644 index 000000000..7a1891037 --- /dev/null +++ b/sfx2/source/doc/printhelper.cxx @@ -0,0 +1,807 @@ +/* -*- 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 "printhelper.hxx" + +#include <com/sun/star/view/XPrintJob.hpp> +#include <com/sun/star/awt/Size.hpp> +#include <com/sun/star/lang/IllegalArgumentException.hpp> +#include <com/sun/star/view/PaperFormat.hpp> +#include <com/sun/star/view/PaperOrientation.hpp> +#include <com/sun/star/ucb/NameClash.hpp> +#include <com/sun/star/frame/XModel.hpp> +#include <com/sun/star/view/DuplexMode.hpp> +#include <comphelper/processfactory.hxx> +#include <svl/itemset.hxx> +#include <svl/lstner.hxx> +#include <unotools/tempfile.hxx> +#include <osl/file.hxx> +#include <osl/thread.hxx> +#include <tools/urlobj.hxx> +#include <tools/diagnose_ex.h> +#include <ucbhelper/content.hxx> +#include <comphelper/interfacecontainer4.hxx> +#include <cppuhelper/implbase.hxx> +#include <vcl/settings.hxx> +#include <vcl/svapp.hxx> + +#include <sfx2/viewfrm.hxx> +#include <sfx2/viewsh.hxx> +#include <sfx2/printer.hxx> +#include <sfx2/objsh.hxx> +#include <sfx2/event.hxx> + +#define SFX_PRINTABLESTATE_CANCELJOB css::view::PrintableState(-2) + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; + +struct IMPL_PrintListener_DataContainer : public SfxListener +{ + SfxObjectShellRef m_pObjectShell; + std::mutex m_aMutex; + comphelper::OInterfaceContainerHelper4<view::XPrintJobListener> m_aJobListeners; + uno::Reference< css::view::XPrintJob> m_xPrintJob; + css::uno::Sequence< css::beans::PropertyValue > m_aPrintOptions; + + explicit IMPL_PrintListener_DataContainer() + { + } + + + void Notify( SfxBroadcaster& aBC , + const SfxHint& aHint ) override ; +}; + +static awt::Size impl_Size_Object2Struct( const Size& aSize ) +{ + awt::Size aReturnValue; + aReturnValue.Width = aSize.Width() ; + aReturnValue.Height = aSize.Height() ; + return aReturnValue ; +} + +static Size impl_Size_Struct2Object( const awt::Size& aSize ) +{ + Size aReturnValue; + aReturnValue.setWidth( aSize.Width ) ; + aReturnValue.setHeight( aSize.Height ) ; + return aReturnValue ; +} + +namespace { + +class SfxPrintJob_Impl : public cppu::WeakImplHelper +< + css::view::XPrintJob +> +{ + IMPL_PrintListener_DataContainer* m_pData; + +public: + explicit SfxPrintJob_Impl( IMPL_PrintListener_DataContainer* pData ); + virtual Sequence< css::beans::PropertyValue > SAL_CALL getPrintOptions( ) override; + virtual Sequence< css::beans::PropertyValue > SAL_CALL getPrinter( ) override; + virtual Reference< css::view::XPrintable > SAL_CALL getPrintable( ) override; + virtual void SAL_CALL cancelJob() override; +}; + +} + +SfxPrintJob_Impl::SfxPrintJob_Impl( IMPL_PrintListener_DataContainer* pData ) + : m_pData( pData ) +{ +} + +Sequence< css::beans::PropertyValue > SAL_CALL SfxPrintJob_Impl::getPrintOptions() +{ + return m_pData->m_aPrintOptions; +} + +Sequence< css::beans::PropertyValue > SAL_CALL SfxPrintJob_Impl::getPrinter() +{ + if( m_pData->m_pObjectShell.is() ) + { + Reference < view::XPrintable > xPrintable( m_pData->m_pObjectShell->GetModel(), UNO_QUERY ); + if ( xPrintable.is() ) + return xPrintable->getPrinter(); + } + return Sequence< css::beans::PropertyValue >(); +} + +Reference< css::view::XPrintable > SAL_CALL SfxPrintJob_Impl::getPrintable() +{ + Reference < view::XPrintable > xPrintable( m_pData->m_pObjectShell.is() ? m_pData->m_pObjectShell->GetModel() : nullptr, UNO_QUERY ); + return xPrintable; +} + +void SAL_CALL SfxPrintJob_Impl::cancelJob() +{ + // FIXME: how to cancel PrintJob via API?! + if( m_pData->m_pObjectShell.is() ) + m_pData->m_pObjectShell->Broadcast( SfxPrintingHint( SFX_PRINTABLESTATE_CANCELJOB ) ); +} + +SfxPrintHelper::SfxPrintHelper() +{ + m_pData.reset(new IMPL_PrintListener_DataContainer()); +} + +void SAL_CALL SfxPrintHelper::initialize( const css::uno::Sequence< css::uno::Any >& aArguments ) +{ + if ( !aArguments.hasElements() ) + return; + + css::uno::Reference < css::frame::XModel > xModel; + aArguments[0] >>= xModel; + m_pData->m_pObjectShell = SfxObjectShell::GetShellFromComponent(xModel); + if (m_pData->m_pObjectShell) + m_pData->StartListening(*m_pData->m_pObjectShell); +} + +SfxPrintHelper::~SfxPrintHelper() +{ +} + +namespace +{ + view::PaperFormat convertToPaperFormat(Paper eFormat) + { + view::PaperFormat eRet; + switch (eFormat) + { + case PAPER_A3: + eRet = view::PaperFormat_A3; + break; + case PAPER_A4: + eRet = view::PaperFormat_A4; + break; + case PAPER_A5: + eRet = view::PaperFormat_A5; + break; + case PAPER_B4_ISO: + eRet = view::PaperFormat_B4; + break; + case PAPER_B5_ISO: + eRet = view::PaperFormat_B5; + break; + case PAPER_LETTER: + eRet = view::PaperFormat_LETTER; + break; + case PAPER_LEGAL: + eRet = view::PaperFormat_LEGAL; + break; + case PAPER_TABLOID: + eRet = view::PaperFormat_TABLOID; + break; + case PAPER_USER: + default: + eRet = view::PaperFormat_USER; + break; + } + return eRet; + } + + Paper convertToPaper(view::PaperFormat eFormat) + { + Paper eRet(PAPER_USER); + switch (eFormat) + { + case view::PaperFormat_A3: + eRet = PAPER_A3; + break; + case view::PaperFormat_A4: + eRet = PAPER_A4; + break; + case view::PaperFormat_A5: + eRet = PAPER_A5; + break; + case view::PaperFormat_B4: + eRet = PAPER_B4_ISO; + break; + case view::PaperFormat_B5: + eRet = PAPER_B5_ISO; + break; + case view::PaperFormat_LETTER: + eRet = PAPER_LETTER; + break; + case view::PaperFormat_LEGAL: + eRet = PAPER_LEGAL; + break; + case view::PaperFormat_TABLOID: + eRet = PAPER_TABLOID; + break; + case view::PaperFormat_USER: + eRet = PAPER_USER; + break; + case view::PaperFormat::PaperFormat_MAKE_FIXED_SIZE: + break; + //deliberate no default to force warn on a new papersize + } + return eRet; + } +} + + +// XPrintable + + +uno::Sequence< beans::PropertyValue > SAL_CALL SfxPrintHelper::getPrinter() +{ + // object already disposed? + SolarMutexGuard aGuard; + + // search for any view of this document that is currently printing + const Printer *pPrinter = nullptr; + SfxViewFrame *pViewFrm = m_pData->m_pObjectShell.is() ? SfxViewFrame::GetFirst( m_pData->m_pObjectShell.get(), false ) : nullptr; + SfxViewFrame* pFirst = pViewFrm; + while ( pViewFrm && !pPrinter ) + { + pPrinter = pViewFrm->GetViewShell()->GetActivePrinter(); + pViewFrm = SfxViewFrame::GetNext( *pViewFrm, m_pData->m_pObjectShell.get(), false ); + } + + // if no view is printing currently, use the permanent SfxPrinter instance + if ( !pPrinter && pFirst ) + pPrinter = pFirst->GetViewShell()->GetPrinter(true); + + if ( !pPrinter ) + return uno::Sequence< beans::PropertyValue >(); + + uno::Sequence< beans::PropertyValue > aPrinter(8); + + aPrinter.getArray()[7].Name = "CanSetPaperSize"; + aPrinter.getArray()[7].Value <<= pPrinter->HasSupport( PrinterSupport::SetPaperSize ); + + aPrinter.getArray()[6].Name = "CanSetPaperFormat"; + aPrinter.getArray()[6].Value <<= pPrinter->HasSupport( PrinterSupport::SetPaper ); + + aPrinter.getArray()[5].Name = "CanSetPaperOrientation"; + aPrinter.getArray()[5].Value <<= pPrinter->HasSupport( PrinterSupport::SetOrientation ); + + aPrinter.getArray()[4].Name = "IsBusy"; + aPrinter.getArray()[4].Value <<= pPrinter->IsPrinting(); + + aPrinter.getArray()[3].Name = "PaperSize"; + awt::Size aSize = impl_Size_Object2Struct(pPrinter->GetPaperSize() ); + aPrinter.getArray()[3].Value <<= aSize; + + aPrinter.getArray()[2].Name = "PaperFormat"; + view::PaperFormat eFormat = convertToPaperFormat(pPrinter->GetPaper()); + aPrinter.getArray()[2].Value <<= eFormat; + + aPrinter.getArray()[1].Name = "PaperOrientation"; + view::PaperOrientation eOrient = static_cast<view::PaperOrientation>(pPrinter->GetOrientation()); + aPrinter.getArray()[1].Value <<= eOrient; + + aPrinter.getArray()[0].Name = "Name"; + OUString sStringTemp = pPrinter->GetName() ; + aPrinter.getArray()[0].Value <<= sStringTemp; + + return aPrinter; +} + + +// XPrintable + + +void SfxPrintHelper::impl_setPrinter(const uno::Sequence< beans::PropertyValue >& rPrinter, + VclPtr<SfxPrinter>& pPrinter, + SfxPrinterChangeFlags& nChangeFlags, + SfxViewShell*& pViewSh) + +{ + // Get old Printer + SfxViewFrame *pViewFrm = m_pData->m_pObjectShell.is() ? + SfxViewFrame::GetFirst( m_pData->m_pObjectShell.get(), false ) : nullptr; + if ( !pViewFrm ) + return; + + pViewSh = pViewFrm->GetViewShell(); + pPrinter = pViewSh->GetPrinter(true); + if ( !pPrinter ) + return; + + // new Printer-Name available? + nChangeFlags = SfxPrinterChangeFlags::NONE; + sal_Int32 lDummy = 0; + auto pProp = std::find_if(rPrinter.begin(), rPrinter.end(), + [](const beans::PropertyValue &rProp) { return rProp.Name == "Name"; }); + if (pProp != rPrinter.end()) + { + OUString aPrinterName; + if ( ! ( pProp->Value >>= aPrinterName ) ) + throw css::lang::IllegalArgumentException(); + + if ( aPrinterName != pPrinter->GetName() ) + { + pPrinter = VclPtr<SfxPrinter>::Create( pPrinter->GetOptions().Clone(), aPrinterName ); + nChangeFlags = SfxPrinterChangeFlags::PRINTER; + } + } + + Size aSetPaperSize( 0, 0); + view::PaperFormat nPaperFormat = view::PaperFormat_USER; + + // other properties + for ( const beans::PropertyValue &rProp : rPrinter ) + { + // get Property-Value from printer description + // PaperOrientation-Property? + if ( rProp.Name == "PaperOrientation" ) + { + view::PaperOrientation eOrient; + if ( !( rProp.Value >>= eOrient ) ) + { + if ( !( rProp.Value >>= lDummy ) ) + throw css::lang::IllegalArgumentException(); + eOrient = static_cast<view::PaperOrientation>(lDummy); + } + + if ( static_cast<Orientation>(eOrient) != pPrinter->GetOrientation() ) + { + pPrinter->SetOrientation( static_cast<Orientation>(eOrient) ); + nChangeFlags |= SfxPrinterChangeFlags::CHG_ORIENTATION; + } + } + + // PaperFormat-Property? + else if ( rProp.Name == "PaperFormat" ) + { + if ( !( rProp.Value >>= nPaperFormat ) ) + { + if ( !( rProp.Value >>= lDummy ) ) + throw css::lang::IllegalArgumentException(); + nPaperFormat = static_cast<view::PaperFormat>(lDummy); + } + + if ( convertToPaper(nPaperFormat) != pPrinter->GetPaper() ) + { + pPrinter->SetPaper( convertToPaper(nPaperFormat) ); + nChangeFlags |= SfxPrinterChangeFlags::CHG_SIZE; + } + } + + // PaperSize-Property? + else if ( rProp.Name == "PaperSize" ) + { + awt::Size aTempSize ; + if ( !( rProp.Value >>= aTempSize ) ) + { + throw css::lang::IllegalArgumentException(); + } + aSetPaperSize = impl_Size_Struct2Object(aTempSize); + } + + // PrinterTray-Property + else if ( rProp.Name == "PrinterPaperTray" ) + { + OUString aTmp; + if ( !( rProp.Value >>= aTmp ) ) + throw css::lang::IllegalArgumentException(); + const sal_uInt16 nCount = pPrinter->GetPaperBinCount(); + for (sal_uInt16 nBin=0; nBin<nCount; nBin++) + { + OUString aName( pPrinter->GetPaperBinName(nBin) ); + if ( aName == aTmp ) + { + pPrinter->SetPaperBin(nBin); + break; + } + } + } + } + + // The PaperSize may be set only when actually PAPER_USER + // applies, otherwise the driver could choose an invalid format. + if(nPaperFormat == view::PaperFormat_USER && aSetPaperSize.Width()) + { + // Bug 56929 - MapMode of 100mm which recalculated when + // the device is set. Additionally only set if they were really changed. + aSetPaperSize = pPrinter->LogicToPixel(aSetPaperSize, MapMode(MapUnit::Map100thMM)); + if( aSetPaperSize != pPrinter->GetPaperSizePixel() ) + { + pPrinter->SetPaperSizeUser( pPrinter->PixelToLogic( aSetPaperSize ) ); + nChangeFlags |= SfxPrinterChangeFlags::CHG_SIZE; + } + } + + //wait until printing is done + SfxPrinter* pDocPrinter = pViewSh->GetPrinter(); + while ( pDocPrinter->IsPrinting() && !Application::IsQuit()) + Application::Yield(); +} + +void SAL_CALL SfxPrintHelper::setPrinter(const uno::Sequence< beans::PropertyValue >& rPrinter) +{ + // object already disposed? + SolarMutexGuard aGuard; + + SfxViewShell* pViewSh = nullptr; + VclPtr<SfxPrinter> pPrinter; + SfxPrinterChangeFlags nChangeFlags = SfxPrinterChangeFlags::NONE; + impl_setPrinter(rPrinter,pPrinter,nChangeFlags,pViewSh); + // set new printer + if ( pViewSh && pPrinter ) + pViewSh->SetPrinter( pPrinter, nChangeFlags ); +} + + +// ImplPrintWatch thread for asynchronous printing with moving temp. file to ucb location + +namespace { + +/* This implements a thread which will be started to wait for asynchronous + print jobs to temp. locally files. If they finish we move the temp. files + to their right locations by using the ucb. + */ +class ImplUCBPrintWatcher : public ::osl::Thread +{ + private: + /// of course we must know the printer which execute the job + VclPtr<SfxPrinter> m_pPrinter; + /// this describes the target location for the printed temp file + OUString m_sTargetURL; + /// it holds the temp file alive, till the print job will finish and remove it from disk automatically if the object die + ::utl::TempFile* m_pTempFile; + + public: + /* initialize this watcher but don't start it */ + ImplUCBPrintWatcher( SfxPrinter* pPrinter, ::utl::TempFile* pTempFile, const OUString& sTargetURL ) + : m_pPrinter ( pPrinter ) + , m_sTargetURL( sTargetURL ) + , m_pTempFile ( pTempFile ) + {} + + /* waits for finishing of the print job and moves the temp file afterwards + Note: Starting of the job is done outside this thread! + But we have to free some of the given resources on heap! + */ + void SAL_CALL run() override + { + osl_setThreadName("ImplUCBPrintWatcher"); + + /* SAFE { */ + { + SolarMutexGuard aGuard; + while( m_pPrinter->IsPrinting() && !Application::IsQuit()) + Application::Yield(); + m_pPrinter.clear(); // don't delete it! It's borrowed only :-) + } + /* } SAFE */ + + // lock for further using of our member isn't necessary - because + // we run alone by definition. Nobody join for us nor use us... + moveAndDeleteTemp(&m_pTempFile,m_sTargetURL); + + // finishing of this run() method will call onTerminate() automatically + // kill this thread there! + } + + /* nobody wait for this thread. We must kill ourself ... + */ + void SAL_CALL onTerminated() override + { + delete this; + } + + /* static helper to move the temp. file to the target location by using the ucb + It's static to be usable from outside too. So it's not really necessary to start + the thread, if finishing of the job was detected outside this thread. + But it must be called without using a corresponding thread for the given parameter! + */ + static void moveAndDeleteTemp( ::utl::TempFile** ppTempFile, std::u16string_view sTargetURL ) + { + // move the file + try + { + INetURLObject aSplitter(sTargetURL); + OUString sFileName = aSplitter.getName( + INetURLObject::LAST_SEGMENT, + true, + INetURLObject::DecodeMechanism::WithCharset); + if (aSplitter.removeSegment() && !sFileName.isEmpty()) + { + ::ucbhelper::Content aSource( + (*ppTempFile)->GetURL(), + css::uno::Reference< css::ucb::XCommandEnvironment >(), + comphelper::getProcessComponentContext()); + + ::ucbhelper::Content aTarget( + aSplitter.GetMainURL(INetURLObject::DecodeMechanism::NONE), + css::uno::Reference< css::ucb::XCommandEnvironment >(), + comphelper::getProcessComponentContext()); + + aTarget.transferContent( + aSource, + ::ucbhelper::InsertOperation::Copy, + sFileName, + css::ucb::NameClash::OVERWRITE); + } + } + catch (const css::uno::Exception&) + { + TOOLS_WARN_EXCEPTION( "sfx.doc", ""); + } + + // kill the temp file! + delete *ppTempFile; + *ppTempFile = nullptr; + } +}; + +} + +// XPrintable + +void SAL_CALL SfxPrintHelper::print(const uno::Sequence< beans::PropertyValue >& rOptions) +{ + if( Application::GetSettings().GetMiscSettings().GetDisablePrinting() ) + return; + + // object already disposed? + // object already disposed? + SolarMutexGuard aGuard; + + // get view for sfx printing capabilities + SfxViewFrame *pViewFrm = m_pData->m_pObjectShell.is() ? + SfxViewFrame::GetFirst( m_pData->m_pObjectShell.get(), false ) : nullptr; + if ( !pViewFrm ) + return; + SfxViewShell* pView = pViewFrm->GetViewShell(); + if ( !pView ) + return; + bool bMonitor = false; + // We need this information at the end of this method, if we start the vcl printer + // by executing the slot. Because if it is a ucb relevant URL we must wait for + // finishing the print job and move the temporary local file by using the ucb + // to the right location. But in case of no file name is given or it is already + // a local one we can suppress this special handling. Because then vcl makes all + // right for us. + OUString sUcbUrl; + ::utl::TempFile* pUCBPrintTempFile = nullptr; + + uno::Sequence < beans::PropertyValue > aCheckedArgs( rOptions.getLength() ); + auto pCheckedArgs = aCheckedArgs.getArray(); + sal_Int32 nProps = 0; + bool bWaitUntilEnd = false; + sal_Int16 nDuplexMode = css::view::DuplexMode::UNKNOWN; + for ( const beans::PropertyValue &rProp : rOptions ) + { + // get Property-Value from options + // FileName-Property? + if ( rProp.Name == "FileName" ) + { + // unpack th URL and check for a valid and well known protocol + OUString sTemp; + if ( + ( rProp.Value.getValueType()!=cppu::UnoType<OUString>::get()) || + (!(rProp.Value>>=sTemp)) + ) + { + throw css::lang::IllegalArgumentException(); + } + + OUString sPath; + OUString sURL (sTemp); + INetURLObject aCheck(sURL ); + if (aCheck.GetProtocol()==INetProtocol::NotValid) + { + // OK - it's not a valid URL. But may it's a simple + // system path directly. It will be supported for historical + // reasons. Otherwise we break too much external code... + // We try to convert it to a file URL. If it's possible + // we put the system path to the item set and let vcl work with it. + // No ucb or thread will be necessary then. In case it couldn't be + // converted it's not a URL nor a system path. Then we can't accept + // this parameter and have to throw an exception. + const OUString& sSystemPath(sTemp); + OUString sFileURL; + if (::osl::FileBase::getFileURLFromSystemPath(sSystemPath,sFileURL)!=::osl::FileBase::E_None) + throw css::lang::IllegalArgumentException(); + pCheckedArgs[nProps].Name = rProp.Name; + pCheckedArgs[nProps++].Value <<= sFileURL; + // and append the local filename + aCheckedArgs.realloc( aCheckedArgs.getLength()+1 ); + pCheckedArgs = aCheckedArgs.getArray(); + pCheckedArgs[nProps].Name = "LocalFileName"; + pCheckedArgs[nProps++].Value <<= sTemp; + } + else + // It's a valid URL. but now we must know, if it is a local one or not. + // It's a question of using ucb or not! + if (osl::FileBase::getSystemPathFromFileURL(sURL, sPath) == osl::FileBase::E_None) + { + // it's a local file, we can use vcl without special handling + // And we have to use the system notation of the incoming URL. + // But it into the descriptor and let the slot be executed at + // the end of this method. + pCheckedArgs[nProps].Name = rProp.Name; + pCheckedArgs[nProps++].Value <<= sTemp; + // and append the local filename + aCheckedArgs.realloc( aCheckedArgs.getLength()+1 ); + pCheckedArgs = aCheckedArgs.getArray(); + pCheckedArgs[nProps].Name = "LocalFileName"; + pCheckedArgs[nProps++].Value <<= sPath; + } + else + { + // it's a ucb target. So we must use a temp. file for vcl + // and move it after printing by using the ucb. + // Create a temp file on the heap (because it must delete the + // real file on disk automatically if it die - bt we have to share it with + // some other sources ... e.g. the ImplUCBPrintWatcher). + // And we put the name of this temp file to the descriptor instead + // of the URL. The URL we save for later using separately. + // Execution of the print job will be done later by executing + // a slot ... + if(!pUCBPrintTempFile) + pUCBPrintTempFile = new ::utl::TempFile(); + pUCBPrintTempFile->EnableKillingFile(); + + //FIXME: does it work? + pCheckedArgs[nProps].Name = "LocalFileName"; + pCheckedArgs[nProps++].Value <<= pUCBPrintTempFile->GetFileName(); + sUcbUrl = sURL; + } + } + + // CopyCount-Property + else if ( rProp.Name == "CopyCount" ) + { + sal_Int32 nCopies = 0; + if ( !( rProp.Value >>= nCopies ) ) + throw css::lang::IllegalArgumentException(); + pCheckedArgs[nProps].Name = rProp.Name; + pCheckedArgs[nProps++].Value <<= nCopies; + } + + // Collate-Property + // Sort-Property (deprecated) + else if ( rProp.Name == "Collate" || rProp.Name == "Sort" ) + { + bool bTemp; + if ( !(rProp.Value >>= bTemp) ) + throw css::lang::IllegalArgumentException(); + pCheckedArgs[nProps].Name = "Collate"; + pCheckedArgs[nProps++].Value <<= bTemp; + } + + else if ( rProp.Name == "SinglePrintJobs" ) + { + bool bTemp; + if ( !(rProp.Value >>= bTemp) ) + throw css::lang::IllegalArgumentException(); + pCheckedArgs[nProps].Name = "SinglePrintJobs"; + pCheckedArgs[nProps++].Value <<= bTemp; + } + + // Pages-Property + else if ( rProp.Name == "Pages" ) + { + OUString sTemp; + if( !(rProp.Value >>= sTemp) ) + throw css::lang::IllegalArgumentException(); + pCheckedArgs[nProps].Name = rProp.Name; + pCheckedArgs[nProps++].Value <<= sTemp; + } + + // MonitorVisible + else if ( rProp.Name == "MonitorVisible" ) + { + if( !(rProp.Value >>= bMonitor) ) + throw css::lang::IllegalArgumentException(); + pCheckedArgs[nProps].Name = rProp.Name; + pCheckedArgs[nProps++].Value <<= bMonitor; + } + + // Wait + else if ( rProp.Name == "Wait" ) + { + if ( !(rProp.Value >>= bWaitUntilEnd) ) + throw css::lang::IllegalArgumentException(); + pCheckedArgs[nProps].Name = rProp.Name; + pCheckedArgs[nProps++].Value <<= bWaitUntilEnd; + } + + else if ( rProp.Name == "DuplexMode" ) + { + if ( !(rProp.Value >>= nDuplexMode ) ) + throw css::lang::IllegalArgumentException(); + pCheckedArgs[nProps].Name = rProp.Name; + pCheckedArgs[nProps++].Value <<= nDuplexMode; + } + } + + if ( nProps != aCheckedArgs.getLength() ) + aCheckedArgs.realloc(nProps); + + // Execute the print request every time. + // It doesn't matter if it is a real printer used or we print to a local file + // nor if we print to a temp file and move it afterwards by using the ucb. + // That will be handled later. see pUCBPrintFile below! + pView->ExecPrint( aCheckedArgs, true, false ); + + // Ok - may be execution before has finished (or started!) printing. + // And may it was a printing to a file. + // Now we have to check if we can move the file (if necessary) via UCB to its right location. + // Cases: + // a) printing finished => move the file directly and forget the watcher thread + // b) printing is asynchron and runs currently => start watcher thread and exit this method + // This thread make all necessary things by itself. + if (!pUCBPrintTempFile) + return; + + // a) + SfxPrinter* pPrinter = pView->GetPrinter(); + if ( ! pPrinter->IsPrinting() ) + ImplUCBPrintWatcher::moveAndDeleteTemp(&pUCBPrintTempFile,sUcbUrl); + // b) + else + { + // Note: we create(d) some resource on the heap (thread and temp file). + // They will be deleted by the thread automatically if it finishes its run() method. + ImplUCBPrintWatcher* pWatcher = new ImplUCBPrintWatcher( pPrinter, pUCBPrintTempFile, sUcbUrl ); + pWatcher->create(); + } +} + +void IMPL_PrintListener_DataContainer::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) +{ + const SfxPrintingHint* pPrintHint = dynamic_cast<const SfxPrintingHint*>(&rHint); + if ( &rBC != m_pObjectShell.get() + || !pPrintHint + || pPrintHint->GetWhich() == SFX_PRINTABLESTATE_CANCELJOB ) + return; + + if ( pPrintHint->GetWhich() == css::view::PrintableState_JOB_STARTED ) + { + if ( !m_xPrintJob.is() ) + m_xPrintJob = new SfxPrintJob_Impl( this ); + m_aPrintOptions = pPrintHint->GetOptions(); + } + + std::unique_lock aGuard(m_aMutex); + if (!m_aJobListeners.getLength(aGuard)) + return; + view::PrintJobEvent aEvent; + aEvent.Source = m_xPrintJob; + aEvent.State = pPrintHint->GetWhich(); + + comphelper::OInterfaceIteratorHelper4 pIterator(aGuard, m_aJobListeners); + aGuard.unlock(); + while (pIterator.hasMoreElements()) + pIterator.next()->printJobEvent( aEvent ); +} + +void SAL_CALL SfxPrintHelper::addPrintJobListener( const css::uno::Reference< css::view::XPrintJobListener >& xListener ) +{ + std::unique_lock aGuard(m_pData->m_aMutex); + m_pData->m_aJobListeners.addInterface( aGuard, xListener ); +} + +void SAL_CALL SfxPrintHelper::removePrintJobListener( const css::uno::Reference< css::view::XPrintJobListener >& xListener ) +{ + std::unique_lock aGuard(m_pData->m_aMutex); + m_pData->m_aJobListeners.removeInterface( aGuard, xListener ); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/printhelper.hxx b/sfx2/source/doc/printhelper.hxx new file mode 100644 index 000000000..a38e3d7a4 --- /dev/null +++ b/sfx2/source/doc/printhelper.hxx @@ -0,0 +1,68 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_SFX2_SOURCE_DOC_PRINTHELPER_HXX +#define INCLUDED_SFX2_SOURCE_DOC_PRINTHELPER_HXX + +#include <memory> +#include <sal/config.h> +#include <sfx2/viewsh.hxx> +#include <sal/types.h> + +#include <com/sun/star/view/XPrintable.hpp> +#include <com/sun/star/view/XPrintJobBroadcaster.hpp> +#include <com/sun/star/uno/Sequence.hxx> +#include <com/sun/star/uno/Reference.hxx> +#include <com/sun/star/uno/Any.hxx> +#include <com/sun/star/lang/XInitialization.hpp> +#include <cppuhelper/implbase.hxx> + +struct IMPL_PrintListener_DataContainer; +class SfxViewShell; +class SfxPrinter; + +class SfxPrintHelper : public cppu::WeakImplHelper + < css::view::XPrintable + , css::view::XPrintJobBroadcaster + , css::lang::XInitialization > +{ +public: + + SfxPrintHelper() ; + virtual ~SfxPrintHelper() override ; + + void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& aArguments ) override; + virtual void SAL_CALL addPrintJobListener( const css::uno::Reference< css::view::XPrintJobListener >& xListener ) override; + virtual void SAL_CALL removePrintJobListener( const css::uno::Reference< css::view::XPrintJobListener >& xListener ) override; + virtual css::uno::Sequence< css::beans::PropertyValue > SAL_CALL getPrinter() override; + virtual void SAL_CALL setPrinter( const css::uno::Sequence< css::beans::PropertyValue >& seqPrinter ) override; + virtual void SAL_CALL print( const css::uno::Sequence< css::beans::PropertyValue >& seqOptions ) override; + +private: + + std::unique_ptr<IMPL_PrintListener_DataContainer> m_pData ; + void impl_setPrinter(const css::uno::Sequence< css::beans::PropertyValue >& rPrinter, + VclPtr<SfxPrinter>& pPrinter, + SfxPrinterChangeFlags& nChangeFlags, + SfxViewShell*& pViewSh); +} ; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/saveastemplatedlg.cxx b/sfx2/source/doc/saveastemplatedlg.cxx new file mode 100644 index 000000000..6f9fd1b47 --- /dev/null +++ b/sfx2/source/doc/saveastemplatedlg.cxx @@ -0,0 +1,178 @@ +/* -*- 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/. + */ + +#include <comphelper/processfactory.hxx> +#include <comphelper/string.hxx> +#include <comphelper/storagehelper.hxx> +#include <sfx2/sfxresid.hxx> +#include <sfx2/app.hxx> +#include <sfx2/fcontnr.hxx> +#include <sfx2/docfac.hxx> +#include <sfx2/doctempl.hxx> +#include <sfx2/docfilt.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> +#include <sot/storage.hxx> + +#include <com/sun/star/frame/DocumentTemplates.hpp> +#include <com/sun/star/frame/XStorable.hpp> + +#include <sfx2/strings.hrc> + +#include <saveastemplatedlg.hxx> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::frame; + +// Class SfxSaveAsTemplateDialog -------------------------------------------------- + +SfxSaveAsTemplateDialog::SfxSaveAsTemplateDialog(weld::Window* pParent, const uno::Reference<frame::XModel> &rModel) + : GenericDialogController(pParent, "sfx/ui/saveastemplatedlg.ui", "SaveAsTemplateDialog") + , m_xLBCategory(m_xBuilder->weld_tree_view("categorylb")) + , m_xCBXDefault(m_xBuilder->weld_check_button("defaultcb")) + , m_xTemplateNameEdit(m_xBuilder->weld_entry("name_entry")) + , m_xOKButton(m_xBuilder->weld_button("ok")) + , mnRegionPos(0) + , m_xModel(rModel) +{ + m_xLBCategory->append_text(SfxResId(STR_CATEGORY_NONE)); + initialize(); + SetCategoryLBEntries(msCategories); + + m_xTemplateNameEdit->connect_changed(LINK(this, SfxSaveAsTemplateDialog, TemplateNameEditHdl)); + m_xLBCategory->connect_changed(LINK(this, SfxSaveAsTemplateDialog, SelectCategoryHdl)); + m_xLBCategory->set_size_request(m_xLBCategory->get_approximate_digit_width() * 32, + m_xLBCategory->get_height_rows(8)); + m_xOKButton->connect_clicked(LINK(this, SfxSaveAsTemplateDialog, OkClickHdl)); + + m_xOKButton->set_sensitive(false); + m_xOKButton->set_label(SfxResId(STR_SAVEDOC)); +} + +IMPL_LINK_NOARG(SfxSaveAsTemplateDialog, OkClickHdl, weld::Button&, void) +{ + std::unique_ptr<weld::MessageDialog> xQueryDlg(Application::CreateMessageDialog(m_xDialog.get(), VclMessageType::Question, + VclButtonsType::YesNo, OUString())); + if(!IsTemplateNameUnique()) + { + OUString sQueryMsg(SfxResId(STR_QMSG_TEMPLATE_OVERWRITE)); + sQueryMsg = sQueryMsg.replaceFirst("$1",msTemplateName); + xQueryDlg->set_primary_text(sQueryMsg.replaceFirst("$2", msSelectedCategory)); + + if (xQueryDlg->run() == RET_NO) + return; + } + + if (SaveTemplate()) + m_xDialog->response(RET_OK); + else + { + OUString sText( SfxResId(STR_ERROR_SAVEAS) ); + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(), VclMessageType::Warning, + VclButtonsType::Ok, sText.replaceFirst("$1", msTemplateName))); + xBox->run(); + } +} + +IMPL_LINK_NOARG(SfxSaveAsTemplateDialog, TemplateNameEditHdl, weld::Entry&, void) +{ + msTemplateName = comphelper::string::strip(m_xTemplateNameEdit->get_text(), ' '); + SelectCategoryHdl(*m_xLBCategory); +} + +IMPL_LINK_NOARG(SfxSaveAsTemplateDialog, SelectCategoryHdl, weld::TreeView&, void) +{ + if (m_xLBCategory->get_selected_index() == 0) + { + msSelectedCategory = OUString(); + m_xOKButton->set_sensitive(false); + } + else + { + msSelectedCategory = m_xLBCategory->get_selected_text(); + m_xOKButton->set_sensitive(!msTemplateName.isEmpty()); + } +} + +void SfxSaveAsTemplateDialog::initialize() +{ + sal_uInt16 nCount = maDocTemplates.GetRegionCount(); + for (sal_uInt16 i = 0; i < nCount; ++i) + { + OUString sCategoryName(maDocTemplates.GetFullRegionName(i)); + msCategories.push_back(sCategoryName); + } +} + +void SfxSaveAsTemplateDialog::SetCategoryLBEntries(const std::vector<OUString>& rFolderNames) +{ + for (size_t i = 0, n = rFolderNames.size(); i < n; ++i) + m_xLBCategory->insert_text(i+1, rFolderNames[i]); + m_xLBCategory->select(0); +} + +bool SfxSaveAsTemplateDialog::IsTemplateNameUnique() +{ + std::vector<OUString>::iterator it=find(msCategories.begin(), msCategories.end(), msSelectedCategory); + mnRegionPos = std::distance(msCategories.begin(), it); + + sal_uInt16 nEntries = maDocTemplates.GetCount(mnRegionPos); + for(sal_uInt16 i = 0; i < nEntries; i++) + { + OUString aName = maDocTemplates.GetName(mnRegionPos, i); + if(aName == msTemplateName) + return false; + } + + return true; +} + +bool SfxSaveAsTemplateDialog::SaveTemplate() +{ + uno::Reference< frame::XStorable > xStorable(m_xModel, uno::UNO_QUERY_THROW ); + + uno::Reference< frame::XDocumentTemplates > xTemplates(frame::DocumentTemplates::create(comphelper::getProcessComponentContext()) ); + + if (!xTemplates->storeTemplate( msSelectedCategory, msTemplateName, xStorable )) + return false; + + sal_uInt16 nDocId = maDocTemplates.GetCount(mnRegionPos); + OUString sURL = maDocTemplates.GetTemplateTargetURLFromComponent(msSelectedCategory, msTemplateName); + bool bIsSaved = maDocTemplates.InsertTemplate( mnRegionPos, nDocId, msTemplateName, sURL); + + if (!bIsSaved) + return false; + + if (!sURL.isEmpty() && m_xCBXDefault->get_active()) + { + OUString aServiceName; + try + { + uno::Reference< embed::XStorage > xStorage = + comphelper::OStorageHelper::GetStorageFromURL( sURL, embed::ElementModes::READ ); + + SotClipboardFormatId nFormat = SotStorage::GetFormatID( xStorage ); + + std::shared_ptr<const SfxFilter> pFilter = SfxGetpApp()->GetFilterMatcher().GetFilter4ClipBoardId( nFormat ); + + if ( pFilter ) + aServiceName = pFilter->GetServiceName(); + } + catch( uno::Exception& ) + {} + + if(!aServiceName.isEmpty()) + SfxObjectFactory::SetStandardTemplate(aServiceName, sURL); + } + + maDocTemplates.Update(); + return true; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/sfxbasemodel.cxx b/sfx2/source/doc/sfxbasemodel.cxx new file mode 100644 index 000000000..dc9a056e3 --- /dev/null +++ b/sfx2/source/doc/sfxbasemodel.cxx @@ -0,0 +1,4561 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <sal/config.h> + +#include <algorithm> +#include <memory> +#include <config_features.h> + +#include <sfx2/sfxbasemodel.hxx> + +#include <com/sun/star/datatransfer/UnsupportedFlavorException.hpp> +#include <com/sun/star/task/XInteractionHandler.hpp> +#include <com/sun/star/task/ErrorCodeIOException.hpp> +#include <com/sun/star/task/ErrorCodeRequest.hpp> +#include <com/sun/star/view/XSelectionSupplier.hpp> +#include <com/sun/star/view/XPrintJobListener.hpp> +#include <com/sun/star/lang/DisposedException.hpp> +#include <com/sun/star/lang/IllegalArgumentException.hpp> +#include <com/sun/star/lang/NoSupportException.hpp> +#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp> +#include <com/sun/star/lang/NotInitializedException.hpp> +#include <com/sun/star/frame/Desktop.hpp> +#include <com/sun/star/frame/IllegalArgumentIOException.hpp> +#include <com/sun/star/frame/XUntitledNumbers.hpp> +#include <com/sun/star/frame/DoubleInitializationException.hpp> +#include <com/sun/star/embed/XStorage.hpp> +#include <com/sun/star/document/XStorageChangeListener.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/beans/XPropertySetInfo.hpp> +#include <com/sun/star/container/XIndexContainer.hpp> +#include <com/sun/star/script/provider/theMasterScriptProviderFactory.hpp> +#include <com/sun/star/script/provider/XScriptProvider.hpp> +#include <com/sun/star/ui/UIConfigurationManager.hpp> +#include <com/sun/star/embed/ElementModes.hpp> +#include <com/sun/star/embed/Aspects.hpp> +#include <com/sun/star/document/DocumentProperties.hpp> +#include <com/sun/star/frame/XTransientDocumentsDocumentContentFactory.hpp> +#include <com/sun/star/ucb/XCommandEnvironment.hpp> +#include <com/sun/star/ucb/ContentCreationException.hpp> +#include <com/sun/star/ucb/CommandAbortedException.hpp> +#include <com/sun/star/util/XCloneable.hpp> +#include <com/sun/star/util/InvalidStateException.hpp> +#include <com/sun/star/util/CloseVetoException.hpp> +#include <comphelper/enumhelper.hxx> +#include <comphelper/indexedpropertyvalues.hxx> +#include <comphelper/string.hxx> + +#include <cppuhelper/implbase.hxx> +#include <comphelper/multicontainer2.hxx> +#include <cppuhelper/exc_hlp.hxx> +#include <comphelper/processfactory.hxx> +#include <comphelper/propertyvalue.hxx> +#include <comphelper/sequenceashashmap.hxx> +#include <comphelper/namedvaluecollection.hxx> +#include <o3tl/safeint.hxx> +#include <o3tl/string_view.hxx> +#include <svl/itemset.hxx> +#include <svl/stritem.hxx> +#include <svl/eitem.hxx> +#include <svl/grabbagitem.hxx> +#include <tools/urlobj.hxx> +#include <tools/debug.hxx> +#include <tools/diagnose_ex.h> +#include <tools/svborder.hxx> +#include <unotools/tempfile.hxx> +#include <osl/mutex.hxx> +#include <vcl/errcode.hxx> +#include <vcl/filter/SvmWriter.hxx> +#include <vcl/salctype.hxx> +#include <vcl/gdimtf.hxx> +#include <comphelper/fileformat.h> +#include <comphelper/servicehelper.hxx> +#include <comphelper/storagehelper.hxx> +#include <toolkit/helper/vclunohelper.hxx> +#include <vcl/transfer.hxx> +#include <svtools/ehdl.hxx> +#include <svtools/sfxecode.hxx> +#include <sal/log.hxx> +#include <framework/configimporter.hxx> +#include <framework/titlehelper.hxx> +#include <comphelper/numberedcollection.hxx> +#include <unotools/ucbhelper.hxx> +#include <ucbhelper/content.hxx> + +#include <sfx2/sfxbasecontroller.hxx> +#include <sfx2/viewfac.hxx> +#include <workwin.hxx> +#include <sfx2/signaturestate.hxx> +#include <sfx2/sfxuno.hxx> +#include <objshimp.hxx> +#include <sfx2/viewfrm.hxx> +#include <sfx2/viewsh.hxx> +#include <sfx2/docfile.hxx> +#include <sfx2/docfilt.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/module.hxx> +#include <basic/basmgr.hxx> +#include <sfx2/event.hxx> +#include <eventsupplier.hxx> +#include <sfx2/sfxsids.hrc> +#include <sfx2/strings.hrc> +#include <sfx2/app.hxx> +#include <sfx2/docfac.hxx> +#include <sfx2/fcontnr.hxx> +#include <sfx2/docstoragemodifylistener.hxx> +#include <sfx2/brokenpackageint.hxx> +#include "graphhelp.hxx" +#include <docundomanager.hxx> +#include <openurlhint.hxx> +#include <sfx2/msgpool.hxx> +#include <sfx2/DocumentMetadataAccess.hxx> +#include "printhelper.hxx" +#include <sfx2/sfxresid.hxx> +#include <comphelper/profilezone.hxx> +#include <vcl/threadex.hxx> +#include <unotools/mediadescriptor.hxx> + +// namespaces + + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using ::com::sun::star::beans::PropertyValue; +using ::com::sun::star::document::CmisProperty; +using ::com::sun::star::frame::XFrame; +using ::com::sun::star::frame::XController; +using ::com::sun::star::frame::XController2; +using ::com::sun::star::lang::IllegalArgumentException; +using ::com::sun::star::io::IOException; +using ::com::sun::star::uno::Sequence; +using ::com::sun::star::document::XDocumentRecovery; +using ::com::sun::star::document::XUndoManager; +using ::com::sun::star::document::XUndoAction; +using ::com::sun::star::frame::XModel; + +namespace { + +/** This Listener is used to get notified when the XDocumentProperties of the + XModel change. + */ +class SfxDocInfoListener_Impl : public ::cppu::WeakImplHelper< + util::XModifyListener > +{ + +public: + SfxObjectShell& m_rShell; + + explicit SfxDocInfoListener_Impl( SfxObjectShell& i_rDoc ) + : m_rShell(i_rDoc) + { }; + + virtual void SAL_CALL disposing( const lang::EventObject& ) override; + virtual void SAL_CALL modified( const lang::EventObject& ) override; +}; + +} + +void SAL_CALL SfxDocInfoListener_Impl::modified( const lang::EventObject& ) +{ + SolarMutexGuard aSolarGuard; + + // notify changes to the SfxObjectShell + m_rShell.FlushDocInfo(); +} + +void SAL_CALL SfxDocInfoListener_Impl::disposing( const lang::EventObject& ) +{ +} + + +// impl. declarations + + +struct IMPL_SfxBaseModel_DataContainer : public ::sfx2::IModifiableDocument +{ + // counter for SfxBaseModel instances created. + static sal_Int64 g_nInstanceCounter ; + SfxObjectShellRef m_pObjectShell ; + OUString m_sURL ; + OUString m_sRuntimeUID ; + OUString m_aPreusedFilterName ; + comphelper::OMultiTypeInterfaceContainerHelper2 m_aInterfaceContainer ; + std::unordered_map<css::uno::Reference< css::drawing::XShape >, + std::vector<css::uno::Reference< css::document::XShapeEventListener >>> maShapeListeners; + Reference< XInterface > m_xParent ; + Reference< frame::XController > m_xCurrent ; + Reference< document::XDocumentProperties > m_xDocumentProperties ; + Reference< script::XStarBasicAccess > m_xStarBasicAccess ; + Reference< container::XNameReplace > m_xEvents ; + Sequence< beans::PropertyValue> m_seqArguments ; + std::vector< Reference< frame::XController > > m_seqControllers ; + Reference< container::XIndexAccess > m_contViewData ; + sal_uInt16 m_nControllerLockCount ; + bool m_bClosed ; + bool m_bClosing ; + bool m_bSaving ; + bool m_bSuicide ; + bool m_bExternalTitle ; + bool m_bModifiedSinceLastSave ; + Reference< view::XPrintable> m_xPrintable ; + Reference< ui::XUIConfigurationManager2 > m_xUIConfigurationManager; + ::rtl::Reference< ::sfx2::DocumentStorageModifyListener > m_pStorageModifyListen ; + OUString m_sModuleIdentifier ; + Reference< frame::XTitle > m_xTitleHelper ; + Reference< frame::XUntitledNumbers > m_xNumberedControllers ; + Reference< rdf::XDocumentMetadataAccess> m_xDocumentMetadata ; + ::rtl::Reference< ::sfx2::DocumentUndoManager > m_pDocumentUndoManager ; + Sequence< document::CmisProperty> m_cmisProperties ; + std::shared_ptr<SfxGrabBagItem> m_xGrabBagItem ; + + IMPL_SfxBaseModel_DataContainer( ::osl::Mutex& rMutex, SfxObjectShell* pObjectShell ) + : m_pObjectShell ( pObjectShell ) + , m_aInterfaceContainer ( rMutex ) + , m_nControllerLockCount ( 0 ) + , m_bClosed ( false ) + , m_bClosing ( false ) + , m_bSaving ( false ) + , m_bSuicide ( false ) + , m_bExternalTitle ( false ) + , m_bModifiedSinceLastSave( false ) + { + // increase global instance counter. + ++g_nInstanceCounter; + // set own Runtime UID + m_sRuntimeUID = OUString::number( g_nInstanceCounter ); + } + + virtual ~IMPL_SfxBaseModel_DataContainer() + { + } + + // ::sfx2::IModifiableDocument + virtual void storageIsModified() override + { + if ( m_pObjectShell.is() && !m_pObjectShell->IsModified() ) + m_pObjectShell->SetModified(); + } + + void impl_setDocumentProperties( + const Reference< document::XDocumentProperties >& ); + + Reference<rdf::XDocumentMetadataAccess> GetDMA() + { + if (!m_xDocumentMetadata.is()) + { + OSL_ENSURE(m_pObjectShell.is(), "GetDMA: no object shell?"); + if (!m_pObjectShell.is()) + { + return nullptr; + } + + const Reference<XComponentContext> xContext( + ::comphelper::getProcessComponentContext()); + const Reference<frame::XModel> xModel( + m_pObjectShell->GetModel()); + const Reference<lang::XMultiComponentFactory> xMsf( + xContext->getServiceManager()); + const Reference<frame:: + XTransientDocumentsDocumentContentFactory> xTDDCF( + xMsf->createInstanceWithContext( + "com.sun.star.frame.TransientDocumentsDocumentContentFactory", + xContext), + UNO_QUERY_THROW); + const Reference<ucb::XContent> xContent( + xTDDCF->createDocumentContent(xModel) ); + OSL_ENSURE(xContent.is(), "GetDMA: cannot create DocumentContent"); + if (!xContent.is()) + { + return nullptr; + } + OUString uri = xContent->getIdentifier()->getContentIdentifier(); + OSL_ENSURE(!uri.isEmpty(), "GetDMA: empty uri?"); + if (!uri.isEmpty() && !uri.endsWith("/")) + { + uri += "/"; + } + + m_xDocumentMetadata = new ::sfx2::DocumentMetadataAccess( + xContext, *m_pObjectShell, uri); + } + return m_xDocumentMetadata; + } + + Reference<rdf::XDocumentMetadataAccess> CreateDMAUninitialized() + { + return (m_pObjectShell.is()) + ? new ::sfx2::DocumentMetadataAccess( + ::comphelper::getProcessComponentContext(), *m_pObjectShell) + : nullptr; + } +}; + +// static member initialization. +sal_Int64 IMPL_SfxBaseModel_DataContainer::g_nInstanceCounter = 0; + +namespace { + +// Listener that forwards notifications from the PrintHelper to the "real" listeners +class SfxPrintHelperListener_Impl : public ::cppu::WeakImplHelper< view::XPrintJobListener > +{ +public: + IMPL_SfxBaseModel_DataContainer* m_pData; + explicit SfxPrintHelperListener_Impl( IMPL_SfxBaseModel_DataContainer* pData ) + : m_pData( pData ) + {} + + virtual void SAL_CALL disposing( const lang::EventObject& aEvent ) override ; + virtual void SAL_CALL printJobEvent( const view::PrintJobEvent& rEvent ) override; +}; + +} + +void SAL_CALL SfxPrintHelperListener_Impl::disposing( const lang::EventObject& ) +{ + m_pData->m_xPrintable = nullptr; +} + +void SAL_CALL SfxPrintHelperListener_Impl::printJobEvent( const view::PrintJobEvent& rEvent ) +{ + ::comphelper::OInterfaceContainerHelper2* pContainer = m_pData->m_aInterfaceContainer.getContainer( cppu::UnoType<view::XPrintJobListener>::get()); + if ( pContainer!=nullptr ) + { + ::comphelper::OInterfaceIteratorHelper2 pIterator(*pContainer); + while (pIterator.hasMoreElements()) + static_cast<view::XPrintJobListener*>(pIterator.next())->printJobEvent( rEvent ); + } +} + +namespace { + +// SfxOwnFramesLocker ==================================================================================== +// allows to lock all the frames related to the provided SfxObjectShell +class SfxOwnFramesLocker +{ + Sequence< Reference< frame::XFrame > > m_aLockedFrames; + + static vcl::Window* GetVCLWindow( const Reference< frame::XFrame >& xFrame ); +public: + explicit SfxOwnFramesLocker( SfxObjectShell const * ObjechShell ); + ~SfxOwnFramesLocker(); +}; + +} + +SfxOwnFramesLocker::SfxOwnFramesLocker( SfxObjectShell const * pObjectShell ) +{ + if ( !pObjectShell ) + return; + + for ( SfxViewFrame *pFrame = SfxViewFrame::GetFirst( pObjectShell ); + pFrame; + pFrame = SfxViewFrame::GetNext( *pFrame, pObjectShell ) + ) + { + SfxFrame& rSfxFrame = pFrame->GetFrame(); + try + { + // get vcl window related to the frame and lock it if it is still not locked + const Reference< frame::XFrame >& xFrame = rSfxFrame.GetFrameInterface(); + vcl::Window* pWindow = GetVCLWindow( xFrame ); + if ( !pWindow ) + throw RuntimeException(); + + if ( pWindow->IsEnabled() ) + { + pWindow->Disable(); + + try + { + sal_Int32 nLen = m_aLockedFrames.getLength(); + m_aLockedFrames.realloc( nLen + 1 ); + m_aLockedFrames.getArray()[nLen] = xFrame; + } + catch( Exception& ) + { + pWindow->Enable(); + throw; + } + } + } + catch( Exception& ) + { + OSL_FAIL( "Not possible to lock the frame window!" ); + } + } +} + +SfxOwnFramesLocker::~SfxOwnFramesLocker() +{ + for ( auto& rFrame : asNonConstRange(m_aLockedFrames) ) + { + try + { + if ( rFrame.is() ) + { + // get vcl window related to the frame and unlock it + vcl::Window* pWindow = GetVCLWindow( rFrame ); + if ( !pWindow ) + throw RuntimeException(); + + pWindow->Enable(); + + rFrame.clear(); + } + } + catch( Exception& ) + { + OSL_FAIL( "Can't unlock the frame window!" ); + } + } +} + +vcl::Window* SfxOwnFramesLocker::GetVCLWindow( const Reference< frame::XFrame >& xFrame ) +{ + VclPtr<vcl::Window> pWindow; + + if ( xFrame.is() ) + { + Reference< awt::XWindow > xWindow = xFrame->getContainerWindow(); + if ( xWindow.is() ) + pWindow = VCLUnoHelper::GetWindow( xWindow ); + } + + return pWindow; +} + +namespace { + +// SfxSaveGuard ==================================================================================== +class SfxSaveGuard +{ + private: + Reference< frame::XModel > m_xModel; + IMPL_SfxBaseModel_DataContainer* m_pData; + std::unique_ptr<SfxOwnFramesLocker> m_pFramesLock; + + SfxSaveGuard(SfxSaveGuard const &) = delete; + void operator =(const SfxSaveGuard&) = delete; + + public: + SfxSaveGuard(const Reference< frame::XModel >& xModel , + IMPL_SfxBaseModel_DataContainer* pData); + ~SfxSaveGuard(); +}; + +} + +SfxSaveGuard::SfxSaveGuard(const Reference< frame::XModel >& xModel , + IMPL_SfxBaseModel_DataContainer* pData) + : m_xModel ( xModel ) + , m_pData ( pData ) +{ + if ( m_pData->m_bClosed ) + throw lang::DisposedException("Object already disposed."); + + m_pData->m_bSaving = true; + m_pFramesLock.reset(new SfxOwnFramesLocker( m_pData->m_pObjectShell.get() )); +} + +SfxSaveGuard::~SfxSaveGuard() +{ + m_pFramesLock.reset(); + + m_pData->m_bSaving = false; + + // m_bSuicide was set e.g. in case someone tried to close a document, while it was used for + // storing at the same time. Further m_bSuicide was set to sal_True only if close(sal_True) was called. + // So the ownership was delegated to the place where a veto exception was thrown. + // Now we have to call close() again and delegate the ownership to the next one, which + // can't accept that. Close(sal_False) can't work in this case. Because then the document will may be never closed... + + if ( !m_pData->m_bSuicide ) + return; + + // Reset this state. In case the new close() request is not accepted by someone else... + // it's not a good idea to have two "owners" for close.-) + m_pData->m_bSuicide = false; + try + { + Reference< util::XCloseable > xClose(m_xModel, UNO_QUERY); + if (xClose.is()) + xClose->close(true); + } + catch(const util::CloseVetoException&) + {} +} + +SfxBaseModel::SfxBaseModel( SfxObjectShell *pObjectShell ) +: BaseMutex() +, m_pData( std::make_shared<IMPL_SfxBaseModel_DataContainer>( m_aMutex, pObjectShell ) ) +, m_bSupportEmbeddedScripts( pObjectShell && pObjectShell->Get_Impl() && !pObjectShell->Get_Impl()->m_bNoBasicCapabilities ) +, m_bSupportDocRecovery( pObjectShell && pObjectShell->Get_Impl() && pObjectShell->Get_Impl()->m_bDocRecoverySupport ) +{ + if ( pObjectShell != nullptr ) + { + StartListening( *pObjectShell ) ; + } +} + +// destructor +SfxBaseModel::~SfxBaseModel() +{ +} + +// XInterface +Any SAL_CALL SfxBaseModel::queryInterface( const uno::Type& rType ) +{ + if ( ( !m_bSupportEmbeddedScripts && rType.equals( cppu::UnoType<document::XEmbeddedScripts>::get() ) ) + || ( !m_bSupportDocRecovery && rType.equals( cppu::UnoType<XDocumentRecovery>::get() ) ) + ) + return Any(); + + return SfxBaseModel_Base::queryInterface( rType ); +} + + +// XTypeProvider + + +namespace +{ + void lcl_stripType( Sequence< uno::Type >& io_rTypes, const uno::Type& i_rTypeToStrip ) + { + Sequence< uno::Type > aStrippedTypes( io_rTypes.getLength() - 1 ); + ::std::remove_copy_if( + std::cbegin(io_rTypes), + std::cend(io_rTypes), + aStrippedTypes.getArray(), + [&i_rTypeToStrip](const uno::Type& aType) { return aType == i_rTypeToStrip; } + ); + io_rTypes = aStrippedTypes; + } +} + +Sequence< uno::Type > SAL_CALL SfxBaseModel::getTypes() +{ + Sequence< uno::Type > aTypes( SfxBaseModel_Base::getTypes() ); + + if ( !m_bSupportEmbeddedScripts ) + lcl_stripType( aTypes, cppu::UnoType<document::XEmbeddedScripts>::get() ); + + if ( !m_bSupportDocRecovery ) + lcl_stripType( aTypes, cppu::UnoType<XDocumentRecovery>::get() ); + + return aTypes; +} + + +// XTypeProvider + + +Sequence< sal_Int8 > SAL_CALL SfxBaseModel::getImplementationId() +{ + return css::uno::Sequence<sal_Int8>(); +} + + +// XStarBasicAccess + +#if HAVE_FEATURE_SCRIPTING + +static Reference< script::XStarBasicAccess > implGetStarBasicAccess( SfxObjectShell const * pObjectShell ) +{ + Reference< script::XStarBasicAccess > xRet; + +#if !HAVE_FEATURE_SCRIPTING + (void) pObjectShell; +#else + if( pObjectShell ) + { + BasicManager* pMgr = pObjectShell->GetBasicManager(); + xRet = getStarBasicAccess( pMgr ); + } +#endif + return xRet; +} + +#endif + +Reference< container::XNameContainer > SAL_CALL SfxBaseModel::getLibraryContainer() +{ +#if !HAVE_FEATURE_SCRIPTING + Reference< container::XNameContainer > dummy; + + return dummy; +#else + SfxModelGuard aGuard( *this ); + + Reference< script::XStarBasicAccess >& rxAccess = m_pData->m_xStarBasicAccess; + if( !rxAccess.is() && m_pData->m_pObjectShell.is() ) + rxAccess = implGetStarBasicAccess( m_pData->m_pObjectShell.get() ); + + Reference< container::XNameContainer > xRet; + if( rxAccess.is() ) + xRet = rxAccess->getLibraryContainer(); + return xRet; +#endif +} + +/**___________________________________________________________________________________________________ + @seealso XStarBasicAccess +*/ +void SAL_CALL SfxBaseModel::createLibrary( const OUString& LibName, const OUString& Password, + const OUString& ExternalSourceURL, const OUString& LinkTargetURL ) +{ +#if !HAVE_FEATURE_SCRIPTING + (void) LibName; + (void) Password; + (void) ExternalSourceURL; + (void) LinkTargetURL; +#else + SfxModelGuard aGuard( *this ); + + Reference< script::XStarBasicAccess >& rxAccess = m_pData->m_xStarBasicAccess; + if( !rxAccess.is() && m_pData->m_pObjectShell.is() ) + rxAccess = implGetStarBasicAccess( m_pData->m_pObjectShell.get() ); + + if( rxAccess.is() ) + rxAccess->createLibrary( LibName, Password, ExternalSourceURL, LinkTargetURL ); +#endif +} + +/**___________________________________________________________________________________________________ + @seealso XStarBasicAccess +*/ +void SAL_CALL SfxBaseModel::addModule( const OUString& LibraryName, const OUString& ModuleName, + const OUString& Language, const OUString& Source ) +{ +#if !HAVE_FEATURE_SCRIPTING + (void) LibraryName; + (void) ModuleName; + (void) Language; + (void) Source; +#else + SfxModelGuard aGuard( *this ); + + Reference< script::XStarBasicAccess >& rxAccess = m_pData->m_xStarBasicAccess; + if( !rxAccess.is() && m_pData->m_pObjectShell.is() ) + rxAccess = implGetStarBasicAccess( m_pData->m_pObjectShell.get() ); + + if( rxAccess.is() ) + rxAccess->addModule( LibraryName, ModuleName, Language, Source ); +#endif +} + +/**___________________________________________________________________________________________________ + @seealso XStarBasicAccess +*/ +void SAL_CALL SfxBaseModel::addDialog( const OUString& LibraryName, const OUString& DialogName, + const Sequence< sal_Int8 >& Data ) +{ +#if !HAVE_FEATURE_SCRIPTING + (void) LibraryName; + (void) DialogName; + (void) Data; +#else + SfxModelGuard aGuard( *this ); + + Reference< script::XStarBasicAccess >& rxAccess = m_pData->m_xStarBasicAccess; + if( !rxAccess.is() && m_pData->m_pObjectShell.is() ) + rxAccess = implGetStarBasicAccess( m_pData->m_pObjectShell.get() ); + + if( rxAccess.is() ) + rxAccess->addDialog( LibraryName, DialogName, Data ); +#endif +} + + +// XChild + + +Reference< XInterface > SAL_CALL SfxBaseModel::getParent() +{ + SfxModelGuard aGuard( *this ); + + return m_pData->m_xParent; +} + + +// XChild + + +void SAL_CALL SfxBaseModel::setParent(const Reference< XInterface >& Parent) +{ + SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING ); + m_pData->m_xParent = Parent; +} + + +// XChild + + +void SAL_CALL SfxBaseModel::dispose() +{ + SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING ); + + if ( !m_pData->m_bClosed ) + { + // gracefully accept wrong dispose calls instead of close call + // and try to make it work (may be really disposed later!) + try + { + close( true ); + } + catch ( util::CloseVetoException& ) + { + } + + return; + } + + if ( m_pData->m_pStorageModifyListen.is() ) + { + m_pData->m_pStorageModifyListen->dispose(); + m_pData->m_pStorageModifyListen = nullptr; + } + + if ( m_pData->m_pDocumentUndoManager.is() ) + { + m_pData->m_pDocumentUndoManager->disposing(); + m_pData->m_pDocumentUndoManager = nullptr; + } + + lang::EventObject aEvent( static_cast<frame::XModel *>(this) ); + m_pData->m_aInterfaceContainer.disposeAndClear( aEvent ); + + m_pData->m_xDocumentProperties.clear(); + + m_pData->m_xDocumentMetadata.clear(); + + if ( m_pData->m_pObjectShell.is() ) + { + EndListening( *m_pData->m_pObjectShell ); + } + + m_pData->m_xCurrent.clear(); + m_pData->m_seqControllers.clear(); + + // m_pData member must be set to zero before delete is called to + // force disposed exception whenever someone tries to access our + // instance while in the dtor. + m_pData.reset(); +} + + +// XChild + + +void SAL_CALL SfxBaseModel::addEventListener( const Reference< lang::XEventListener >& aListener ) +{ + SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING ); + m_pData->m_aInterfaceContainer.addInterface( cppu::UnoType<lang::XEventListener>::get(), aListener ); +} + + +// XChild + + +void SAL_CALL SfxBaseModel::removeEventListener( const Reference< lang::XEventListener >& aListener ) +{ + SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING ); + m_pData->m_aInterfaceContainer.removeInterface( cppu::UnoType<lang::XEventListener>::get(), aListener ); +} + +void +IMPL_SfxBaseModel_DataContainer::impl_setDocumentProperties( + const Reference< document::XDocumentProperties >& rxNewDocProps) +{ + m_xDocumentProperties.set(rxNewDocProps, UNO_SET_THROW); + if (m_pObjectShell.is()) + { + Reference<util::XModifyBroadcaster> const xMB( + m_xDocumentProperties, UNO_QUERY_THROW); + xMB->addModifyListener(new SfxDocInfoListener_Impl(*m_pObjectShell)); + } +} + +// document::XDocumentPropertiesSupplier: +Reference< document::XDocumentProperties > SAL_CALL +SfxBaseModel::getDocumentProperties() +{ + SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING ); + if ( !m_pData->m_xDocumentProperties.is() ) + { + Reference< document::XDocumentProperties > xDocProps( + document::DocumentProperties::create( ::comphelper::getProcessComponentContext() ) ); + m_pData->impl_setDocumentProperties(xDocProps); + } + + return m_pData->m_xDocumentProperties; +} + + +// lang::XEventListener + + +void SAL_CALL SfxBaseModel::disposing( const lang::EventObject& aObject ) +{ + SolarMutexGuard aGuard; + if ( impl_isDisposed() ) + return; + + Reference< util::XModifyListener > xMod( aObject.Source, UNO_QUERY ); + Reference< lang::XEventListener > xListener( aObject.Source, UNO_QUERY ); + Reference< document::XEventListener > xDocListener( aObject.Source, UNO_QUERY ); + + if ( xMod.is() ) + m_pData->m_aInterfaceContainer.removeInterface( cppu::UnoType<util::XModifyListener>::get(), xMod ); + else if ( xListener.is() ) + m_pData->m_aInterfaceContainer.removeInterface( cppu::UnoType<lang::XEventListener>::get(), xListener ); + else if ( xDocListener.is() ) + m_pData->m_aInterfaceContainer.removeInterface( cppu::UnoType<document::XEventListener>::get(), xListener ); +} + + +// frame::XModel + + +sal_Bool SAL_CALL SfxBaseModel::attachResource( const OUString& rURL , + const Sequence< beans::PropertyValue >& rArgs ) +{ + SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING ); + if ( rURL.isEmpty() && rArgs.getLength() == 1 && rArgs[0].Name == "SetEmbedded" ) + { + // allows to set a windowless document to EMBEDDED state + // but _only_ before load() or initNew() methods + if ( m_pData->m_pObjectShell.is() && !m_pData->m_pObjectShell->GetMedium() ) + { + bool bEmb(false); + if ( ( rArgs[0].Value >>= bEmb ) && bEmb ) + m_pData->m_pObjectShell->SetCreateMode_Impl( SfxObjectCreateMode::EMBEDDED ); + } + + return true; + } + + if ( m_pData->m_pObjectShell.is() ) + { + m_pData->m_sURL = rURL; + + SfxObjectShell* pObjectShell = m_pData->m_pObjectShell.get(); + + Sequence< sal_Int32 > aWinExtent; + for (const beans::PropertyValue & rProp : rArgs) + { + if (rProp.Name == "WinExtent" && (rProp.Value >>= aWinExtent) && ( aWinExtent.getLength() == 4 ) ) + { + tools::Rectangle aVisArea( aWinExtent[0], aWinExtent[1], aWinExtent[2], aWinExtent[3] ); + aVisArea = OutputDevice::LogicToLogic(aVisArea, MapMode(MapUnit::Map100thMM), MapMode(pObjectShell->GetMapUnit())); + pObjectShell->SetVisArea( aVisArea ); + } + bool bBreakMacroSign = false; + if ( rProp.Name == "BreakMacroSignature" && (rProp.Value >>= bBreakMacroSign) ) + { + pObjectShell->BreakMacroSign_Impl( bBreakMacroSign ); + } + bool bMacroEventRead = false; + if ( rProp.Name == "MacroEventRead" && (rProp.Value >>= bMacroEventRead) && bMacroEventRead) + { + pObjectShell->SetMacroCallsSeenWhileLoading(); + } + } + Sequence<beans::PropertyValue> aStrippedArgs(rArgs.getLength()); + beans::PropertyValue* pStripped = aStrippedArgs.getArray(); + for (const beans::PropertyValue & rProp : rArgs) + { + if (rProp.Name == "WinExtent" + || rProp.Name == "BreakMacroSignature" + || rProp.Name == "MacroEventRead" + || rProp.Name == "Stream" + || rProp.Name == "InputStream" + || rProp.Name == "URL" + || rProp.Name == "Frame" + || rProp.Name == "Password" + || rProp.Name == "EncryptionData") + continue; + *pStripped++ = rProp; + } + aStrippedArgs.realloc(pStripped - aStrippedArgs.getArray()); + + // TODO/LATER: all the parameters that are accepted by ItemSet of the DocShell must be removed here + + m_pData->m_seqArguments = aStrippedArgs; + + SfxMedium* pMedium = pObjectShell->GetMedium(); + if ( pMedium ) + { + SfxAllItemSet aSet( pObjectShell->GetPool() ); + TransformParameters( SID_OPENDOC, rArgs, aSet ); + + // the arguments are not allowed to reach the medium + aSet.ClearItem( SID_FILE_NAME ); + aSet.ClearItem( SID_FILLFRAME ); + + pMedium->GetItemSet()->Put( aSet ); + const SfxStringItem* pItem = aSet.GetItem<SfxStringItem>(SID_FILTER_NAME, false); + if ( pItem ) + pMedium->SetFilter( + pObjectShell->GetFactory().GetFilterContainer()->GetFilter4FilterName( pItem->GetValue() ) ); + + const SfxStringItem* pTitleItem = aSet.GetItem<SfxStringItem>(SID_DOCINFO_TITLE, false); + if ( pTitleItem ) + { + SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pObjectShell ); + if ( pFrame ) + pFrame->UpdateTitle(); + } + } + } + + return true ; +} + + +// frame::XModel + + +OUString SAL_CALL SfxBaseModel::getURL() +{ + SfxModelGuard aGuard( *this ); + return m_pData->m_sURL ; +} + + +// frame::XModel + +Sequence< beans::PropertyValue > SAL_CALL SfxBaseModel::getArgs() +{ + return getArgs2({}); +} + +// frame::XModel3 + +Sequence< beans::PropertyValue > SAL_CALL SfxBaseModel::getArgs2(const Sequence<OUString> & requestedArgsSeq ) +{ + SfxModelGuard aGuard( *this ); + + if (!SfxApplication::Get()) // tdf#113755 + { + SAL_WARN("sfx.appl", "Unexpected operations on model"); + return m_pData->m_seqArguments; + } + + std::set<std::u16string_view> requestedArgs; + for (OUString const & s : requestedArgsSeq) + requestedArgs.insert(s); + + if ( m_pData->m_pObjectShell.is() ) + { + Sequence< beans::PropertyValue > seqArgsNew; + Sequence< beans::PropertyValue > seqArgsOld; + SfxAllItemSet aSet( m_pData->m_pObjectShell->GetPool() ); + + // we need to know which properties are supported by the transformer + // hopefully it is a temporary solution, I guess nonconvertable properties + // should not be supported so then there will be only ItemSet from medium + + TransformItems( SID_OPENDOC, *(m_pData->m_pObjectShell->GetMedium()->GetItemSet()), seqArgsNew ); + TransformParameters( SID_OPENDOC, m_pData->m_seqArguments, aSet ); + TransformItems( SID_OPENDOC, aSet, seqArgsOld ); + + sal_Int32 nNewLength = seqArgsNew.getLength(); + + if (requestedArgs.empty() || requestedArgs.count(u"WinExtent")) + { + // "WinExtent" property should be updated always. + // We can store it now to overwrite an old value + // since it is not from ItemSet + tools::Rectangle aTmpRect = m_pData->m_pObjectShell->GetVisArea( ASPECT_CONTENT ); + aTmpRect = OutputDevice::LogicToLogic(aTmpRect, MapMode(m_pData->m_pObjectShell->GetMapUnit()), MapMode(MapUnit::Map100thMM)); + + Sequence< sal_Int32 > aRectSeq + { + o3tl::narrowing<int>(aTmpRect.Left()), + o3tl::narrowing<int>(aTmpRect.Top()), + o3tl::narrowing<int>(aTmpRect.IsWidthEmpty() ? aTmpRect.Left() : aTmpRect.Right()), + o3tl::narrowing<int>(aTmpRect.IsHeightEmpty() ? aTmpRect.Top() : aTmpRect.Bottom()) + }; + + seqArgsNew.realloc( ++nNewLength ); + auto pseqArgsNew = seqArgsNew.getArray(); + pseqArgsNew[ nNewLength - 1 ].Name = "WinExtent"; + pseqArgsNew[ nNewLength - 1 ].Value <<= aRectSeq; + } + + if (requestedArgs.empty() || requestedArgs.count(u"PreusedFilterName")) + { + if ( !m_pData->m_aPreusedFilterName.isEmpty() ) + { + seqArgsNew.realloc( ++nNewLength ); + auto pseqArgsNew = seqArgsNew.getArray(); + pseqArgsNew[ nNewLength - 1 ].Name = "PreusedFilterName"; + pseqArgsNew[ nNewLength - 1 ].Value <<= m_pData->m_aPreusedFilterName; + } + } + + if (requestedArgs.empty() || requestedArgs.count(u"DocumentBorder")) + { + SfxViewFrame* pFrame = SfxViewFrame::GetFirst( m_pData->m_pObjectShell.get() ); + if ( pFrame ) + { + SvBorder aBorder = pFrame->GetBorderPixelImpl(); + + Sequence< sal_Int32 > aBorderSeq + { + o3tl::narrowing<int>(aBorder.Left()), + o3tl::narrowing<int>(aBorder.Top()), + o3tl::narrowing<int>(aBorder.Right()), + o3tl::narrowing<int>(aBorder.Bottom()) + }; + + seqArgsNew.realloc( ++nNewLength ); + auto pseqArgsNew = seqArgsNew.getArray(); + pseqArgsNew[ nNewLength - 1 ].Name = "DocumentBorder"; + pseqArgsNew[ nNewLength - 1 ].Value <<= aBorderSeq; + } + } + + if (requestedArgs.empty()) + { + // only the values that are not supported by the ItemSet must be cached here + Sequence< beans::PropertyValue > aFinalCache; + sal_Int32 nFinalLength = 0; + + for ( const auto& rOrg : std::as_const(m_pData->m_seqArguments) ) + { + auto bNew = std::none_of(std::cbegin(seqArgsOld), std::cend(seqArgsOld), + [&rOrg](const beans::PropertyValue& rOld){ return rOld.Name == rOrg.Name; }); + if ( bNew ) + { + // the entity with this name should be new for seqArgsNew + // since it is not supported by transformer + + seqArgsNew.realloc( ++nNewLength ); + seqArgsNew.getArray()[ nNewLength - 1 ] = rOrg; + + aFinalCache.realloc( ++nFinalLength ); + aFinalCache.getArray()[ nFinalLength - 1 ] = rOrg; + } + } + + m_pData->m_seqArguments = aFinalCache; + } + + return seqArgsNew; + } + + return m_pData->m_seqArguments; +} + +void SAL_CALL SfxBaseModel::setArgs(const Sequence<beans::PropertyValue>& aArgs) +{ + SfxModelGuard aGuard( *this ); + + SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium(); + if (!pMedium) + { + throw util::InvalidStateException( + "Medium could not be retrieved, unable to execute setArgs"); + } + + for (const auto& rArg : aArgs) + { + OUString sValue; + bool bValue; + bool ok = false; + if (rArg.Name == "SuggestedSaveAsName") + { + if (rArg.Value >>= sValue) + { + pMedium->GetItemSet()->Put(SfxStringItem(SID_SUGGESTEDSAVEASNAME, sValue)); + ok = true; + } + } + else if (rArg.Name == "SuggestedSaveAsDir") + { + if (rArg.Value >>= sValue) + { + pMedium->GetItemSet()->Put(SfxStringItem(SID_SUGGESTEDSAVEASDIR, sValue)); + ok = true; + } + } + else if (rArg.Name == "LockContentExtraction") + { + if (rArg.Value >>= bValue) + { + pMedium->GetItemSet()->Put(SfxBoolItem(SID_LOCK_CONTENT_EXTRACTION, bValue)); + ok = true; + } + } + else if (rArg.Name == "LockExport") + { + if (rArg.Value >>= bValue) + { + pMedium->GetItemSet()->Put(SfxBoolItem(SID_LOCK_EXPORT, bValue)); + ok = true; + } + } + else if (rArg.Name == "LockPrint") + { + if (rArg.Value >>= bValue) + { + pMedium->GetItemSet()->Put(SfxBoolItem(SID_LOCK_PRINT, bValue)); + ok = true; + } + } + else if (rArg.Name == "LockSave") + { + if (rArg.Value >>= bValue) + { + pMedium->GetItemSet()->Put(SfxBoolItem(SID_LOCK_SAVE, bValue)); + ok = true; + } + } + else if (rArg.Name == "LockEditDoc") + { + if (rArg.Value >>= bValue) + { + pMedium->GetItemSet()->Put(SfxBoolItem(SID_LOCK_EDITDOC, bValue)); + ok = true; + } + } + else if (rArg.Name == "Replaceable") + { + if (rArg.Value >>= bValue) + { + pMedium->GetItemSet()->Put(SfxBoolItem(SID_REPLACEABLE, bValue)); + ok = true; + } + } + else if (rArg.Name == "EncryptionData") + { + pMedium->GetItemSet()->Put(SfxUnoAnyItem(SID_ENCRYPTIONDATA, rArg.Value)); + ok = true; + } + if (!ok) + { + throw lang::IllegalArgumentException("Setting property not supported: " + rArg.Name, + comphelper::getProcessComponentContext(), 0); + } + } +} + +// frame::XModel + + +void SAL_CALL SfxBaseModel::connectController( const Reference< frame::XController >& xController ) +{ + SfxModelGuard aGuard( *this ); + OSL_PRECOND( xController.is(), "SfxBaseModel::connectController: invalid controller!" ); + if ( !xController.is() ) + return; + + m_pData->m_seqControllers.push_back(xController); + + if ( m_pData->m_seqControllers.size() == 1 ) + { + SfxViewFrame* pViewFrame = SfxViewFrame::Get( xController, GetObjectShell() ); + ENSURE_OR_THROW( pViewFrame, "SFX document without SFX view!?" ); + pViewFrame->UpdateDocument_Impl(); + const OUString sDocumentURL = GetObjectShell()->GetMedium()->GetName(); + if ( !sDocumentURL.isEmpty() ) + SfxGetpApp()->Broadcast( SfxOpenUrlHint( sDocumentURL ) ); + } +} + + +// frame::XModel + + +void SAL_CALL SfxBaseModel::disconnectController( const Reference< frame::XController >& xController ) +{ + SfxModelGuard aGuard( *this ); + + if ( m_pData->m_seqControllers.empty() ) + return; + + auto& vec = m_pData->m_seqControllers; + vec.erase(std::remove(vec.begin(), vec.end(), xController), vec.end()); + + if ( xController == m_pData->m_xCurrent ) + m_pData->m_xCurrent.clear(); +} + +namespace +{ + class ControllerLockUndoAction : public ::cppu::WeakImplHelper< XUndoAction > + { + public: + ControllerLockUndoAction( const Reference< XModel >& i_model, const bool i_undoIsUnlock ) + :m_xModel( i_model ) + ,m_bUndoIsUnlock( i_undoIsUnlock ) + { + } + + // XUndoAction + virtual OUString SAL_CALL getTitle() override; + virtual void SAL_CALL undo( ) override; + virtual void SAL_CALL redo( ) override; + + private: + const Reference< XModel > m_xModel; + const bool m_bUndoIsUnlock; + }; + + OUString SAL_CALL ControllerLockUndoAction::getTitle() + { + // this action is intended to be used within an UndoContext only, so nobody will ever see this title ... + return OUString(); + } + + void SAL_CALL ControllerLockUndoAction::undo( ) + { + if ( m_bUndoIsUnlock ) + m_xModel->unlockControllers(); + else + m_xModel->lockControllers(); + } + + void SAL_CALL ControllerLockUndoAction::redo( ) + { + if ( m_bUndoIsUnlock ) + m_xModel->lockControllers(); + else + m_xModel->unlockControllers(); + } +} + + +// frame::XModel + + +void SAL_CALL SfxBaseModel::lockControllers() +{ + SfxModelGuard aGuard( *this ); + + ++m_pData->m_nControllerLockCount ; + + if ( m_pData->m_pDocumentUndoManager.is() + && m_pData->m_pDocumentUndoManager->isInContext() + && !m_pData->m_pDocumentUndoManager->isLocked() + ) + { + m_pData->m_pDocumentUndoManager->addUndoAction( new ControllerLockUndoAction( this, true ) ); + } +} + + +// frame::XModel + + +void SAL_CALL SfxBaseModel::unlockControllers() +{ + SfxModelGuard aGuard( *this ); + + --m_pData->m_nControllerLockCount ; + + if ( m_pData->m_pDocumentUndoManager.is() + && m_pData->m_pDocumentUndoManager->isInContext() + && !m_pData->m_pDocumentUndoManager->isLocked() + ) + { + m_pData->m_pDocumentUndoManager->addUndoAction( new ControllerLockUndoAction( this, false ) ); + } +} + + +// frame::XModel + + +sal_Bool SAL_CALL SfxBaseModel::hasControllersLocked() +{ + SfxModelGuard aGuard( *this ); + return ( m_pData->m_nControllerLockCount != 0 ) ; +} + + +// frame::XModel + + +Reference< frame::XController > SAL_CALL SfxBaseModel::getCurrentController() +{ + SfxModelGuard aGuard( *this ); + + // get the last active controller of this model + if ( m_pData->m_xCurrent.is() ) + return m_pData->m_xCurrent; + + // get the first controller of this model + return !m_pData->m_seqControllers.empty() ? m_pData->m_seqControllers.front() : m_pData->m_xCurrent; +} + + +// frame::XModel + + +void SAL_CALL SfxBaseModel::setCurrentController( const Reference< frame::XController >& xCurrentController ) +{ + SfxModelGuard aGuard( *this ); + + m_pData->m_xCurrent = xCurrentController; +} + + +// frame::XModel + + +Reference< XInterface > SAL_CALL SfxBaseModel::getCurrentSelection() +{ + SfxModelGuard aGuard( *this ); + + Reference< XInterface > xReturn; + Reference< frame::XController > xController = getCurrentController() ; + + if ( xController.is() ) + { + Reference< view::XSelectionSupplier > xDocView( xController, UNO_QUERY ); + if ( xDocView.is() ) + { + Any aSel = xDocView->getSelection(); + aSel >>= xReturn ; + } + } + + return xReturn ; +} + + +// XModifiable2 + + +sal_Bool SAL_CALL SfxBaseModel::disableSetModified() +{ + SfxModelGuard aGuard( *this ); + + if ( !m_pData->m_pObjectShell.is() ) + throw RuntimeException(); + + bool bResult = m_pData->m_pObjectShell->IsEnableSetModified(); + m_pData->m_pObjectShell->EnableSetModified( false ); + + return bResult; +} + +sal_Bool SAL_CALL SfxBaseModel::enableSetModified() +{ + SfxModelGuard aGuard( *this ); + + if ( !m_pData->m_pObjectShell.is() ) + throw RuntimeException(); + + bool bResult = m_pData->m_pObjectShell->IsEnableSetModified(); + m_pData->m_pObjectShell->EnableSetModified(); + + return bResult; +} + +sal_Bool SAL_CALL SfxBaseModel::isSetModifiedEnabled() +{ + SfxModelGuard aGuard( *this ); + + if ( !m_pData->m_pObjectShell.is() ) + throw RuntimeException(); + + return m_pData->m_pObjectShell->IsEnableSetModified(); +} + + +// XModifiable + + +sal_Bool SAL_CALL SfxBaseModel::isModified() +{ + SfxModelGuard aGuard( *this ); + + return m_pData->m_pObjectShell.is() && m_pData->m_pObjectShell->IsModified(); +} + + +// XModifiable + + +void SAL_CALL SfxBaseModel::setModified( sal_Bool bModified ) +{ + SfxModelGuard aGuard( *this ); + + if ( m_pData->m_pObjectShell.is() ) + m_pData->m_pObjectShell->SetModified(bModified); +} + + +// XModifiable + + +void SAL_CALL SfxBaseModel::addModifyListener(const Reference< util::XModifyListener >& xListener) +{ + SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING ); + + m_pData->m_aInterfaceContainer.addInterface( cppu::UnoType<util::XModifyListener>::get(),xListener ); +} + + +// XModifiable + + +void SAL_CALL SfxBaseModel::removeModifyListener(const Reference< util::XModifyListener >& xListener) +{ + SfxModelGuard aGuard( *this ); + + m_pData->m_aInterfaceContainer.removeInterface( cppu::UnoType<util::XModifyListener>::get(), xListener ); +} + + +// XCloseable + + +void SAL_CALL SfxBaseModel::close( sal_Bool bDeliverOwnership ) +{ + SolarMutexGuard aGuard; + if ( impl_isDisposed() || m_pData->m_bClosed || m_pData->m_bClosing ) + return; + + Reference< XInterface > xSelfHold( static_cast< ::cppu::OWeakObject* >(this) ); + lang::EventObject aSource ( static_cast< ::cppu::OWeakObject* >(this) ); + comphelper::OInterfaceContainerHelper2* pContainer = m_pData->m_aInterfaceContainer.getContainer( cppu::UnoType<util::XCloseListener>::get()); + if (pContainer!=nullptr) + { + comphelper::OInterfaceIteratorHelper2 pIterator(*pContainer); + while (pIterator.hasMoreElements()) + { + try + { + static_cast<util::XCloseListener*>(pIterator.next())->queryClosing( aSource, bDeliverOwnership ); + } + catch( RuntimeException& ) + { + pIterator.remove(); + } + } + } + + if ( m_pData->m_bSaving ) + { + if (bDeliverOwnership) + m_pData->m_bSuicide = true; + throw util::CloseVetoException( + "Can not close while saving.", + static_cast< util::XCloseable* >(this)); + } + + // no own objections against closing! + m_pData->m_bClosing = true; + pContainer = m_pData->m_aInterfaceContainer.getContainer( cppu::UnoType<util::XCloseListener>::get()); + if (pContainer!=nullptr) + { + comphelper::OInterfaceIteratorHelper2 pCloseIterator(*pContainer); + while (pCloseIterator.hasMoreElements()) + { + try + { + static_cast<util::XCloseListener*>(pCloseIterator.next())->notifyClosing( aSource ); + } + catch( RuntimeException& ) + { + pCloseIterator.remove(); + } + } + } + + m_pData->m_bClosed = true; + m_pData->m_bClosing = false; + + dispose(); +} + + +// XCloseBroadcaster + + +void SAL_CALL SfxBaseModel::addCloseListener( const Reference< util::XCloseListener >& xListener ) +{ + SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING ); + + m_pData->m_aInterfaceContainer.addInterface( cppu::UnoType<util::XCloseListener>::get(), xListener ); +} + + +// XCloseBroadcaster + + +void SAL_CALL SfxBaseModel::removeCloseListener( const Reference< util::XCloseListener >& xListener ) +{ + SfxModelGuard aGuard( *this ); + + m_pData->m_aInterfaceContainer.removeInterface( cppu::UnoType<util::XCloseListener>::get(), xListener ); +} + + +// XPrintable + + +Sequence< beans::PropertyValue > SAL_CALL SfxBaseModel::getPrinter() +{ + SfxModelGuard aGuard( *this ); + + impl_getPrintHelper(); + return m_pData->m_xPrintable->getPrinter(); +} + +void SAL_CALL SfxBaseModel::setPrinter(const Sequence< beans::PropertyValue >& rPrinter) +{ + SfxModelGuard aGuard( *this ); + + impl_getPrintHelper(); + m_pData->m_xPrintable->setPrinter( rPrinter ); +} + +void SAL_CALL SfxBaseModel::print(const Sequence< beans::PropertyValue >& rOptions) +{ + SfxModelGuard aGuard( *this ); + + impl_getPrintHelper(); + + // tdf#123728 Always print on main thread to avoid deadlocks + vcl::solarthread::syncExecute([this, &rOptions]() { m_pData->m_xPrintable->print(rOptions); }); +} + +// XStorable + + +sal_Bool SAL_CALL SfxBaseModel::hasLocation() +{ + SfxModelGuard aGuard( *this ); + + return m_pData->m_pObjectShell.is() && m_pData->m_pObjectShell->HasName(); +} + + +// XStorable + + +OUString SAL_CALL SfxBaseModel::getLocation() +{ + SfxModelGuard aGuard( *this ); + + if ( m_pData->m_pObjectShell.is() ) + { + // TODO/LATER: is it correct that the shared document returns shared file location? + if ( m_pData->m_pObjectShell->IsDocShared() ) + return m_pData->m_pObjectShell->GetSharedFileURL(); + else + return m_pData->m_pObjectShell->GetMedium()->GetName(); + } + + return m_pData->m_sURL; +} + + +// XStorable + + +sal_Bool SAL_CALL SfxBaseModel::isReadonly() +{ + SfxModelGuard aGuard( *this ); + + return !m_pData->m_pObjectShell.is() || m_pData->m_pObjectShell->IsReadOnly(); +} + +// XStorable2 + + +void SAL_CALL SfxBaseModel::storeSelf( const Sequence< beans::PropertyValue >& aSeqArgs ) +{ + SfxModelGuard aGuard( *this ); + + if ( !m_pData->m_pObjectShell.is() ) + return; + + SfxSaveGuard aSaveGuard(this, m_pData.get()); + + bool bCheckIn = false; + bool bOnMainThread = false; + for ( const auto& rArg : aSeqArgs ) + { + // check that only acceptable parameters are provided here + if ( rArg.Name != "VersionComment" && rArg.Name != "Author" + && rArg.Name != "DontTerminateEdit" + && rArg.Name != "InteractionHandler" && rArg.Name != "StatusIndicator" + && rArg.Name != "VersionMajor" + && rArg.Name != "FailOnWarning" + && rArg.Name != "CheckIn" + && rArg.Name != "NoFileSync" + && rArg.Name != "OnMainThread" ) + { + const OUString aMessage( "Unexpected MediaDescriptor parameter: " + rArg.Name ); + throw lang::IllegalArgumentException( aMessage, Reference< XInterface >(), 1 ); + } + else if ( rArg.Name == "CheckIn" ) + { + rArg.Value >>= bCheckIn; + } + else if (rArg.Name == "OnMainThread") + { + rArg.Value >>= bOnMainThread; + } + } + + // Remove CheckIn property if needed + sal_uInt16 nSlotId = SID_SAVEDOC; + Sequence< beans::PropertyValue > aArgs = aSeqArgs; + if ( bCheckIn ) + { + nSlotId = SID_CHECKIN; + sal_Int32 nLength = aSeqArgs.getLength( ); + aArgs = Sequence< beans::PropertyValue >( nLength - 1 ); + std::copy_if(aSeqArgs.begin(), aSeqArgs.end(), aArgs.getArray(), + [](const beans::PropertyValue& rProp) { return rProp.Name != "CheckIn"; }); + } + + std::optional<SfxAllItemSet> pParams(SfxGetpApp()->GetPool() ); + TransformParameters( nSlotId, aArgs, *pParams ); + + SfxGetpApp()->NotifyEvent( SfxEventHint( SfxEventHintId::SaveDoc, GlobalEventConfig::GetEventName(GlobalEventId::SAVEDOC), m_pData->m_pObjectShell.get() ) ); + + bool bRet = false; + + // TODO/LATER: let the embedded case of saving be handled more careful + if ( m_pData->m_pObjectShell->GetCreateMode() == SfxObjectCreateMode::EMBEDDED ) + { + // If this is an embedded object that has no URL based location it should be stored to own storage. + // An embedded object can have a location based on URL in case it is a link, then it should be + // stored in normal way. + if ( !hasLocation() || getLocation().startsWith("private:") ) + { + // actually in this very rare case only UI parameters have sense + // TODO/LATER: should be done later, after integration of sb19 + bRet = m_pData->m_pObjectShell->DoSave() + && m_pData->m_pObjectShell->DoSaveCompleted(); + } + else + { + bRet = m_pData->m_pObjectShell->Save_Impl( &*pParams ); + } + } + else + { + // Tell the SfxMedium if we are in checkin instead of normal save + m_pData->m_pObjectShell->GetMedium( )->SetInCheckIn( nSlotId == SID_CHECKIN ); + if (bOnMainThread) + bRet = vcl::solarthread::syncExecute( + [this, &pParams] { return m_pData->m_pObjectShell->Save_Impl(&*pParams); }); + else + bRet = m_pData->m_pObjectShell->Save_Impl(&*pParams); + m_pData->m_pObjectShell->GetMedium( )->SetInCheckIn( nSlotId != SID_CHECKIN ); + } + + pParams.reset(); + + ErrCode nErrCode = m_pData->m_pObjectShell->GetError() ? m_pData->m_pObjectShell->GetError() + : ERRCODE_IO_CANTWRITE; + m_pData->m_pObjectShell->ResetError(); + + if ( bRet ) + { + m_pData->m_aPreusedFilterName = GetMediumFilterName_Impl(); + + SfxGetpApp()->NotifyEvent( SfxEventHint( SfxEventHintId::SaveDocDone, GlobalEventConfig::GetEventName(GlobalEventId::SAVEDOCDONE), m_pData->m_pObjectShell.get() ) ); + } + else + { + // write the contents of the logger to the file + SfxGetpApp()->NotifyEvent( SfxEventHint( SfxEventHintId::SaveDocFailed, GlobalEventConfig::GetEventName(GlobalEventId::SAVEDOCFAILED), m_pData->m_pObjectShell.get() ) ); + + throw task::ErrorCodeIOException( + "SfxBaseModel::storeSelf: " + nErrCode.toHexString(), + Reference< XInterface >(), sal_uInt32(nErrCode)); + } +} + + +// XStorable + + +void SAL_CALL SfxBaseModel::store() +{ + comphelper::ProfileZone aZone("store"); + storeSelf( Sequence< beans::PropertyValue >() ); +} + + +// XStorable + + +void SAL_CALL SfxBaseModel::storeAsURL( const OUString& rURL , + const Sequence< beans::PropertyValue >& rArgs ) +{ + SfxModelGuard aGuard( *this ); + comphelper::ProfileZone aZone("storeAs"); + + if ( !m_pData->m_pObjectShell.is() ) + return; + + SfxSaveGuard aSaveGuard(this, m_pData.get()); + + utl::MediaDescriptor aDescriptor(rArgs); + bool bOnMainThread = aDescriptor.getUnpackedValueOrDefault("OnMainThread", false); + if (bOnMainThread) + { + vcl::solarthread::syncExecute([this, rURL, rArgs]() { impl_store(rURL, rArgs, false); }); + } + else + { + impl_store(rURL, rArgs, false); + } + + Sequence< beans::PropertyValue > aSequence ; + TransformItems( SID_OPENDOC, *m_pData->m_pObjectShell->GetMedium()->GetItemSet(), aSequence ); + attachResource( rURL, aSequence ); + + loadCmisProperties( ); + +#if OSL_DEBUG_LEVEL > 0 + const SfxStringItem* pPasswdItem = SfxItemSet::GetItem<SfxStringItem>(m_pData->m_pObjectShell->GetMedium()->GetItemSet(), SID_PASSWORD, false); + OSL_ENSURE( !pPasswdItem, "There should be no Password property in the document MediaDescriptor!" ); +#endif +} + + +// XUndoManagerSupplier + +Reference< XUndoManager > SAL_CALL SfxBaseModel::getUndoManager( ) +{ + SfxModelGuard aGuard( *this ); + if ( !m_pData->m_pDocumentUndoManager.is() ) + m_pData->m_pDocumentUndoManager.set( new ::sfx2::DocumentUndoManager( *this ) ); + return m_pData->m_pDocumentUndoManager; +} + + +// XStorable + + +void SAL_CALL SfxBaseModel::storeToURL( const OUString& rURL , + const Sequence< beans::PropertyValue >& rArgs ) +{ + SfxModelGuard aGuard( *this ); + comphelper::ProfileZone aZone("storeToURL"); + + if ( !m_pData->m_pObjectShell.is() ) + return; + + SfxSaveGuard aSaveGuard(this, m_pData.get()); + try { + utl::MediaDescriptor aDescriptor(rArgs); + bool bOnMainThread = aDescriptor.getUnpackedValueOrDefault("OnMainThread", false); + if (bOnMainThread) + vcl::solarthread::syncExecute([this, rURL, rArgs]() { impl_store(rURL, rArgs, true); }); + else + impl_store(rURL, rArgs, true); + } + catch (const uno::Exception &e) + { + // convert to the exception we announce in the throw + // (eg. neon likes to throw InteractiveAugmentedIOException which + // is not an io::IOException) + throw io::IOException(e.Message, e.Context); + } +} + +sal_Bool SAL_CALL SfxBaseModel::wasModifiedSinceLastSave() +{ + SfxModelGuard aGuard( *this ); + return m_pData->m_bModifiedSinceLastSave; +} + +void SAL_CALL SfxBaseModel::storeToRecoveryFile( const OUString& i_TargetLocation, const Sequence< PropertyValue >& i_MediaDescriptor ) +{ + SfxModelGuard aGuard( *this ); + + // delegate + SfxSaveGuard aSaveGuard( this, m_pData.get() ); + impl_store( i_TargetLocation, i_MediaDescriptor, true ); + + // no need for subsequent calls to storeToRecoveryFile, unless we're modified, again + m_pData->m_bModifiedSinceLastSave = false; +} + +void SAL_CALL SfxBaseModel::recoverFromFile( const OUString& i_SourceLocation, const OUString& i_SalvagedFile, const Sequence< PropertyValue >& i_MediaDescriptor ) +{ + SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING ); + + // delegate to our "load" method + ::comphelper::NamedValueCollection aMediaDescriptor( i_MediaDescriptor ); + + // our load implementation expects the SalvagedFile to be in the media descriptor + OSL_ENSURE( !aMediaDescriptor.has( "SalvagedFile" ) || ( aMediaDescriptor.getOrDefault( "SalvagedFile", OUString() ) == i_SalvagedFile ), + "SfxBaseModel::recoverFromFile: inconsistent information!" ); + aMediaDescriptor.put( "SalvagedFile", i_SalvagedFile ); + + // similar for the to-be-loaded file + OSL_ENSURE( !aMediaDescriptor.has( "URL" ) || ( aMediaDescriptor.getOrDefault( "URL", OUString() ) == i_SourceLocation ), + "SfxBaseModel::recoverFromFile: inconsistent information!" ); + aMediaDescriptor.put( "URL", i_SourceLocation ); + + load( aMediaDescriptor.getPropertyValues() ); + + // Note: The XDocumentRecovery interface specification requires us to do an attachResource after loading. + // However, we will not do this here, as we know that our load implementation (respectively some method + // called from there) already did so. + // In particular, the load process might already have modified some elements of the media + // descriptor, for instance the MacroExecMode (in case the user was involved to decide about it), and we do + // not want to overwrite it with the "old" elements passed to this method here. +} + + +// XLoadable + + +void SAL_CALL SfxBaseModel::initNew() +{ + SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING ); + if ( IsInitialized() ) + throw frame::DoubleInitializationException( OUString(), *this ); + + // the object shell should exist always + DBG_ASSERT( m_pData->m_pObjectShell.is(), "Model is useless without an ObjectShell" ); + if ( !m_pData->m_pObjectShell.is() ) + return; + + if( m_pData->m_pObjectShell->GetMedium() ) + throw frame::DoubleInitializationException(); + + bool bRes = m_pData->m_pObjectShell->DoInitNew(); + ErrCode nErrCode = m_pData->m_pObjectShell->GetError() ? + m_pData->m_pObjectShell->GetError() : ERRCODE_IO_CANTCREATE; + m_pData->m_pObjectShell->ResetError(); + + if ( !bRes ) + throw task::ErrorCodeIOException( + "SfxBaseModel::initNew: " + nErrCode.toHexString(), + Reference< XInterface >(), sal_uInt32(nErrCode)); +} + +namespace { + +OUString getFilterProvider( SfxMedium const & rMedium ) +{ + const std::shared_ptr<const SfxFilter>& pFilter = rMedium.GetFilter(); + if (!pFilter) + return OUString(); + + return pFilter->GetProviderName(); +} + +void setUpdatePickList( SfxMedium* pMedium ) +{ + if (!pMedium) + return; + + bool bHidden = false; + const SfxBoolItem* pHidItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_HIDDEN, false); + if (pHidItem) + bHidden = pHidItem->GetValue(); + + pMedium->SetUpdatePickList(!bHidden); +} + +} + +void SAL_CALL SfxBaseModel::load( const Sequence< beans::PropertyValue >& seqArguments ) +{ + SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING ); + if ( IsInitialized() ) + throw frame::DoubleInitializationException( OUString(), *this ); + + // the object shell should exist always + DBG_ASSERT( m_pData->m_pObjectShell.is(), "Model is useless without an ObjectShell" ); + + if (!m_pData->m_pObjectShell.is()) + return; + + if( m_pData->m_pObjectShell->GetMedium() ) + // if a Medium is present, the document is already initialized + throw frame::DoubleInitializationException(); + + SfxMedium* pMedium = new SfxMedium( seqArguments ); + + ErrCode nError = ERRCODE_NONE; + if (!getFilterProvider(*pMedium).isEmpty()) + { + if (!m_pData->m_pObjectShell->DoLoadExternal(pMedium)) + nError = ERRCODE_IO_GENERAL; + + pMedium = handleLoadError(nError, pMedium); + setUpdatePickList(pMedium); + return; + } + + OUString aFilterName; + const SfxStringItem* pFilterNameItem = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_FILTER_NAME, false); + if( pFilterNameItem ) + aFilterName = pFilterNameItem->GetValue(); + if( !m_pData->m_pObjectShell->GetFactory().GetFilterContainer()->GetFilter4FilterName( aFilterName ) ) + { + // filtername is not valid + delete pMedium; + throw frame::IllegalArgumentIOException(); + } + + const SfxStringItem* pSalvageItem = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_DOC_SALVAGE, false); + bool bSalvage = pSalvageItem != nullptr; + + // load document + if ( !m_pData->m_pObjectShell->DoLoad(pMedium) ) + nError=ERRCODE_IO_GENERAL; + + // QUESTION: if the following happens outside of DoLoad, something important is missing there! + Reference< task::XInteractionHandler > xHandler = pMedium->GetInteractionHandler(); + if( m_pData->m_pObjectShell->GetErrorCode() ) + { + nError = m_pData->m_pObjectShell->GetErrorCode(); + if ( nError == ERRCODE_IO_BROKENPACKAGE && xHandler.is() ) + { + const OUString aDocName( pMedium->GetURLObject().getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset ) ); + const SfxBoolItem* pRepairItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_REPAIRPACKAGE, false); + if ( !pRepairItem || !pRepairItem->GetValue() ) + { + RequestPackageReparation aRequest( aDocName ); + xHandler->handle( aRequest.GetRequest() ); + if( aRequest.isApproved() ) + { + // broken package: try second loading and allow repair + pMedium->GetItemSet()->Put( SfxBoolItem( SID_REPAIRPACKAGE, true ) ); + pMedium->GetItemSet()->Put( SfxBoolItem( SID_TEMPLATE, true ) ); + pMedium->GetItemSet()->Put( SfxStringItem( SID_DOCINFO_TITLE, aDocName ) ); + + // the error must be reset and the storage must be reopened in new mode + pMedium->ResetError(); + pMedium->CloseStorage(); + m_pData->m_pObjectShell->PrepareSecondTryLoad_Impl(); + nError = ERRCODE_NONE; + if ( !m_pData->m_pObjectShell->DoLoad(pMedium) ) + nError=ERRCODE_IO_GENERAL; + if (m_pData->m_pObjectShell->GetErrorCode()) + nError = m_pData->m_pObjectShell->GetErrorCode(); + } + } + + if ( nError == ERRCODE_IO_BROKENPACKAGE ) + { + // repair either not allowed or not successful + NotifyBrokenPackage aRequest( aDocName ); + xHandler->handle( aRequest.GetRequest() ); + } + } + } + + if( m_pData->m_pObjectShell->IsAbortingImport() ) + nError = ERRCODE_ABORT; + + if( bSalvage ) + { + // file recovery: restore original filter + const SfxStringItem* pFilterItem = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_FILTER_NAME, false); + SfxFilterMatcher& rMatcher = SfxGetpApp()->GetFilterMatcher(); + std::shared_ptr<const SfxFilter> pSetFilter = rMatcher.GetFilter4FilterName( pFilterItem->GetValue() ); + pMedium->SetFilter( pSetFilter ); + m_pData->m_pObjectShell->SetModified(); + } + + // TODO/LATER: maybe the mode should be retrieved from outside and the preused filter should not be set + if ( m_pData->m_pObjectShell->GetCreateMode() == SfxObjectCreateMode::EMBEDDED ) + { + const SfxStringItem* pFilterItem = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_FILTER_NAME, false); + if ( pFilterItem ) + m_pData->m_aPreusedFilterName = pFilterItem->GetValue(); + } + + if ( !nError ) + nError = pMedium->GetError(); + + m_pData->m_pObjectShell->ResetError(); + + pMedium = handleLoadError(nError, pMedium); + loadCmisProperties(); + setUpdatePickList(pMedium); + +#if OSL_DEBUG_LEVEL > 0 + const SfxStringItem* pPasswdItem = SfxItemSet::GetItem<SfxStringItem>(pMedium->GetItemSet(), SID_PASSWORD, false); + OSL_ENSURE( !pPasswdItem, "There should be no Password property in the document MediaDescriptor!" ); +#endif +} + + +// XTransferable + + +Any SAL_CALL SfxBaseModel::getTransferData( const datatransfer::DataFlavor& aFlavor ) +{ + SfxModelGuard aGuard( *this ); + + Any aAny; + + if ( m_pData->m_pObjectShell.is() ) + { + if ( aFlavor.MimeType == "application/x-openoffice-objectdescriptor-xml;windows_formatname=\"Star Object Descriptor (XML)\"" ) + { + if ( aFlavor.DataType != cppu::UnoType<Sequence< sal_Int8 >>::get() ) + throw datatransfer::UnsupportedFlavorException(); + + TransferableObjectDescriptor aDesc; + + aDesc.maClassName = m_pData->m_pObjectShell->GetClassName(); + aDesc.maTypeName = aFlavor.HumanPresentableName; + + // TODO/LATER: ViewAspect needs to be sal_Int64 + aDesc.mnViewAspect = sal::static_int_cast< sal_uInt16 >( embed::Aspects::MSOLE_CONTENT ); + + Size aSize = m_pData->m_pObjectShell->GetVisArea().GetSize(); + + MapUnit aMapUnit = m_pData->m_pObjectShell->GetMapUnit(); + aDesc.maSize = OutputDevice::LogicToLogic(aSize, MapMode(aMapUnit), MapMode(MapUnit::Map100thMM)); + aDesc.maDragStartPos = Point(); + aDesc.maDisplayName.clear(); + + SvMemoryStream aMemStm( 1024, 1024 ); + WriteTransferableObjectDescriptor( aMemStm, aDesc ); + aAny <<= Sequence< sal_Int8 >( static_cast< const sal_Int8* >( aMemStm.GetData() ), aMemStm.Tell() ); + } + else if ( aFlavor.MimeType == "application/x-openoffice-embed-source;windows_formatname=\"Star EMBS\"" ) + { + if ( aFlavor.DataType != cppu::UnoType<Sequence< sal_Int8 >>::get() ) + throw datatransfer::UnsupportedFlavorException(); + + try + { + utl::TempFile aTmp; + aTmp.EnableKillingFile(); + storeToURL( aTmp.GetURL(), Sequence < beans::PropertyValue >() ); + std::unique_ptr<SvStream> pStream(aTmp.GetStream( StreamMode::READ )); + const sal_uInt32 nLen = pStream->TellEnd(); + Sequence< sal_Int8 > aSeq( nLen ); + pStream->ReadBytes(aSeq.getArray(), nLen); + if( aSeq.hasElements() ) + aAny <<= aSeq; + } + catch ( Exception& ) + { + } + } + else if ( aFlavor.MimeType == "application/x-openoffice-gdimetafile;windows_formatname=\"GDIMetaFile\"" ) + { + if ( aFlavor.DataType != cppu::UnoType<Sequence< sal_Int8 >>::get() ) + throw datatransfer::UnsupportedFlavorException(); + + + std::shared_ptr<GDIMetaFile> xMetaFile = + m_pData->m_pObjectShell->GetPreviewMetaFile( true ); + + if (xMetaFile) + { + SvMemoryStream aMemStm( 65535, 65535 ); + aMemStm.SetVersion( SOFFICE_FILEFORMAT_CURRENT ); + + SvmWriter aWriter( aMemStm ); + aWriter.Write( *xMetaFile ); + aAny <<= Sequence< sal_Int8 >( static_cast< const sal_Int8* >( aMemStm.GetData() ), + aMemStm.TellEnd() ); + } + } + else if ( aFlavor.MimeType == "application/x-openoffice-highcontrast-gdimetafile;windows_formatname=\"GDIMetaFile\"" ) + { + if ( aFlavor.DataType != cppu::UnoType<Sequence< sal_Int8 >>::get() ) + throw datatransfer::UnsupportedFlavorException(); + + std::shared_ptr<GDIMetaFile> xMetaFile = + m_pData->m_pObjectShell->GetPreviewMetaFile( true ); + + if (xMetaFile) + { + SvMemoryStream aMemStm( 65535, 65535 ); + aMemStm.SetVersion( SOFFICE_FILEFORMAT_CURRENT ); + + SvmWriter aWriter( aMemStm ); + aWriter.Write( *xMetaFile ); + aAny <<= Sequence< sal_Int8 >( static_cast< const sal_Int8* >( aMemStm.GetData() ), + aMemStm.TellEnd() ); + } + } + else if ( aFlavor.MimeType == "application/x-openoffice-emf;windows_formatname=\"Image EMF\"" ) + { + if ( aFlavor.DataType == cppu::UnoType<Sequence< sal_Int8 >>::get() ) + { + std::shared_ptr<GDIMetaFile> xMetaFile = + m_pData->m_pObjectShell->GetPreviewMetaFile( true ); + + if (xMetaFile) + { + std::unique_ptr<SvMemoryStream> xStream( + GraphicHelper::getFormatStrFromGDI_Impl( + xMetaFile.get(), ConvertDataFormat::EMF ) ); + if (xStream) + { + xStream->SetVersion( SOFFICE_FILEFORMAT_CURRENT ); + aAny <<= Sequence< sal_Int8 >( static_cast< const sal_Int8* >( xStream->GetData() ), + xStream->TellEnd() ); + } + } + } + else if ( GraphicHelper::supportsMetaFileHandle_Impl() + && aFlavor.DataType == cppu::UnoType<sal_uInt64>::get()) + { + std::shared_ptr<GDIMetaFile> xMetaFile = + m_pData->m_pObjectShell->GetPreviewMetaFile( true ); + + if (xMetaFile) + { + aAny <<= reinterpret_cast< sal_uInt64 >( + GraphicHelper::getEnhMetaFileFromGDI_Impl( xMetaFile.get() ) ); + } + } + else + throw datatransfer::UnsupportedFlavorException(); + } + else if ( aFlavor.MimeType == "application/x-openoffice-wmf;windows_formatname=\"Image WMF\"" ) + { + if ( aFlavor.DataType == cppu::UnoType<Sequence< sal_Int8 >>::get() ) + { + std::shared_ptr<GDIMetaFile> xMetaFile = + m_pData->m_pObjectShell->GetPreviewMetaFile( true ); + + if (xMetaFile) + { + std::unique_ptr<SvMemoryStream> xStream( + GraphicHelper::getFormatStrFromGDI_Impl( + xMetaFile.get(), ConvertDataFormat::WMF ) ); + + if (xStream) + { + xStream->SetVersion( SOFFICE_FILEFORMAT_CURRENT ); + aAny <<= Sequence< sal_Int8 >( static_cast< const sal_Int8* >( xStream->GetData() ), + xStream->TellEnd() ); + } + } + } + else if ( GraphicHelper::supportsMetaFileHandle_Impl() + && aFlavor.DataType == cppu::UnoType<sal_uInt64>::get()) + { + // means HGLOBAL handler to memory storage containing METAFILEPICT structure + + std::shared_ptr<GDIMetaFile> xMetaFile = + m_pData->m_pObjectShell->GetPreviewMetaFile( true ); + + if (xMetaFile) + { + Size aMetaSize = xMetaFile->GetPrefSize(); + aAny <<= reinterpret_cast< sal_uInt64 >( + GraphicHelper::getWinMetaFileFromGDI_Impl( + xMetaFile.get(), aMetaSize ) ); + } + } + else + throw datatransfer::UnsupportedFlavorException(); + } + else if ( aFlavor.MimeType == "application/x-openoffice-bitmap;windows_formatname=\"Bitmap\"" ) + { + if ( aFlavor.DataType != cppu::UnoType<Sequence< sal_Int8 >>::get() ) + throw datatransfer::UnsupportedFlavorException(); + + std::shared_ptr<GDIMetaFile> xMetaFile = + m_pData->m_pObjectShell->GetPreviewMetaFile( true ); + + if (xMetaFile) + { + std::unique_ptr<SvMemoryStream> xStream( + GraphicHelper::getFormatStrFromGDI_Impl( + xMetaFile.get(), ConvertDataFormat::BMP ) ); + + if (xStream) + { + xStream->SetVersion( SOFFICE_FILEFORMAT_CURRENT ); + aAny <<= Sequence< sal_Int8 >( static_cast< const sal_Int8* >( xStream->GetData() ), + xStream->TellEnd() ); + } + } + } + else if ( aFlavor.MimeType == "image/png" ) + { + if ( aFlavor.DataType != cppu::UnoType<Sequence< sal_Int8 >>::get() ) + throw datatransfer::UnsupportedFlavorException(); + + std::shared_ptr<GDIMetaFile> xMetaFile = + m_pData->m_pObjectShell->GetPreviewMetaFile( true ); + + if (xMetaFile) + { + std::unique_ptr<SvMemoryStream> xStream( + GraphicHelper::getFormatStrFromGDI_Impl( + xMetaFile.get(), ConvertDataFormat::PNG ) ); + + if (xStream) + { + xStream->SetVersion( SOFFICE_FILEFORMAT_CURRENT ); + aAny <<= Sequence< sal_Int8 >( static_cast< const sal_Int8* >( xStream->GetData() ), + xStream->TellEnd() ); + } + } + } + else + throw datatransfer::UnsupportedFlavorException(); + } + + return aAny; +} + + +// XTransferable + + +Sequence< datatransfer::DataFlavor > SAL_CALL SfxBaseModel::getTransferDataFlavors() +{ + SfxModelGuard aGuard( *this ); + + const sal_Int32 nSuppFlavors = GraphicHelper::supportsMetaFileHandle_Impl() ? 10 : 8; + Sequence< datatransfer::DataFlavor > aFlavorSeq( nSuppFlavors ); + auto pFlavorSeq = aFlavorSeq.getArray(); + + pFlavorSeq[0].MimeType = + "application/x-openoffice-gdimetafile;windows_formatname=\"GDIMetaFile\""; + pFlavorSeq[0].HumanPresentableName = "GDIMetaFile"; + pFlavorSeq[0].DataType = cppu::UnoType<Sequence< sal_Int8 >>::get(); + + pFlavorSeq[1].MimeType = + "application/x-openoffice-highcontrast-gdimetafile;windows_formatname=\"GDIMetaFile\""; + pFlavorSeq[1].HumanPresentableName = "GDIMetaFile"; + pFlavorSeq[1].DataType = cppu::UnoType<Sequence< sal_Int8 >>::get(); + + pFlavorSeq[2].MimeType = + "application/x-openoffice-emf;windows_formatname=\"Image EMF\"" ; + pFlavorSeq[2].HumanPresentableName = "Enhanced Windows MetaFile"; + pFlavorSeq[2].DataType = cppu::UnoType<Sequence< sal_Int8 >>::get(); + + pFlavorSeq[3].MimeType = + "application/x-openoffice-wmf;windows_formatname=\"Image WMF\""; + pFlavorSeq[3].HumanPresentableName = "Windows MetaFile"; + pFlavorSeq[3].DataType = cppu::UnoType<Sequence< sal_Int8 >>::get(); + + pFlavorSeq[4].MimeType = + "application/x-openoffice-objectdescriptor-xml;windows_formatname=\"Star Object Descriptor (XML)\""; + pFlavorSeq[4].HumanPresentableName = "Star Object Descriptor (XML)"; + pFlavorSeq[4].DataType = cppu::UnoType<Sequence< sal_Int8 >>::get(); + + pFlavorSeq[5].MimeType = + "application/x-openoffice-embed-source-xml;windows_formatname=\"Star Embed Source (XML)\""; + pFlavorSeq[5].HumanPresentableName = "Star Embed Source (XML)"; + pFlavorSeq[5].DataType = cppu::UnoType<Sequence< sal_Int8 >>::get(); + + pFlavorSeq[6].MimeType = + "application/x-openoffice-bitmap;windows_formatname=\"Bitmap\""; + pFlavorSeq[6].HumanPresentableName = "Bitmap"; + pFlavorSeq[6].DataType = cppu::UnoType<Sequence< sal_Int8 >>::get(); + + pFlavorSeq[7].MimeType = "image/png"; + pFlavorSeq[7].HumanPresentableName = "PNG"; + pFlavorSeq[7].DataType = cppu::UnoType<Sequence< sal_Int8 >>::get(); + + if ( nSuppFlavors == 10 ) + { + pFlavorSeq[8].MimeType = + "application/x-openoffice-emf;windows_formatname=\"Image EMF\""; + pFlavorSeq[8].HumanPresentableName = "Enhanced Windows MetaFile"; + pFlavorSeq[8].DataType = cppu::UnoType<sal_uInt64>::get(); + + pFlavorSeq[9].MimeType = + "application/x-openoffice-wmf;windows_formatname=\"Image WMF\""; + pFlavorSeq[9].HumanPresentableName = "Windows MetaFile"; + pFlavorSeq[9].DataType = cppu::UnoType<sal_uInt64>::get(); + } + + return aFlavorSeq; +} + + +// XTransferable + + +sal_Bool SAL_CALL SfxBaseModel::isDataFlavorSupported( const datatransfer::DataFlavor& aFlavor ) +{ + SfxModelGuard aGuard( *this ); + + if ( aFlavor.MimeType == "application/x-openoffice-gdimetafile;windows_formatname=\"GDIMetaFile\"" ) + { + if ( aFlavor.DataType == cppu::UnoType<Sequence< sal_Int8 >>::get() ) + return true; + } + else if ( aFlavor.MimeType == "application/x-openoffice-highcontrast-gdimetafile;windows_formatname=\"GDIMetaFile\"" ) + { + if ( aFlavor.DataType == cppu::UnoType<Sequence< sal_Int8 >>::get() ) + return true; + } + else if ( aFlavor.MimeType == "application/x-openoffice-emf;windows_formatname=\"Image EMF\"" ) + { + if ( aFlavor.DataType == cppu::UnoType<Sequence< sal_Int8 >>::get() ) + return true; + else if ( GraphicHelper::supportsMetaFileHandle_Impl() + && aFlavor.DataType == cppu::UnoType<sal_uInt64>::get()) + return true; + } + else if ( aFlavor.MimeType == "application/x-openoffice-wmf;windows_formatname=\"Image WMF\"" ) + { + if ( aFlavor.DataType == cppu::UnoType<Sequence< sal_Int8 >>::get() ) + return true; + else if ( GraphicHelper::supportsMetaFileHandle_Impl() + && aFlavor.DataType == cppu::UnoType<sal_uInt64>::get()) + return true; + } + else if ( aFlavor.MimeType == "application/x-openoffice-objectdescriptor-xml;windows_formatname=\"Star Object Descriptor (XML)\"" ) + { + if ( aFlavor.DataType == cppu::UnoType<Sequence< sal_Int8 >>::get() ) + return true; + } + else if ( aFlavor.MimeType == "application/x-openoffice-embed-source;windows_formatname=\"Star EMBS\"" ) + { + if ( aFlavor.DataType == cppu::UnoType<Sequence< sal_Int8 >>::get() ) + return true; + } + else if ( aFlavor.MimeType == "application/x-openoffice-bitmap;windows_formatname=\"Bitmap\"" ) + { + if ( aFlavor.DataType == cppu::UnoType<Sequence< sal_Int8 >>::get() ) + return true; + } + else if ( aFlavor.MimeType == "image/png" ) + { + if ( aFlavor.DataType == cppu::UnoType<Sequence< sal_Int8 >>::get() ) + return true; + } + + return false; +} + + +// XEventsSupplier + + +Reference< container::XNameReplace > SAL_CALL SfxBaseModel::getEvents() +{ + SfxModelGuard aGuard( *this ); + + if ( ! m_pData->m_xEvents.is() ) + { + m_pData->m_xEvents = new SfxEvents_Impl( m_pData->m_pObjectShell.get(), this ); + } + + return m_pData->m_xEvents; +} + + +// XEmbeddedScripts + + +Reference< script::XStorageBasedLibraryContainer > SAL_CALL SfxBaseModel::getBasicLibraries() +{ + SfxModelGuard aGuard( *this ); + + Reference< script::XStorageBasedLibraryContainer > xBasicLibraries; + if ( m_pData->m_pObjectShell.is() ) + xBasicLibraries.set(m_pData->m_pObjectShell->GetBasicContainer(), UNO_QUERY); + return xBasicLibraries; +} + +Reference< script::XStorageBasedLibraryContainer > SAL_CALL SfxBaseModel::getDialogLibraries() +{ + SfxModelGuard aGuard( *this ); + + Reference< script::XStorageBasedLibraryContainer > xDialogLibraries; + if ( m_pData->m_pObjectShell.is() ) + xDialogLibraries.set(m_pData->m_pObjectShell->GetDialogContainer(), UNO_QUERY); + return xDialogLibraries; +} + +sal_Bool SAL_CALL SfxBaseModel::getAllowMacroExecution() +{ + SfxModelGuard aGuard( *this ); + + if ( m_pData->m_pObjectShell.is() ) + return m_pData->m_pObjectShell->AdjustMacroMode(); + return false; +} + + +// XScriptInvocationContext + + +Reference< document::XEmbeddedScripts > SAL_CALL SfxBaseModel::getScriptContainer() +{ + SfxModelGuard aGuard( *this ); + + Reference< document::XEmbeddedScripts > xDocumentScripts; + + try + { + Reference< frame::XModel > xDocument( this ); + xDocumentScripts.set( xDocument, UNO_QUERY ); + while ( !xDocumentScripts.is() && xDocument.is() ) + { + Reference< container::XChild > xDocAsChild( xDocument, UNO_QUERY ); + if ( !xDocAsChild.is() ) + { + xDocument = nullptr; + break; + } + + xDocument.set( xDocAsChild->getParent(), UNO_QUERY ); + xDocumentScripts.set( xDocument, UNO_QUERY ); + } + } + catch( const Exception& ) + { + DBG_UNHANDLED_EXCEPTION("sfx.doc"); + xDocumentScripts = nullptr; + } + + return xDocumentScripts; +} + + +// XEventBroadcaster + + +void SAL_CALL SfxBaseModel::addEventListener( const Reference< document::XEventListener >& aListener ) +{ + SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING ); + + m_pData->m_aInterfaceContainer.addInterface( cppu::UnoType<document::XEventListener>::get(), aListener ); +} + + +// XEventBroadcaster + + +void SAL_CALL SfxBaseModel::removeEventListener( const Reference< document::XEventListener >& aListener ) +{ + SfxModelGuard aGuard( *this ); + + m_pData->m_aInterfaceContainer.removeInterface( cppu::UnoType<document::XEventListener>::get(), aListener ); +} + +// XShapeEventBroadcaster + +void SAL_CALL SfxBaseModel::addShapeEventListener( const css::uno::Reference< css::drawing::XShape >& xShape, const Reference< document::XShapeEventListener >& xListener ) +{ + assert(xShape.is() && "no shape?"); + SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING ); + + m_pData->maShapeListeners[xShape].push_back(xListener); +} + + +// XShapeEventBroadcaster + + +void SAL_CALL SfxBaseModel::removeShapeEventListener( const css::uno::Reference< css::drawing::XShape >& xShape, const Reference< document::XShapeEventListener >& xListener ) +{ + SfxModelGuard aGuard( *this ); + + auto it = m_pData->maShapeListeners.find(xShape); + if (it != m_pData->maShapeListeners.end()) + { + auto rVec = it->second; + auto it2 = std::find(rVec.begin(), rVec.end(), xListener); + if (it2 != rVec.end()) + { + rVec.erase(it2); + if (rVec.empty()) + m_pData->maShapeListeners.erase(it); + } + } +} + +// XDocumentEventBroadcaster + + +void SAL_CALL SfxBaseModel::addDocumentEventListener( const Reference< document::XDocumentEventListener >& aListener ) +{ + SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING ); + m_pData->m_aInterfaceContainer.addInterface( cppu::UnoType<document::XDocumentEventListener>::get(), aListener ); +} + + +void SAL_CALL SfxBaseModel::removeDocumentEventListener( const Reference< document::XDocumentEventListener >& aListener ) +{ + SfxModelGuard aGuard( *this ); + m_pData->m_aInterfaceContainer.removeInterface( cppu::UnoType<document::XDocumentEventListener>::get(), aListener ); +} + + +void SAL_CALL SfxBaseModel::notifyDocumentEvent( const OUString&, const Reference< frame::XController2 >&, const Any& ) +{ + throw lang::NoSupportException("SfxBaseModel controls all the sent notifications itself!" ); +} + +Sequence<document::CmisProperty> SAL_CALL SfxBaseModel::getCmisProperties() +{ + if (impl_isDisposed()) + return Sequence<document::CmisProperty>(); + return m_pData->m_cmisProperties; +} + +void SAL_CALL SfxBaseModel::setCmisProperties( const Sequence< document::CmisProperty >& _cmisproperties ) +{ + m_pData->m_cmisProperties = _cmisproperties; +} + +void SAL_CALL SfxBaseModel::updateCmisProperties( const Sequence< document::CmisProperty >& aProperties ) +{ + SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium(); + if ( !pMedium ) + return; + + try + { + ::ucbhelper::Content aContent( pMedium->GetName( ), + Reference<ucb::XCommandEnvironment>(), + comphelper::getProcessComponentContext() ); + + aContent.executeCommand( "updateProperties", uno::Any( aProperties ) ); + loadCmisProperties( ); + } + catch (const Exception & e) + { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetRuntimeException( e.Message, + e.Context, anyEx ); + } + +} + +void SAL_CALL SfxBaseModel::checkOut( ) +{ + SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium(); + if ( !pMedium ) + return; + + try + { + ::ucbhelper::Content aContent( pMedium->GetName(), + Reference<ucb::XCommandEnvironment>(), + comphelper::getProcessComponentContext() ); + + Any aResult = aContent.executeCommand( "checkout", Any( ) ); + OUString sURL; + aResult >>= sURL; + + m_pData->m_pObjectShell->GetMedium( )->SetName( sURL ); + m_pData->m_pObjectShell->GetMedium( )->GetMedium_Impl( ); + m_pData->m_xDocumentProperties->setTitle( getTitle( ) ); + Sequence< beans::PropertyValue > aSequence ; + TransformItems( SID_OPENDOC, *pMedium->GetItemSet(), aSequence ); + attachResource( sURL, aSequence ); + + // Reload the CMIS properties + loadCmisProperties( ); + } + catch ( const Exception & e ) + { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetRuntimeException( e.Message, + e.Context, anyEx ); + } +} + +void SAL_CALL SfxBaseModel::cancelCheckOut( ) +{ + SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium(); + if ( !pMedium ) + return; + + try + { + ::ucbhelper::Content aContent( pMedium->GetName(), + Reference<ucb::XCommandEnvironment>(), + comphelper::getProcessComponentContext() ); + + Any aResult = aContent.executeCommand( "cancelCheckout", Any( ) ); + OUString sURL; + aResult >>= sURL; + + m_pData->m_pObjectShell->GetMedium( )->SetName( sURL ); + } + catch ( const Exception & e ) + { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetRuntimeException( e.Message, + e.Context, anyEx ); + } +} + +void SAL_CALL SfxBaseModel::checkIn( sal_Bool bIsMajor, const OUString& rMessage ) +{ + SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium(); + if ( !pMedium ) + return; + + try + { + Sequence< beans::PropertyValue > aProps{ + comphelper::makePropertyValue("VersionMajor", bIsMajor), + comphelper::makePropertyValue("VersionComment", rMessage), + comphelper::makePropertyValue("CheckIn", true) + }; + + const OUString sName( pMedium->GetName( ) ); + storeSelf( aProps ); + + // Refresh pMedium as it has probably changed during the storeSelf call + pMedium = m_pData->m_pObjectShell->GetMedium( ); + const OUString sNewName( pMedium->GetName( ) ); + + // URL has changed, update the document + if ( sName != sNewName ) + { + m_pData->m_xDocumentProperties->setTitle( getTitle( ) ); + Sequence< beans::PropertyValue > aSequence ; + TransformItems( SID_OPENDOC, *pMedium->GetItemSet(), aSequence ); + attachResource( sNewName, aSequence ); + + // Reload the CMIS properties + loadCmisProperties( ); + } + } + catch ( const Exception & e ) + { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetRuntimeException( e.Message, + e.Context, anyEx ); + } +} + +uno::Sequence< document::CmisVersion > SAL_CALL SfxBaseModel::getAllVersions( ) +{ + uno::Sequence<document::CmisVersion> aVersions; + if (impl_isDisposed()) + return aVersions; + SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium(); + if ( pMedium ) + { + try + { + ::ucbhelper::Content aContent( pMedium->GetName(), + Reference<ucb::XCommandEnvironment>(), + comphelper::getProcessComponentContext() ); + + Any aResult = aContent.executeCommand( "getAllVersions", Any( ) ); + aResult >>= aVersions; + } + catch ( const Exception & e ) + { + css::uno::Any anyEx = cppu::getCaughtException(); + throw lang::WrappedTargetRuntimeException( e.Message, + e.Context, anyEx ); + } + } + return aVersions; +} + +bool SfxBaseModel::getBoolPropertyValue( const OUString& rName ) +{ + bool bValue = false; + if ( m_pData->m_pObjectShell.is() ) + { + SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium(); + if ( pMedium ) + { + try + { + ::ucbhelper::Content aContent( pMedium->GetName( ), + utl::UCBContentHelper::getDefaultCommandEnvironment(), + comphelper::getProcessComponentContext() ); + Reference < beans::XPropertySetInfo > xProps = aContent.getProperties(); + if ( xProps->hasPropertyByName( rName ) ) + { + aContent.getPropertyValue( rName ) >>= bValue; + } + } + catch ( const Exception & ) + { + // Simply ignore it: it's likely the document isn't versionable in that case + bValue = false; + } + } + } + return bValue; +} + +sal_Bool SAL_CALL SfxBaseModel::isVersionable( ) +{ + return getBoolPropertyValue( "IsVersionable" ); +} + +sal_Bool SAL_CALL SfxBaseModel::canCheckOut( ) +{ + return getBoolPropertyValue( "CanCheckOut" ); +} + +sal_Bool SAL_CALL SfxBaseModel::canCancelCheckOut( ) +{ + return getBoolPropertyValue( "CanCancelCheckOut" ); +} + +sal_Bool SAL_CALL SfxBaseModel::canCheckIn( ) +{ + return getBoolPropertyValue( "CanCheckIn" ); +} + +void SfxBaseModel::loadCmisProperties( ) +{ + SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium(); + if ( !pMedium ) + return; + + try + { + ::ucbhelper::Content aContent( pMedium->GetName( ), + utl::UCBContentHelper::getDefaultCommandEnvironment(), + comphelper::getProcessComponentContext() ); + Reference < beans::XPropertySetInfo > xProps = aContent.getProperties(); + static const OUStringLiteral aCmisProps( u"CmisProperties" ); + if ( xProps->hasPropertyByName( aCmisProps ) ) + { + Sequence< document::CmisProperty> aCmisProperties; + aContent.getPropertyValue( aCmisProps ) >>= aCmisProperties; + setCmisProperties( aCmisProperties ); + } + } + catch (const ucb::ContentCreationException &) + { + } + catch (const ucb::CommandAbortedException &) + { + } +} + +SfxMedium* SfxBaseModel::handleLoadError( ErrCode nError, SfxMedium* pMedium ) +{ + if (!nError) + { + // No error condition. + return pMedium; + } + + bool bSilent = false; + const SfxBoolItem* pSilentItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_SILENT, false); + if( pSilentItem ) + bSilent = pSilentItem->GetValue(); + + bool bWarning = nError.IsWarning(); + if ( nError != ERRCODE_IO_BROKENPACKAGE && !bSilent ) + { + // broken package was handled already + if ( SfxObjectShell::UseInteractionToHandleError(pMedium->GetInteractionHandler(), nError) && !bWarning) + { + // abort loading (except for warnings) + nError = ERRCODE_IO_ABORT; + } + } + + if ( m_pData->m_pObjectShell->GetMedium() != pMedium ) + { + // for whatever reason document now has another medium + OSL_FAIL("Document has rejected the medium?!"); + delete pMedium; + pMedium = nullptr; + } + + if ( !bWarning ) // #i30711# don't abort loading if it's only a warning + { + nError = nError ? nError : ERRCODE_IO_CANTREAD; + throw task::ErrorCodeIOException( + "SfxBaseModel::handleLoadError: 0x" + nError.toHexString(), + Reference< XInterface >(), sal_uInt32(nError)); + } + + return pMedium; +} + + +// SfxListener + + +static void addTitle_Impl( Sequence < beans::PropertyValue >& rSeq, const OUString& rTitle ) +{ + auto [begin, end] = asNonConstRange(rSeq); + auto pProp = std::find_if(begin, end, + [](const beans::PropertyValue& rProp) { return rProp.Name == "Title"; }); + if (pProp != end) + { + pProp->Value <<= rTitle; + } + else + { + sal_Int32 nCount = rSeq.getLength(); + rSeq.realloc( nCount+1 ); + auto& el = rSeq.getArray()[nCount]; + el.Name = "Title"; + el.Value <<= rTitle; + } +} + +void SfxBaseModel::Notify( SfxBroadcaster& rBC , + const SfxHint& rHint ) +{ + if ( !m_pData ) + return; + + if ( &rBC != m_pData->m_pObjectShell.get() ) + return; + + if ( rHint.GetId() == SfxHintId::DocChanged ) + changing(); + + const SfxEventHint* pNamedHint = dynamic_cast<const SfxEventHint*>(&rHint); + if ( pNamedHint ) + { + + switch ( pNamedHint->GetEventId() ) + { + case SfxEventHintId::StorageChanged: + { + if ( m_pData->m_xUIConfigurationManager.is() + && m_pData->m_pObjectShell->GetCreateMode() != SfxObjectCreateMode::EMBEDDED ) + { + Reference< embed::XStorage > xConfigStorage; + static const OUStringLiteral aUIConfigFolderName( u"Configurations2" ); + + xConfigStorage = getDocumentSubStorage( aUIConfigFolderName, embed::ElementModes::READWRITE ); + if ( !xConfigStorage.is() ) + xConfigStorage = getDocumentSubStorage( aUIConfigFolderName, embed::ElementModes::READ ); + + if ( xConfigStorage.is() || !m_pData->m_pObjectShell->GetStorage()->hasByName( aUIConfigFolderName ) ) + { + // the storage is different, since otherwise it could not be opened, so it must be exchanged + m_pData->m_xUIConfigurationManager->setStorage( xConfigStorage ); + } + else + { + OSL_FAIL( "Unexpected scenario!" ); + } + } + + ListenForStorage_Impl( m_pData->m_pObjectShell->GetStorage() ); + } + break; + + case SfxEventHintId::LoadFinished: + { + impl_getPrintHelper(); + ListenForStorage_Impl( m_pData->m_pObjectShell->GetStorage() ); + m_pData->m_bModifiedSinceLastSave = false; + } + break; + + case SfxEventHintId::SaveAsDocDone: + { + m_pData->m_sURL = m_pData->m_pObjectShell->GetMedium()->GetName(); + + SfxItemSet *pSet = m_pData->m_pObjectShell->GetMedium()->GetItemSet(); + Sequence< beans::PropertyValue > aArgs; + TransformItems( SID_SAVEASDOC, *pSet, aArgs ); + addTitle_Impl( aArgs, m_pData->m_pObjectShell->GetTitle() ); + attachResource( m_pData->m_pObjectShell->GetMedium()->GetName(), aArgs ); + } + break; + + case SfxEventHintId::DocCreated: + { + impl_getPrintHelper(); + m_pData->m_bModifiedSinceLastSave = false; + } + break; + + case SfxEventHintId::ModifyChanged: + { + m_pData->m_bModifiedSinceLastSave = isModified(); + } + break; + default: break; + } + + Any aSupplement; + if (const SfxPrintingHint* pPrintingHint = dynamic_cast<const SfxPrintingHint*>(&rHint)) + aSupplement <<= pPrintingHint->GetWhich(); + const SfxViewEventHint* pViewHint = dynamic_cast<const SfxViewEventHint*>(&rHint); + postEvent_Impl( pNamedHint->GetEventName(), pViewHint ? pViewHint->GetController() : Reference< frame::XController2 >(), aSupplement ); + } + + if ( rHint.GetId() == SfxHintId::TitleChanged ) + { + addTitle_Impl( m_pData->m_seqArguments, m_pData->m_pObjectShell->GetTitle() ); + postEvent_Impl( GlobalEventConfig::GetEventName( GlobalEventId::TITLECHANGED ) ); + } + else if ( rHint.GetId() == SfxHintId::ModeChanged ) + { + postEvent_Impl( GlobalEventConfig::GetEventName( GlobalEventId::MODECHANGED ) ); + } +} + + +// public impl. + + +void SfxBaseModel::NotifyModifyListeners_Impl() const +{ + comphelper::OInterfaceContainerHelper2* pIC = m_pData->m_aInterfaceContainer.getContainer( cppu::UnoType<util::XModifyListener>::get()); + if ( pIC ) + { + lang::EventObject aEvent( static_cast<frame::XModel *>(const_cast<SfxBaseModel *>(this)) ); + pIC->notifyEach( &util::XModifyListener::modified, aEvent ); + } + + // this notification here is done too generously, we cannot simply assume that we're really modified + // now, but we need to check it ... + m_pData->m_bModifiedSinceLastSave = const_cast< SfxBaseModel* >( this )->isModified(); +} + +void SfxBaseModel::changing() +{ + SfxModelGuard aGuard( *this ); + + // the notification should not be sent if the document can not be modified + if ( !m_pData->m_pObjectShell.is() || !m_pData->m_pObjectShell->IsEnableSetModified() ) + return; + + NotifyModifyListeners_Impl(); +} + + +// public impl. + + +SfxObjectShell* SfxBaseModel::GetObjectShell() const +{ + return m_pData ? m_pData->m_pObjectShell.get() : nullptr; +} + + +// public impl. + + +bool SfxBaseModel::IsInitialized() const +{ + if ( !m_pData || !m_pData->m_pObjectShell.is() ) + { + OSL_FAIL( "SfxBaseModel::IsInitialized: this should have been caught earlier!" ); + return false; + } + + return m_pData->m_pObjectShell->GetMedium() != nullptr; +} + +void SfxBaseModel::MethodEntryCheck( const bool i_mustBeInitialized ) const +{ + if ( impl_isDisposed() ) + throw lang::DisposedException( OUString(), *const_cast< SfxBaseModel* >( this ) ); + if ( i_mustBeInitialized && !IsInitialized() ) + throw lang::NotInitializedException( OUString(), *const_cast< SfxBaseModel* >( this ) ); +} + +bool SfxBaseModel::impl_isDisposed() const +{ + return ( m_pData == nullptr ) ; +} + + +// private impl. + + +OUString SfxBaseModel::GetMediumFilterName_Impl() const +{ + std::shared_ptr<const SfxFilter> pFilter; + SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium(); + if ( pMedium ) + pFilter = pMedium->GetFilter(); + + if ( pFilter ) + return pFilter->GetName(); + + return OUString(); +} + +void SfxBaseModel::impl_store( const OUString& sURL , + const Sequence< beans::PropertyValue >& seqArguments , + bool bSaveTo ) +{ + if( sURL.isEmpty() ) + throw frame::IllegalArgumentIOException(); + + bool bSaved = false; + if ( !bSaveTo && m_pData->m_pObjectShell.is() && !sURL.isEmpty() + && !sURL.startsWith( "private:stream" ) + && ::utl::UCBContentHelper::EqualURLs( getLocation(), sURL ) ) + { + // this is the same file URL as the current document location, try to use storeOwn if possible + + ::comphelper::SequenceAsHashMap aArgHash( seqArguments ); + static const OUStringLiteral aFilterString( u"FilterName" ); + const OUString aFilterName( aArgHash.getUnpackedValueOrDefault( aFilterString, OUString() ) ); + if ( !aFilterName.isEmpty() ) + { + SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium(); + if ( pMedium ) + { + const std::shared_ptr<const SfxFilter>& pFilter = pMedium->GetFilter(); + if ( pFilter && aFilterName == pFilter->GetFilterName() ) + { + // #i119366# - If the former file saving with password, do not trying in StoreSelf anyway... + bool bFormerPassword = false; + { + uno::Sequence< beans::NamedValue > aOldEncryptionData; + if (GetEncryptionData_Impl( pMedium->GetItemSet(), aOldEncryptionData )) + { + bFormerPassword = true; + } + } + if ( !bFormerPassword ) + { + aArgHash.erase( aFilterString ); + aArgHash.erase( "URL" ); + + try + { + storeSelf( aArgHash.getAsConstPropertyValueList() ); + bSaved = true; + } + catch( const lang::IllegalArgumentException& ) + { +#if HAVE_FEATURE_MULTIUSER_ENVIRONMENT + // some additional arguments do not allow to use saving, SaveAs should be done + // but only for normal documents, the shared documents would be overwritten in this case + // that would mean an information loss + // TODO/LATER: need a new interaction for this case + if ( m_pData->m_pObjectShell->IsDocShared() ) + { + uno::Sequence< beans::NamedValue > aNewEncryptionData = aArgHash.getUnpackedValueOrDefault("EncryptionData", uno::Sequence< beans::NamedValue >() ); + if ( !aNewEncryptionData.hasElements() ) + { + aNewEncryptionData = ::comphelper::OStorageHelper::CreatePackageEncryptionData( aArgHash.getUnpackedValueOrDefault("Password", OUString()) ); + } + + uno::Sequence< beans::NamedValue > aOldEncryptionData; + (void)GetEncryptionData_Impl( pMedium->GetItemSet(), aOldEncryptionData ); + + if ( !aOldEncryptionData.hasElements() && !aNewEncryptionData.hasElements() ) + throw; + else + { + // if the password is changed a special error should be used in case of shared document + throw task::ErrorCodeIOException("Can not change password for shared document.", uno::Reference< uno::XInterface >(), sal_uInt32(ERRCODE_SFX_SHARED_NOPASSWORDCHANGE) ); + } + } +#endif + } + } + } + } + } + } + + if ( bSaved || !m_pData->m_pObjectShell.is() ) + return; + + SfxGetpApp()->NotifyEvent( SfxEventHint( bSaveTo ? SfxEventHintId::SaveToDoc : SfxEventHintId::SaveAsDoc, GlobalEventConfig::GetEventName( bSaveTo ? GlobalEventId::SAVETODOC : GlobalEventId::SAVEASDOC ), + m_pData->m_pObjectShell.get() ) ); + + std::optional<SfxAllItemSet> pItemSet(SfxGetpApp()->GetPool()); + pItemSet->Put(SfxStringItem(SID_FILE_NAME, sURL)); + if ( bSaveTo ) + pItemSet->Put(SfxBoolItem(SID_SAVETO, true)); + + TransformParameters(SID_SAVEASDOC, seqArguments, *pItemSet); + + const SfxBoolItem* pCopyStreamItem = pItemSet->GetItem<SfxBoolItem>(SID_COPY_STREAM_IF_POSSIBLE, false); + + if ( pCopyStreamItem && pCopyStreamItem->GetValue() && !bSaveTo ) + { + throw frame::IllegalArgumentIOException( + "CopyStreamIfPossible parameter is not acceptable for storeAsURL() call!" ); + } + + sal_uInt32 nModifyPasswordHash = 0; + Sequence< beans::PropertyValue > aModifyPasswordInfo; + const SfxUnoAnyItem* pModifyPasswordInfoItem = pItemSet->GetItem<SfxUnoAnyItem>(SID_MODIFYPASSWORDINFO, false); + if ( pModifyPasswordInfoItem ) + { + // it contains either a simple hash or a set of PropertyValues + // TODO/LATER: the sequence of PropertyValue should replace the hash completely in future + sal_Int32 nMPHTmp = 0; + pModifyPasswordInfoItem->GetValue() >>= nMPHTmp; + nModifyPasswordHash = static_cast<sal_uInt32>(nMPHTmp); + pModifyPasswordInfoItem->GetValue() >>= aModifyPasswordInfo; + } + pItemSet->ClearItem(SID_MODIFYPASSWORDINFO); + sal_uInt32 nOldModifyPasswordHash = m_pData->m_pObjectShell->GetModifyPasswordHash(); + m_pData->m_pObjectShell->SetModifyPasswordHash( nModifyPasswordHash ); + Sequence< beans::PropertyValue > aOldModifyPasswordInfo = m_pData->m_pObjectShell->GetModifyPasswordInfo(); + m_pData->m_pObjectShell->SetModifyPasswordInfo( aModifyPasswordInfo ); + + // since saving a document modifies its DocumentProperties, the current + // DocumentProperties must be saved on "SaveTo", so it can be restored + // after saving + bool bCopyTo = bSaveTo || + m_pData->m_pObjectShell->GetCreateMode() == SfxObjectCreateMode::EMBEDDED; + Reference<document::XDocumentProperties> xOldDocProps; + if ( bCopyTo ) + { + xOldDocProps = getDocumentProperties(); + const Reference<util::XCloneable> xCloneable(xOldDocProps, + UNO_QUERY_THROW); + const Reference<document::XDocumentProperties> xNewDocProps( + xCloneable->createClone(), UNO_QUERY_THROW); + m_pData->m_xDocumentProperties = xNewDocProps; + } + + bool bRet = m_pData->m_pObjectShell->APISaveAs_Impl(sURL, *pItemSet, seqArguments); + + if ( bCopyTo ) + { + // restore DocumentProperties if a copy was created + m_pData->m_xDocumentProperties = xOldDocProps; + } + + Reference < task::XInteractionHandler > xHandler; + const SfxUnoAnyItem* pItem = pItemSet->GetItem<SfxUnoAnyItem>(SID_INTERACTIONHANDLER, false); + if ( pItem ) + pItem->GetValue() >>= xHandler; + + pItemSet.reset(); + + ErrCode nErrCode = m_pData->m_pObjectShell->GetErrorCode(); + if ( !bRet && !nErrCode ) + { + SAL_WARN("sfx.doc", "Storing has failed, no error is set!"); + nErrCode = ERRCODE_IO_CANTWRITE; + } + m_pData->m_pObjectShell->ResetError(); + + if ( bRet ) + { + if ( nErrCode ) + { + // must be a warning - use Interactionhandler if possible or abandon + if ( xHandler.is() ) + { + // TODO/LATER: a general way to set the error context should be available + SfxErrorContext aEc( ERRCTX_SFX_SAVEASDOC, m_pData->m_pObjectShell->GetTitle() ); + + task::ErrorCodeRequest aErrorCode; + aErrorCode.ErrCode = sal_uInt32(nErrCode); + SfxMedium::CallApproveHandler( xHandler, Any( aErrorCode ), false ); + } + } + + if ( !bSaveTo ) + { + m_pData->m_aPreusedFilterName = GetMediumFilterName_Impl(); + m_pData->m_pObjectShell->SetModifyPasswordEntered(); + + SfxGetpApp()->NotifyEvent( SfxEventHint( SfxEventHintId::SaveAsDocDone, GlobalEventConfig::GetEventName(GlobalEventId::SAVEASDOCDONE), m_pData->m_pObjectShell.get() ) ); + } + else + { + m_pData->m_pObjectShell->SetModifyPasswordHash( nOldModifyPasswordHash ); + m_pData->m_pObjectShell->SetModifyPasswordInfo( aOldModifyPasswordInfo ); + + SfxGetpApp()->NotifyEvent( SfxEventHint( SfxEventHintId::SaveToDocDone, GlobalEventConfig::GetEventName(GlobalEventId::SAVETODOCDONE), m_pData->m_pObjectShell.get() ) ); + } + } + else + { + m_pData->m_pObjectShell->SetModifyPasswordHash( nOldModifyPasswordHash ); + m_pData->m_pObjectShell->SetModifyPasswordInfo( aOldModifyPasswordInfo ); + + + SfxGetpApp()->NotifyEvent( SfxEventHint( bSaveTo ? SfxEventHintId::SaveToDocFailed : SfxEventHintId::SaveAsDocFailed, GlobalEventConfig::GetEventName( bSaveTo ? GlobalEventId::SAVETODOCFAILED : GlobalEventId::SAVEASDOCFAILED), + m_pData->m_pObjectShell.get() ) ); + + std::stringstream aErrCode; + aErrCode << nErrCode; + throw task::ErrorCodeIOException( + "SfxBaseModel::impl_store <" + sURL + "> failed: " + OUString::fromUtf8(aErrCode.str().c_str()), + Reference< XInterface >(), sal_uInt32(nErrCode)); + } +} + + +namespace { +template< typename ListenerT, typename EventT > +class NotifySingleListenerIgnoreRE +{ +private: + typedef void ( SAL_CALL ListenerT::*NotificationMethod )( const EventT& ); + NotificationMethod m_pMethod; + const EventT& m_rEvent; +public: + NotifySingleListenerIgnoreRE( NotificationMethod method, const EventT& event ) : m_pMethod( method ), m_rEvent( event ) { } + + void operator()( const Reference<ListenerT>& listener ) const + { + try + { + (listener.get()->*m_pMethod)( m_rEvent ); + } + catch( RuntimeException& ) + { + // this exception is ignored to avoid problems with invalid listeners, the listener should be probably thrown away in future + } + } +}; +} // anonymous namespace + +void SfxBaseModel::postEvent_Impl( const OUString& aName, const Reference< frame::XController2 >& xController, const Any& supplement ) +{ + // object already disposed? + if ( impl_isDisposed() ) + return; + + // keep m_pData alive, if notified target would dispose the document + std::shared_ptr<IMPL_SfxBaseModel_DataContainer> xKeepAlive(m_pData); + + // also make sure this object doesn't self-destruct while notifying + rtl::Reference<SfxBaseModel> xHoldAlive(this); + + DBG_ASSERT( !aName.isEmpty(), "Empty event name!" ); + if (aName.isEmpty()) + return; + + comphelper::OInterfaceContainerHelper2* pIC = + m_pData->m_aInterfaceContainer.getContainer( cppu::UnoType<document::XDocumentEventListener>::get()); + if ( pIC ) + { + SAL_INFO("sfx.doc", "SfxDocumentEvent: " + aName); + + document::DocumentEvent aDocumentEvent( static_cast<frame::XModel*>(this), aName, xController, supplement ); + + pIC->forEach< document::XDocumentEventListener, NotifySingleListenerIgnoreRE< document::XDocumentEventListener, document::DocumentEvent > >( + NotifySingleListenerIgnoreRE< document::XDocumentEventListener, document::DocumentEvent >( + &document::XDocumentEventListener::documentEventOccured, + aDocumentEvent ) ); + } + + pIC = m_pData->m_aInterfaceContainer.getContainer( cppu::UnoType<document::XEventListener>::get()); + if ( pIC ) + { + SAL_INFO("sfx.doc", "SfxEvent: " + aName); + + document::EventObject aEvent( static_cast<frame::XModel*>(this), aName ); + + pIC->forEach< document::XEventListener, NotifySingleListenerIgnoreRE< document::XEventListener, document::EventObject > >( + NotifySingleListenerIgnoreRE< document::XEventListener, document::EventObject >( + &document::XEventListener::notifyEvent, + aEvent ) ); + } + +} + +Reference < container::XIndexAccess > SAL_CALL SfxBaseModel::getViewData() +{ + SfxModelGuard aGuard( *this ); + + if ( m_pData->m_pObjectShell.is() && !m_pData->m_contViewData.is() ) + { + SfxViewFrame *pActFrame = SfxViewFrame::Current(); + if ( !pActFrame || pActFrame->GetObjectShell() != m_pData->m_pObjectShell.get() ) + pActFrame = SfxViewFrame::GetFirst( m_pData->m_pObjectShell.get() ); + + if ( !pActFrame || !pActFrame->GetViewShell() ) + // currently no frame for this document at all or View is under construction + return Reference < container::XIndexAccess >(); + + m_pData->m_contViewData = new comphelper::IndexedPropertyValuesContainer(); + + if ( !m_pData->m_contViewData.is() ) + { + // error: no container class available! + return Reference < container::XIndexAccess >(); + } + + Reference < container::XIndexContainer > xCont( m_pData->m_contViewData, UNO_QUERY ); + sal_Int32 nCount = 0; + Sequence < beans::PropertyValue > aSeq; + for ( SfxViewFrame *pFrame = SfxViewFrame::GetFirst( m_pData->m_pObjectShell.get() ); pFrame; + pFrame = SfxViewFrame::GetNext( *pFrame, m_pData->m_pObjectShell.get() ) ) + { + bool bIsActive = ( pFrame == pActFrame ); + pFrame->GetViewShell()->WriteUserDataSequence( aSeq ); + xCont->insertByIndex( bIsActive ? 0 : nCount, Any(aSeq) ); + nCount++; + } + } + + return m_pData->m_contViewData; +} + +void SAL_CALL SfxBaseModel::setViewData( const Reference < container::XIndexAccess >& aData ) +{ + SfxModelGuard aGuard( *this ); + + m_pData->m_contViewData = aData; +} + +/** calls all XEventListeners */ +void SfxBaseModel::notifyEvent( const document::EventObject& aEvent ) const +{ + // object already disposed? + if ( impl_isDisposed() ) + return; + + comphelper::OInterfaceContainerHelper2* pIC = m_pData->m_aInterfaceContainer.getContainer( + cppu::UnoType<document::XEventListener>::get()); + if( !pIC ) + + return; + + comphelper::OInterfaceIteratorHelper2 aIt( *pIC ); + while( aIt.hasMoreElements() ) + { + try + { + static_cast<document::XEventListener *>(aIt.next())->notifyEvent( aEvent ); + } + catch( RuntimeException& ) + { + aIt.remove(); + } + } + // for right now, we're only doing the event that this particular performance problem needed + if (aEvent.EventName == "ShapeModified") + { + uno::Reference<drawing::XShape> xShape(aEvent.Source, uno::UNO_QUERY); + if (xShape.is()) + { + auto it = m_pData->maShapeListeners.find(xShape); + if (it != m_pData->maShapeListeners.end()) + for (auto const & rListenerUnoRef : it->second) + rListenerUnoRef->notifyShapeEvent(aEvent); + } + } +} + +/** returns true if someone added a XEventListener to this XEventBroadcaster */ +bool SfxBaseModel::hasEventListeners() const +{ + return !impl_isDisposed() + && ( (nullptr != m_pData->m_aInterfaceContainer.getContainer( cppu::UnoType<document::XEventListener>::get()) ) + || !m_pData->maShapeListeners.empty()); +} + +void SAL_CALL SfxBaseModel::addPrintJobListener( const Reference< view::XPrintJobListener >& xListener ) +{ + SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING ); + + impl_getPrintHelper(); + Reference < view::XPrintJobBroadcaster > xPJB( m_pData->m_xPrintable, UNO_QUERY ); + if ( xPJB.is() ) + xPJB->addPrintJobListener( xListener ); +} + +void SAL_CALL SfxBaseModel::removePrintJobListener( const Reference< view::XPrintJobListener >& xListener ) +{ + SfxModelGuard aGuard( *this ); + + impl_getPrintHelper(); + Reference < view::XPrintJobBroadcaster > xPJB( m_pData->m_xPrintable, UNO_QUERY ); + if ( xPJB.is() ) + xPJB->removePrintJobListener( xListener ); +} + +sal_Int64 SAL_CALL SfxBaseModel::getSomething( const Sequence< sal_Int8 >& aIdentifier ) +{ + SvGlobalName aName( aIdentifier ); + if (aName == SvGlobalName( SFX_GLOBAL_CLASSID )) + { + SolarMutexGuard aGuard; + SfxObjectShell *const pObjectShell(GetObjectShell()); + if (pObjectShell) + { + return comphelper::getSomething_cast(pObjectShell); + } + } + + return 0; +} + + +// XDocumentSubStorageSupplier + + +void SfxBaseModel::ListenForStorage_Impl( const Reference< embed::XStorage >& xStorage ) +{ + Reference< util::XModifiable > xModifiable( xStorage, UNO_QUERY ); + if ( xModifiable.is() ) + { + if ( !m_pData->m_pStorageModifyListen.is() ) + { + m_pData->m_pStorageModifyListen = new ::sfx2::DocumentStorageModifyListener( *m_pData, Application::GetSolarMutex() ); + } + + // no need to deregister the listening for old storage since it should be disposed automatically + xModifiable->addModifyListener( m_pData->m_pStorageModifyListen ); + } +} + +Reference< embed::XStorage > SAL_CALL SfxBaseModel::getDocumentSubStorage( const OUString& aStorageName, sal_Int32 nMode ) +{ + SfxModelGuard aGuard( *this ); + + Reference< embed::XStorage > xResult; + if ( m_pData->m_pObjectShell.is() ) + { + Reference< embed::XStorage > xStorage = m_pData->m_pObjectShell->GetStorage(); + if ( xStorage.is() ) + { + try + { + xResult = xStorage->openStorageElement( aStorageName, nMode ); + } + catch ( Exception& ) + { + } + } + } + + return xResult; +} + +Sequence< OUString > SAL_CALL SfxBaseModel::getDocumentSubStoragesNames() +{ + SfxModelGuard aGuard( *this ); + + Sequence< OUString > aResult; + bool bSuccess = false; + if ( m_pData->m_pObjectShell.is() ) + { + Reference < embed::XStorage > xStorage = m_pData->m_pObjectShell->GetStorage(); + if ( xStorage.is() ) + { + const Sequence< OUString > aTemp = xStorage->getElementNames(); + sal_Int32 nResultSize = 0; + for ( const auto& rName : aTemp ) + { + if ( xStorage->isStorageElement( rName ) ) + { + aResult.realloc( ++nResultSize ); + aResult.getArray()[ nResultSize - 1 ] = rName; + } + } + + bSuccess = true; + } + } + + if ( !bSuccess ) + throw io::IOException(); + + return aResult; +} + + +// XScriptProviderSupplier + + +Reference< script::provider::XScriptProvider > SAL_CALL SfxBaseModel::getScriptProvider() +{ + SfxModelGuard aGuard( *this ); + + Reference< script::provider::XScriptProviderFactory > xScriptProviderFactory = + script::provider::theMasterScriptProviderFactory::get( ::comphelper::getProcessComponentContext() ); + + Reference< XScriptInvocationContext > xScriptContext( this ); + + Reference< script::provider::XScriptProvider > xScriptProvider( + xScriptProviderFactory->createScriptProvider( Any( xScriptContext ) ), + UNO_SET_THROW ); + + return xScriptProvider; +} + + +// XUIConfigurationManagerSupplier + + +OUString const & SfxBaseModel::getRuntimeUID() const +{ + OSL_ENSURE( !m_pData->m_sRuntimeUID.isEmpty(), + "SfxBaseModel::getRuntimeUID - ID is empty!" ); + return m_pData->m_sRuntimeUID; +} + +bool SfxBaseModel::hasValidSignatures() const +{ + SolarMutexGuard aGuard; + if ( m_pData->m_pObjectShell.is() ) + return ( m_pData->m_pObjectShell->ImplGetSignatureState() == SignatureState::OK ); + return false; +} + +void SfxBaseModel::getGrabBagItem(css::uno::Any& rVal) const +{ + if (m_pData->m_xGrabBagItem) + m_pData->m_xGrabBagItem->QueryValue(rVal); + else + rVal <<= uno::Sequence<beans::PropertyValue>(); +} + +void SfxBaseModel::setGrabBagItem(const css::uno::Any& rVal) +{ + if (!m_pData->m_xGrabBagItem) + m_pData->m_xGrabBagItem = std::make_shared<SfxGrabBagItem>(); + + m_pData->m_xGrabBagItem->PutValue(rVal, 0); +} + +static void GetCommandFromSequence( OUString& rCommand, sal_Int32& nIndex, const Sequence< beans::PropertyValue >& rSeqPropValue ) +{ + nIndex = -1; + + auto pPropValue = std::find_if(rSeqPropValue.begin(), rSeqPropValue.end(), + [](const beans::PropertyValue& rPropValue) { return rPropValue.Name == "Command"; }); + if (pPropValue != rSeqPropValue.end()) + { + pPropValue->Value >>= rCommand; + nIndex = static_cast<sal_Int32>(std::distance(rSeqPropValue.begin(), pPropValue)); + } +} + +static void ConvertSlotsToCommands( SfxObjectShell const * pDoc, Reference< container::XIndexContainer > const & rToolbarDefinition ) +{ + if ( !pDoc ) + return; + + SfxModule* pModule( pDoc->GetFactory().GetModule() ); + Sequence< beans::PropertyValue > aSeqPropValue; + + for ( sal_Int32 i = 0; i < rToolbarDefinition->getCount(); i++ ) + { + if ( rToolbarDefinition->getByIndex( i ) >>= aSeqPropValue ) + { + OUString aCommand; + sal_Int32 nIndex( -1 ); + GetCommandFromSequence( aCommand, nIndex, aSeqPropValue ); + if ( nIndex >= 0 && aCommand.startsWith( "slot:" ) ) + { + const sal_uInt16 nSlot = o3tl::toInt32(aCommand.subView( 5 )); + + // We have to replace the old "slot-Command" with our new ".uno:-Command" + const SfxSlot* pSlot = pModule->GetSlotPool()->GetSlot( nSlot ); + if ( pSlot ) + { + OUStringBuffer aStrBuf( ".uno:" ); + aStrBuf.appendAscii( pSlot->GetUnoName() ); + + aCommand = aStrBuf.makeStringAndClear(); + aSeqPropValue.getArray()[nIndex].Value <<= aCommand; + rToolbarDefinition->replaceByIndex( i, Any( aSeqPropValue )); + } + } + } + } +} + +Reference< ui::XUIConfigurationManager > SAL_CALL SfxBaseModel::getUIConfigurationManager() +{ + return Reference< ui::XUIConfigurationManager >( getUIConfigurationManager2(), UNO_QUERY_THROW ); +} + +Reference< ui::XUIConfigurationManager2 > SfxBaseModel::getUIConfigurationManager2() +{ + SfxModelGuard aGuard( *this ); + + if ( !m_pData->m_xUIConfigurationManager.is() ) + { + Reference< ui::XUIConfigurationManager2 > xNewUIConfMan = + ui::UIConfigurationManager::create( comphelper::getProcessComponentContext() ); + + Reference< embed::XStorage > xConfigStorage; + + OUString aUIConfigFolderName( "Configurations2" ); + // First try to open with READWRITE and then READ + xConfigStorage = getDocumentSubStorage( aUIConfigFolderName, embed::ElementModes::READWRITE ); + if ( xConfigStorage.is() ) + { + static const OUStringLiteral aMediaTypeProp( u"MediaType" ); + OUString aMediaType; + Reference< beans::XPropertySet > xPropSet( xConfigStorage, UNO_QUERY ); + Any a = xPropSet->getPropertyValue( aMediaTypeProp ); + if ( !( a >>= aMediaType ) || aMediaType.isEmpty()) + { + xPropSet->setPropertyValue( aMediaTypeProp, Any(OUString("application/vnd.sun.xml.ui.configuration")) ); + } + } + else + xConfigStorage = getDocumentSubStorage( aUIConfigFolderName, embed::ElementModes::READ ); + + // initialize ui configuration manager with document substorage + xNewUIConfMan->setStorage( xConfigStorage ); + + // embedded objects did not support local configuration data until OOo 3.0, so there's nothing to + // migrate + if ( m_pData->m_pObjectShell->GetCreateMode() != SfxObjectCreateMode::EMBEDDED ) + { + // Import old UI configuration from OOo 1.x + + // Try to open with READ + Reference< embed::XStorage > xOOo1ConfigStorage = getDocumentSubStorage( "Configurations", embed::ElementModes::READ ); + if ( xOOo1ConfigStorage.is() ) + { + Reference< XComponentContext > xContext( ::comphelper::getProcessComponentContext() ); + std::vector< Reference< container::XIndexContainer > > rToolbars; + + bool bImported = framework::UIConfigurationImporterOOo1x::ImportCustomToolbars( + xNewUIConfMan, rToolbars, xContext, xOOo1ConfigStorage ); + if ( bImported ) + { + SfxObjectShell* pObjShell = SfxBaseModel::GetObjectShell(); + + for ( size_t i = 0; i < rToolbars.size(); i++ ) + { + const OUString sId(OUString::number( i + 1 )); + const OUString aCustomTbxName = "private:resource/toolbar/custom_OOo1x_" + sId; + + Reference< container::XIndexContainer > xToolbar = rToolbars[i]; + ConvertSlotsToCommands( pObjShell, xToolbar ); + if ( !xNewUIConfMan->hasSettings( aCustomTbxName )) + { + // Set UIName for the toolbar with container property + Reference< beans::XPropertySet > xPropSet( xToolbar, UNO_QUERY ); + if ( xPropSet.is() ) + { + try + { + xPropSet->setPropertyValue( "UIName", Any( "Toolbar " + sId ) ); + } + catch ( beans::UnknownPropertyException& ) + { + } + } + + xNewUIConfMan->insertSettings( aCustomTbxName, xToolbar ); + xNewUIConfMan->store(); + } + } + } + } + } + + m_pData->m_xUIConfigurationManager = xNewUIConfMan; + } + + return m_pData->m_xUIConfigurationManager; +} + + +// XVisualObject + + +void SAL_CALL SfxBaseModel::setVisualAreaSize( sal_Int64 nAspect, const awt::Size& aSize ) +{ + SfxModelGuard aGuard( *this ); + + if ( !m_pData->m_pObjectShell.is() ) + throw Exception("no object shell", nullptr); // TODO: error handling + + SfxViewFrame* pViewFrm = SfxViewFrame::GetFirst( m_pData->m_pObjectShell.get(), false ); + if ( pViewFrm && m_pData->m_pObjectShell->GetCreateMode() == SfxObjectCreateMode::EMBEDDED && !pViewFrm->GetFrame().IsInPlace() ) + { + VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( pViewFrm->GetFrame().GetFrameInterface()->getContainerWindow() ); + Size aWinSize = pWindow->GetSizePixel(); + awt::Size aCurrent = getVisualAreaSize( nAspect ); + Size aDiff( aSize.Width-aCurrent.Width, aSize.Height-aCurrent.Height ); + aDiff = pViewFrm->GetViewShell()->GetWindow()->LogicToPixel( aDiff ); + aWinSize.AdjustWidth(aDiff.Width() ); + aWinSize.AdjustHeight(aDiff.Height() ); + pWindow->SetSizePixel( aWinSize ); + } + else + { + tools::Rectangle aTmpRect = m_pData->m_pObjectShell->GetVisArea( ASPECT_CONTENT ); + aTmpRect.SetSize( Size( aSize.Width, aSize.Height ) ); + m_pData->m_pObjectShell->SetVisArea( aTmpRect ); + } +} + +awt::Size SAL_CALL SfxBaseModel::getVisualAreaSize( sal_Int64 /*nAspect*/ ) +{ + SfxModelGuard aGuard( *this ); + + if ( !m_pData->m_pObjectShell.is() ) + throw Exception("no object shell", nullptr); // TODO: error handling + + tools::Rectangle aTmpRect = m_pData->m_pObjectShell->GetVisArea( ASPECT_CONTENT ); + + return awt::Size( aTmpRect.GetWidth(), aTmpRect.GetHeight() ); +} + + +sal_Int32 SAL_CALL SfxBaseModel::getMapUnit( sal_Int64 /*nAspect*/ ) +{ + SfxModelGuard aGuard( *this ); + + if ( !m_pData->m_pObjectShell.is() ) + throw Exception("no object shell", nullptr); // TODO: error handling + + return VCLUnoHelper::VCL2UnoEmbedMapUnit( m_pData->m_pObjectShell->GetMapUnit() ); +} + +embed::VisualRepresentation SAL_CALL SfxBaseModel::getPreferredVisualRepresentation( ::sal_Int64 /*nAspect*/ ) +{ + SfxModelGuard aGuard( *this ); + + datatransfer::DataFlavor aDataFlavor( + "application/x-openoffice-gdimetafile;windows_formatname=\"GDIMetaFile\"", + "GDIMetaFile", + cppu::UnoType<Sequence< sal_Int8 >>::get() ); + + embed::VisualRepresentation aVisualRepresentation; + aVisualRepresentation.Data = getTransferData( aDataFlavor ); + aVisualRepresentation.Flavor = aDataFlavor; + + return aVisualRepresentation; +} + + +// XStorageBasedDocument + + +void SAL_CALL SfxBaseModel::loadFromStorage( const Reference< embed::XStorage >& xStorage, + const Sequence< beans::PropertyValue >& aMediaDescriptor ) +{ + SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING ); + if ( IsInitialized() ) + throw frame::DoubleInitializationException( OUString(), *this ); + + // after i36090 is fixed the pool from object shell can be used + // SfxAllItemSet aSet( m_pData->m_pObjectShell->GetPool() ); + SfxAllItemSet aSet( SfxGetpApp()->GetPool() ); + + // the BaseURL is part of the ItemSet + SfxMedium* pMedium = new SfxMedium( xStorage, OUString() ); + TransformParameters( SID_OPENDOC, aMediaDescriptor, aSet ); + pMedium->GetItemSet()->Put( aSet ); + + // allow to use an interactionhandler (if there is one) + pMedium->UseInteractionHandler( true ); + + const SfxBoolItem* pTemplateItem = aSet.GetItem<SfxBoolItem>(SID_TEMPLATE, false); + bool bTemplate = pTemplateItem && pTemplateItem->GetValue(); + m_pData->m_pObjectShell->SetActivateEvent_Impl( bTemplate ? SfxEventHintId::CreateDoc : SfxEventHintId::OpenDoc ); + m_pData->m_pObjectShell->Get_Impl()->bOwnsStorage = false; + + // load document + if ( !m_pData->m_pObjectShell->DoLoad(pMedium) ) + { + ErrCode nError = m_pData->m_pObjectShell->GetErrorCode(); + nError = nError ? nError : ERRCODE_IO_CANTREAD; + throw task::ErrorCodeIOException( + "SfxBaseModel::loadFromStorage: " + nError.toHexString(), + Reference< XInterface >(), sal_uInt32(nError)); + } + loadCmisProperties( ); +} + +void SAL_CALL SfxBaseModel::storeToStorage( const Reference< embed::XStorage >& xStorage, + const Sequence< beans::PropertyValue >& aMediaDescriptor ) +{ + SfxModelGuard aGuard( *this ); + + if ( !m_pData->m_pObjectShell.is() ) + throw io::IOException(); // TODO: + + auto xSet = std::make_shared<SfxAllItemSet>(m_pData->m_pObjectShell->GetPool()); + TransformParameters( SID_SAVEASDOC, aMediaDescriptor, *xSet ); + + // TODO/LATER: maybe a special URL "private:storage" should be used + const SfxStringItem* pItem = xSet->GetItem<SfxStringItem>(SID_FILTER_NAME, false); + sal_Int32 nVersion = SOFFICE_FILEFORMAT_CURRENT; + if( pItem ) + { + std::shared_ptr<const SfxFilter> pFilter = SfxGetpApp()->GetFilterMatcher().GetFilter4FilterName( pItem->GetValue() ); + if ( pFilter && pFilter->UsesStorage() ) + nVersion = pFilter->GetVersion(); + } + + bool bSuccess = false; + if ( xStorage == m_pData->m_pObjectShell->GetStorage() ) + { + // storing to the own storage + bSuccess = m_pData->m_pObjectShell->DoSave(); + } + else + { + // TODO/LATER: if the provided storage has some data inside the storing might fail, probably the storage must be truncated + // TODO/LATER: is it possible to have a template here? + m_pData->m_pObjectShell->SetupStorage( xStorage, nVersion, false ); + + // BaseURL is part of the ItemSet + SfxMedium aMedium( xStorage, OUString(), xSet ); + aMedium.CanDisposeStorage_Impl( false ); + if ( aMedium.GetFilter() ) + { + // storing without a valid filter will often crash + bSuccess = m_pData->m_pObjectShell->DoSaveObjectAs( aMedium, true ); + m_pData->m_pObjectShell->DoSaveCompleted(); + } + } + + ErrCode nError = m_pData->m_pObjectShell->GetErrorCode(); + m_pData->m_pObjectShell->ResetError(); + + // the warnings are currently not transported + if ( !bSuccess ) + { + nError = nError ? nError : ERRCODE_IO_GENERAL; + throw task::ErrorCodeIOException( + "SfxBaseModel::storeToStorage: " + nError.toHexString(), + Reference< XInterface >(), sal_uInt32(nError)); + } +} + +void SAL_CALL SfxBaseModel::switchToStorage( const Reference< embed::XStorage >& xStorage ) +{ + SfxModelGuard aGuard( *this ); + + if ( !m_pData->m_pObjectShell.is() ) + throw io::IOException(); // TODO: + + // the persistence should be switched only if the storage is different + if ( xStorage != m_pData->m_pObjectShell->GetStorage() ) + { + if ( !m_pData->m_pObjectShell->SwitchPersistence( xStorage ) ) + { + ErrCode nError = m_pData->m_pObjectShell->GetErrorCode(); + nError = nError ? nError : ERRCODE_IO_GENERAL; + throw task::ErrorCodeIOException( + "SfxBaseModel::switchToStorage: " + nError.toHexString(), + Reference< XInterface >(), sal_uInt32(nError)); + } + else + { + // UICfgMgr has a reference to the old storage, update it + getUIConfigurationManager2()->setStorage( xStorage ); + } + } + m_pData->m_pObjectShell->Get_Impl()->bOwnsStorage = false; +} + +Reference< embed::XStorage > SAL_CALL SfxBaseModel::getDocumentStorage() +{ + SfxModelGuard aGuard( *this ); + + if ( !m_pData->m_pObjectShell.is() ) + throw io::IOException(); // TODO + + return m_pData->m_pObjectShell->GetStorage(); +} + +void SAL_CALL SfxBaseModel::addStorageChangeListener( + const Reference< document::XStorageChangeListener >& xListener ) +{ + SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING ); + + m_pData->m_aInterfaceContainer.addInterface( + cppu::UnoType<document::XStorageChangeListener>::get(), xListener ); +} + +void SAL_CALL SfxBaseModel::removeStorageChangeListener( + const Reference< document::XStorageChangeListener >& xListener ) +{ + SfxModelGuard aGuard( *this ); + + m_pData->m_aInterfaceContainer.removeInterface( + cppu::UnoType<document::XStorageChangeListener>::get(), xListener ); +} + +void SfxBaseModel::impl_getPrintHelper() +{ + if ( m_pData->m_xPrintable.is() ) + return; + m_pData->m_xPrintable = new SfxPrintHelper(); + Reference < lang::XInitialization > xInit( m_pData->m_xPrintable, UNO_QUERY ); + xInit->initialize( { Any(Reference < frame::XModel > (this)) } ); + Reference < view::XPrintJobBroadcaster > xBrd( m_pData->m_xPrintable, UNO_QUERY ); + xBrd->addPrintJobListener( new SfxPrintHelperListener_Impl( m_pData.get() ) ); +} + + +// css.frame.XModule + void SAL_CALL SfxBaseModel::setIdentifier(const OUString& Identifier) +{ + SfxModelGuard aGuard( *this ); + m_pData->m_sModuleIdentifier = Identifier; +} + + +// css.frame.XModule + OUString SAL_CALL SfxBaseModel::getIdentifier() +{ + SfxModelGuard aGuard( *this ); + if (!m_pData->m_sModuleIdentifier.isEmpty()) + return m_pData->m_sModuleIdentifier; + if (m_pData->m_pObjectShell.is()) + return m_pData->m_pObjectShell->GetFactory().GetDocumentServiceName(); + return OUString(); +} + + +Reference< frame::XTitle > SfxBaseModel::impl_getTitleHelper () +{ + SfxModelGuard aGuard( *this ); + + if ( ! m_pData->m_xTitleHelper.is ()) + { + Reference< XComponentContext > xContext = ::comphelper::getProcessComponentContext(); + Reference< frame::XUntitledNumbers > xDesktop( frame::Desktop::create(xContext), UNO_QUERY_THROW); + + m_pData->m_xTitleHelper = new ::framework::TitleHelper(xContext, Reference< frame::XModel >(this), xDesktop); + } + + return m_pData->m_xTitleHelper; +} + + +Reference< frame::XUntitledNumbers > SfxBaseModel::impl_getUntitledHelper () +{ + SfxModelGuard aGuard( *this ); + + if ( ! m_pData->m_xNumberedControllers.is ()) + { + rtl::Reference<::comphelper::NumberedCollection> pHelper = new ::comphelper::NumberedCollection(); + m_pData->m_xNumberedControllers = pHelper; + pHelper->setOwner (Reference< frame::XModel >(this)); + pHelper->setUntitledPrefix (" : "); + } + + return m_pData->m_xNumberedControllers; +} + + +// css.frame.XTitle +OUString SAL_CALL SfxBaseModel::getTitle() +{ + // SYNCHRONIZED -> + SfxModelGuard aGuard( *this ); + + OUString aResult = impl_getTitleHelper()->getTitle (); + if ( !m_pData->m_bExternalTitle && m_pData->m_pObjectShell ) + { + SfxMedium* pMedium = m_pData->m_pObjectShell->GetMedium(); + if ( pMedium ) + { + try { + ::ucbhelper::Content aContent( pMedium->GetName(), + utl::UCBContentHelper::getDefaultCommandEnvironment(), + comphelper::getProcessComponentContext() ); + const Reference < beans::XPropertySetInfo > xProps + = aContent.getProperties(); + if ( xProps.is() ) + { + static const OUStringLiteral aServerTitle( u"TitleOnServer" ); + if ( xProps->hasPropertyByName( aServerTitle ) ) + { + Any aAny = aContent.getPropertyValue( aServerTitle ); + aAny >>= aResult; + } + } + } + catch (const ucb::ContentCreationException &) + { + } + catch (const ucb::CommandAbortedException &) + { + } + const SfxBoolItem* pRepairedDocItem = SfxItemSet::GetItem<SfxBoolItem>(pMedium->GetItemSet(), SID_REPAIRPACKAGE, false); + if ( pRepairedDocItem && pRepairedDocItem->GetValue() ) + aResult += SfxResId(STR_REPAIREDDOCUMENT); + } + + if ( m_pData->m_pObjectShell->IsReadOnlyUI() || (pMedium && pMedium->IsReadOnly()) ) + aResult += SfxResId(STR_READONLY); + else if ( m_pData->m_pObjectShell->IsDocShared() ) + aResult += SfxResId(STR_SHARED); + + if ( m_pData->m_pObjectShell->GetDocumentSignatureState() == SignatureState::OK ) + aResult += SfxResId(RID_XMLSEC_DOCUMENTSIGNED); + } + + return aResult; +} + + +// css.frame.XTitle +void SAL_CALL SfxBaseModel::setTitle( const OUString& sTitle ) +{ + // SYNCHRONIZED -> + SfxModelGuard aGuard( *this ); + + impl_getTitleHelper()->setTitle (sTitle); + m_pData->m_bExternalTitle = true; +} + + +// css.frame.XTitleChangeBroadcaster +void SAL_CALL SfxBaseModel::addTitleChangeListener( const Reference< frame::XTitleChangeListener >& xListener ) +{ + // SYNCHRONIZED -> + SfxModelGuard aGuard( *this, SfxModelGuard::E_INITIALIZING ); + + Reference< frame::XTitleChangeBroadcaster > xBroadcaster(impl_getTitleHelper(), UNO_QUERY); + if (xBroadcaster.is ()) + xBroadcaster->addTitleChangeListener (xListener); +} + + +// css.frame.XTitleChangeBroadcaster +void SAL_CALL SfxBaseModel::removeTitleChangeListener( const Reference< frame::XTitleChangeListener >& xListener ) +{ + // SYNCHRONIZED -> + SfxModelGuard aGuard( *this ); + + Reference< frame::XTitleChangeBroadcaster > xBroadcaster(impl_getTitleHelper(), UNO_QUERY); + if (xBroadcaster.is ()) + xBroadcaster->removeTitleChangeListener (xListener); +} + + +// css.frame.XUntitledNumbers +::sal_Int32 SAL_CALL SfxBaseModel::leaseNumber( const Reference< XInterface >& xComponent ) +{ + SfxModelGuard aGuard( *this ); + + return impl_getUntitledHelper ()->leaseNumber (xComponent); +} + + +// css.frame.XUntitledNumbers +void SAL_CALL SfxBaseModel::releaseNumber( ::sal_Int32 nNumber ) +{ + SfxModelGuard aGuard( *this ); + impl_getUntitledHelper ()->releaseNumber (nNumber); +} + + +// css.frame.XUntitledNumbers +void SAL_CALL SfxBaseModel::releaseNumberForComponent( const Reference< XInterface >& xComponent ) +{ + SfxModelGuard aGuard( *this ); + impl_getUntitledHelper ()->releaseNumberForComponent (xComponent); +} + + +// css.frame.XUntitledNumbers +OUString SAL_CALL SfxBaseModel::getUntitledPrefix() +{ + SfxModelGuard aGuard( *this ); + return impl_getUntitledHelper ()->getUntitledPrefix (); +} + + +// frame::XModel2 +Reference< container::XEnumeration > SAL_CALL SfxBaseModel::getControllers() +{ + SfxModelGuard aGuard( *this ); + + sal_Int32 c = m_pData->m_seqControllers.size(); + Sequence< Any > lEnum(c); + std::transform(m_pData->m_seqControllers.begin(), m_pData->m_seqControllers.end(), + lEnum.getArray(), [](const auto& x) { return css::uno::Any(x); }); + + return new ::comphelper::OAnyEnumeration(lEnum); +} + + +// frame::XModel2 +Sequence< OUString > SAL_CALL SfxBaseModel::getAvailableViewControllerNames() +{ + SfxModelGuard aGuard( *this ); + + const SfxObjectFactory& rDocumentFactory = GetObjectShell()->GetFactory(); + const sal_Int16 nViewFactoryCount = rDocumentFactory.GetViewFactoryCount(); + + Sequence< OUString > aViewNames( nViewFactoryCount ); + auto aViewNamesRange = asNonConstRange(aViewNames); + for ( sal_Int16 nViewNo = 0; nViewNo < nViewFactoryCount; ++nViewNo ) + aViewNamesRange[nViewNo] = rDocumentFactory.GetViewFactory( nViewNo ).GetAPIViewName(); + return aViewNames; +} + + +// frame::XModel2 +Reference< frame::XController2 > SAL_CALL SfxBaseModel::createDefaultViewController( const Reference< frame::XFrame >& i_rFrame ) +{ + SfxModelGuard aGuard( *this ); + + const SfxObjectFactory& rDocumentFactory = GetObjectShell()->GetFactory(); + const OUString sDefaultViewName = rDocumentFactory.GetViewFactory().GetAPIViewName(); + + aGuard.clear(); + + return createViewController( sDefaultViewName, Sequence< PropertyValue >(), i_rFrame ); +} + + +namespace sfx::intern { + + /** a class which, in its dtor, cleans up various objects (well, at the moment only the frame) collected during + the creation of a document view, unless the creation was successful. + */ + class ViewCreationGuard + { + public: + ViewCreationGuard() + :m_bSuccess( false ) + { + } + + ~ViewCreationGuard() + { + if ( !m_bSuccess && m_aWeakFrame && !m_aWeakFrame->GetCurrentDocument() ) + { + m_aWeakFrame->SetFrameInterface_Impl( nullptr ); + m_aWeakFrame->DoClose(); + } + } + + void takeFrameOwnership( SfxFrame* i_pFrame ) + { + OSL_PRECOND( !m_aWeakFrame, "ViewCreationGuard::takeFrameOwnership: already have a frame!" ); + OSL_PRECOND( i_pFrame != nullptr, "ViewCreationGuard::takeFrameOwnership: invalid frame!" ); + m_aWeakFrame = i_pFrame; + } + + void releaseAll() + { + m_bSuccess = true; + } + + private: + bool m_bSuccess; + SfxFrameWeakRef m_aWeakFrame; + }; +} + + +SfxViewFrame* SfxBaseModel::FindOrCreateViewFrame_Impl( const Reference< XFrame >& i_rFrame, ::sfx::intern::ViewCreationGuard& i_rGuard ) const +{ + SfxViewFrame* pViewFrame = nullptr; + for ( pViewFrame = SfxViewFrame::GetFirst( GetObjectShell(), false ); + pViewFrame; + pViewFrame= SfxViewFrame::GetNext( *pViewFrame, GetObjectShell(), false ) + ) + { + if ( pViewFrame->GetFrame().GetFrameInterface() == i_rFrame ) + break; + } + if ( !pViewFrame ) + { + #if OSL_DEBUG_LEVEL > 0 + for ( SfxFrame* pCheckFrame = SfxFrame::GetFirst(); + pCheckFrame; + pCheckFrame = SfxFrame::GetNext( *pCheckFrame ) + ) + { + if ( pCheckFrame->GetFrameInterface() == i_rFrame ) + { + if ( ( pCheckFrame->GetCurrentViewFrame() != nullptr ) + || ( pCheckFrame->GetCurrentDocument() != nullptr ) + ) + // Note that it is perfectly legitimate that during loading into an XFrame which already contains + // a document, there exist two SfxFrame instances bound to this XFrame - the old one, which will be + // destroyed later, and the new one, which we're going to create + continue; + + OSL_FAIL( "SfxBaseModel::FindOrCreateViewFrame_Impl: there already is an SfxFrame for the given XFrame, but no view in it!" ); + // nowadays, we're the only instance allowed to create an SfxFrame for an XFrame, so this case here should not happen + break; + } + } + #endif + + SfxFrame* pTargetFrame = SfxFrame::Create( i_rFrame ); + ENSURE_OR_THROW( pTargetFrame, "could not create an SfxFrame" ); + i_rGuard.takeFrameOwnership( pTargetFrame ); + + // prepare it + pTargetFrame->PrepareForDoc_Impl( *GetObjectShell() ); + + // create view frame + pViewFrame = new SfxViewFrame( *pTargetFrame, GetObjectShell() ); + } + return pViewFrame; +} + + +// frame::XModel2 +Reference< frame::XController2 > SAL_CALL SfxBaseModel::createViewController( + const OUString& i_rViewName, const Sequence< PropertyValue >& i_rArguments, const Reference< XFrame >& i_rFrame ) +{ + SfxModelGuard aGuard( *this ); + + if ( !i_rFrame.is() ) + throw lang::IllegalArgumentException( OUString(), *this, 3 ); + + // find the proper SFX view factory + SfxViewFactory* pViewFactory = GetObjectShell()->GetFactory().GetViewFactoryByViewName( i_rViewName ); + if ( !pViewFactory ) + throw IllegalArgumentException( OUString(), *this, 1 ); + + // determine previous shell (used in some special cases) + Reference< XController > xPreviousController( i_rFrame->getController() ); + const Reference< XModel > xMe( this ); + if ( ( xPreviousController.is() ) + && ( xMe != xPreviousController->getModel() ) + ) + { + xPreviousController.clear(); + } + SfxViewShell* pOldViewShell = SfxViewShell::Get( xPreviousController ); + OSL_ENSURE( !xPreviousController.is() || ( pOldViewShell != nullptr ), + "SfxBaseModel::createViewController: invalid old controller!" ); + + // a guard which will clean up in case of failure + ::sfx::intern::ViewCreationGuard aViewCreationGuard; + + // determine the ViewFrame belonging to the given XFrame + SfxViewFrame* pViewFrame = FindOrCreateViewFrame_Impl( i_rFrame, aViewCreationGuard ); + SAL_WARN_IF( !pViewFrame , "sfx.doc", "SfxBaseModel::createViewController: no frame?" ); + + // delegate to SFX' view factory + pViewFrame->GetBindings().ENTERREGISTRATIONS(); + SfxViewShell* pViewShell = pViewFactory->CreateInstance( pViewFrame, pOldViewShell ); + pViewFrame->GetBindings().LEAVEREGISTRATIONS(); + ENSURE_OR_THROW( pViewShell, "invalid view shell provided by factory" ); + + // by setting the ViewShell it is prevented that disposing the Controller will destroy this ViewFrame also + pViewFrame->GetDispatcher()->SetDisableFlags( SfxDisableFlags::NONE ); + pViewFrame->SetViewShell_Impl( pViewShell ); + + // remember ViewID + pViewFrame->SetCurViewId_Impl( pViewFactory->GetOrdinal() ); + + // ensure a default controller, if the view shell did not provide an own implementation + if ( !pViewShell->GetController().is() ) + pViewShell->SetController( new SfxBaseController( pViewShell ) ); + + // pass the creation arguments to the controller + SfxBaseController* pBaseController = pViewShell->GetBaseController_Impl(); + ENSURE_OR_THROW( pBaseController, "invalid controller implementation!" ); + pBaseController->SetCreationArguments_Impl( i_rArguments ); + + // some initial view settings, coming from our most recent attachResource call + ::comphelper::NamedValueCollection aDocumentLoadArgs( getArgs2( { "ViewOnly", "PluginMode" } ) ); + if ( aDocumentLoadArgs.getOrDefault( "ViewOnly", false ) ) + pViewFrame->GetFrame().SetMenuBarOn_Impl( false ); + + const sal_Int16 nPluginMode = aDocumentLoadArgs.getOrDefault( "PluginMode", sal_Int16( 0 ) ); + if ( nPluginMode == 1 ) + { + pViewFrame->ForceOuterResize_Impl(); + pViewFrame->GetBindings().HidePopups(); + + SfxFrame& rFrame = pViewFrame->GetFrame(); + // MBA: layoutmanager of inplace frame starts locked and invisible + rFrame.GetWorkWindow_Impl()->MakeVisible_Impl( false ); + rFrame.GetWorkWindow_Impl()->Lock_Impl( true ); + + rFrame.GetWindow().SetBorderStyle( WindowBorderStyle::NOBORDER ); + pViewFrame->GetWindow().SetBorderStyle( WindowBorderStyle::NOBORDER ); + } + + // tell the guard we were successful + aViewCreationGuard.releaseAll(); + + // outta here + return pBaseController; +} + + +// RDF DocumentMetadataAccess + +// rdf::XRepositorySupplier: +Reference< rdf::XRepository > SAL_CALL +SfxBaseModel::getRDFRepository() +{ + SfxModelGuard aGuard( *this ); + + const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA()); + if (!xDMA.is()) { + throw RuntimeException( "model has no document metadata", *this ); + } + + return xDMA->getRDFRepository(); +} + +// rdf::XNode: +OUString SAL_CALL +SfxBaseModel::getStringValue() +{ + SfxModelGuard aGuard( *this ); + + const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA()); + if (!xDMA.is()) { + throw RuntimeException( "model has no document metadata", *this ); + } + + return xDMA->getStringValue(); +} + +// rdf::XURI: +OUString SAL_CALL +SfxBaseModel::getNamespace() +{ + SfxModelGuard aGuard( *this ); + + const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA()); + if (!xDMA.is()) { + throw RuntimeException( "model has no document metadata", *this ); + } + + return xDMA->getNamespace(); +} + +OUString SAL_CALL +SfxBaseModel::getLocalName() +{ + SfxModelGuard aGuard( *this ); + + const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA()); + if (!xDMA.is()) { + throw RuntimeException( "model has no document metadata", *this ); + } + + return xDMA->getLocalName(); +} + +// rdf::XDocumentMetadataAccess: +Reference< rdf::XMetadatable > SAL_CALL +SfxBaseModel::getElementByMetadataReference( + const beans::StringPair & i_rReference) +{ + SfxModelGuard aGuard( *this ); + + const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA()); + if (!xDMA.is()) { + throw RuntimeException( "model has no document metadata", *this ); + } + + return xDMA->getElementByMetadataReference(i_rReference); +} + +Reference< rdf::XMetadatable > SAL_CALL +SfxBaseModel::getElementByURI(const Reference< rdf::XURI > & i_xURI) +{ + SfxModelGuard aGuard( *this ); + + const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA()); + if (!xDMA.is()) { + throw RuntimeException( "model has no document metadata", *this ); + } + + return xDMA->getElementByURI(i_xURI); +} + +Sequence< Reference< rdf::XURI > > SAL_CALL +SfxBaseModel::getMetadataGraphsWithType( + const Reference<rdf::XURI> & i_xType) +{ + SfxModelGuard aGuard( *this ); + + const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA()); + if (!xDMA.is()) { + throw RuntimeException( "model has no document metadata", *this ); + } + + return xDMA->getMetadataGraphsWithType(i_xType); +} + +Reference<rdf::XURI> SAL_CALL +SfxBaseModel::addMetadataFile(const OUString & i_rFileName, + const Sequence < Reference< rdf::XURI > > & i_rTypes) +{ + SfxModelGuard aGuard( *this ); + + const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA()); + if (!xDMA.is()) { + throw RuntimeException( "model has no document metadata", *this ); + } + + return xDMA->addMetadataFile(i_rFileName, i_rTypes); +} + +Reference<rdf::XURI> SAL_CALL +SfxBaseModel::importMetadataFile(::sal_Int16 i_Format, + const Reference< io::XInputStream > & i_xInStream, + const OUString & i_rFileName, + const Reference< rdf::XURI > & i_xBaseURI, + const Sequence < Reference< rdf::XURI > > & i_rTypes) +{ + SfxModelGuard aGuard( *this ); + + const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA()); + if (!xDMA.is()) { + throw RuntimeException( "model has no document metadata", *this ); + } + + return xDMA->importMetadataFile(i_Format, + i_xInStream, i_rFileName, i_xBaseURI, i_rTypes); +} + +void SAL_CALL +SfxBaseModel::removeMetadataFile( + const Reference< rdf::XURI > & i_xGraphName) +{ + SfxModelGuard aGuard( *this ); + + const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA()); + if (!xDMA.is()) { + throw RuntimeException( "model has no document metadata", *this ); + } + + return xDMA->removeMetadataFile(i_xGraphName); +} + +void SAL_CALL +SfxBaseModel::addContentOrStylesFile(const OUString & i_rFileName) +{ + SfxModelGuard aGuard( *this ); + + const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA()); + if (!xDMA.is()) { + throw RuntimeException( "model has no document metadata", *this ); + } + + return xDMA->addContentOrStylesFile(i_rFileName); +} + +void SAL_CALL +SfxBaseModel::removeContentOrStylesFile(const OUString & i_rFileName) +{ + SfxModelGuard aGuard( *this ); + + const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA()); + if (!xDMA.is()) { + throw RuntimeException( "model has no document metadata", *this ); + } + + return xDMA->removeContentOrStylesFile(i_rFileName); +} + +void SAL_CALL +SfxBaseModel::loadMetadataFromStorage( + Reference< embed::XStorage > const & i_xStorage, + Reference<rdf::XURI> const & i_xBaseURI, + Reference<task::XInteractionHandler> const & i_xHandler) +{ + SfxModelGuard aGuard( *this ); + + const Reference<rdf::XDocumentMetadataAccess> xDMA( + m_pData->CreateDMAUninitialized()); + if (!xDMA.is()) { + throw RuntimeException( "model has no document metadata", *this ); + } + + try { + xDMA->loadMetadataFromStorage(i_xStorage, i_xBaseURI, i_xHandler); + } catch (lang::IllegalArgumentException &) { + throw; // not initialized + } catch (Exception &) { + // UGLY: if it's a RuntimeException, we can't be sure DMA is initialized + m_pData->m_xDocumentMetadata = xDMA; + throw; + } + m_pData->m_xDocumentMetadata = xDMA; + +} + +void SAL_CALL +SfxBaseModel::storeMetadataToStorage( + Reference< embed::XStorage > const & i_xStorage) +{ + SfxModelGuard aGuard( *this ); + + const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA()); + if (!xDMA.is()) { + throw RuntimeException( "model has no document metadata", *this ); + } + + return xDMA->storeMetadataToStorage(i_xStorage); +} + +void SAL_CALL +SfxBaseModel::loadMetadataFromMedium( + const Sequence< beans::PropertyValue > & i_rMedium) +{ + SfxModelGuard aGuard( *this ); + + const Reference<rdf::XDocumentMetadataAccess> xDMA( + m_pData->CreateDMAUninitialized()); + if (!xDMA.is()) { + throw RuntimeException( "model has no document metadata", *this ); + } + + try { + xDMA->loadMetadataFromMedium(i_rMedium); + } catch (lang::IllegalArgumentException &) { + throw; // not initialized + } catch (Exception &) { + // UGLY: if it's a RuntimeException, we can't be sure DMA is initialized + m_pData->m_xDocumentMetadata = xDMA; + throw; + } + m_pData->m_xDocumentMetadata = xDMA; +} + +void SAL_CALL +SfxBaseModel::storeMetadataToMedium( + const Sequence< beans::PropertyValue > & i_rMedium) +{ + SfxModelGuard aGuard( *this ); + + const Reference<rdf::XDocumentMetadataAccess> xDMA(m_pData->GetDMA()); + if (!xDMA.is()) { + throw RuntimeException( "model has no document metadata", *this ); + } + + return xDMA->storeMetadataToMedium(i_rMedium); +} + + +// = SfxModelSubComponent + + +SfxModelSubComponent::~SfxModelSubComponent() +{ +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/sfxmodelfactory.cxx b/sfx2/source/doc/sfxmodelfactory.cxx new file mode 100644 index 000000000..a14ff68b1 --- /dev/null +++ b/sfx2/source/doc/sfxmodelfactory.cxx @@ -0,0 +1,110 @@ +/* -*- 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 <sfx2/sfxmodelfactory.hxx> + +#include <com/sun/star/beans/NamedValue.hpp> +#include <com/sun/star/lang/XInitialization.hpp> + +#include <comphelper/namedvaluecollection.hxx> + +#include <osl/diagnose.h> + +#include <algorithm> + + +namespace sfx2 +{ + + + using ::com::sun::star::uno::Reference; + using ::com::sun::star::uno::XInterface; + using ::com::sun::star::uno::UNO_QUERY; + using ::com::sun::star::uno::Any; + using ::com::sun::star::uno::Sequence; + using ::com::sun::star::beans::NamedValue; + using ::com::sun::star::beans::PropertyValue; + using ::com::sun::star::lang::XInitialization; + + + + namespace + { + struct IsSpecialArgument + { + static bool isSpecialArgumentName( std::u16string_view _rValueName ) + { + return _rValueName == u"EmbeddedObject" || _rValueName == u"EmbeddedScriptSupport" || _rValueName == u"DocumentRecoverySupport"; + } + + bool operator()( const Any& _rArgument ) const + { + NamedValue aNamedValue; + if ( ( _rArgument >>= aNamedValue ) && isSpecialArgumentName( aNamedValue.Name ) ) + return true; + PropertyValue aPropertyValue; + return ( _rArgument >>= aPropertyValue ) && isSpecialArgumentName( aPropertyValue.Name ); + } + }; + } + + + css::uno::Reference<css::uno::XInterface> createSfxModelInstance( + const css::uno::Sequence<css::uno::Any> & _rArguments, + std::function<css::uno::Reference<css::uno::XInterface>(SfxModelFlags)> creationFunc) + { + ::comphelper::NamedValueCollection aArgs( _rArguments ); + const bool bEmbeddedObject = aArgs.getOrDefault( "EmbeddedObject", false ); + const bool bScriptSupport = aArgs.getOrDefault( "EmbeddedScriptSupport", true ); + const bool bDocRecoverySupport = aArgs.getOrDefault( "DocumentRecoverySupport", true ); + + SfxModelFlags nCreationFlags = + ( bEmbeddedObject ? SfxModelFlags::EMBEDDED_OBJECT : SfxModelFlags::NONE ) + | ( bScriptSupport ? SfxModelFlags::NONE : SfxModelFlags::DISABLE_EMBEDDED_SCRIPTS ) + | ( bDocRecoverySupport ? SfxModelFlags::NONE : SfxModelFlags::DISABLE_DOCUMENT_RECOVERY ); + + Reference< XInterface > xInstance( creationFunc(nCreationFlags ) ); + + // to mimic the behaviour of the default factory's createInstanceWithArguments, we initialize + // the object with the given arguments, stripped by the three special ones + Sequence< Any > aStrippedArguments( _rArguments.getLength() ); + Any* pStrippedArgs = aStrippedArguments.getArray(); + Any* pStrippedArgsEnd = ::std::remove_copy_if( + _rArguments.begin(), + _rArguments.end(), + pStrippedArgs, + IsSpecialArgument() + ); + aStrippedArguments.realloc( pStrippedArgsEnd - pStrippedArgs ); + + if ( aStrippedArguments.hasElements() ) + { + Reference< XInitialization > xModelInit( xInstance, UNO_QUERY ); + OSL_ENSURE( xModelInit.is(), "SfxModelFactory::createInstanceWithArguments: no XInitialization!" ); + if ( xModelInit.is() ) + xModelInit->initialize( aStrippedArguments ); + } + + return xInstance; + } + + +} // namespace sfx2 + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/signaturestate.cxx b/sfx2/source/doc/signaturestate.cxx new file mode 100644 index 000000000..d511fa31a --- /dev/null +++ b/sfx2/source/doc/signaturestate.cxx @@ -0,0 +1,59 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/. + */ + +#include <sfx2/signaturestate.hxx> + +#include <com/sun/star/security/CertificateValidity.hpp> +#include <com/sun/star/security/DocumentSignatureInformation.hpp> + +using namespace css; + +namespace DocumentSignatures +{ +SignatureState +getSignatureState(const uno::Sequence<security::DocumentSignatureInformation>& aSigInfo) +{ + bool bCertValid = true; + SignatureState nResult = SignatureState::NOSIGNATURES; + bool bCompleteSignature = true; + if (!aSigInfo.hasElements()) + return nResult; + + nResult = SignatureState::OK; + for (const auto& rInfo : aSigInfo) + { + if (bCertValid) + { + sal_Int32 nCertStat = rInfo.CertificateStatus; + bCertValid = nCertStat == security::CertificateValidity::VALID; + } + + if (!rInfo.SignatureIsValid) + { + nResult = SignatureState::BROKEN; + break; + } + bCompleteSignature &= !rInfo.PartialDocumentSignature; + } + + if (nResult == SignatureState::OK && !bCertValid && !bCompleteSignature) + nResult = SignatureState::NOTVALIDATED_PARTIAL_OK; + else if (nResult == SignatureState::OK && !bCertValid) + nResult = SignatureState::NOTVALIDATED; + else if (nResult == SignatureState::OK && bCertValid && !bCompleteSignature) + nResult = SignatureState::PARTIAL_OK; + + // this code must not check whether the document is modified + // it should only check the provided info + + return nResult; +} +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/sfx2/source/doc/syspath.cxx b/sfx2/source/doc/syspath.cxx new file mode 100644 index 000000000..fb949def0 --- /dev/null +++ b/sfx2/source/doc/syspath.cxx @@ -0,0 +1,37 @@ +/* -*- 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 "syspath.hxx" +#include "syspathw32.hxx" + +namespace SystemPath +{ +bool GetUserTemplateLocation(sal_Unicode* pFolder, int nSize) +{ +#ifdef _WIN32 + return ::GetUserTemplateLocation(pFolder, nSize); +#else + (void)pFolder; + (void)nSize; + return false; +#endif +} +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/syspath.hxx b/sfx2/source/doc/syspath.hxx new file mode 100644 index 000000000..9c135993c --- /dev/null +++ b/sfx2/source/doc/syspath.hxx @@ -0,0 +1,32 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_SFX2_SOURCE_DOC_SYSPATH_HXX +#define INCLUDED_SFX2_SOURCE_DOC_SYSPATH_HXX + +#include <sal/types.h> + +namespace SystemPath +{ +bool GetUserTemplateLocation(sal_Unicode*, int nSize); +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/syspathw32.cxx b/sfx2/source/doc/syspathw32.cxx new file mode 100644 index 000000000..f60f45982 --- /dev/null +++ b/sfx2/source/doc/syspathw32.cxx @@ -0,0 +1,69 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <sal/config.h> +#include <sal/types.h> +#include <o3tl/char16_t2wchar_t.hxx> + +#ifdef _WIN32 + +#undef WB_LEFT +#undef WB_RIGHT + +#include <shlobj.h> + +#include "syspathw32.hxx" + +static bool SHGetSpecialFolderW32( int nFolderID, WCHAR* pszFolder, int nSize ) +{ + LPITEMIDLIST pidl; + HRESULT hHdl = SHGetSpecialFolderLocation( nullptr, nFolderID, &pidl ); + + if( hHdl == NOERROR ) + { + WCHAR *lpFolder = static_cast< WCHAR* >( HeapAlloc( GetProcessHeap(), 0, 16000 )); + + SHGetPathFromIDListW( pidl, lpFolder ); + wcsncpy( pszFolder, lpFolder, nSize ); + + HeapFree( GetProcessHeap(), 0, lpFolder ); + IMalloc *pMalloc; + if( NOERROR == SHGetMalloc(&pMalloc) ) + { + pMalloc->Free( pidl ); + pMalloc->Release(); + } + } + return true; +} + +#endif + +bool GetUserTemplateLocation(sal_Unicode* pFolder, int nSize) +{ +#ifdef _WIN32 + return SHGetSpecialFolderW32( CSIDL_TEMPLATES, o3tl::toW(pFolder), nSize ); +#else + (void)pFolder; + (void)nSize; + return false; +#endif +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/syspathw32.hxx b/sfx2/source/doc/syspathw32.hxx new file mode 100644 index 000000000..7a06950c5 --- /dev/null +++ b/sfx2/source/doc/syspathw32.hxx @@ -0,0 +1,33 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#ifndef INCLUDED_SFX2_SOURCE_DOC_SYSPATHW32_HXX +#define INCLUDED_SFX2_SOURCE_DOC_SYSPATHW32_HXX + +#include <sal/config.h> + +#include <sal/types.h> + +#if defined _WIN32 +bool GetUserTemplateLocation(sal_Unicode*, int nSize); +#endif + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/templatedlg.cxx b/sfx2/source/doc/templatedlg.cxx new file mode 100644 index 000000000..42e570e75 --- /dev/null +++ b/sfx2/source/doc/templatedlg.cxx @@ -0,0 +1,1396 @@ +/* -*- 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/. + */ + +#include <sfx2/templatedlg.hxx> + +#include <sfx2/inputdlg.hxx> +#include <sfx2/module.hxx> + +#include <comphelper/processfactory.hxx> +#include <comphelper/propertyvalue.hxx> +#include <comphelper/string.hxx> +#include <comphelper/storagehelper.hxx> +#include <sfx2/app.hxx> +#include <sfx2/docfac.hxx> +#include <sfx2/docfilt.hxx> +#include <sfx2/fcontnr.hxx> +#include <sfx2/filedlghelper.hxx> +#include <sfx2/objsh.hxx> +#include <sfx2/sfxresid.hxx> +#include <sfx2/templatedlglocalview.hxx> +#include <templatecontaineritem.hxx> +#include <templateviewitem.hxx> +#include <sfx2/thumbnailviewitem.hxx> +#include <sot/storage.hxx> +#include <tools/urlobj.hxx> +#include <unotools/moduleoptions.hxx> +#include <unotools/pathoptions.hxx> +#include <unotools/viewoptions.hxx> +#include <vcl/event.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> + +#include <com/sun/star/beans/NamedValue.hpp> +#include <com/sun/star/beans/PropertyValue.hpp> +#include <com/sun/star/document/MacroExecMode.hpp> +#include <com/sun/star/document/UpdateDocMode.hpp> +#include <com/sun/star/embed/XStorage.hpp> +#include <com/sun/star/embed/ElementModes.hpp> +#include <com/sun/star/frame/Desktop.hpp> +#include <com/sun/star/frame/XStorable.hpp> +#include <com/sun/star/ui/dialogs/ExecutableDialogResults.hpp> +#include <com/sun/star/ui/dialogs/TemplateDescription.hpp> +#include <com/sun/star/ui/dialogs/XFolderPicker2.hpp> +#include <com/sun/star/task/InteractionHandler.hpp> +#include <comphelper/dispatchcommand.hxx> + +#include <sfx2/strings.hrc> +#include <bitmaps.hlst> + +constexpr OUStringLiteral TM_SETTING_MANAGER = u"TemplateManager"; +constexpr OUStringLiteral TM_SETTING_LASTFOLDER = u"LastFolder"; +constexpr OUStringLiteral TM_SETTING_LASTAPPLICATION = u"LastApplication"; +constexpr OUStringLiteral TM_SETTING_VIEWMODE = u"ViewMode"; + +#define MNI_ACTION_NEW_FOLDER "new" +#define MNI_ACTION_RENAME_FOLDER "rename" +#define MNI_ACTION_DELETE_FOLDER "delete" +#define MNI_ACTION_DEFAULT "default" +#define MNI_ACTION_DEFAULT_WRITER "default_writer" +#define MNI_ACTION_DEFAULT_CALC "default_calc" +#define MNI_ACTION_DEFAULT_IMPRESS "default_impress" +#define MNI_ACTION_DEFAULT_DRAW "default_draw" +#define MNI_ACTION_IMPORT "import_template" +#define MNI_ACTION_EXTENSIONS "extensions" +#define MNI_ALL_APPLICATIONS 0 +#define MNI_WRITER 1 +#define MNI_CALC 2 +#define MNI_IMPRESS 3 +#define MNI_DRAW 4 + +using namespace ::com::sun::star; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::embed; +using namespace ::com::sun::star::frame; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::ui::dialogs; +using namespace ::com::sun::star::document; + +static bool lcl_getServiceName (const OUString &rFileURL, OUString &rName ); + +static std::vector<OUString> lcl_getAllFactoryURLs (); + +namespace { + +class SearchView_Keyword +{ +public: + + SearchView_Keyword (const OUString &rKeyword, FILTER_APPLICATION App) + : maKeyword(rKeyword.toAsciiLowerCase()), meApp(App) + {} + + bool operator() (const TemplateItemProperties &rItem) + { + bool bRet = true; + + INetURLObject aUrl(rItem.aPath); + OUString aExt = aUrl.getExtension(); + + if (meApp == FILTER_APPLICATION::WRITER) + { + bRet = aExt == "ott" || aExt == "stw" || aExt == "oth" || aExt == "dot" || aExt == "dotx"; + } + else if (meApp == FILTER_APPLICATION::CALC) + { + bRet = aExt == "ots" || aExt == "stc" || aExt == "xlt" || aExt == "xltm" || aExt == "xltx"; + } + else if (meApp == FILTER_APPLICATION::IMPRESS) + { + bRet = aExt == "otp" || aExt == "sti" || aExt == "pot" || aExt == "potm" || aExt == "potx"; + } + else if (meApp == FILTER_APPLICATION::DRAW) + { + bRet = aExt == "otg" || aExt == "std"; + } + + return bRet && MatchSubstring(rItem.aName); + } + + bool MatchSubstring( OUString const & sItemName ) + { + if(maKeyword.isEmpty()) + return false; + return sItemName.toAsciiLowerCase().indexOf(maKeyword) >= 0; + } + +private: + + OUString maKeyword; + FILTER_APPLICATION meApp; +}; + +} + +/*** + * + * Order items in ascending order (useful for the selection sets and move/copy operations since the associated ids + * change when processed by the SfxDocumentTemplates class so we want to process to ones with higher id first) + * + ***/ + +static bool cmpSelectionItems (const ThumbnailViewItem *pItem1, const ThumbnailViewItem *pItem2) +{ + return pItem1->mnId > pItem2->mnId; +} + +SfxTemplateManagerDlg::SfxTemplateManagerDlg(weld::Window *pParent) + : GenericDialogController(pParent, "sfx/ui/templatedlg.ui", "TemplateDialog") + , maSelTemplates(cmpSelectionItems) + , mxDesktop(Desktop::create(comphelper::getProcessComponentContext())) + , m_aUpdateDataTimer( "SfxTemplateManagerDlg UpdateDataTimer" ) + , mxSearchFilter(m_xBuilder->weld_entry("search_filter")) + , mxCBApp(m_xBuilder->weld_combo_box("filter_application")) + , mxCBFolder(m_xBuilder->weld_combo_box("filter_folder")) + , mxOKButton(m_xBuilder->weld_button("ok")) + , mxCBXHideDlg(m_xBuilder->weld_check_button("hidedialogcb")) + , mxActionBar(m_xBuilder->weld_menu_button("action_menu")) + , mxLocalView(new TemplateDlgLocalView(m_xBuilder->weld_scrolled_window("scrolllocal", true), + m_xBuilder->weld_menu("contextmenu"), + m_xBuilder->weld_tree_view("tree_list"))) + , mxLocalViewWeld(new weld::CustomWeld(*m_xBuilder, "template_view", *mxLocalView)) + , mxListViewButton(m_xBuilder->weld_toggle_button("list_view_btn")) + , mxThumbnailViewButton(m_xBuilder->weld_toggle_button("thumbnail_view_btn")) + , mViewMode(TemplateViewMode::eThumbnailView) +{ + // Create popup menus + mxActionBar->append_item(MNI_ACTION_NEW_FOLDER, SfxResId(STR_CATEGORY_NEW), BMP_ACTION_NEW_CATEGORY); + mxActionBar->append_item(MNI_ACTION_RENAME_FOLDER, SfxResId(STR_CATEGORY_RENAME), BMP_ACTION_RENAME); + mxActionBar->append_item(MNI_ACTION_DELETE_FOLDER, SfxResId(STR_CATEGORY_DELETE), BMP_ACTION_DELETE_CATEGORY); + mxActionBar->append_separator("separator"); + mxActionBar->append_item(MNI_ACTION_DEFAULT, SfxResId(STR_ACTION_RESET_ALL_DEFAULT_TEMPLATES)); + mxActionBar->append_item(MNI_ACTION_DEFAULT_WRITER, SfxResId(STR_ACTION_RESET_WRITER_TEMPLATE), BMP_ACTION_DEFAULT_WRITER); + mxActionBar->append_item(MNI_ACTION_DEFAULT_CALC, SfxResId(STR_ACTION_RESET_CALC_TEMPLATE), BMP_ACTION_DEFAULT_CALC); + mxActionBar->append_item(MNI_ACTION_DEFAULT_IMPRESS, SfxResId(STR_ACTION_RESET_IMPRESS_TEMPLATE), BMP_ACTION_DEFAULT_IMPRESS); + mxActionBar->append_item(MNI_ACTION_DEFAULT_DRAW, SfxResId(STR_ACTION_RESET_DRAW_TEMPLATE), BMP_ACTION_DEFAULT_DRAW); + mxActionBar->append_separator("separator2"); + mxActionBar->append_item(MNI_ACTION_IMPORT, SfxResId(STR_ACTION_IMPORT), BMP_ACTION_IMPORT); + mxActionBar->append_item(MNI_ACTION_EXTENSIONS, SfxResId(STR_ACTION_EXTENSIONS), BMP_ACTION_EXTENSIONS); + + mxActionBar->connect_selected(LINK(this,SfxTemplateManagerDlg,MenuSelectHdl)); + + mxLocalView->setItemMaxTextLength(TEMPLATE_ITEM_MAX_TEXT_LENGTH); + mxLocalView->setItemDimensions(TEMPLATE_ITEM_MAX_WIDTH,TEMPLATE_ITEM_THUMBNAIL_MAX_HEIGHT, + TEMPLATE_ITEM_MAX_HEIGHT-TEMPLATE_ITEM_THUMBNAIL_MAX_HEIGHT, + TEMPLATE_ITEM_PADDING); + + mxLocalView->setItemStateHdl(LINK(this,SfxTemplateManagerDlg,TVItemStateHdl)); + mxLocalView->setCreateContextMenuHdl(LINK(this,SfxTemplateManagerDlg, CreateContextMenuHdl)); + mxLocalView->setOpenRegionHdl(LINK(this,SfxTemplateManagerDlg, OpenRegionHdl)); + mxLocalView->setOpenTemplateHdl(LINK(this,SfxTemplateManagerDlg, OpenTemplateHdl)); + mxLocalView->setEditTemplateHdl(LINK(this,SfxTemplateManagerDlg, EditTemplateHdl)); + mxLocalView->setDeleteTemplateHdl(LINK(this,SfxTemplateManagerDlg, DeleteTemplateHdl)); + mxLocalView->setDefaultTemplateHdl(LINK(this,SfxTemplateManagerDlg, DefaultTemplateHdl)); + mxLocalView->setMoveTemplateHdl(LINK(this,SfxTemplateManagerDlg, MoveTemplateHdl)); + mxLocalView->setExportTemplateHdl(LINK(this,SfxTemplateManagerDlg, ExportTemplateHdl)); + + mxLocalView->ShowTooltips(true); + + // Set width and height of the templates thumbnail viewer to acommodate 3 rows and 4 columns of items + mxLocalViewWeld->set_size_request(TEMPLATE_ITEM_MAX_WIDTH * 5, TEMPLATE_ITEM_MAX_HEIGHT_SUB * 3); + + mxOKButton->connect_clicked(LINK(this, SfxTemplateManagerDlg, OkClickHdl)); + // FIXME: rather than disabling make dispatchCommand(".uno:AdditionsDialog") work in start center + if ( !SfxModule::GetActiveModule() ) + mxActionBar->set_item_sensitive(MNI_ACTION_EXTENSIONS, false); + else + mxActionBar->set_item_sensitive(MNI_ACTION_EXTENSIONS, true); + mxListViewButton->connect_toggled(LINK(this, SfxTemplateManagerDlg, ListViewHdl)); + mxThumbnailViewButton->connect_toggled(LINK(this, SfxTemplateManagerDlg, ThumbnailViewHdl)); + + mxSearchFilter->connect_changed(LINK(this, SfxTemplateManagerDlg, SearchUpdateHdl)); + mxSearchFilter->connect_focus_in(LINK( this, SfxTemplateManagerDlg, GetFocusHdl )); + mxSearchFilter->connect_focus_out(LINK( this, SfxTemplateManagerDlg, LoseFocusHdl )); + mxSearchFilter->connect_key_press(LINK( this, SfxTemplateManagerDlg, KeyInputHdl)); + + mxActionBar->show(); + + mxLocalView->Populate(); + mxLocalView->filterItems(ViewFilter_Application(FILTER_APPLICATION::NONE)); + + mxCBApp->set_active(0); + fillFolderComboBox(); + + mxActionBar->set_item_visible(MNI_ACTION_EXTENSIONS, true); + mxActionBar->set_item_visible(MNI_ACTION_IMPORT, true); + mxActionBar->set_item_visible(MNI_ACTION_NEW_FOLDER, true); + + mxOKButton->set_label(SfxResId(STR_OPEN)); + + mxCBApp->connect_changed(LINK(this, SfxTemplateManagerDlg, SelectApplicationHdl)); + mxCBFolder->connect_changed(LINK(this, SfxTemplateManagerDlg, SelectRegionHdl)); + + mxLocalView->Show(); + + m_aUpdateDataTimer.SetInvokeHandler(LINK(this, SfxTemplateManagerDlg, ImplUpdateDataHdl)); + m_aUpdateDataTimer.SetTimeout(EDIT_UPDATEDATA_TIMEOUT); + + mxLocalView->connect_focus_rect(LINK(this, SfxTemplateManagerDlg, FocusRectLocalHdl)); + bMakeSelItemVisible = false; +} + +SfxTemplateManagerDlg::~SfxTemplateManagerDlg() +{ + writeSettings(); + + // Ignore view events since we are cleaning the object + mxLocalView->setItemStateHdl(Link<const ThumbnailViewItem*,void>()); + mxLocalView->setOpenRegionHdl(Link<void*,void>()); + mxLocalView->setOpenTemplateHdl(Link<ThumbnailViewItem*, void>()); +} + +short SfxTemplateManagerDlg::run() +{ + //use application specific settings if there's no previous setting + getApplicationSpecificSettings(); + readSettings(); + updateMenuItems(); + + return weld::GenericDialogController::run(); +} + +IMPL_LINK(SfxTemplateManagerDlg, KeyInputHdl, const KeyEvent&, rKeyEvent, bool) +{ + if (mxSearchFilter != nullptr && !mxSearchFilter->get_text().isEmpty()) + { + vcl::KeyCode aKeyCode = rKeyEvent.GetKeyCode(); + sal_uInt16 nKeyCode = aKeyCode.GetCode(); + + if ( nKeyCode == KEY_ESCAPE ) + { + mxSearchFilter->set_text(""); + SearchUpdateHdl(*mxSearchFilter); + return true; + } + } + return false; +} + +void SfxTemplateManagerDlg::setDocumentModel(const uno::Reference<frame::XModel> &rModel) +{ + m_xModel = rModel; +} + +void SfxTemplateManagerDlg::setTemplateViewMode(TemplateViewMode eViewMode) +{ + if(eViewMode == TemplateViewMode::eThumbnailView && mViewMode != TemplateViewMode::eThumbnailView) + { + mxThumbnailViewButton->set_state(TRISTATE_TRUE); + mxListViewButton->set_state(TRISTATE_FALSE); + mxLocalView->ThumbnailView::GrabFocus(); + mViewMode = eViewMode; + mxLocalView->setTemplateViewMode(eViewMode); + mxLocalView->Show(); + } + if(eViewMode == TemplateViewMode::eListView && mViewMode != TemplateViewMode::eListView) + { + mxListViewButton->set_state(TRISTATE_TRUE); + mxThumbnailViewButton->set_state(TRISTATE_FALSE); + mxLocalView->ListView::grab_focus(); + mViewMode = eViewMode; + mxLocalView->setTemplateViewMode(eViewMode); + mxLocalView->Show(); + } +} + +TemplateViewMode SfxTemplateManagerDlg::getTemplateViewMode() const +{ + return mViewMode; +} + + +FILTER_APPLICATION SfxTemplateManagerDlg::getCurrentApplicationFilter() const +{ + const sal_Int16 nCurAppId = mxCBApp->get_active(); + + if (nCurAppId == MNI_WRITER) + return FILTER_APPLICATION::WRITER; + else if (nCurAppId == MNI_IMPRESS) + return FILTER_APPLICATION::IMPRESS; + else if (nCurAppId == MNI_CALC) + return FILTER_APPLICATION::CALC; + else if (nCurAppId == MNI_DRAW) + return FILTER_APPLICATION::DRAW; + + return FILTER_APPLICATION::NONE; +} + +void SfxTemplateManagerDlg::fillFolderComboBox() +{ + std::vector<OUString> aFolderNames = mxLocalView->getFolderNames(); + + for (size_t i = 0, n = aFolderNames.size(); i < n; ++i) + mxCBFolder->append_text(aFolderNames[i]); + mxCBFolder->set_active(0); + mxActionBar->set_item_sensitive(MNI_ACTION_RENAME_FOLDER, false); + mxActionBar->set_item_sensitive(MNI_ACTION_DELETE_FOLDER, false); +} + +void SfxTemplateManagerDlg::getApplicationSpecificSettings() +{ + if ( ! m_xModel.is() ) + { + mxCBApp->set_active(0); + mxCBFolder->set_active(0); + mxActionBar->set_item_sensitive(MNI_ACTION_RENAME_FOLDER, false); + mxActionBar->set_item_sensitive(MNI_ACTION_DELETE_FOLDER, false); + mxLocalView->filterItems(ViewFilter_Application(getCurrentApplicationFilter())); + mxLocalView->showAllTemplates(); + return; + } + + SvtModuleOptions::EFactory eFactory = SvtModuleOptions::ClassifyFactoryByModel(m_xModel); + + switch(eFactory) + { + case SvtModuleOptions::EFactory::WRITER: + case SvtModuleOptions::EFactory::WRITERWEB: + case SvtModuleOptions::EFactory::WRITERGLOBAL: + mxCBApp->set_active(MNI_WRITER); + break; + case SvtModuleOptions::EFactory::CALC: + mxCBApp->set_active(MNI_CALC); + break; + case SvtModuleOptions::EFactory::IMPRESS: + mxCBApp->set_active(MNI_IMPRESS); + break; + case SvtModuleOptions::EFactory::DRAW: + mxCBApp->set_active(MNI_DRAW); + break; + default: + mxCBApp->set_active(0); + break; + } + + mxLocalView->filterItems(ViewFilter_Application(getCurrentApplicationFilter())); + mxCBFolder->set_active(0); + mxActionBar->set_item_sensitive(MNI_ACTION_RENAME_FOLDER, false); + mxActionBar->set_item_sensitive(MNI_ACTION_DELETE_FOLDER, false); + mxLocalView->showAllTemplates(); +} + +void SfxTemplateManagerDlg::readSettings () +{ + OUString aLastFolder; + SvtViewOptions aViewSettings( EViewType::Dialog, TM_SETTING_MANAGER ); + sal_Int16 nViewMode = -1; + + if ( aViewSettings.Exists() ) + { + sal_uInt16 nTmp = 0; + aViewSettings.GetUserItem(TM_SETTING_LASTFOLDER) >>= aLastFolder; + aViewSettings.GetUserItem(TM_SETTING_LASTAPPLICATION) >>= nTmp; + aViewSettings.GetUserItem(TM_SETTING_VIEWMODE) >>= nViewMode; + + //open last remembered application only when application model is not set + if(!m_xModel.is()) + { + switch (nTmp) + { + case MNI_WRITER: + mxCBApp->set_active(MNI_WRITER); + break; + case MNI_CALC: + mxCBApp->set_active(MNI_CALC); + break; + case MNI_IMPRESS: + mxCBApp->set_active(MNI_IMPRESS); + break; + case MNI_DRAW: + mxCBApp->set_active(MNI_DRAW); + break; + default: + mxCBApp->set_active(0); + break; + } + } + } + + mxLocalView->filterItems(ViewFilter_Application(getCurrentApplicationFilter())); + + if (aLastFolder.isEmpty()) + { + //show all categories + mxCBFolder->set_active(0); + mxActionBar->set_item_sensitive(MNI_ACTION_RENAME_FOLDER, false); + mxActionBar->set_item_sensitive(MNI_ACTION_DELETE_FOLDER, false); + mxLocalView->showAllTemplates(); + } + else + { + mxCBFolder->set_active_text(aLastFolder); + mxLocalView->showRegion(aLastFolder); + bool bIsBuiltInRegion = mxLocalView->IsBuiltInRegion(aLastFolder); + mxActionBar->set_item_sensitive(MNI_ACTION_RENAME_FOLDER, !bIsBuiltInRegion); + mxActionBar->set_item_sensitive(MNI_ACTION_DELETE_FOLDER, !bIsBuiltInRegion); + } + + if(nViewMode == static_cast<sal_Int16>(TemplateViewMode::eListView) || + nViewMode == static_cast<sal_Int16>(TemplateViewMode::eThumbnailView)) + { + TemplateViewMode eViewMode = static_cast<TemplateViewMode>(nViewMode); + setTemplateViewMode(eViewMode); + } + else + { + //Default ViewMode + setTemplateViewMode(TemplateViewMode::eThumbnailView); + } +} + +void SfxTemplateManagerDlg::writeSettings () +{ + OUString aLastFolder; + + if (mxLocalView->getCurRegionId()) + aLastFolder = mxLocalView->getRegionName(mxLocalView->getCurRegionId()-1); + + // last folder + Sequence< NamedValue > aSettings + { + { TM_SETTING_LASTFOLDER, css::uno::Any(aLastFolder) }, + { TM_SETTING_LASTAPPLICATION, css::uno::Any(sal_uInt16(mxCBApp->get_active())) }, + { TM_SETTING_VIEWMODE, css::uno::Any(static_cast<sal_Int16>(getTemplateViewMode()))} + }; + + // write + SvtViewOptions aViewSettings(EViewType::Dialog, TM_SETTING_MANAGER); + aViewSettings.SetUserData(aSettings); +} + +IMPL_LINK_NOARG(SfxTemplateManagerDlg, SelectApplicationHdl, weld::ComboBox&, void) +{ + mxLocalView->filterItems(ViewFilter_Application(getCurrentApplicationFilter())); + SelectRegionHdl(*mxCBFolder); + updateMenuItems(); +} + +IMPL_LINK_NOARG(SfxTemplateManagerDlg, SelectRegionHdl, weld::ComboBox&, void) +{ + const OUString sSelectedRegion = mxCBFolder->get_active_text(); + + if(mxCBFolder->get_active() == 0) + { + mxActionBar->set_item_sensitive(MNI_ACTION_RENAME_FOLDER, false); + mxActionBar->set_item_sensitive(MNI_ACTION_DELETE_FOLDER, false); + } + else + { + bool bIsBuiltInRegion = mxLocalView->IsBuiltInRegion(sSelectedRegion); + mxActionBar->set_item_sensitive(MNI_ACTION_RENAME_FOLDER, !bIsBuiltInRegion); + mxActionBar->set_item_sensitive(MNI_ACTION_DELETE_FOLDER, !bIsBuiltInRegion); + } + SearchUpdate(); +} + +IMPL_LINK(SfxTemplateManagerDlg, TVItemStateHdl, const ThumbnailViewItem*, pItem, void) +{ + const TemplateViewItem *pViewItem = dynamic_cast<const TemplateViewItem*>(pItem); + + if (pViewItem) + OnTemplateState(pItem); +} + +IMPL_LINK(SfxTemplateManagerDlg, MenuSelectHdl, const OString&, rIdent, void) +{ + if (rIdent == MNI_ACTION_NEW_FOLDER) + OnCategoryNew(); + else if (rIdent == MNI_ACTION_RENAME_FOLDER) + OnCategoryRename(); + else if (rIdent == MNI_ACTION_DELETE_FOLDER) + OnCategoryDelete(); + else if (rIdent == MNI_ACTION_DEFAULT) + { + DefaultTemplateMenuSelectHdl(MNI_ACTION_DEFAULT_WRITER); + DefaultTemplateMenuSelectHdl(MNI_ACTION_DEFAULT_CALC); + DefaultTemplateMenuSelectHdl(MNI_ACTION_DEFAULT_IMPRESS); + DefaultTemplateMenuSelectHdl(MNI_ACTION_DEFAULT_DRAW); + } + else if(rIdent == MNI_ACTION_DEFAULT_WRITER || rIdent == MNI_ACTION_DEFAULT_CALC || + rIdent == MNI_ACTION_DEFAULT_IMPRESS || rIdent == MNI_ACTION_DEFAULT_DRAW ) + DefaultTemplateMenuSelectHdl(rIdent); + else if(rIdent == MNI_ACTION_IMPORT) + ImportActionHdl(); + else if(rIdent == MNI_ACTION_EXTENSIONS) + ExtensionsActionHdl(); +} + +void SfxTemplateManagerDlg::DefaultTemplateMenuSelectHdl(std::string_view rIdent) +{ + SvtModuleOptions aModOpt; + OUString aFactoryURL; + if (rIdent == MNI_ACTION_DEFAULT_WRITER) + aFactoryURL = aModOpt.GetFactoryEmptyDocumentURL( SvtModuleOptions::EFactory::WRITER); + else if (rIdent == MNI_ACTION_DEFAULT_CALC) + aFactoryURL = aModOpt.GetFactoryEmptyDocumentURL( SvtModuleOptions::EFactory::CALC); + else if (rIdent == MNI_ACTION_DEFAULT_IMPRESS) + aFactoryURL = aModOpt.GetFactoryEmptyDocumentURL( SvtModuleOptions::EFactory::IMPRESS); + else if (rIdent == MNI_ACTION_DEFAULT_DRAW) + aFactoryURL = aModOpt.GetFactoryEmptyDocumentURL( SvtModuleOptions::EFactory::DRAW); + else + return; + + OUString aServiceName = SfxObjectShell::GetServiceNameFromFactory(aFactoryURL); + OUString sPrevDefault = SfxObjectFactory::GetStandardTemplate( aServiceName ); + if(!sPrevDefault.isEmpty()) + { + mxLocalView->RemoveDefaultTemplateIcon(sPrevDefault); + } + + SfxObjectFactory::SetStandardTemplate( aServiceName, OUString() ); + mxLocalView->refreshDefaultColumn(); + updateMenuItems(); +} + +IMPL_LINK_NOARG(SfxTemplateManagerDlg, OkClickHdl, weld::Button&, void) +{ + OnTemplateOpen(); + m_xDialog->response(RET_OK); +} + +IMPL_LINK_NOARG(SfxTemplateManagerDlg, MoveTemplateHdl, void*, void) +{ + // modal dialog to select templates category + SfxTemplateCategoryDialog aDlg(m_xDialog.get()); + aDlg.SetCategoryLBEntries(mxLocalView->getFolderNames()); + + size_t nItemId = 0; + + if (aDlg.run() != RET_OK) + return; + + const OUString& sCategory = aDlg.GetSelectedCategory(); + bool bIsNewCategory = aDlg.IsNewCategoryCreated(); + if(bIsNewCategory) + { + if (!sCategory.isEmpty()) + { + nItemId = mxLocalView->createRegion(sCategory); + if(nItemId) + mxCBFolder->append_text(sCategory); + } + } + else + nItemId = mxLocalView->getRegionId(sCategory); + + if(nItemId) + { + localMoveTo(nItemId); + } + + mxLocalView->reload(); + SearchUpdate(); +} +IMPL_LINK_NOARG(SfxTemplateManagerDlg, ExportTemplateHdl, void*, void) +{ + OnTemplateExport(); +} + +void SfxTemplateManagerDlg::ImportActionHdl() +{ + if(mxCBFolder->get_active() == 0) + { + //Modal Dialog to select Category + SfxTemplateCategoryDialog aDlg(m_xDialog.get()); + aDlg.SetCategoryLBEntries(mxLocalView->getFolderNames()); + + if (aDlg.run() == RET_OK) + { + const OUString& sCategory = aDlg.GetSelectedCategory(); + bool bIsNewCategory = aDlg.IsNewCategoryCreated(); + if(bIsNewCategory) + { + if(mxLocalView->createRegion(sCategory)) + { + mxCBFolder->append_text(sCategory); + OnTemplateImportCategory(sCategory); + } + else + { + OUString aMsg( SfxResId(STR_CREATE_ERROR) ); + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Warning, VclButtonsType::Ok, + aMsg.replaceFirst("$1", sCategory))); + xBox->run(); + return; + } + } + else + OnTemplateImportCategory(sCategory); + } + } + else + { + const auto sCategory = mxCBFolder->get_active_text(); + OnTemplateImportCategory(sCategory); + } + mxLocalView->reload(); + SearchUpdate(); +} + +void SfxTemplateManagerDlg::ExtensionsActionHdl() +{ + uno::Sequence<beans::PropertyValue> aArgs{ comphelper::makePropertyValue( + "AdditionsTag", OUString("Templates")) }; + comphelper::dispatchCommand(".uno:AdditionsDialog", aArgs); +} + +IMPL_LINK_NOARG(SfxTemplateManagerDlg, OpenRegionHdl, void*, void) +{ + maSelTemplates.clear(); + mxOKButton->set_sensitive(false); + mxActionBar->show(); +} + +IMPL_LINK(SfxTemplateManagerDlg, CreateContextMenuHdl, ThumbnailViewItem*, pItem, void) +{ + const TemplateViewItem *pViewItem = dynamic_cast<TemplateViewItem*>(pItem); + bool bIsDefault = false; + bool bIsInternal = false; + std::vector<const TemplateViewItem*> aSelTemplates; + for(const auto& aSelTmpl : maSelTemplates) + { + const TemplateViewItem *aItem = dynamic_cast<const TemplateViewItem*>(aSelTmpl); + aSelTemplates.push_back(aItem); + } + + for(const auto& aSelTmpl : aSelTemplates) + { + if(aSelTmpl->IsDefaultTemplate()) + bIsDefault = true; + if(TemplateLocalView::IsInternalTemplate(aSelTmpl->getPath())) + { + bIsInternal = true; + if(bIsDefault) + break; + } + } + + if (!pViewItem) + return; + + bool bIsSingleSel = maSelTemplates.size() == 1; + OUString aDefaultImg; + INetURLObject aUrl(pViewItem->getPath()); + if (ViewFilter_Application::isFilteredExtension(FILTER_APPLICATION::WRITER, aUrl.getExtension())) + aDefaultImg = BMP_ACTION_DEFAULT_WRITER; + else if (ViewFilter_Application::isFilteredExtension(FILTER_APPLICATION::CALC, aUrl.getExtension())) + aDefaultImg = BMP_ACTION_DEFAULT_CALC; + else if (ViewFilter_Application::isFilteredExtension(FILTER_APPLICATION::IMPRESS, aUrl.getExtension())) + aDefaultImg = BMP_ACTION_DEFAULT_IMPRESS; + else if (ViewFilter_Application::isFilteredExtension(FILTER_APPLICATION::DRAW, aUrl.getExtension())) + aDefaultImg = BMP_ACTION_DEFAULT_DRAW; + mxLocalView->createContextMenu(bIsDefault, bIsInternal, bIsSingleSel, aDefaultImg); +} + +IMPL_LINK(SfxTemplateManagerDlg, OpenTemplateHdl, ThumbnailViewItem*, pItem, void) +{ + uno::Sequence< PropertyValue > aArgs{ + comphelper::makePropertyValue("AsTemplate", true), + comphelper::makePropertyValue("MacroExecutionMode", MacroExecMode::USE_CONFIG), + comphelper::makePropertyValue("UpdateDocMode", UpdateDocMode::ACCORDING_TO_CONFIG), + comphelper::makePropertyValue("InteractionHandler", task::InteractionHandler::createWithParent( ::comphelper::getProcessComponentContext(), nullptr )), + comphelper::makePropertyValue("ReadOnly", true) + }; + + TemplateViewItem *pTemplateItem = static_cast<TemplateViewItem*>(pItem); + + try + { + mxDesktop->loadComponentFromURL(pTemplateItem->getPath(),"_default", 0, aArgs ); + } + catch( const uno::Exception& ) + { + } + + m_xDialog->response(RET_OK); +} + +IMPL_LINK(SfxTemplateManagerDlg, EditTemplateHdl, ThumbnailViewItem*, pItem, void) +{ + uno::Sequence< PropertyValue > aArgs{ + comphelper::makePropertyValue("AsTemplate", false), + comphelper::makePropertyValue("MacroExecutionMode", MacroExecMode::USE_CONFIG), + comphelper::makePropertyValue("UpdateDocMode", UpdateDocMode::ACCORDING_TO_CONFIG) + }; + + uno::Reference< XStorable > xStorable; + TemplateViewItem *pViewItem = static_cast<TemplateViewItem*>(pItem); + + try + { + xStorable.set( mxDesktop->loadComponentFromURL(pViewItem->getPath(),"_default", 0, aArgs ), + uno::UNO_QUERY ); + } + catch( const uno::Exception& ) + { + } + + m_xDialog->response(RET_OK); +} + +IMPL_LINK_NOARG(SfxTemplateManagerDlg, DeleteTemplateHdl, void*, void) +{ + std::set<const ThumbnailViewItem*,selection_cmp_fn> aSelTemplates = maSelTemplates; + OUString aDeletedTemplate; + + for (auto const& pItem : aSelTemplates) + { + const TemplateViewItem *pViewItem = static_cast<const TemplateViewItem*>(pItem); + sal_uInt16 nRegionItemId = mxLocalView->getRegionId(pViewItem->mnRegionId); + + if (!mxLocalView->removeTemplate(pViewItem->mnDocId + 1, nRegionItemId))//mnId w.r.t. region is mnDocId + 1; + { + aDeletedTemplate += pItem->maTitle+"\n"; + } + } + + if (!aDeletedTemplate.isEmpty()) + { + OUString aMsg( SfxResId(STR_MSG_ERROR_DELETE_TEMPLATE) ); + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Warning, VclButtonsType::Ok, + aMsg.replaceFirst("$1",aDeletedTemplate))); + xBox->run(); + } +} + +IMPL_LINK(SfxTemplateManagerDlg, DefaultTemplateHdl, ThumbnailViewItem*, pItem, void) +{ + TemplateViewItem *pViewItem = static_cast<TemplateViewItem*>(pItem); + OUString aServiceName; + + if(!pViewItem->IsDefaultTemplate()) + { + if (lcl_getServiceName(pViewItem->getPath(),aServiceName)) + { + OUString sPrevDefault = SfxObjectFactory::GetStandardTemplate( aServiceName ); + if(!sPrevDefault.isEmpty()) + { + mxLocalView->RemoveDefaultTemplateIcon(sPrevDefault); + } + SfxObjectFactory::SetStandardTemplate(aServiceName,pViewItem->getPath()); + pViewItem->showDefaultIcon(true); + } + } + else + { + if(lcl_getServiceName(pViewItem->getPath(),aServiceName)) + { + SfxObjectFactory::SetStandardTemplate( aServiceName, OUString() ); + pViewItem->showDefaultIcon(false); + } + } + + updateMenuItems(); +} + +IMPL_LINK_NOARG(SfxTemplateManagerDlg, SearchUpdateHdl, weld::Entry&, void) +{ + m_aUpdateDataTimer.Start(); +} + +IMPL_LINK_NOARG(SfxTemplateManagerDlg, ImplUpdateDataHdl, Timer*, void) +{ + SearchUpdate(); +} + +IMPL_LINK_NOARG(SfxTemplateManagerDlg, LoseFocusHdl, weld::Widget&, void) +{ + if (m_aUpdateDataTimer.IsActive()) + { + m_aUpdateDataTimer.Stop(); + m_aUpdateDataTimer.Invoke(); + } +} + +IMPL_LINK_NOARG ( SfxTemplateManagerDlg, ListViewHdl, weld::Toggleable&, void ) +{ + setTemplateViewMode(TemplateViewMode::eListView); +} + +IMPL_LINK_NOARG ( SfxTemplateManagerDlg, ThumbnailViewHdl, weld::Toggleable&, void ) +{ + setTemplateViewMode(TemplateViewMode::eThumbnailView); + bMakeSelItemVisible = true; +} + +IMPL_LINK_NOARG(SfxTemplateManagerDlg, FocusRectLocalHdl, weld::Widget&, tools::Rectangle) +{ + if(bMakeSelItemVisible && !maSelTemplates.empty()) + mxLocalView->MakeItemVisible((*maSelTemplates.begin())->mnId); + bMakeSelItemVisible = false; + return tools::Rectangle(); +} + +void SfxTemplateManagerDlg::SearchUpdate() +{ + const OUString sSelectedRegion = mxCBFolder->get_active_text(); + mxLocalView->setCurRegionId(mxLocalView->getRegionId(sSelectedRegion)); + OUString aKeyword = mxSearchFilter->get_text(); + mxLocalView->Clear(); + std::function<bool(const TemplateItemProperties &)> aFunc = + [&](const TemplateItemProperties &rItem)->bool + { + return aKeyword.isEmpty() || SearchView_Keyword(aKeyword, getCurrentApplicationFilter())(rItem); + }; + + std::vector<TemplateItemProperties> aItems = mxLocalView->getFilteredItems(aFunc); + mxLocalView->insertItems(aItems, mxCBFolder->get_active()!=0, true); + mxLocalView->Invalidate(); +} + +IMPL_LINK_NOARG(SfxTemplateManagerDlg, GetFocusHdl, weld::Widget&, void) +{ + mxLocalView->deselectItems(); + maSelTemplates.clear(); +} + +void SfxTemplateManagerDlg::OnTemplateState (const ThumbnailViewItem *pItem) +{ + bool bInSelection = maSelTemplates.find(pItem) != maSelTemplates.end(); + + if (pItem->isSelected()) + { + if (maSelTemplates.empty()) + { + mxOKButton->set_sensitive(true); + } + else if (maSelTemplates.size() != 1 || !bInSelection) + { + mxOKButton->set_sensitive(false); + } + + if (!bInSelection) + maSelTemplates.insert(pItem); + } + else + { + if (bInSelection) + { + maSelTemplates.erase(pItem); + + if (maSelTemplates.empty()) + { + mxOKButton->set_sensitive(false); + } + else if (maSelTemplates.size() == 1) + { + mxOKButton->set_sensitive(true); + } + } + } + +} + +void SfxTemplateManagerDlg::OnTemplateImportCategory(std::u16string_view sCategory) +{ + sfx2::FileDialogHelper aFileDlg(css::ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE, + FileDialogFlags::MultiSelection, m_xDialog.get()); + aFileDlg.SetContext(sfx2::FileDialogHelper::TemplateImport); + + // add "All" filter + aFileDlg.AddFilter( SfxResId(STR_SFX_FILTERNAME_ALL), + FILEDIALOG_FILTER_ALL ); + + // add template filter + OUString sFilterExt; + OUString sFilterName( SfxResId( STR_TEMPLATE_FILTER ) ); + + // add filters of modules which are installed + SvtModuleOptions aModuleOpt; + if ( aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::WRITER ) ) + sFilterExt += "*.ott;*.stw;*.oth;*.dotx;*.dot"; + + if ( aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::CALC ) ) + { + if ( !sFilterExt.isEmpty() ) + sFilterExt += ";"; + + sFilterExt += "*.ots;*.stc;*.xltx;*.xlt"; + } + + if ( aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::IMPRESS ) ) + { + if ( !sFilterExt.isEmpty() ) + sFilterExt += ";"; + + sFilterExt += "*.otp;*.sti;*.pot;*.potx"; + } + + if ( aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::DRAW ) ) + { + if ( !sFilterExt.isEmpty() ) + sFilterExt += ";"; + + sFilterExt += "*.otg;*.std"; + } + + if ( !sFilterExt.isEmpty() ) + sFilterExt += ";"; + + sFilterExt += "*.vor"; + + sFilterName += " (" + sFilterExt + ")"; + + aFileDlg.AddFilter( sFilterName, sFilterExt ); + aFileDlg.SetCurrentFilter( sFilterName ); + + ErrCode nCode = aFileDlg.Execute(); + + if ( nCode != ERRCODE_NONE ) + return; + + const css::uno::Sequence<OUString> aFiles = aFileDlg.GetSelectedFiles(); + + if (!aFiles.hasElements()) + return; + + //Import to the selected regions + TemplateContainerItem* pContItem = mxLocalView->getRegion(sCategory); + if(!pContItem) + return; + + OUString aTemplateList; + + for (const auto& rFile : aFiles) + { + if(!mxLocalView->copyFrom(pContItem, rFile)) + { + if (aTemplateList.isEmpty()) + aTemplateList = rFile; + else + aTemplateList += "\n" + rFile; + } + } + + if (!aTemplateList.isEmpty()) + { + OUString aMsg(SfxResId(STR_MSG_ERROR_IMPORT)); + aMsg = aMsg.replaceFirst("$1",pContItem->maTitle); + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Warning, VclButtonsType::Ok, + aMsg.replaceFirst("$2",aTemplateList))); + xBox->run(); + } +} + +void SfxTemplateManagerDlg::OnTemplateExport() +{ + uno::Reference<XComponentContext> xContext(comphelper::getProcessComponentContext()); + uno::Reference<XFolderPicker2> xFolderPicker = sfx2::createFolderPicker(xContext, m_xDialog.get()); + + xFolderPicker->setDisplayDirectory(SvtPathOptions().GetWorkPath()); + + sal_Int16 nResult = xFolderPicker->execute(); + sal_Int16 nCount = maSelTemplates.size(); + + if( nResult != ExecutableDialogResults::OK ) + return; + + OUString aTemplateList; + INetURLObject aPathObj(xFolderPicker->getDirectory()); + aPathObj.setFinalSlash(); + + // export templates from the current view + + sal_uInt16 i = 1; + auto aSelTemplates = maSelTemplates; + for (auto const& selTemplate : aSelTemplates) + { + const TemplateViewItem *pItem = static_cast<const TemplateViewItem*>(selTemplate); + + INetURLObject aItemPath(pItem->getPath()); + + if ( 1 == i ) + aPathObj.Append(aItemPath.getName()); + else + aPathObj.setName(aItemPath.getName()); + + OUString aPath = aPathObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ); + + if (!mxLocalView->exportTo(pItem->mnDocId + 1, //mnId w.r.t. region = mDocId + 1 + mxLocalView->getRegionId(pItem->mnRegionId), //pItem->mnRegionId does not store actual region Id + aPath)) + { + if (aTemplateList.isEmpty()) + aTemplateList = pItem->maTitle; + else + aTemplateList += "\n" + pItem->maTitle; + } + ++i; + mxLocalView->deselectItems(); + } + + if (!aTemplateList.isEmpty()) + { + OUString aText( SfxResId(STR_MSG_ERROR_EXPORT) ); + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Warning, VclButtonsType::Ok, + aText.replaceFirst("$1",aTemplateList))); + xBox->run(); + } + else + { + OUString sText( SfxResId(STR_MSG_EXPORT_SUCCESS) ); + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Info, VclButtonsType::Ok, + sText.replaceFirst("$1", OUString::number(nCount)))); + xBox->run(); + } +} + +void SfxTemplateManagerDlg::OnTemplateOpen () +{ + ThumbnailViewItem *pItem = const_cast<ThumbnailViewItem*>(*maSelTemplates.begin()); + + OpenTemplateHdl(pItem); +} + +void SfxTemplateManagerDlg::OnCategoryNew() +{ + InputDialog dlg(m_xDialog.get(), SfxResId(STR_INPUT_NEW)); + dlg.set_title(SfxResId(STR_WINDOW_TITLE_RENAME_NEW_CATEGORY)); + int ret = dlg.run(); + + if (!ret) + return; + + OUString aName = dlg.GetEntryText(); + + if(mxLocalView->createRegion(aName)) + mxCBFolder->append_text(aName); + else + { + OUString aMsg( SfxResId(STR_CREATE_ERROR) ); + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Warning, VclButtonsType::Ok, + aMsg.replaceFirst("$1", aName))); + xBox->run(); + } +} + +void SfxTemplateManagerDlg::OnCategoryRename() +{ + OUString sCategory = mxCBFolder->get_active_text(); + InputDialog dlg(m_xDialog.get(), SfxResId(STR_INPUT_NEW)); + dlg.set_title(SfxResId(STR_WINDOW_TITLE_RENAME_CATEGORY)); + dlg.SetEntryText(sCategory); + int ret = dlg.run(); + + if (!ret) + return; + + OUString aName = dlg.GetEntryText(); + + if(mxLocalView->renameRegion(sCategory, aName)) + { + sal_Int32 nPos = mxCBFolder->find_text(sCategory); + mxCBFolder->remove(nPos); + mxCBFolder->insert_text(nPos, aName); + mxCBFolder->set_active(nPos); + + mxLocalView->reload(); + SearchUpdate(); + } + else + { + OUString aMsg( SfxResId(STR_CREATE_ERROR) ); + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Warning, VclButtonsType::Ok, + aMsg.replaceFirst("$1", aName))); + xBox->run(); + } +} + +void SfxTemplateManagerDlg::OnCategoryDelete() +{ + const auto sCategory = mxCBFolder->get_active_text(); + std::unique_ptr<weld::MessageDialog> popupDlg(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Question, VclButtonsType::YesNo, + SfxResId(STR_QMSG_SEL_FOLDER_DELETE).replaceFirst("$1",sCategory))); + if (popupDlg->run() != RET_YES) + return; + + sal_Int16 nItemId = mxLocalView->getRegionId(sCategory); + + if (!mxLocalView->removeRegion(nItemId)) + { + OUString sMsg( SfxResId(STR_MSG_ERROR_DELETE_FOLDER) ); + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Warning, VclButtonsType::Ok, + sMsg.replaceFirst("$1",sCategory))); + xBox->run(); + } + else + { + mxCBFolder->remove_text(sCategory); + } + + mxLocalView->reload(); + mxLocalView->showAllTemplates(); + mxCBApp->set_active(0); + mxCBFolder->set_active(0); + SearchUpdate(); + mxActionBar->set_item_sensitive(MNI_ACTION_RENAME_FOLDER, false); + mxActionBar->set_item_sensitive(MNI_ACTION_DELETE_FOLDER, false); + updateMenuItems(); +} + +void SfxTemplateManagerDlg::updateMenuItems () +{ + + mxActionBar->set_item_visible(MNI_ACTION_DEFAULT, false); + mxActionBar->set_item_visible(MNI_ACTION_DEFAULT_WRITER, false); + mxActionBar->set_item_visible(MNI_ACTION_DEFAULT_CALC, false); + mxActionBar->set_item_visible(MNI_ACTION_DEFAULT_IMPRESS, false); + mxActionBar->set_item_visible(MNI_ACTION_DEFAULT_DRAW, false); + mxActionBar->set_item_sensitive(MNI_ACTION_DEFAULT, false); + mxActionBar->set_item_sensitive(MNI_ACTION_DEFAULT_WRITER, false); + mxActionBar->set_item_sensitive(MNI_ACTION_DEFAULT_CALC, false); + mxActionBar->set_item_sensitive(MNI_ACTION_DEFAULT_IMPRESS, false); + mxActionBar->set_item_sensitive(MNI_ACTION_DEFAULT_DRAW, false); + + SvtModuleOptions aModOpt; + if( mxCBApp->get_active() == MNI_WRITER) + { + mxActionBar->set_item_visible(MNI_ACTION_DEFAULT_WRITER, true); + if(!aModOpt.GetFactoryStandardTemplate( SvtModuleOptions::EFactory::WRITER).isEmpty()) + mxActionBar->set_item_sensitive(MNI_ACTION_DEFAULT_WRITER, true); + } + else if( mxCBApp->get_active() == MNI_CALC ) + { + mxActionBar->set_item_visible(MNI_ACTION_DEFAULT_CALC, true); + if(!aModOpt.GetFactoryStandardTemplate( SvtModuleOptions::EFactory::CALC).isEmpty()) + mxActionBar->set_item_sensitive(MNI_ACTION_DEFAULT_CALC, true); + } + else if(mxCBApp->get_active() == MNI_IMPRESS) + { + mxActionBar->set_item_visible(MNI_ACTION_DEFAULT_IMPRESS, true); + if(!aModOpt.GetFactoryStandardTemplate( SvtModuleOptions::EFactory::IMPRESS).isEmpty()) + mxActionBar->set_item_sensitive(MNI_ACTION_DEFAULT_IMPRESS, true); + } + else if(mxCBApp->get_active() == MNI_DRAW) + { + mxActionBar->set_item_visible(MNI_ACTION_DEFAULT_DRAW, true); + if(!aModOpt.GetFactoryStandardTemplate( SvtModuleOptions::EFactory::DRAW).isEmpty()) + mxActionBar->set_item_sensitive(MNI_ACTION_DEFAULT_DRAW, true); + } + else if(mxCBApp->get_active() == MNI_ALL_APPLICATIONS) + { + mxActionBar->set_item_visible(MNI_ACTION_DEFAULT, true); + if(!lcl_getAllFactoryURLs().empty()) + mxActionBar->set_item_sensitive(MNI_ACTION_DEFAULT, true); + } +} + +void SfxTemplateManagerDlg::localMoveTo(sal_uInt16 nItemId) +{ + if (nItemId) + { + // Move templates to desired folder if for some reason move fails + // try copying them. + mxLocalView->moveTemplates(maSelTemplates,nItemId); + } +} + +static bool lcl_getServiceName ( const OUString &rFileURL, OUString &rName ) +{ + bool bRet = false; + + if ( !rFileURL.isEmpty() ) + { + try + { + uno::Reference< embed::XStorage > xStorage = + comphelper::OStorageHelper::GetStorageFromURL( rFileURL, embed::ElementModes::READ ); + + SotClipboardFormatId nFormat = SotStorage::GetFormatID( xStorage ); + + std::shared_ptr<const SfxFilter> pFilter = SfxGetpApp()->GetFilterMatcher().GetFilter4ClipBoardId( nFormat ); + + if ( pFilter ) + { + rName = pFilter->GetServiceName(); + bRet = true; + } + } + catch( uno::Exception& ) + {} + } + + return bRet; +} + +static std::vector<OUString> lcl_getAllFactoryURLs () +{ + SvtModuleOptions aModOpt; + std::vector<OUString> aList; + const css::uno::Sequence<OUString> &aServiceNames = aModOpt.GetAllServiceNames(); + + for( const auto& rServiceName : aServiceNames ) + { + if ( ! SfxObjectFactory::GetStandardTemplate( rServiceName ).isEmpty() ) + { + SvtModuleOptions::EFactory eFac = SvtModuleOptions::EFactory::WRITER; + SvtModuleOptions::ClassifyFactoryByName( rServiceName, eFac ); + aList.push_back(aModOpt.GetFactoryEmptyDocumentURL(eFac)); + } + } + + return aList; +} + + +// Class SfxTemplateCategoryDialog -------------------------------------------------- + +SfxTemplateCategoryDialog::SfxTemplateCategoryDialog(weld::Window* pParent) + : GenericDialogController(pParent, "sfx/ui/templatecategorydlg.ui", "TemplatesCategoryDialog") + , mbIsNewCategory(false) + , mxLBCategory(m_xBuilder->weld_tree_view("categorylb")) + , mxSelectLabel(m_xBuilder->weld_label("select_label")) + , mxNewCategoryEdit(m_xBuilder->weld_entry("category_entry")) + , mxCreateLabel(m_xBuilder->weld_label("create_label")) + , mxOKButton(m_xBuilder->weld_button("ok")) +{ + mxLBCategory->append_text(SfxResId(STR_CATEGORY_NONE)); + mxNewCategoryEdit->connect_changed(LINK(this, SfxTemplateCategoryDialog, NewCategoryEditHdl)); + mxLBCategory->set_size_request(mxLBCategory->get_approximate_digit_width() * 32, + mxLBCategory->get_height_rows(8)); + mxLBCategory->connect_changed(LINK(this, SfxTemplateCategoryDialog, SelectCategoryHdl)); + mxOKButton->set_sensitive(false); +} + +SfxTemplateCategoryDialog::~SfxTemplateCategoryDialog() +{ +} + +IMPL_LINK_NOARG(SfxTemplateCategoryDialog, NewCategoryEditHdl, weld::Entry&, void) +{ + OUString sParam = comphelper::string::strip(mxNewCategoryEdit->get_text(), ' '); + mxLBCategory->set_sensitive(sParam.isEmpty()); + if(!sParam.isEmpty()) + { + msSelectedCategory = sParam; + mbIsNewCategory = true; + mxOKButton->set_sensitive(true); + } + else + { + SelectCategoryHdl(*mxLBCategory); + mbIsNewCategory = false; + } +} + +IMPL_LINK_NOARG(SfxTemplateCategoryDialog, SelectCategoryHdl, weld::TreeView&, void) +{ + if (mxLBCategory->get_selected_index() == 0) + { + msSelectedCategory = OUString(); + mxOKButton->set_sensitive(false); + mxNewCategoryEdit->set_sensitive(true); + } + else + { + msSelectedCategory = mxLBCategory->get_selected_text(); + mxNewCategoryEdit->set_sensitive(false); + mxOKButton->set_sensitive(true); + } + + mbIsNewCategory = false; +} + +void SfxTemplateCategoryDialog::SetCategoryLBEntries(std::vector<OUString> aFolderNames) +{ + for (size_t i = 0, n = aFolderNames.size(); i < n; ++i) + mxLBCategory->append_text(aFolderNames[i]); + mxLBCategory->select(0); +} + +// SfxTemplateSelectionDialog ----------------------------------------------------------------- + +SfxTemplateSelectionDlg::SfxTemplateSelectionDlg(weld::Window* pParent) + : SfxTemplateManagerDlg(pParent) + , maIdle("sfx2 SfxTemplateManagerDlg maIdle") +{ + mxCBApp->set_active(MNI_IMPRESS); + mxCBFolder->set_active(0); + m_xDialog->set_title(SfxResId(STR_TEMPLATE_SELECTION)); + + if (mxLocalView->IsVisible()) + { + mxLocalView->filterItems(ViewFilter_Application(getCurrentApplicationFilter())); + mxLocalView->showAllTemplates(); + } + + mxCBApp->set_sensitive(false); + mxActionBar->show(); + mxCBXHideDlg->show(); + mxCBXHideDlg->set_active(true); + + mxLocalView->setOpenTemplateHdl(LINK(this,SfxTemplateSelectionDlg, OpenTemplateHdl)); + mxOKButton->connect_clicked(LINK(this, SfxTemplateSelectionDlg, OkClickHdl)); + updateMenuItems(); +} + +SfxTemplateSelectionDlg::~SfxTemplateSelectionDlg() +{ + maIdle.Stop(); +} + +short SfxTemplateSelectionDlg::run() +{ + // tdf#124597 at startup this dialog is launched before its parent window + // has taken its final size. The parent size request is processed during + // the dialogs event loop so configure this dialog to center to + // the parents pending geometry request + m_xDialog->set_centered_on_parent(true); + + // tdf#125079 toggle off the size tracking at some future idle point + maIdle.SetPriority(TaskPriority::LOWEST); + maIdle.SetInvokeHandler(LINK(this,SfxTemplateSelectionDlg,TimeOut)); + maIdle.Start(); + setTemplateViewMode(TemplateViewMode::eThumbnailView); + + return weld::GenericDialogController::run(); +} + +IMPL_LINK_NOARG(SfxTemplateSelectionDlg, TimeOut, Timer*, void) +{ + m_xDialog->set_centered_on_parent(false); +} + +IMPL_LINK(SfxTemplateSelectionDlg, OpenTemplateHdl, ThumbnailViewItem*, pItem, void) +{ + TemplateViewItem *pViewItem = static_cast<TemplateViewItem*>(pItem); + msTemplatePath = pViewItem->getPath(); + + m_xDialog->response(RET_OK); +} + +IMPL_LINK_NOARG(SfxTemplateSelectionDlg, OkClickHdl, weld::Button&, void) +{ + TemplateViewItem *pViewItem = static_cast<TemplateViewItem*>(const_cast<ThumbnailViewItem*>(*maSelTemplates.begin())); + msTemplatePath = pViewItem->getPath(); + + m_xDialog->response(RET_OK); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sfx2/source/doc/watermarkitem.cxx b/sfx2/source/doc/watermarkitem.cxx new file mode 100644 index 000000000..4e64afd7f --- /dev/null +++ b/sfx2/source/doc/watermarkitem.cxx @@ -0,0 +1,82 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/. + */ + +#include <sfx2/watermarkitem.hxx> +#include <sfx2/sfxsids.hrc> +#include <comphelper/propertysequence.hxx> + +SfxWatermarkItem::SfxWatermarkItem() +: SfxPoolItem( SID_WATERMARK ) +, m_aText( "" ) +, m_aFont( "Liberation Sans" ) +, m_nAngle( 45 ) +, m_nTransparency( 50 ) +, m_nColor( 0xc0c0c0 ) +{ +} + +SfxPoolItem* SfxWatermarkItem::CreateDefault() +{ + return new SfxWatermarkItem(); +} + +bool SfxWatermarkItem::operator==( const SfxPoolItem& rCmp ) const +{ + return ( SfxPoolItem::operator==( rCmp ) && + m_aText == static_cast<const SfxWatermarkItem&>(rCmp).m_aText && + m_aFont == static_cast<const SfxWatermarkItem&>(rCmp).m_aFont && + m_nAngle == static_cast<const SfxWatermarkItem&>(rCmp).m_nAngle && + m_nTransparency == static_cast<const SfxWatermarkItem&>(rCmp).m_nTransparency && + m_nColor == static_cast<const SfxWatermarkItem&>(rCmp).m_nColor ); +} + +SfxWatermarkItem* SfxWatermarkItem::Clone( SfxItemPool *) const +{ + return new SfxWatermarkItem(*this); +} + +bool SfxWatermarkItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const +{ + rVal <<= comphelper::InitPropertySequence( { + { "Text", css::uno::Any( m_aText ) }, + { "Font", css::uno::Any( m_aFont ) }, + { "Angle", css::uno::Any( m_nAngle ) }, + { "Transparency", css::uno::Any( m_nTransparency ) }, + { "Color", css::uno::Any( m_nColor ) }, + } ); + + return true; +} + +bool SfxWatermarkItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) +{ + css::uno::Sequence<css::beans::PropertyValue> aSequence; + + if ( rVal >>= aSequence ) + { + for(const auto& aEntry : std::as_const(aSequence)) + { + if(aEntry.Name == "Text") + aEntry.Value >>= m_aText; + if(aEntry.Name == "Font") + aEntry.Value >>= m_aFont; + if(aEntry.Name == "Angle") + aEntry.Value >>= m_nAngle; + if(aEntry.Name == "Transparency") + aEntry.Value >>= m_nTransparency; + if(aEntry.Name == "Color") + aEntry.Value >>= m_nColor; + } + return true; + } + + return false; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/sfx2/source/doc/zoomitem.cxx b/sfx2/source/doc/zoomitem.cxx new file mode 100644 index 000000000..60f193e85 --- /dev/null +++ b/sfx2/source/doc/zoomitem.cxx @@ -0,0 +1,172 @@ +/* -*- 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 <sfx2/zoomitem.hxx> +#include <com/sun/star/uno/Sequence.hxx> +#include <com/sun/star/beans/PropertyValue.hpp> + +#include <comphelper/propertyvalue.hxx> +#include <osl/diagnose.h> + +#include <cassert> + + +SfxPoolItem* SvxZoomItem::CreateDefault() { return new SvxZoomItem; } + +constexpr OUStringLiteral ZOOM_PARAM_VALUE = u"Value"; +constexpr OUStringLiteral ZOOM_PARAM_VALUESET = u"ValueSet"; +constexpr OUStringLiteral ZOOM_PARAM_TYPE = u"Type"; +#define ZOOM_PARAMS 3 + + +SvxZoomItem::SvxZoomItem +( + SvxZoomType eZoomType, + sal_uInt16 nVal, + sal_uInt16 _nWhich +) +: SfxUInt16Item( _nWhich, nVal ), + nValueSet( SvxZoomEnableFlags::ALL ), + eType( eZoomType ) +{ +} + +SvxZoomItem* SvxZoomItem::Clone( SfxItemPool * /*pPool*/ ) const +{ + return new SvxZoomItem( *this ); +} + +bool SvxZoomItem::operator==( const SfxPoolItem& rAttr ) const +{ + assert(SfxPoolItem::operator==(rAttr)); + + const SvxZoomItem& rItem = static_cast<const SvxZoomItem&>(rAttr); + + return ( GetValue() == rItem.GetValue() && + nValueSet == rItem.GetValueSet() && + eType == rItem.GetType() ); +} + +bool SvxZoomItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const +{ + nMemberId &= ~CONVERT_TWIPS; + switch( nMemberId ) + { + case 0: + { + css::uno::Sequence< css::beans::PropertyValue > aSeq{ + comphelper::makePropertyValue(ZOOM_PARAM_VALUE, sal_Int32( GetValue() )), + comphelper::makePropertyValue(ZOOM_PARAM_VALUESET, sal_Int16( nValueSet )), + comphelper::makePropertyValue(ZOOM_PARAM_TYPE, sal_Int16( eType )) + }; + assert(aSeq.getLength() == ZOOM_PARAMS); + rVal <<= aSeq; + break; + } + + case MID_VALUE: rVal <<= static_cast<sal_Int32>(GetValue()); break; + case MID_VALUESET: rVal <<= static_cast<sal_Int16>(nValueSet); break; + case MID_TYPE: rVal <<= static_cast<sal_Int16>(eType); break; + default: + OSL_FAIL("sfx2::SvxZoomItem::QueryValue(), Wrong MemberId!"); + return false; + } + + return true; +} + +bool SvxZoomItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId ) +{ + nMemberId &= ~CONVERT_TWIPS; + switch( nMemberId ) + { + case 0: + { + css::uno::Sequence< css::beans::PropertyValue > aSeq; + if (( rVal >>= aSeq ) && ( aSeq.getLength() == ZOOM_PARAMS )) + { + sal_Int32 nValueTmp( 0 ); + sal_Int16 nValueSetTmp( 0 ); + sal_Int16 nTypeTmp( 0 ); + bool bAllConverted( true ); + sal_Int16 nConvertedCount( 0 ); + for ( const auto& rProp : std::as_const(aSeq) ) + { + if ( rProp.Name == ZOOM_PARAM_VALUE ) + { + bAllConverted &= ( rProp.Value >>= nValueTmp ); + ++nConvertedCount; + } + else if ( rProp.Name == ZOOM_PARAM_VALUESET ) + { + bAllConverted &= ( rProp.Value >>= nValueSetTmp ); + ++nConvertedCount; + } + else if ( rProp.Name == ZOOM_PARAM_TYPE ) + { + bAllConverted &= ( rProp.Value >>= nTypeTmp ); + ++nConvertedCount; + } + } + + if ( bAllConverted && nConvertedCount == ZOOM_PARAMS ) + { + SetValue( static_cast<sal_uInt16>(nValueTmp) ); + nValueSet = static_cast<SvxZoomEnableFlags>(nValueSetTmp); + eType = static_cast<SvxZoomType>(nTypeTmp); + return true; + } + } + return false; + } + case MID_VALUE: + { + sal_Int32 nVal = 0; + if ( rVal >>= nVal ) + { + SetValue( static_cast<sal_uInt16>(nVal) ); + return true; + } + else + return false; + } + + case MID_VALUESET: + case MID_TYPE: + { + sal_Int16 nVal; + if ( rVal >>= nVal ) + { + if ( nMemberId == MID_VALUESET ) + nValueSet = static_cast<SvxZoomEnableFlags>(nVal); + else if ( nMemberId == MID_TYPE ) + eType = static_cast<SvxZoomType>(nVal); + return true; + } + else + return false; + } + + default: + OSL_FAIL("sfx2::SvxZoomItem::PutValue(), Wrong MemberId!"); + return false; + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |