move preventduplicateinteraction from framework to sfx2 consumer

Change-Id: I1388a88ba20b5cde65cd1d88694775b071a0dff6
Reviewed-on: https://gerrit.libreoffice.org/45099
Reviewed-by: Caolán McNamara <caolanm@redhat.com>
Tested-by: Caolán McNamara <caolanm@redhat.com>

4 files changed, 471 insertions, 3 deletions

diff --git a/sfx2/Library_sfx.mk b/sfx2/Library_sfx.mk
index 3dd3d892ed4c..d721b72438a8 100644
--- a/sfx2/Library_sfx.mk
+++ b/sfx2/Library_sfx.mk
@@ -115,6 +115,7 @@ $(eval $(call gb_Library_add_exception_objects,sfx,\
     sfx2/source/appl/newhelp \
     sfx2/source/appl/opengrf \
     sfx2/source/appl/openuriexternally \
+    sfx2/source/appl/preventduplicateinteraction \
     sfx2/source/appl/sfxhelp \
     sfx2/source/appl/sfxpicklist \
     sfx2/source/appl/shellimpl \
diff --git a/sfx2/inc/preventduplicateinteraction.hxx b/sfx2/inc/preventduplicateinteraction.hxx
new file mode 100644
index 000000000000..f7bec486a2cf
--- /dev/null
+++ b/sfx2/inc/preventduplicateinteraction.hxx
@@ -0,0 +1,235 @@
+/* -*- 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_FRAMEWORK_PREVENTDUPLICATEINTERACTION_HXX
+#define INCLUDED_FRAMEWORK_PREVENTDUPLICATEINTERACTION_HXX
+
+#include <vector>
+
+#include <com/sun/star/task/XInteractionHandler2.hpp>
+#include <com/sun/star/task/XInteractionRequest.hpp>
+
+#include <cppuhelper/implbase.hxx>
+
+namespace com { namespace sun { namespace star { namespace uno {
+    class XComponentContext;
+} } } }
+
+namespace sfx2 {
+
+/**
+    @short      Prevent us from showing the same interaction more than once during
+                the same transaction.
+
+    @descr      Every interaction provided to this helper will be safed ... handled by the internal
+                used UUIInteractionHandler (!) and never be handled a second time!
+
+                On the other side there exists some interactions, which allow a retry.
+                So this helper allow to set a list of interactions combined with a retry value.
+ */
+struct ThreadHelpBase2
+{
+    public:
+        mutable ::osl::Mutex m_aLock;
+};
+
+class PreventDuplicateInteraction : private ThreadHelpBase2
+                                    ,public ::cppu::WeakImplHelper< css::task::XInteractionHandler2 >
+{
+
+    // structs, types etc.
+    public:
+
+        struct InteractionInfo
+        {
+            public:
+                /// describe the interaction.
+                css::uno::Type m_aInteraction;
+                /// after max count was reached this interaction will be blocked.
+                sal_Int32 m_nMaxCount;
+                /// count how often this interaction was called.
+                sal_Int32 m_nCallCount;
+                /** hold the last intercepted request (matching the set interaction type) alive
+                so it can be used for further checks */
+                css::uno::Reference< css::task::XInteractionRequest > m_xRequest;
+
+            public:
+
+                InteractionInfo(const css::uno::Type& aInteraction,
+                                      sal_Int32       nMaxCount   )
+                    : m_aInteraction(aInteraction)
+                    , m_nMaxCount   (nMaxCount   )
+                    , m_nCallCount  (0           )
+                {}
+
+                InteractionInfo(const InteractionInfo& aCopy)
+                    : m_aInteraction(aCopy.m_aInteraction)
+                    , m_nMaxCount   (aCopy.m_nMaxCount   )
+                    , m_nCallCount  (aCopy.m_nCallCount  )
+                    , m_xRequest    (aCopy.m_xRequest    )
+                {}
+        };
+
+        typedef ::std::vector< InteractionInfo > InteractionList;
+
+
+    // member
+    private:
+
+        /// Used to create needed uno services at runtime.
+        css::uno::Reference< css::uno::XComponentContext > m_xContext;
+
+        /** The outside interaction handler, which is used to handle every incoming interaction,
+            if it's not blocked. */
+        css::uno::Reference< css::task::XInteractionHandler > m_xHandler;
+
+        /** This list describe which and how incoming interactions must be handled.
+            Further it contains all collected information after this interaction
+            object was used.*/
+        InteractionList m_lInteractionRules;
+
+
+    // uno interface
+    public:
+
+
+        /**
+            @interface  XInteractionHandler
+            @short      called from outside to handle a problem
+            @descr      We filter the incoming interactions. some of them
+                        will be forwarded to the generic UI interaction handler.
+                        So we must not implement it twice. Some other ones
+                        will be aborted only.
+
+            @threadsafe yes
+        */
+        virtual void SAL_CALL handle(const css::uno::Reference< css::task::XInteractionRequest >& xRequest) override;
+
+
+        /**
+            @interface  XInteractionHandler2
+            @short      called from outside to handle a problem
+            @descr      We filter the incoming interactions. some of them
+                        will be forwarded to the generic UI interaction handler.
+                        So we must not implement it twice. Some other ones
+                        will be aborted only.
+
+            @threadsafe yes
+        */
+        virtual sal_Bool SAL_CALL handleInteractionRequest( const css::uno::Reference< css::task::XInteractionRequest >& xRequest ) override;
+
+
+        /**
+            @interface  XInterface
+            @short      called to query another interface of the component
+            @descr      Will allow to query for XInteractionHandler2 if and only if m_xHandler supports this interface, too.
+
+            @threadsafe yes
+        */
+        virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type& aType ) override;
+
+    // c++ interface
+    public:
+
+
+        /**
+            @short      ctor to guarantee right initialized instances of this class
+            @descr      It uses the given uno service manager to create the global
+                        generic UI interaction handler for later internal using.
+
+            @param      xSMGR
+                            uno service manager for creating services internally
+
+            @threadsafe not necessary
+        */
+        PreventDuplicateInteraction(const css::uno::Reference< css::uno::XComponentContext >& rxContext);
+
+
+        /**
+            @short      dtor to free used memory.
+         */
+        virtual ~PreventDuplicateInteraction() override;
+
+
+        /**
+            @short      set the outside interaction handler, which must be used internally
+                        if the interaction will not be blocked by the set list of rules.
+
+            @note       This overwrites the settings of e.g. useDefaultUUIHandler()!
+
+            @param      xHandler
+                        the new interaction handler
+         */
+        void setHandler(const css::uno::Reference< css::task::XInteractionHandler >& xHandler);
+
+
+        /**
+            @short      instead of setting an outside interaction handler, this method
+                        make sure the default UUI interaction handler of the office is used.
+
+            @note       This overwrites the settings of e.g. setHandler()!
+         */
+        void useDefaultUUIHandler();
+
+
+        /**
+            @short      add a new interaction to the list of interactions, which
+                        must be handled by this helper.
+
+            @descr      This method must be called immediately after a new instance of this helper was
+                        created. Without such list of InteractionRules, this instances does nothing!
+                        On the other side there is no possibility to remove rules.
+                        So the same instance can't be used within different transactions.
+                        It's a OneWay-object .-)
+
+            @param      aInteractionInfo
+                        describe the type of interaction, hos often it can be called etcpp.
+
+            @threadsafe yes
+        */
+        void addInteractionRule(const PreventDuplicateInteraction::InteractionInfo& aInteractionInfo);
+
+
+        /**
+            @short      return the info struct for the specified interaction.
+
+            @param      aInteraction
+                        specify the interaction.
+
+            @param      pReturn
+                        provides information about:
+                        - the count how often this interaction was handled during the
+                          lifetime of this helper.
+                        - the interaction itself, so it can be analyzed further
+
+            @return     [boolean]
+                        true if the queried interaction could be found.
+                        false otherwise.
+
+            @threadsafe yes
+        */
+        bool getInteractionInfo(const css::uno::Type&                               aInteraction,
+                                                  PreventDuplicateInteraction::InteractionInfo* pReturn     ) const;
+};
+
+} // namespace sfx2
+
+#endif // INCLUDED_FRAMEWORK_PREVENTDUPLICATEINTERACTION_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/appopen.cxx b/sfx2/source/appl/appopen.cxx
index 8e1a16c00f17..0ae86d85f9b4 100644
--- a/sfx2/source/appl/appopen.cxx
+++ b/sfx2/source/appl/appopen.cxx
@@ -53,7 +53,7 @@
 #include <svl/eitem.hxx>
 #include <sfx2/doctempl.hxx>
 #include <svtools/sfxecode.hxx>
-#include <framework/preventduplicateinteraction.hxx>
+#include <preventduplicateinteraction.hxx>
 #include <svtools/ehdl.hxx>
 #include <basic/sbxobj.hxx>
 #include <svl/urihelper.hxx>
@@ -666,7 +666,7 @@ void SfxApplication::OpenDocExec_Impl( SfxRequest& rReq )
             // intercept all incoming interactions and provide useful information
             // later if the following transaction was finished.
 
-            ::framework::PreventDuplicateInteraction*                 pHandler       = new ::framework::PreventDuplicateInteraction(::comphelper::getProcessComponentContext());
+            ::sfx2::PreventDuplicateInteraction*                 pHandler       = new ::sfx2::PreventDuplicateInteraction(::comphelper::getProcessComponentContext());
             css::uno::Reference< css::task::XInteractionHandler >     xHandler       (static_cast< css::task::XInteractionHandler* >(pHandler), css::uno::UNO_QUERY);
             css::uno::Reference< css::task::XInteractionHandler >     xWrappedHandler;
 
@@ -685,7 +685,7 @@ void SfxApplication::OpenDocExec_Impl( SfxRequest& rReq )
 
             // define rules for this handler
             css::uno::Type                                            aInteraction = ::cppu::UnoType<css::task::ErrorCodeRequest>::get();
-            ::framework::PreventDuplicateInteraction::InteractionInfo aRule        (aInteraction, 1);
+            ::sfx2::PreventDuplicateInteraction::InteractionInfo aRule        (aInteraction, 1);
             pHandler->addInteractionRule(aRule);
 
             if (!aDocService.isEmpty())
diff --git a/sfx2/source/appl/preventduplicateinteraction.cxx b/sfx2/source/appl/preventduplicateinteraction.cxx
new file mode 100644
index 000000000000..bf7eeab13a16
--- /dev/null
+++ b/sfx2/source/appl/preventduplicateinteraction.cxx
@@ -0,0 +1,232 @@
+/* -*- 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 <preventduplicateinteraction.hxx>
+
+#include <osl/diagnose.h>
+
+#include <com/sun/star/task/InteractionHandler.hpp>
+#include <com/sun/star/task/XInteractionAbort.hpp>
+#include <com/sun/star/task/XInteractionRetry.hpp>
+
+namespace sfx2 {
+
+PreventDuplicateInteraction::PreventDuplicateInteraction(const css::uno::Reference< css::uno::XComponentContext >& rxContext)
+    : ThreadHelpBase2()
+    , m_xContext(rxContext)
+{
+}
+
+PreventDuplicateInteraction::~PreventDuplicateInteraction()
+{
+}
+
+void PreventDuplicateInteraction::setHandler(const css::uno::Reference< css::task::XInteractionHandler >& xHandler)
+{
+    // SAFE ->
+    ::osl::ResettableMutexGuard aLock(m_aLock);
+    m_xHandler = xHandler;
+    aLock.clear();
+    // <- SAFE
+}
+
+void PreventDuplicateInteraction::useDefaultUUIHandler()
+{
+    // SAFE ->
+    ::osl::ResettableMutexGuard aLock(m_aLock);
+    aLock.clear();
+    // <- SAFE
+
+    css::uno::Reference< css::task::XInteractionHandler > xHandler( css::task::InteractionHandler::createWithParent( m_xContext, nullptr ), css::uno::UNO_QUERY_THROW );
+
+    // SAFE ->
+    aLock.reset();
+    m_xHandler = xHandler;
+    aLock.clear();
+    // <- SAFE
+}
+
+css::uno::Any SAL_CALL PreventDuplicateInteraction::queryInterface( const css::uno::Type& aType )
+{
+    if ( aType.equals( cppu::UnoType<XInteractionHandler2>::get() ) )
+    {
+        ::osl::ResettableMutexGuard aLock(m_aLock);
+        css::uno::Reference< css::task::XInteractionHandler2 > xHandler( m_xHandler, css::uno::UNO_QUERY );
+        if ( !xHandler.is() )
+            return css::uno::Any();
+    }
+    return ::cppu::WeakImplHelper< css::task::XInteractionHandler2 >::queryInterface( aType );
+}
+
+void SAL_CALL PreventDuplicateInteraction::handle(const css::uno::Reference< css::task::XInteractionRequest >& xRequest)
+{
+    css::uno::Any aRequest  = xRequest->getRequest();
+    bool          bHandleIt = true;
+
+    // SAFE ->
+    ::osl::ResettableMutexGuard aLock(m_aLock);
+
+    InteractionList::iterator pIt;
+    for (  pIt  = m_lInteractionRules.begin();
+           pIt != m_lInteractionRules.end();
+         ++pIt                               )
+    {
+        InteractionInfo& rInfo = *pIt;
+
+        if (aRequest.isExtractableTo(rInfo.m_aInteraction))
+        {
+            ++rInfo.m_nCallCount;
+            rInfo.m_xRequest = xRequest;
+            bHandleIt = (rInfo.m_nCallCount <= rInfo.m_nMaxCount);
+            break;
+        }
+    }
+
+    css::uno::Reference< css::task::XInteractionHandler > xHandler = m_xHandler;
+
+    aLock.clear();
+    // <- SAFE
+
+    if ( bHandleIt && xHandler.is() )
+    {
+        xHandler->handle(xRequest);
+    }
+    else
+    {
+        const css::uno::Sequence< css::uno::Reference< css::task::XInteractionContinuation > > lContinuations = xRequest->getContinuations();
+        sal_Int32 c = lContinuations.getLength();
+        sal_Int32 i = 0;
+        for (i=0; i<c; ++i)
+        {
+            css::uno::Reference< css::task::XInteractionAbort > xAbort(lContinuations[i], css::uno::UNO_QUERY);
+            if (xAbort.is())
+            {
+                xAbort->select();
+                break;
+            }
+        }
+    }
+}
+
+sal_Bool SAL_CALL PreventDuplicateInteraction::handleInteractionRequest( const css::uno::Reference< css::task::XInteractionRequest >& xRequest )
+{
+    css::uno::Any aRequest  = xRequest->getRequest();
+    bool      bHandleIt = true;
+
+    // SAFE ->
+    ::osl::ResettableMutexGuard aLock(m_aLock);
+
+    InteractionList::iterator pIt;
+    for (  pIt  = m_lInteractionRules.begin();
+           pIt != m_lInteractionRules.end();
+         ++pIt                               )
+    {
+        InteractionInfo& rInfo = *pIt;
+
+        if (aRequest.isExtractableTo(rInfo.m_aInteraction))
+        {
+            ++rInfo.m_nCallCount;
+            rInfo.m_xRequest = xRequest;
+            bHandleIt = (rInfo.m_nCallCount <= rInfo.m_nMaxCount);
+            break;
+        }
+    }
+
+    css::uno::Reference< css::task::XInteractionHandler2 > xHandler( m_xHandler, css::uno::UNO_QUERY );
+    OSL_ENSURE( xHandler.is() || !m_xHandler.is(),
+        "PreventDuplicateInteraction::handleInteractionRequest: inconsistency!" );
+
+    aLock.clear();
+    // <- SAFE
+
+    if ( bHandleIt && xHandler.is() )
+    {
+        return xHandler->handleInteractionRequest(xRequest);
+    }
+    else
+    {
+        const css::uno::Sequence< css::uno::Reference< css::task::XInteractionContinuation > > lContinuations = xRequest->getContinuations();
+        sal_Int32 c = lContinuations.getLength();
+        sal_Int32 i = 0;
+        for (i=0; i<c; ++i)
+        {
+            css::uno::Reference< css::task::XInteractionAbort > xAbort(lContinuations[i], css::uno::UNO_QUERY);
+            if (xAbort.is())
+            {
+                xAbort->select();
+                break;
+            }
+        }
+    }
+    return false;
+}
+
+void PreventDuplicateInteraction::addInteractionRule(const PreventDuplicateInteraction::InteractionInfo& aInteractionInfo)
+{
+    // SAFE ->
+    ::osl::ResettableMutexGuard aLock(m_aLock);
+
+    InteractionList::iterator pIt;
+    for (  pIt  = m_lInteractionRules.begin();
+           pIt != m_lInteractionRules.end();
+         ++pIt                               )
+    {
+        InteractionInfo& rInfo = *pIt;
+        if (rInfo.m_aInteraction == aInteractionInfo.m_aInteraction)
+        {
+            rInfo.m_nMaxCount  = aInteractionInfo.m_nMaxCount;
+            rInfo.m_nCallCount = aInteractionInfo.m_nCallCount;
+            return;
+        }
+    }
+
+    m_lInteractionRules.push_back(aInteractionInfo);
+
+    aLock.clear();
+    // <- SAFE
+}
+
+bool PreventDuplicateInteraction::getInteractionInfo(const css::uno::Type&                               aInteraction,
+                                                           PreventDuplicateInteraction::InteractionInfo* pReturn     ) const
+{
+    // SAFE ->
+    ::osl::ResettableMutexGuard aLock(m_aLock);
+
+    PreventDuplicateInteraction::InteractionList::const_iterator pIt;
+    for (  pIt  = m_lInteractionRules.begin();
+           pIt != m_lInteractionRules.end();
+         ++pIt                               )
+    {
+        const PreventDuplicateInteraction::InteractionInfo& rInfo = *pIt;
+        if (rInfo.m_aInteraction == aInteraction)
+        {
+            *pReturn = rInfo;
+            return true;
+        }
+    }
+
+    aLock.clear();
+    // <- SAFE
+
+    return false;
+}
+
+} // namespace sfx2
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */