/* -*- 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 .

 */

#pragma once

#include <com/sun/star/lang/XServiceInfo.hpp>

#include <com/sun/star/frame/XLayoutManager2.hpp>

#include <com/sun/star/ui/XUIConfigurationManager.hpp>

#include <com/sun/star/frame/XModuleManager2.hpp>

#include <com/sun/star/awt/XWindowListener.hpp>

#include <com/sun/star/util/XURLTransformer.hpp>

#include <com/sun/star/ui/XUIElementFactoryManager.hpp>

#include <com/sun/star/ui/DockingArea.hpp>

#include <com/sun/star/uno/XComponentContext.hpp>

#include <com/sun/star/awt/XTopWindow2.hpp>

#include <cppuhelper/basemutex.hxx>

#include <cppuhelper/propshlp.hxx>

#include <cppuhelper/implbase.hxx>

#include <comphelper/multicontainer2.hxx>

#include <cppuhelper/supportsservice.hxx>

#include <comphelper/propertycontainer.hxx>

#include <comphelper/uno3.hxx>

#include <framework/fwkdllapi.h>

#include <framework/uielement.hxx>

#include <tools/gen.hxx>

#include <vcl/timer.hxx>

#include <vcl/vclevent.hxx>

namespace framework

{

class MenuBarManager;

class MenuBarWrapper;

class ProgressBarWrapper;

class ToolbarLayoutManager;

class GlobalSettings;

namespace detail

{

class InfoHelperBuilder;

}

typedef ::cppu::WeakImplHelper<css::lang::XServiceInfo, css::frame::XLayoutManager2,

                               css::awt::XWindowListener>

    LayoutManager_Base;

typedef ::comphelper::OPropertyContainer LayoutManager_PBase;

class FWK_DLLPUBLIC LayoutManager final : public LayoutManager_Base,

                                          private cppu::BaseMutex,

                                          public ::cppu::OBroadcastHelper,

                                          public LayoutManager_PBase

{

public:

    LayoutManager(const css::uno::Reference<css::uno::XComponentContext>& xContext);

    virtual ~LayoutManager() override;

    /** declaration of XInterface, XTypeProvider, XServiceInfo */

    DECLARE_XINTERFACE()

    DECLARE_XTYPEPROVIDER()

    virtual OUString SAL_CALL getImplementationName() override

    {

        return u"com.sun.star.comp.framework.LayoutManager"_ustr;

    }

    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{ u"com.sun.star.frame.LayoutManager"_ustr };

        return aSeq;

    }

    // XLayoutManager

    virtual void SAL_CALL

    attachFrame(const css::uno::Reference<css::frame::XFrame>& Frame) override;

    virtual void SAL_CALL reset() override;

    virtual css::awt::Rectangle SAL_CALL getCurrentDockingArea() override;

    virtual css::uno::Reference<css::ui::XDockingAreaAcceptor>

        SAL_CALL getDockingAreaAcceptor() override;

    virtual void SAL_CALL setDockingAreaAcceptor(

        const css::uno::Reference<css::ui::XDockingAreaAcceptor>& xDockingAreaAcceptor)

        final override;

    virtual void SAL_CALL createElement(const OUString& aName) override;

    virtual void SAL_CALL destroyElement(const OUString& aName) override;

    virtual sal_Bool SAL_CALL requestElement(const OUString& ResourceURL) override;

    virtual css::uno::Reference<css::ui::XUIElement>

        SAL_CALL getElement(const OUString& aName) override;

    virtual css::uno::Sequence<css::uno::Reference<css::ui::XUIElement>>

        SAL_CALL getElements() override;

    virtual sal_Bool SAL_CALL showElement(const OUString& aName) override;

    virtual sal_Bool SAL_CALL hideElement(const OUString& aName) override;

    virtual sal_Bool SAL_CALL dockWindow(const OUString& aName, css::ui::DockingArea DockingArea,

                                         const css::awt::Point& Pos) override;

    virtual sal_Bool SAL_CALL dockAllWindows(::sal_Int16 nElementType) override;

    virtual sal_Bool SAL_CALL floatWindow(const OUString& aName) override;

    virtual sal_Bool SAL_CALL lockWindow(const OUString& ResourceURL) override;

    virtual sal_Bool SAL_CALL unlockWindow(const OUString& ResourceURL) override;

    bool makeContextSensitive(std::u16string_view sResourceURL, bool bSensitive);

    virtual void SAL_CALL setElementSize(const OUString& aName,

                                         const css::awt::Size& aSize) override;

