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

 */

#pragma once

#include <typeinfo>

#include <sal/log.hxx>

#include <vcl/dllapi.h>

#include <utility>

#include <vcl/menu.hxx>

#include <vcl/widgetbuilder.hxx>

#include <vcl/window.hxx>

#include <vcl/vclptr.hxx>

#include <vcl/toolboxid.hxx>

#include <vcl/wintypes.hxx>

#include <vcl/EnumContext.hxx>

#include <vcl/notebookbar/NotebookBarAddonsItem.hxx>

#include <memory>

#include <map>

#include <string_view>

#include <vector>

#ifdef check

#  //some problem with MacOSX and a check define

#  undef check

#endif

class ComboBox;

class FormattedField;

class ListBox;

class MessageDialog;

class NumericFormatter;

class ScrollBar;

class SvTabListBox;

class Slider;

class VclExpander;

class VclMultiLineEdit;

namespace com::sun::star::frame { class XFrame; }

/// Creates a hierarchy of vcl::Windows (widgets) from a .ui file for dialogs, sidebar, etc.

class VCL_DLLPUBLIC VclBuilder final : public WidgetBuilder<vcl::Window, VclPtr<vcl::Window>, PopupMenu, VclPtr<PopupMenu>>

{

public:

    /// These functions create a new widget with parent pParent and return it in rRet

    typedef void (*customMakeWidget)(VclPtr<vcl::Window> &rRet, const VclPtr<vcl::Window> &pParent, stringmap &rVec);

public:

    VclBuilder(vcl::Window* pParent, std::u16string_view sUIRootDir, const OUString& sUIFile,

               OUString sID = {},

               css::uno::Reference<css::frame::XFrame> xFrame

               = css::uno::Reference<css::frame::XFrame>(),

               bool bLegacy = true,

               std::unique_ptr<NotebookBarAddonsItem> pNotebookBarAddonsItem = nullptr);

    virtual ~VclBuilder();

    ///releases references and disposes all children.

    void disposeBuilder();

    //sID may not exist, but must be of type T if it does

    template <typename T = vcl::Window> T* get(std::u16string_view sID);

    vcl::Window*    get_widget_root();

    //release ownership of pWindow, i.e. don't delete it

    void            drop_ownership(const vcl::Window *pWindow);

    //see m_aDeferredProperties, you need this for toplevel dialogs

    //which build themselves from their ctor. The properties on

    //the top level are stored in m_aDeferredProperties and need

    //to be applied post ctor

    void            setDeferredProperties();

    static SymbolType mapStockToSymbol(std::u16string_view icon_name);

private:

    VclBuilder(const VclBuilder&) = delete;

    VclBuilder& operator=(const VclBuilder&) = delete;

    // owner for ListBox/ComboBox UserData

    std::vector<std::unique_ptr<OUString>> m_aUserData;

    //If the toplevel window has any properties which need to be set on it,

    //but the toplevel is the owner of the builder, then its ctor

    //has not been completed during the building, so properties for it

    //are collected here and need to be set afterwards, e.g. during

    //Show or Execute

    stringmap      m_aDeferredProperties;

    std::unique_ptr<NotebookBarAddonsItem> m_pNotebookBarAddonsItem;

    struct PackingData

    {

        bool m_bVerticalOrient;

        sal_Int32 m_nPosition;

        PackingData(bool bVerticalOrient = false)

            : m_bVerticalOrient(bVerticalOrient)

            , m_nPosition(-1)

        {

        }

    };

    struct WinAndId

    {

        OUString m_sID;

        VclPtr<vcl::Window> m_pWindow;

        PackingData m_aPackingData;

        WinAndId(OUString sId, vcl::Window *pWindow, bool bVertical)

            : m_sID(std::move(sId))

            , m_pWindow(pWindow)

            , m_aPackingData(bVertical)

        {

        }

    };

    std::vector<WinAndId> m_aChildren;

    struct ButtonImageWidgetMap

    {

        OUString m_sID;

        OUString m_sValue;

        bool m_bRadio;

        ButtonImageWidgetMap(OUString sId, OUString sValue, bool bRadio)

            : m_sID(std::move(sId))

            , m_sValue(std::move(sValue))

            , m_bRadio(bRadio)

        {

        }

    };

    typedef StringPair TextBufferMap;

    typedef StringPair WidgetAdjustmentMap;

    typedef StringPair ButtonMenuMap;

    void insertComboBoxOrListBoxItems(vcl::Window* pWindow,

                                      const std::vector<ComboBoxTextItem>& rItems,

                                      sal_Int32 nActiveIndex) override;

    static void     mungeTextBuffer(VclMultiLineEdit &rTarget, const TextBuffer &rTextBuffer);

    static void     mungeAdjustment(NumericFormatter &rTarget, const Adjustment &rAdjustment);

    static void     mungeAdjustment(FormattedField &rTarget, const Adjustment &rAdjustment);

    static void     mungeAdjustment(ScrollBar &rTarget, const Adjustment &rAdjustment);

