From ed5640d8b587fbcfed7dd7967f3de04b37a76f26 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 11:06:44 +0200 Subject: Adding upstream version 4:7.4.7. Signed-off-by: Daniel Baumann --- fpicker/source/office/fpsmartcontent.cxx | 325 +++++++++++++++++++++++++++++++ 1 file changed, 325 insertions(+) create mode 100644 fpicker/source/office/fpsmartcontent.cxx (limited to 'fpicker/source/office/fpsmartcontent.cxx') diff --git a/fpicker/source/office/fpsmartcontent.cxx b/fpicker/source/office/fpsmartcontent.cxx new file mode 100644 index 000000000..3f9cad855 --- /dev/null +++ b/fpicker/source/office/fpsmartcontent.cxx @@ -0,0 +1,325 @@ +/* -*- 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 "fpsmartcontent.hxx" + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + + +namespace svt +{ + + + using namespace ::com::sun::star::uno; + using namespace ::com::sun::star::task; + using namespace ::com::sun::star::ucb; + using namespace ::com::sun::star::lang; + using namespace ::com::sun::star::container; + + + //= SmartContent + + + SmartContent::SmartContent() + :m_eState( NOT_BOUND ) + { + } + + + SmartContent::SmartContent( const OUString& _rInitialURL ) + :m_eState( NOT_BOUND ) + { + bindTo( _rInitialURL ); + } + + + SmartContent::~SmartContent() + { + /* This destructor originally contained the following blurb: "Do + not delete the content. Because the content will be used by + the cache." This is just plain silly, because it relies on + the provider caching created contents (which is done by + ucbhelper::ContentProviderImplHelper, but we do not actually + expect all providers to use that, right?) Otherwise we are + just leaking memory. + + TODO: If there is real need for caching the content, it must + be done here. + */ + } + + + void SmartContent::enableOwnInteractionHandler(::svt::OFilePickerInteractionHandler::EInterceptedInteractions eInterceptions) + { + Reference< XComponentContext > xContext = ::comphelper::getProcessComponentContext(); + Reference< XInteractionHandler > xGlobalInteractionHandler( + InteractionHandler::createWithParent(xContext, nullptr), UNO_QUERY_THROW ); + + m_xOwnInteraction = new ::svt::OFilePickerInteractionHandler(xGlobalInteractionHandler); + m_xOwnInteraction->enableInterceptions(eInterceptions); + + m_xCmdEnv = new ::ucbhelper::CommandEnvironment( m_xOwnInteraction, Reference< XProgressHandler >() ); + } + + + void SmartContent::enableDefaultInteractionHandler() + { + m_xOwnInteraction.clear(); + + Reference< XComponentContext > xContext = ::comphelper::getProcessComponentContext(); + Reference< XInteractionHandler > xGlobalInteractionHandler( + InteractionHandler::createWithParent(xContext, nullptr), UNO_QUERY_THROW ); + m_xCmdEnv = new ucbhelper::CommandEnvironment( xGlobalInteractionHandler, Reference< XProgressHandler >() ); + } + + + ::svt::OFilePickerInteractionHandler* SmartContent::getOwnInteractionHandler() const + { + return m_xOwnInteraction.get(); + } + + + SmartContent::InteractionHandlerType SmartContent::queryCurrentInteractionHandler() const + { + if (m_xOwnInteraction.is()) + return IHT_OWN; + + if (!m_xCmdEnv.is()) + return IHT_NONE; + + return IHT_DEFAULT; + } + + + void SmartContent::disableInteractionHandler() + { + m_xOwnInteraction.clear(); + m_xCmdEnv.clear(); + } + + + void SmartContent::bindTo( const OUString& _rURL ) + { + if ( getURL() == _rURL ) + // nothing to do, regardless of the state + return; + + m_pContent.reset(); + m_eState = INVALID; // default to INVALID + m_sURL = _rURL; + + if ( !m_sURL.isEmpty() ) + { + try + { + m_pContent.reset( new ::ucbhelper::Content( _rURL, m_xCmdEnv, comphelper::getProcessComponentContext() ) ); + m_eState = UNKNOWN; + // from now on, the state is unknown -> we cannot know for sure if the content + // is really valid (some UCP's only tell this when asking for properties, not upon + // creation) + } + catch( const ContentCreationException& ) + { + } + catch( const Exception& ) + { + TOOLS_WARN_EXCEPTION( "fpicker", "SmartContent::bindTo: unexpected exception caught!" ); + } + } + else + { + m_eState = NOT_BOUND; + } + + + // don't forget to reset the may internal used interaction handler ... + // But do it only for our own specialized interaction helper! + ::svt::OFilePickerInteractionHandler* pHandler = getOwnInteractionHandler(); + if (pHandler) + { + pHandler->resetUseState(); + pHandler->forgetRequest(); + } + } + + + bool SmartContent::implIs( const OUString& _rURL, Type _eType ) + { + // bind to this content + bindTo( _rURL ); + + // did we survive this? + if ( isInvalid() || !isBound() ) + return false; + + assert( m_pContent && "SmartContent::implIs: inconsistence!" ); + // if, after a bindTo, we don't have a content, then we should be INVALID, or at least + // NOT_BOUND (the latter happens, for example, if somebody tries to ask for an empty URL) + + bool bIs = false; + try + { + if ( Folder == _eType ) + bIs = m_pContent->isFolder(); + else + bIs = m_pContent->isDocument(); + + // from here on, we definitely know that the content is valid + m_eState = VALID; + } + catch( const Exception& ) + { + // now we're definitely invalid + m_eState = INVALID; + } + return bIs; + } + + + void SmartContent::getTitle( OUString& /* [out] */ _rTitle ) + { + if ( !isBound() || isInvalid() ) + return; + + try + { + OUString sTitle; + m_pContent->getPropertyValue("Title") >>= sTitle; + _rTitle = sTitle; + + // from here on, we definitely know that the content is valid + m_eState = VALID; + } + catch( const css::uno::Exception& ) + { + // now we're definitely invalid + m_eState = INVALID; + } + } + + + bool SmartContent::hasParentFolder( ) + { + if ( !isBound() || isInvalid() ) + return false; + + bool bRet = false; + try + { + Reference< XChild > xChild( m_pContent->get(), UNO_QUERY ); + if ( xChild.is() ) + { + Reference< XContent > xParent( xChild->getParent(), UNO_QUERY ); + if ( xParent.is() ) + { + const OUString aParentURL( xParent->getIdentifier()->getContentIdentifier() ); + bRet = ( !aParentURL.isEmpty() && aParentURL != m_pContent->getURL() ); + + // now we're definitely valid + m_eState = VALID; + } + } + } + catch( const Exception& ) + { + // now we're definitely invalid + m_eState = INVALID; + } + return bRet; + } + + + bool SmartContent::canCreateFolder( ) + { + if ( !isBound() || isInvalid() ) + return false; + + bool bRet = false; + try + { + const css::uno::Sequence aContentsInfo = m_pContent->queryCreatableContentsInfo(); + for ( auto const& rInfo : aContentsInfo ) + { + // Simply look for the first KIND_FOLDER... + if ( rInfo.Attributes & ContentInfoAttribute::KIND_FOLDER ) + { + bRet = true; + break; + } + } + + // now we're definitely valid + m_eState = VALID; + } + catch( const Exception& ) + { + // now we're definitely invalid + m_eState = INVALID; + } + return bRet; + } + + OUString SmartContent::createFolder( const OUString& _rTitle ) + { + OUString aCreatedUrl; + try + { + OUString sFolderType; + + const css::uno::Sequence aContentsInfo = m_pContent->queryCreatableContentsInfo(); + for ( auto const& rInfo : aContentsInfo ) + { + // Simply look for the first KIND_FOLDER... + if ( rInfo.Attributes & ContentInfoAttribute::KIND_FOLDER ) + { + sFolderType = rInfo.Type; + break; + } + } + + if ( !sFolderType.isEmpty() ) + { + ucbhelper::Content aCreated; + Sequence< OUString > aNames { "Title" }; + Sequence< Any > aValues { Any(_rTitle) }; + m_pContent->insertNewContent( sFolderType, aNames, aValues, aCreated ); + + aCreatedUrl = aCreated.getURL(); + } + } + catch( const Exception& ) + { + } + return aCreatedUrl; + } + + +} // namespace svt + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ -- cgit v1.2.3