    virtual void SAL_CALL setElementPos(const OUString& aName,

                                        const css::awt::Point& aPos) override;

    virtual void SAL_CALL setElementPosSize(const OUString& aName, const css::awt::Point& aPos,

                                            const css::awt::Size& aSize) override;

    virtual sal_Bool SAL_CALL isElementVisible(const OUString& aName) override;

    virtual sal_Bool SAL_CALL isElementFloating(const OUString& aName) override;

    virtual sal_Bool SAL_CALL isElementDocked(const OUString& aName) override;

    virtual sal_Bool SAL_CALL isElementLocked(const OUString& ResourceURL) override;

    virtual css::awt::Size SAL_CALL getElementSize(const OUString& aName) override;

    virtual css::awt::Point SAL_CALL getElementPos(const OUString& aName) override;

    virtual void SAL_CALL lock() override;

    virtual void SAL_CALL unlock() override;

    virtual void SAL_CALL doLayout() override;

    virtual void SAL_CALL setVisible(sal_Bool bVisible) override;

    virtual sal_Bool SAL_CALL isVisible() override;

    // XMenuBarMergingAcceptor

    virtual sal_Bool SAL_CALL setMergedMenuBar(

        const css::uno::Reference<css::container::XIndexAccess>& xMergedMenuBar) override;

    virtual void SAL_CALL removeMergedMenuBar() override;

    //  XWindowListener

    virtual void SAL_CALL windowResized(const css::awt::WindowEvent& aEvent) override;

    virtual void SAL_CALL windowMoved(const css::awt::WindowEvent& aEvent) override;

    virtual void SAL_CALL windowShown(const css::lang::EventObject& aEvent) override;

    virtual void SAL_CALL windowHidden(const css::lang::EventObject& aEvent) override;

    //   XFrameActionListener

    virtual void SAL_CALL frameAction(const css::frame::FrameActionEvent& aEvent) override;

    //  XEventListener

    using cppu::OPropertySetHelper::disposing;

    virtual void SAL_CALL disposing(const css::lang::EventObject& aEvent) override;

    //  XUIConfigurationListener

    virtual void SAL_CALL elementInserted(const css::ui::ConfigurationEvent& Event) override;

    virtual void SAL_CALL elementRemoved(const css::ui::ConfigurationEvent& Event) override;

    virtual void SAL_CALL elementReplaced(const css::ui::ConfigurationEvent& Event) override;

    //  XLayoutManagerEventBroadcaster

    virtual void SAL_CALL addLayoutManagerEventListener(

        const css::uno::Reference<css::frame::XLayoutManagerListener>& aLayoutManagerListener)

        override;

    virtual void SAL_CALL removeLayoutManagerEventListener(

        const css::uno::Reference<css::frame::XLayoutManagerListener>& aLayoutManagerListener)

        override;

    DECL_LINK(MenuBarClose, void*, void);

    DECL_LINK(WindowEventListener, VclWindowEvent&, void);

    //  called from ToolbarLayoutManager

    void requestLayout();

    /// Reading of settings - shared with ToolbarLayoutManager.

    static bool readWindowStateData(

        const OUString& rName, UIElement& rElementData,

        const css::uno::Reference<css::container::XNameAccess>& rPersistentWindowState,

        std::unique_ptr<GlobalSettings>& rGlobalSettings, bool& bInGlobalSettings,

        const css::uno::Reference<css::uno::XComponentContext>& rComponentContext);

private:

    DECL_LINK(AsyncLayoutHdl, Timer*, void);

    //  menu bar

    void implts_createMenuBar(const OUString& rMenuBarName);

    void impl_clearUpMenuBar();

    void implts_reset(bool bAttach);

    void implts_updateMenuBarClose();

    bool implts_resetMenuBar();

    void implts_createMSCompatibleMenuBar(const OUString& rName);

    //  locking

    void implts_lock();

    bool implts_unlock();

    //  query

    css::uno::Reference<css::ui::XUIElement> implts_findElement(std::u16string_view aName);

    bool implts_readWindowStateData(const OUString& rName, UIElement& rElementData);

    void implts_writeWindowStateData(const OUString& rName, const UIElement& rElementData);

    void implts_destroyElements();

    void implts_toggleFloatingUIElementsVisibility(bool bActive);

    void implts_reparentChildWindows();

    css::uno::Reference<css::ui::XUIElement>

    implts_createDockingWindow(const OUString& aElementName);

    bool implts_isEmbeddedLayoutManager() const;

    css::uno::Reference<css::ui::XUIElement> implts_createElement(const OUString& aName);

    // layouting methods