    static void     mungeAdjustment(Slider &rTarget, const Adjustment &rAdjustment);

    typedef std::map<OUString, int> ImageSizeMap;

    struct VclParserState

    {

        std::vector<TextBufferMap> m_aTextBufferMaps;

        std::vector<WidgetAdjustmentMap> m_aNumericFormatterAdjustmentMaps;

        std::vector<WidgetAdjustmentMap> m_aFormattedFormatterAdjustmentMaps;

        std::vector<WidgetAdjustmentMap> m_aScrollAdjustmentMaps;

        std::vector<WidgetAdjustmentMap> m_aSliderAdjustmentMaps;

        std::vector<ButtonImageWidgetMap> m_aButtonImageWidgetMaps;

        ImageSizeMap m_aImageSizeMap;

        std::vector<ButtonMenuMap> m_aButtonMenuMaps;

        std::map<VclPtr<vcl::Window>, VclPtr<vcl::Window>> m_aRedundantParentWidgets;

        std::map<VclPtr<vcl::Window>, stringmap> m_aAtkInfo;

        std::vector< VclPtr<VclExpander> > m_aExpanderWidgets;

        std::vector< VclPtr<MessageDialog> > m_aMessageDialogs;

        ToolBoxItemId m_nLastToolbarId;

        sal_uInt16 m_nLastMenuItemId;

        /* The renderer/column structure in .ui files for GtkTreeView is a set

           of compromise rules of expressing a layout in gtk terms which the

           vcl equivalent is also able to do.

           The GtkInstanceTreeView ctor has some more details of that.

           The ui files end up containing information as to what each TreeView

           is limited to, whether it will be used as a tree or a list and

           whether there are multiple columns or not, so here we extract enough

           of that information in the generic loader to determine what type of

           role this TreeView has.

        */

        sal_uInt16 m_nTreeViewRenderers;

        sal_uInt16 m_nTreeViewExpanders;

        sal_uInt16 m_nTreeViewColumnCount;

        bool m_bTreeViewSeenTextInColumn;

        bool m_bTreeHasHeader;

        VclParserState();

    };

    OUString    m_sID;

    VclPtr<vcl::Window> m_pParent;

    bool        m_bToplevelHasDeferredInit;

    bool        m_bToplevelHasDeferredProperties;

    bool        m_bToplevelParentFound;

    std::unique_ptr<VclParserState> m_pVclParserState;

    virtual void resetParserState() override;

    vcl::Window *get_by_name(std::u16string_view sID);

    void        delete_by_name(const OUString& sID);

    class sortIntoBestTabTraversalOrder

    {

    public:

                sortIntoBestTabTraversalOrder(VclBuilder *pBuilder)

                    : m_pBuilder(pBuilder) {}

        bool    operator()(const vcl::Window *pA, const vcl::Window *pB) const;

    private:

        VclBuilder *m_pBuilder;

    };

    /// XFrame to be able to extract labels and other properties of the UNO commands (like of .uno:Bold).

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

private:

    // tweak newly inserted child depending on window type

    void tweakInsertedChild(vcl::Window *pParent, vcl::Window* pCurrentChild,

                            std::string_view sType, std::string_view sInternalChild) override;

    VclPtr<vcl::Window> insertObject(vcl::Window* pParent, const OUString& rClass,

                                     std::string_view sType, const OUString& rID, stringmap& rProps,

                                     stringmap& rPangoAttributes, stringmap& rAtkProps) override;

    VclPtr<vcl::Window> makeObject(vcl::Window *pParent,

                    const OUString &rClass, const OUString &rID,

                    stringmap &rVec);

    void        connectNumericFormatterAdjustment(const OUString &id, const OUString &rAdjustment);

    void        connectFormattedFormatterAdjustment(const OUString &id, const OUString &rAdjustment);

    static int  getImageSize(const stringmap &rMap);

    void        extractBuffer(const OUString &id, stringmap &rVec);

    static bool extractAdjustmentToMap(const OUString &id, stringmap &rVec, std::vector<WidgetAdjustmentMap>& rAdjustmentMap);

    void        extractButtonImage(const OUString &id, stringmap &rMap, bool bRadio);

    void applyPackingProperties(vcl::Window* pCurrent, vcl::Window* pParent,

                                const stringmap& rPackingProperties) override;

    virtual void applyTabChildProperties(vcl::Window* pParent, const std::vector<OUString>& rIDs,

                                         std::vector<vcl::EnumContext::Context>& rContext, stringmap& rProperties,

                                         stringmap& rAtkProperties) override;

    void insertMenuObject(PopupMenu* pParent, PopupMenu* pSubMenu, const OUString& rClass,

                          const OUString& rID, stringmap& rProps, stringmap& rAtkProps,

                          accelmap& rAccels) override;

    // if bToolbarItem=true, pParent is the ToolBox that the item belongs to, since there's no widget for the item itself

    void applyAtkProperties(vcl::Window* pWindow, const stringmap& rProperties,

                            bool bToolbarItem) override;

    void setMnemonicWidget(const OUString& rLabelId, const OUString& rMnemonicWidgetId) override;

    void setRadioButtonGroup(const OUString& rRadioButtonId, const OUString& rRadioGroupId) override;

    void setPriority(vcl::Window* pWindow, int nPriority) override;

    void setContext(vcl::Window* pWindow,

                    std::vector<vcl::EnumContext::Context>&& aContext) override;

    virtual bool isHorizontalTabControl(vcl::Window* pWindow) override;

    virtual VclPtr<PopupMenu> createMenu(const OUString& rID) override;

    PackingData get_window_packing_data(const vcl::Window *pWindow) const;

    void        set_window_packing_position(const vcl::Window *pWindow, sal_Int32 nPosition);

    static vcl::Window* prepareWidgetOwnScrolling(vcl::Window *pParent, WinBits &rWinStyle);

    void        cleanupWidgetOwnScrolling(vcl::Window *pScrollParent, vcl::Window *pWindow, stringmap &rMap);

    void set_response(const OUString& rId, int nResponse) override;

    OUString        get_by_window(const vcl::Window *pWindow) const;

    void            delete_by_window(vcl::Window *pWindow);

};

namespace BuilderUtils

{

    //apply the properties of rProps to pWindow

    void set_properties(vcl::Window *pWindow, const VclBuilder::stringmap &rProps);

    //Convert _ gtk markup to ~ vcl markup

    OUString convertMnemonicMarkup(std::u16string_view rIn);

    OUString extractCustomProperty(VclBuilder::stringmap &rMap);

    bool extractDropdown(VclBuilder::stringmap &rMap);

    //add a default value of 25 width-chars to a map if width-chars not set

    void ensureDefaultWidthChars(VclBuilder::stringmap &rMap);

    //Helpers to retrofit all the existing code to the builder

    void reorderWithinParent(std::vector< vcl::Window*>& rChilds, bool bIsButtonBox);

    void reorderWithinParent(vcl::Window &rWindow, sal_uInt16 nNewPosition);

    //Convert an accessibility role name to accessibility role number

    sal_Int16 getRoleFromName(std::u16string_view roleName);

}

//sID may not exist, but must be of type T if it does

template <typename T>

inline T* VclBuilder::get(std::u16string_view sID)

{

    vcl::Window *w = get_by_name(sID);

    SAL_WARN_IF(w && !dynamic_cast<T*>(w), "vcl.layout",

                ".ui widget \"" << OUStringToOString(sID, RTL_TEXTENCODING_UTF8)

                                << "\" needs to correspond to vcl type " << typeid(T).name());

    assert(!w || dynamic_cast<T*>(w));

    return static_cast<T*>(w);

}

Unexecuted instantiation: vcl::Window* VclBuilder::get<vcl::Window>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: MessageDialog* VclBuilder::get<MessageDialog>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: Dialog* VclBuilder::get<Dialog>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: vcl::RoadmapWizard* VclBuilder::get<vcl::RoadmapWizard>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: VclBox* VclBuilder::get<VclBox>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: VclGrid* VclBuilder::get<VclGrid>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: VclPaned* VclBuilder::get<VclPaned>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: VclFrame* VclBuilder::get<VclFrame>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: VclScrolledWindow* VclBuilder::get<VclScrolledWindow>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: Button* VclBuilder::get<Button>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: MenuButton* VclBuilder::get<MenuButton>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: FixedHyperlink* VclBuilder::get<FixedHyperlink>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: PushButton* VclBuilder::get<PushButton>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: RadioButton* VclBuilder::get<RadioButton>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: CheckBox* VclBuilder::get<CheckBox>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: Slider* VclBuilder::get<Slider>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: ProgressBar* VclBuilder::get<ProgressBar>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: Throbber* VclBuilder::get<Throbber>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: FixedImage* VclBuilder::get<FixedImage>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: Calendar* VclBuilder::get<Calendar>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: Edit* VclBuilder::get<Edit>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: FormattedField* VclBuilder::get<FormattedField>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: SvTabListBox* VclBuilder::get<SvTabListBox>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: IconView* VclBuilder::get<IconView>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: Control* VclBuilder::get<Control>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: VclMultiLineEdit* VclBuilder::get<VclMultiLineEdit>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: VclExpander* VclBuilder::get<VclExpander>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: VclDrawingArea* VclBuilder::get<VclDrawingArea>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: DockingWindow* VclBuilder::get<DockingWindow>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: ToolBox* VclBuilder::get<ToolBox>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: ScrollBar* VclBuilder::get<ScrollBar>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: FixedText* VclBuilder::get<FixedText>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

Unexecuted instantiation: VclHBox* VclBuilder::get<VclHBox>(std::__1::basic_string_view<char16_t, std::__1::char_traits<char16_t> >)

/*

 * @return true if rValue is "True", "true", "1", etc.

 */

VCL_DLLPUBLIC bool toBool(std::u16string_view rValue);

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