preventduplicateinteraction.hxx

Go to the documentation of this file.

/* -*- 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/frame/Desktop.hpp>
#include <com/sun/star/frame/TerminationVetoException.hpp>
#include <com/sun/star/lang/XInitialization.hpp>
#include <com/sun/star/task/XInteractionHandler2.hpp>
#include <com/sun/star/task/XInteractionRequest.hpp>
 
#include <comphelper/compbase.hxx>
#include <cppuhelper/implbase.hxx>
 
#include <toolkit/helper/vclunohelper.hxx>
#include <vcl/wrkwin.hxx>
#include <vcl/svapp.hxx>
#include <mutex>
 
namespace com::sun::star::uno {
    class XComponentContext;
}
 
namespace sfx2 {
 
inline void closedialogs(SystemWindow& rTopLevel, bool bCloseRoot)
{
    for (vcl::Window *pChild = rTopLevel.GetWindow(GetWindowType::FirstTopWindowChild); pChild; pChild = rTopLevel.GetWindow(GetWindowType::NextTopWindowSibling))
        closedialogs(dynamic_cast<SystemWindow&>(*pChild), true);
    if (bCloseRoot)
        rTopLevel.Close();
}
 
// This is intended to be the parent for any warning dialogs launched
// during the load of a document so that those dialogs are modal to
// this window and don't block any existing windows.
//
// If there are dialog children open on exit then veto termination,
// close the topmost dialog and retry termination.
class WarningDialogsParent final :
    public comphelper::WeakComponentImplHelper<css::frame::XTerminateListener>
{
private:
    VclPtr<WorkWindow> m_xWin;
    css::uno::Reference<css::awt::XWindow> m_xInterface;
 
private:
 
    DECL_STATIC_LINK(WarningDialogsParent, TerminateDesktop, void*, void);
 
    void closewarningdialogs()
    {
        if (!m_xWin)
            return;
        SolarMutexGuard aSolarGuard;
        closedialogs(*m_xWin, false);
    }
 
public:
 
    using comphelper::WeakComponentImplHelperBase::disposing;
    virtual void SAL_CALL disposing(const css::lang::EventObject&) override
    {
    }
 
    // XTerminateListener
    virtual void SAL_CALL queryTermination(const css::lang::EventObject&) override
    {
        closewarningdialogs();
        Application::PostUserEvent(LINK(this, WarningDialogsParent, TerminateDesktop));
        throw css::frame::TerminationVetoException();
    }
 
    virtual void SAL_CALL notifyTermination(const css::lang::EventObject&) override
    {
    }
 
public:
    WarningDialogsParent()
    {
        SolarMutexGuard aSolarGuard;
        m_xWin = VclPtr<WorkWindow>::Create(nullptr, WB_STDWORK);
        m_xWin->SetText("dialog parent for warning dialogs during load");
        m_xInterface = VCLUnoHelper::GetInterface(m_xWin);
    }
 
    virtual ~WarningDialogsParent() override
    {
        closewarningdialogs();
        m_xWin.disposeAndClear();
    }
 
    const css::uno::Reference<css::awt::XWindow>& GetDialogParent() const
    {
        return m_xInterface;
    }
};
 
class WarningDialogsParentScope
{
private:
    css::uno::Reference<css::frame::XDesktop> m_xDesktop;
    rtl::Reference<WarningDialogsParent> m_xListener;
 
public:
    WarningDialogsParentScope(const css::uno::Reference<css::uno::XComponentContext>& rContext)
        : m_xDesktop(css::frame::Desktop::create(rContext), css::uno::UNO_QUERY_THROW)
        , m_xListener(new WarningDialogsParent)
    {
        m_xDesktop->addTerminateListener(m_xListener);
    }
 
    const css::uno::Reference<css::awt::XWindow>& GetDialogParent() const
    {
        return m_xListener->GetDialogParent();
    }
 
    ~WarningDialogsParentScope()
    {
        m_xDesktop->removeTerminateListener(m_xListener);
    }
};
 
class PreventDuplicateInteraction final :
                                  public ::cppu::WeakImplHelper<css::lang::XInitialization, css::task::XInteractionHandler2>
{
    mutable std::mutex m_aLock;
 
    // structs, types etc.
    public:
 
        struct InteractionInfo
        {
            public:
                css::uno::Type m_aInteraction;
                sal_Int32 m_nMaxCount;
                sal_Int32 m_nCallCount;
                css::uno::Reference< css::task::XInteractionRequest > m_xRequest;
 
            public:
 
                InteractionInfo(const css::uno::Type& aInteraction)
                    : m_aInteraction(aInteraction)
                    , m_nMaxCount   (1   )
                    , m_nCallCount  (0           )
                {}
        };
 
    // member
    private:
 
        css::uno::Reference< css::uno::XComponentContext > m_xContext;
 
        css::uno::Reference< css::task::XInteractionHandler > m_xHandler;
 
        std::unique_ptr<WarningDialogsParentScope> m_xWarningDialogsParent;
 
        std::vector< InteractionInfo > m_lInteractionRules;
 
 
    // uno interface
    public:
 
        virtual void SAL_CALL initialize(const css::uno::Sequence<css::uno::Any>& rArguments) override;
 
        virtual void SAL_CALL handle(const css::uno::Reference< css::task::XInteractionRequest >& xRequest) override;
 
 
        virtual sal_Bool SAL_CALL handleInteractionRequest( const css::uno::Reference< css::task::XInteractionRequest >& xRequest ) override;
 
 
        virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type& aType ) override;
 
    // c++ interface
    public:
 
 
        PreventDuplicateInteraction(css::uno::Reference< css::uno::XComponentContext > xContext);
 
 
        virtual ~PreventDuplicateInteraction() override;
 
 
        void setHandler(const css::uno::Reference< css::task::XInteractionHandler >& xHandler);
 
 
        void useDefaultUUIHandler();
 
 
        void addInteractionRule(const PreventDuplicateInteraction::InteractionInfo& aInteractionInfo);
 
 
        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: */