    bool implts_resizeContainerWindow(const css::awt::Size& rContainerSize,

                                      const css::awt::Point& rComponentPos);

    ::Size implts_getContainerWindowOutputSize();

    void implts_setDockingAreaWindowSizes();

    css::awt::Rectangle implts_calcDockingAreaSizes();

    bool implts_doLayout(bool bForceRequestBorderSpace, bool bOuterResize);

    void implts_doLayout_notify(bool bOuterResize);

    // internal methods to control status/progress bar

    ::Size implts_getStatusBarSize();

    void implts_destroyStatusBar();

    void implts_createStatusBar(const OUString& rStatusBarName);

    void implts_createProgressBar();

    void implts_destroyProgressBar();

    void implts_setStatusBarPosSize(const ::Point& rPos, const ::Size& rSize);

    bool implts_showStatusBar(bool bStoreState = false);

    bool implts_hideStatusBar(bool bStoreState = false);

    void implts_readStatusBarState(const OUString& rStatusBarName);

    bool implts_showProgressBar();

    bool implts_hideProgressBar();

    void implts_backupProgressBarWrapper();

    void implts_setOffset(const sal_Int32 nBottomOffset);

    /// @throws css::uno::RuntimeException

    void implts_setInplaceMenuBar(

        const css::uno::Reference<css::container::XIndexAccess>& xMergedMenuBar);

    /// @throws css::uno::RuntimeException

    void implts_resetInplaceMenuBar();

    void implts_setVisibleState(bool bShow);

    void implts_updateUIElementsVisibleState(bool bShow);

    void implts_setCurrentUIVisibility(bool bShow);

    void implts_notifyListeners(short nEvent, const css::uno::Any& rInfoParam);

    //  OPropertySetHelper

    virtual void SAL_CALL setFastPropertyValue_NoBroadcast(sal_Int32 nHandle,

                                                           const css::uno::Any& aValue) override;

    virtual ::cppu::IPropertyArrayHelper& SAL_CALL getInfoHelper() override;

    virtual css::uno::Reference<css::beans::XPropertySetInfo>

        SAL_CALL getPropertySetInfo() override;

    css::uno::Reference<css::uno::XComponentContext>

        m_xContext; /** reference to factory, which has created this instance. */

    css::uno::Reference<css::util::XURLTransformer> m_xURLTransformer;

    css::uno::Reference<css::frame::XFrame> m_xFrame;

    css::uno::Reference<css::ui::XUIConfigurationManager> m_xModuleCfgMgr;

    css::uno::Reference<css::ui::XUIConfigurationManager> m_xDocCfgMgr;

    css::uno::Reference<css::awt::XWindow> m_xContainerWindow;

    css::uno::Reference<css::awt::XTopWindow2> m_xContainerTopWindow;

    sal_Int32 m_nLockCount;

    bool m_bInplaceMenuSet;

    bool m_bMenuVisible;

    bool m_bVisible;

    bool m_bParentWindowVisible;

    bool m_bMustDoLayout;

    bool m_bAutomaticToolbars;

    bool m_bHideCurrentUI;

    bool m_bGlobalSettings;

    bool m_bPreserveContentSize;

    bool m_bMenuBarCloseButton;

    css::awt::Rectangle m_aDockingArea;

    css::uno::Reference<css::ui::XDockingAreaAcceptor> m_xDockingAreaAcceptor;

    rtl::Reference<MenuBarManager> m_xInplaceMenuBar;

    rtl::Reference<MenuBarWrapper> m_xMenuBar;

    UIElement m_aStatusBarElement;

    UIElement m_aProgressBarElement;

    rtl::Reference<ProgressBarWrapper> m_xProgressBarBackup;

    css::uno::Reference<css::frame::XModuleManager2> m_xModuleManager;

    css::uno::Reference<css::ui::XUIElementFactoryManager> m_xUIElementFactoryManager;

    css::uno::Reference<css::container::XNameAccess> m_xPersistentWindowState;

    css::uno::Reference<css::container::XNameAccess> m_xPersistentWindowStateSupplier;

    std::unique_ptr<GlobalSettings> m_pGlobalSettings;

    OUString m_aModuleIdentifier;

    Timer m_aAsyncLayoutTimer;

    // container for ALL Listener

    comphelper::OMultiTypeInterfaceContainerHelper2 m_aListenerContainer;

    rtl::Reference<ToolbarLayoutManager> m_xToolbarManager;

    bool m_bInSetCurrentUIVisibility;

    friend class detail::InfoHelperBuilder;

};

} // namespace framework

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */