Adding upstream version 4:24.2.0.upstream/4%24.2.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1119 insertions, 0 deletions

diff --git a/include/svtools/editbrowsebox.hxx b/include/svtools/editbrowsebox.hxx
new file mode 100644
index 0000000000..c89a396a9d
--- /dev/null
+++ b/include/svtools/editbrowsebox.hxx
@@ -0,0 +1,1119 @@
+/* -*- 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 <memory>
+#include <svtools/svtdllapi.h>
+#include <tools/ref.hxx>
+
+#include <svtools/brwbox.hxx>
+#include <svtools/brwhead.hxx>
+#include <tools/lineend.hxx>
+#include <vcl/InterimItemWindow.hxx>
+#include <vcl/weldutils.hxx>
+#include <o3tl/typed_flags_set.hxx>
+
+class BrowserDataWin;
+
+// EditBrowseBoxFlags (EBBF)
+enum class EditBrowseBoxFlags
+{
+    NONE                       = 0x0000,
+/** if this bit is _not_ set, the handle column will be invalidated upon
+    changing the row in the browse box.  This is for forcing the row picture to
+    be repainted. If you do not have row pictures or text, you don't need this
+    invalidation, then you would specify this bit to prevent flicker
+*/
+    NO_HANDLE_COLUMN_CONTENT   = 0x0001,
+/** set this bit to activate the cell on a MouseButtonDown, not a MouseButtonUp event
+ */
+    ACTIVATE_ON_BUTTONDOWN     = 0x0002,
+/** if this bit is set and EditBrowseBoxFlags::NO_HANDLE_COLUMN_CONTENT is _not_ set, the handle
+    column is drawn with the text contained in column 0 instead of an image
+*/
+    HANDLE_COLUMN_TEXT         = 0x0004,
+
+/** If this bit is set, tab traveling is somewhat modified<br/>
+    If the control gets the focus because the user pressed the TAB key, then the
+    first or last cell (depending on whether the traveling was cycling forward or backward)
+    gets activated.
+    @see Window::GetGetFocusFlags
+    @see GETFOCUS_*
+*/
+    SMART_TAB_TRAVEL           = 0x0008,
+
+};
+namespace o3tl
+{
+    template<> struct typed_flags<EditBrowseBoxFlags> : is_typed_flags<EditBrowseBoxFlags, 0x0f> {};
+}
+
+namespace svt
+{
+    class ControlBase;
+
+    class SVT_DLLPUBLIC CellController : public SvRefBase
+    {
+        friend class EditBrowseBox;
+        Link<LinkParamNone*, void> maModifyHdl;
+
+        VclPtr<ControlBase>        pWindow;
+        bool                       bSuspended;     // <true> if the window is hidden and disabled
+
+    public:
+
+        CellController(ControlBase* pW);
+        virtual ~CellController() override;
+
+        ControlBase& GetWindow() const { return *const_cast<CellController*>(this)->pWindow; }
+
+        virtual void SaveValue() = 0;
+        virtual bool IsValueChangedFromSaved() const = 0;
+
+        // commit any current changes. Especially, do any reformatting you need (from input formatting
+        // to output formatting) here
+        virtual void CommitModifications();
+
+        // suspending the controller is not cumulative!
+                void        suspend( );
+                void        resume( );
+        bool        isSuspended( ) const { return bSuspended; }
+
+    protected:
+        virtual bool MoveAllowed(const KeyEvent& rEvt) const;
+        void SetModifyHdl(const Link<LinkParamNone*,void>& rLink) { maModifyHdl = rLink; }
+        virtual void ActivatingMouseEvent(const BrowserMouseEvent& rEvt, bool bUp);
+        virtual void callModifyHdl() { maModifyHdl.Call(nullptr); }
+    };
+
+    typedef tools::SvRef<CellController> CellControllerRef;
+
+
+    //= IEditImplementation
+
+    class SVT_DLLPUBLIC IEditImplementation
+    {
+    public:
+        virtual ~IEditImplementation() = 0;
+
+        virtual ControlBase&        GetControl() = 0;
+
+        virtual OUString            GetText( LineEnd aSeparator ) const = 0;
+        virtual void                SetText( const OUString& _rStr ) = 0;
+
+        virtual bool                IsReadOnly() const = 0;
+        virtual void                SetReadOnly( bool bReadOnly ) = 0;
+
+        virtual sal_Int32           GetMaxTextLen() const = 0;
+        virtual void                SetMaxTextLen( sal_Int32 _nMaxLen ) = 0;
+
+        virtual Selection           GetSelection() const = 0;
+        virtual void                SetSelection( const Selection& _rSelection ) = 0;
+
+        virtual void                ReplaceSelected( const OUString& _rStr ) = 0;
+        virtual OUString            GetSelected( LineEnd aSeparator ) const = 0;
+
+        virtual bool                IsValueChangedFromSaved() const = 0;
+        virtual void                SaveValue() = 0;
+
+        virtual bool                CanUp() const = 0;
+        virtual bool                CanDown() const = 0;
+
+        virtual void                Cut() = 0;
+        virtual void                Copy() = 0;
+        virtual void                Paste() = 0;
+
+        // sets a link to call when the text is changed by the user
+        void SetModifyHdl(const Link<LinkParamNone*,void>& rLink)
+        {
+            m_aModify1Hdl = rLink;
+        }
+
+        // sets an additional link to call when the text is changed by the user
+        void SetAuxModifyHdl(const Link<LinkParamNone*,void>& rLink)
+        {
+            m_aModify2Hdl = rLink;
+        }
+
+    private:
+        Link<LinkParamNone*,void> m_aModify1Hdl;
+        Link<LinkParamNone*,void> m_aModify2Hdl;
+
+    protected:
+        void CallModifyHdls()
+        {
+            m_aModify1Hdl.Call(nullptr);
+            m_aModify2Hdl.Call(nullptr);
+        }
+    };
+
+    class SVT_DLLPUBLIC ControlBase : public InterimItemWindow
+    {
+    public:
+        ControlBase(BrowserDataWin* pParent, const OUString& rUIXMLDescription, const OUString& rID);
+
+        virtual void SetEditableReadOnly(bool bReadOnly);
+
+        virtual bool ProcessKey(const KeyEvent& rKEvt);
+
+        virtual void SetPointFont(const vcl::Font& rFont) = 0;
+
+        // chain after the FocusInHdl
+        void SetFocusInHdl(const Link<LinkParamNone*,void>& rHdl)
+        {
+            m_aFocusInHdl = rHdl;
+        }
+
+        // chain after the FocusOutHdl
+        void SetFocusOutHdl(const Link<LinkParamNone*,void>& rHdl)
+        {
+            m_aFocusOutHdl = rHdl;
+        }
+
+        void SetMousePressHdl(const Link<const MouseEvent&,void>& rHdl)
+        {
+            m_aMousePressHdl = rHdl;
+        }
+
+        void SetMouseReleaseHdl(const Link<const MouseEvent&,void>& rHdl)
+        {
+            m_aMouseReleaseHdl = rHdl;
+        }
+
+        void SetMouseMoveHdl(const Link<const MouseEvent&,void>& rHdl)
+        {
+            m_aMouseMoveHdl = rHdl;
+        }
+
+        void SetKeyInputHdl(const Link<const KeyEvent&,void>& rHdl)
+        {
+            m_aKeyInputHdl = rHdl;
+        }
+
+        void SetKeyReleaseHdl(const Link<const KeyEvent&,void>& rHdl)
+        {
+            m_aKeyReleaseHdl = rHdl;
+        }
+
+    protected:
+        DECL_DLLPRIVATE_LINK(KeyInputHdl, const KeyEvent&, bool);
+        DECL_DLLPRIVATE_LINK(KeyReleaseHdl, const KeyEvent&, bool);
+        DECL_DLLPRIVATE_LINK(FocusInHdl, weld::Widget&, void);
+        DECL_DLLPRIVATE_LINK(FocusOutHdl, weld::Widget&, void);
+        DECL_DLLPRIVATE_LINK(MousePressHdl, const MouseEvent&, bool);
+        DECL_DLLPRIVATE_LINK(MouseReleaseHdl, const MouseEvent&, bool);
+        DECL_DLLPRIVATE_LINK(MouseMoveHdl, const MouseEvent&, bool);
+    private:
+        Link<LinkParamNone*,void> m_aFocusInHdl;
+        Link<LinkParamNone*,void> m_aFocusOutHdl;
+        Link<const MouseEvent&,void> m_aMousePressHdl;
+        Link<const MouseEvent&,void> m_aMouseReleaseHdl;
+        Link<const MouseEvent&,void> m_aMouseMoveHdl;
+        Link<const KeyEvent&,void> m_aKeyInputHdl;
+        Link<const KeyEvent&,void> m_aKeyReleaseHdl;
+    };
+
+    class SVT_DLLPUBLIC EditControlBase : public ControlBase
+    {
+    public:
+        EditControlBase(BrowserDataWin* pParent);
+
+        virtual void SetEditableReadOnly(bool bReadOnly) override
+        {
+            m_pEntry->set_editable(!bReadOnly);
+        }
+
+        virtual void SetPointFont(const vcl::Font& rFont) override
+        {
+            m_pEntry->set_font(rFont);
+        }
+
+        virtual void dispose() override;
+
+        weld::Entry& get_widget() { return *m_pEntry; }
+
+        virtual void connect_changed(const Link<weld::Entry&, void>& rLink) = 0;
+        virtual void connect_focus_in(const Link<weld::Widget&, void>& rLink) = 0;
+        virtual void connect_focus_out(const Link<weld::Widget&, void>& rLink) = 0;
+        virtual void connect_key_press(const Link<const KeyEvent&, bool>& rLink) = 0;
+
+    protected:
+        void InitEditControlBase(weld::Entry* pEntry);
+
+    private:
+        weld::Entry* m_pEntry;
+    };
+
+    class SVT_DLLPUBLIC EditControl : public EditControlBase
+    {
+    public:
+        EditControl(BrowserDataWin* pParent);
+
+        virtual void dispose() override;
+
+        virtual void connect_changed(const Link<weld::Entry&, void>& rLink) override
+        {
+            m_xWidget->connect_changed(rLink);
+        }
+
+        virtual void connect_focus_in(const Link<weld::Widget&, void>& rLink) override
+        {
+            m_xWidget->connect_focus_in(rLink);
+        }
+
+        virtual void connect_focus_out(const Link<weld::Widget&, void>& rLink) override
+        {
+            m_xWidget->connect_focus_out(rLink);
+        }
+
+        virtual void connect_key_press(const Link<const KeyEvent&, bool>& rLink) override
+        {
+            m_xWidget->connect_key_press(rLink);
+        }
+
+    protected:
+        std::unique_ptr<weld::Entry> m_xWidget;
+    };
+
+    class SVT_DLLPUBLIC EntryImplementation final : public IEditImplementation
+    {
+        EditControlBase& m_rEdit;
+        int m_nMaxTextLen;
+
+        DECL_LINK(ModifyHdl, weld::Entry&, void);
+    public:
+        EntryImplementation(EditControlBase& rEdit)
+            : m_rEdit(rEdit)
+            , m_nMaxTextLen(0)
+        {
+            m_rEdit.connect_changed(LINK(this, EntryImplementation, ModifyHdl));
+        }
+
+        virtual ControlBase& GetControl() override
+        {
+            return m_rEdit;
+        }
+
+        virtual OUString GetText( LineEnd /*aSeparator*/ ) const override
+        {
+            // ignore the line end - this base implementation does not support it
+            return m_rEdit.get_widget().get_text();
+        }
+
+        virtual void SetText( const OUString& _rStr ) override
+        {
+            return m_rEdit.get_widget().set_text(_rStr);
+        }
+
+        virtual bool IsReadOnly() const override
+        {
+            return !m_rEdit.get_widget().get_editable();
+        }
+
+        virtual void SetReadOnly( bool bReadOnly ) override
+        {
+            m_rEdit.SetEditableReadOnly(bReadOnly);
+        }
+
+        virtual sal_Int32 GetMaxTextLen() const override
+        {
+            return m_nMaxTextLen;
+        }
+
+        virtual void SetMaxTextLen( sal_Int32 nMaxLen ) override
+        {
+            m_nMaxTextLen = nMaxLen;
+            m_rEdit.get_widget().set_max_length(m_nMaxTextLen);
+        }
+
+        virtual Selection GetSelection() const override
+        {
+            int nStartPos, nEndPos;
+            m_rEdit.get_widget().get_selection_bounds(nStartPos, nEndPos);
+            return Selection(nStartPos, nEndPos);
+        }
+
+        virtual void SetSelection( const Selection& rSelection ) override
+        {
+            auto nMin = rSelection.Min();
+            auto nMax = rSelection.Max();
+            m_rEdit.get_widget().select_region(nMin < 0 ? 0 : nMin, nMax == SELECTION_MAX ? -1 : nMax);
+        }
+
+        virtual void ReplaceSelected( const OUString& rStr ) override
+        {
+            m_rEdit.get_widget().replace_selection(rStr);
+        }
+
+        virtual OUString GetSelected( LineEnd /*aSeparator*/ ) const override
+            // ignore the line end - this base implementation does not support it
+        {
+            int nStartPos, nEndPos;
+            weld::Entry& rEntry = m_rEdit.get_widget();
+            rEntry.get_selection_bounds(nStartPos, nEndPos);
+            return rEntry.get_text().copy(std::min(nStartPos, nEndPos), std::abs(nEndPos - nStartPos));
+        }
+
+        virtual bool IsValueChangedFromSaved() const override
+        {
+            return m_rEdit.get_widget().get_value_changed_from_saved();
+        }
+
+        virtual void SaveValue() override
+        {
+            m_rEdit.get_widget().save_value();
+        }
+
+        virtual bool CanUp() const override
+        {
+            return false;
+        }
+
+        virtual bool CanDown() const override
+        {
+            return false;
+        }
+
+        virtual void Cut() override
+        {
+            m_rEdit.get_widget().cut_clipboard();
+        }
+
+        virtual void Copy() override
+        {
+            m_rEdit.get_widget().copy_clipboard();
+        }
+
+        virtual void Paste() override
+        {
+            m_rEdit.get_widget().paste_clipboard();
+        }
+    };
+
+    //= MultiLineTextCell
+
+    /** a multi line edit which can be used in a cell of an EditBrowseBox
+    */
+    class SVT_DLLPUBLIC MultiLineTextCell final : public ControlBase
+    {
+    public:
+        MultiLineTextCell(BrowserDataWin* pParent);
+
+        virtual void SetEditableReadOnly(bool bReadOnly) override
+        {
+            m_xWidget->set_editable(!bReadOnly);
+        }
+
+        virtual void SetPointFont(const vcl::Font& rFont) override
+        {
+            m_xWidget->set_font(rFont);
+        }
+
+        virtual void GetFocus() override;
+
+        virtual void dispose() override;
+
+        void connect_changed(const Link<weld::TextView&, void>& rLink)
+        {
+            m_xWidget->connect_changed(rLink);
+        }
+
+        weld::TextView& get_widget() { return *m_xWidget; }
+
+    private:
+        std::unique_ptr<weld::TextView> m_xWidget;
+
+        virtual bool ProcessKey(const KeyEvent& rKEvt) override;
+    };
+
+    class SVT_DLLPUBLIC MultiLineEditImplementation final : public IEditImplementation
+    {
+        MultiLineTextCell& m_rEdit;
+        int m_nMaxTextLen;
+
+        DECL_LINK(ModifyHdl, weld::TextView&, void);
+    public:
+        MultiLineEditImplementation(MultiLineTextCell& rEdit)
+            : m_rEdit(rEdit)
+            , m_nMaxTextLen(0)
+        {
+            m_rEdit.connect_changed(LINK(this, MultiLineEditImplementation, ModifyHdl));
+        }
+
+        virtual ControlBase& GetControl() override
+        {
+            return m_rEdit;
+        }
+
+        virtual OUString GetText(LineEnd aSeparator) const override;
+
+        virtual void SetText(const OUString& rStr) override
+        {
+            return m_rEdit.get_widget().set_text(rStr);
+        }
+
+        virtual bool IsReadOnly() const override
+        {
+            return !m_rEdit.get_widget().get_editable();
+        }
+
+        virtual void SetReadOnly( bool bReadOnly ) override
+        {
+            m_rEdit.SetEditableReadOnly(bReadOnly);
+        }
+
+        virtual sal_Int32 GetMaxTextLen() const override
+        {
+            return m_nMaxTextLen;
+        }
+
+        virtual void SetMaxTextLen( sal_Int32 nMaxLen ) override
+        {
+            m_nMaxTextLen = nMaxLen;
+            m_rEdit.get_widget().set_max_length(m_nMaxTextLen);
+        }
+
+        virtual Selection GetSelection() const override
+        {
+            int nStartPos, nEndPos;
+            m_rEdit.get_widget().get_selection_bounds(nStartPos, nEndPos);
+            return Selection(nStartPos, nEndPos);
+        }
+
+        virtual void SetSelection( const Selection& rSelection ) override
+        {
+            auto nMin = rSelection.Min();
+            auto nMax = rSelection.Max();
+            m_rEdit.get_widget().select_region(nMin < 0 ? 0 : nMin, nMax == SELECTION_MAX ? -1 : nMax);
+        }
+
+        virtual void ReplaceSelected( const OUString& rStr ) override
+        {
+            m_rEdit.get_widget().replace_selection(rStr);
+        }
+
+        virtual OUString GetSelected( LineEnd aSeparator ) const override;
+
+        virtual bool IsValueChangedFromSaved() const override
+        {
+            return m_rEdit.get_widget().get_value_changed_from_saved();
+        }
+
+        virtual void SaveValue() override
+        {
+            m_rEdit.get_widget().save_value();
+        }
+
+        virtual bool CanUp() const override
+        {
+            return m_rEdit.get_widget().can_move_cursor_with_up();
+        }
+
+        virtual bool CanDown() const override
+        {
+            return m_rEdit.get_widget().can_move_cursor_with_down();
+        }
+
+        virtual void Cut() override
+        {
+            m_rEdit.get_widget().cut_clipboard();
+        }
+
+        virtual void Copy() override
+        {
+            m_rEdit.get_widget().copy_clipboard();
+        }
+
+        virtual void Paste() override
+        {
+            m_rEdit.get_widget().paste_clipboard();
+        }
+    };
+
+
+    //= EditCellController
+    class SVT_DLLPUBLIC EditCellController : public CellController
+    {
+        IEditImplementation*    m_pEditImplementation;
+        bool                    m_bOwnImplementation;   // did we create m_pEditImplementation?
+
+    public:
+        EditCellController( EditControlBase* _pEdit );
+        EditCellController( IEditImplementation* _pImplementation );
+        virtual ~EditCellController( ) override;
+
+        const IEditImplementation* GetEditImplementation( ) const { return m_pEditImplementation; }
+              IEditImplementation* GetEditImplementation( )       { return m_pEditImplementation; }
+
+        virtual bool IsValueChangedFromSaved() const override;
+        virtual void SaveValue() override;
+
+        void Modify()
+        {
+            ModifyHdl(nullptr);
+        }
+
+    protected:
+        virtual bool MoveAllowed(const KeyEvent& rEvt) const override;
+    private:
+        DECL_LINK(ModifyHdl, LinkParamNone*, void);
+    };
+
+    //= CheckBoxControl
+    class SVT_DLLPUBLIC CheckBoxControl final : public ControlBase
+    {
+        std::unique_ptr<weld::CheckButton> m_xBox;
+        weld::TriStateEnabled m_aModeState;
+        Link<weld::CheckButton&,void> m_aToggleLink;
+        Link<LinkParamNone*,void> m_aModify1Hdl;
+        Link<LinkParamNone*,void> m_aModify2Hdl;
+
+    public:
+        CheckBoxControl(BrowserDataWin* pParent);
+        virtual ~CheckBoxControl() override;
+        virtual void dispose() override;
+
+        virtual void SetPointFont(const vcl::Font& rFont) override;
+
+        void SetToggleHdl(const Link<weld::CheckButton&,void>& rHdl) {m_aToggleLink = rHdl;}
+
+        // sets a link to call when the text is changed by the user
+        void SetModifyHdl(const Link<LinkParamNone*,void>& rHdl)
+        {
+            m_aModify1Hdl = rHdl;
+        }
+
+        // sets an additional link to call when the text is changed by the user
+        void SetAuxModifyHdl(const Link<LinkParamNone*,void>& rLink)
+        {
+            m_aModify2Hdl = rLink;
+        }
+
+        void SetState(TriState eState);
+        TriState GetState() const { return m_xBox->get_state(); }
+
+        void EnableTriState(bool bTriState);
+
+        weld::CheckButton&   GetBox() {return *m_xBox;};
+
+        // for pseudo-click when initially clicking in a cell activates
+        // the cell and performs a state change on the button as if
+        // it was clicked on
+        void Clicked();
+
+    private:
+        DECL_DLLPRIVATE_LINK(OnToggle, weld::Toggleable&, void);
+
+        void CallModifyHdls()
+        {
+            m_aModify1Hdl.Call(nullptr);
+            m_aModify2Hdl.Call(nullptr);
+        }
+    };
+
+    //= CheckBoxCellController
+    class SVT_DLLPUBLIC CheckBoxCellController final : public CellController
+    {
+    public:
+
+        CheckBoxCellController(CheckBoxControl* pWin);
+        weld::CheckButton& GetCheckBox() const;
+
+        virtual bool IsValueChangedFromSaved() const override;
+        virtual void SaveValue() override;
+
+    private:
+        virtual void ActivatingMouseEvent(const BrowserMouseEvent& rEvt, bool bUp) override;
+        DECL_DLLPRIVATE_LINK(ModifyHdl, LinkParamNone*, void);
+    };
+
+    //= ComboBoxControl
+    class SVT_DLLPUBLIC ComboBoxControl final : public ControlBase
+    {
+    private:
+        std::unique_ptr<weld::ComboBox> m_xWidget;
+        Link<LinkParamNone*,void> m_aModify1Hdl;
+        Link<bool,void> m_aModify2Hdl;
+
+        friend class ComboBoxCellController;
+
+    public:
+        ComboBoxControl(BrowserDataWin* pParent);
+
+        virtual void SetPointFont(const vcl::Font& rFont) override;
+
+        virtual void SetEditableReadOnly(bool bReadOnly) override
+        {
+            m_xWidget->set_entry_editable(!bReadOnly);
+        }
+
+        weld::ComboBox& get_widget() { return *m_xWidget; }
+
+        // sets a link to call when the selection is changed by the user
+        void SetModifyHdl(const Link<LinkParamNone*,void>& rHdl)
+        {
+            m_aModify1Hdl = rHdl;
+        }
+
+        // sets an additional link to call when the selection is changed by the user
+        // bool arg is true when triggered interactively by the user
+        void SetAuxModifyHdl(const Link<bool,void>& rLink)
+        {
+            m_aModify2Hdl = rLink;
+        }
+
+        void TriggerAuxModify()
+        {
+            m_aModify2Hdl.Call(false);
+        }
+
+        virtual void dispose() override;
+
+    private:
+        DECL_DLLPRIVATE_LINK(SelectHdl, weld::ComboBox&, void);
+
+        void CallModifyHdls()
+        {
+            m_aModify1Hdl.Call(nullptr);
+            m_aModify2Hdl.Call(true);
+        }
+    };
+
+    //= ComboBoxCellController
+    class SVT_DLLPUBLIC ComboBoxCellController final : public CellController
+    {
+    public:
+
+        ComboBoxCellController(ComboBoxControl* pParent);
+        weld::ComboBox& GetComboBox() const { return static_cast<ComboBoxControl&>(GetWindow()).get_widget(); }
+
+        virtual bool IsValueChangedFromSaved() const override;
+        virtual void SaveValue() override;
+
+    private:
+        virtual bool MoveAllowed(const KeyEvent& rEvt) const override;
+        DECL_DLLPRIVATE_LINK(ModifyHdl, LinkParamNone*, void);
+    };
+
+    //= ListBoxControl
+    class SVT_DLLPUBLIC ListBoxControl final : public ControlBase
+    {
+    private:
+        std::unique_ptr<weld::ComboBox> m_xWidget;
+        Link<LinkParamNone*,void> m_aModify1Hdl;
+        Link<bool,void> m_aModify2Hdl;
+
+        friend class ListBoxCellController;
+
+    public:
+        ListBoxControl(BrowserDataWin* pParent);
+
+        virtual void SetPointFont(const vcl::Font& rFont) override;
+
+        weld::ComboBox& get_widget() { return *m_xWidget; }
+
+        // sets a link to call when the selection is changed by the user
+        void SetModifyHdl(const Link<LinkParamNone*,void>& rHdl)
+        {
+            m_aModify1Hdl = rHdl;
+        }
+
+        // sets an additional link to call when the selection is changed,
+        // bool arg is true when triggered interactively by the user
+        void SetAuxModifyHdl(const Link<bool,void>& rLink)
+        {
+            m_aModify2Hdl = rLink;
+        }
+
+        void TriggerAuxModify()
+        {
+            m_aModify2Hdl.Call(false);
+        }
+
+        virtual void dispose() override;
+    private:
+        DECL_DLLPRIVATE_LINK(SelectHdl, weld::ComboBox&, void);
+
+        void CallModifyHdls()
+        {
+            m_aModify1Hdl.Call(nullptr);
+            m_aModify2Hdl.Call(true);
+        }
+    };
+
+    //= ListBoxCellController
+    class SVT_DLLPUBLIC ListBoxCellController : public CellController
+    {
+    public:
+
+        ListBoxCellController(ListBoxControl* pParent);
+        weld::ComboBox& GetListBox() const { return static_cast<ListBoxControl&>(GetWindow()).get_widget(); }
+
+        virtual bool IsValueChangedFromSaved() const override;
+        virtual void SaveValue() override;
+
+    protected:
+        virtual bool MoveAllowed(const KeyEvent& rEvt) const override;
+    private:
+        DECL_DLLPRIVATE_LINK(ListBoxSelectHdl, LinkParamNone*, void);
+    };
+
+    class SVT_DLLPUBLIC FormattedControlBase : public EditControlBase
+    {
+    public:
+        FormattedControlBase(BrowserDataWin* pParent, bool bSpinVariant);
+
+        virtual void dispose() override;
+
+        virtual void connect_changed(const Link<weld::Entry&, void>& rLink) override;
+        virtual void connect_focus_in(const Link<weld::Widget&, void>& rLink) override;
+        virtual void connect_focus_out(const Link<weld::Widget&, void>& rLink) override;
+        virtual void connect_key_press(const Link<const KeyEvent&, bool>& rLink) override;
+
+        weld::EntryFormatter& get_formatter();
+
+    protected:
+        bool m_bSpinVariant;
+        std::unique_ptr<weld::Entry> m_xEntry;
+        std::unique_ptr<weld::FormattedSpinButton> m_xSpinButton;
+        std::unique_ptr<weld::EntryFormatter> m_xEntryFormatter;
+
+        void InitFormattedControlBase();
+    };
+
+    class SVT_DLLPUBLIC FormattedControl final : public FormattedControlBase
+    {
+    public:
+        FormattedControl(BrowserDataWin* pParent, bool bSpinVariant);
+    };
+
+    class SVT_DLLPUBLIC DoubleNumericControl final : public FormattedControlBase
+    {
+    public:
+        DoubleNumericControl(BrowserDataWin* pParent, bool bSpinVariant);
+    };
+
+    class SVT_DLLPUBLIC LongCurrencyControl final : public FormattedControlBase
+    {
+    public:
+        LongCurrencyControl(BrowserDataWin* pParent, bool bSpinVariant);
+    };
+
+    class SVT_DLLPUBLIC TimeControl final : public FormattedControlBase
+    {
+    public:
+        TimeControl(BrowserDataWin* pParent, bool bSpinVariant);
+    };
+
+    class SVT_DLLPUBLIC DateControl final : public FormattedControlBase
+    {
+    public:
+        DateControl(BrowserDataWin* pParent, bool bDropDown);
+
+        void SetDate(const Date& rDate);
+
+        virtual void dispose() override;
+    private:
+        std::unique_ptr<weld::MenuButton> m_xMenuButton;
+        std::unique_ptr<weld::Builder> m_xCalendarBuilder;
+        std::unique_ptr<weld::Widget> m_xTopLevel;
+        std::unique_ptr<weld::Calendar> m_xCalendar;
+        std::unique_ptr<weld::Widget> m_xExtras;
+        std::unique_ptr<weld::Button> m_xTodayBtn;
+        std::unique_ptr<weld::Button> m_xNoneBtn;
+
+        DECL_DLLPRIVATE_LINK(ToggleHdl, weld::Toggleable&, void);
+        DECL_DLLPRIVATE_LINK(ActivateHdl, weld::Calendar&, void);
+        DECL_DLLPRIVATE_LINK(ImplClickHdl, weld::Button&, void);
+    };
+
+    class SVT_DLLPUBLIC PatternControl final : public EditControlBase
+    {
+    public:
+        PatternControl(BrowserDataWin* pParent);
+
+        weld::PatternFormatter& get_formatter() { return *m_xEntryFormatter; }
+
+        virtual void connect_changed(const Link<weld::Entry&, void>& rLink) override;
+        virtual void connect_focus_in(const Link<weld::Widget&, void>& rLink) override;
+        virtual void connect_focus_out(const Link<weld::Widget&, void>& rLink) override;
+        virtual void connect_key_press(const Link<const KeyEvent&, bool>& rLink) override;
+
+        virtual void dispose() override;
+    private:
+        std::unique_ptr<weld::Entry> m_xWidget;
+        std::unique_ptr<weld::PatternFormatter> m_xEntryFormatter;
+    };
+
+    //= FormattedFieldCellController
+    class SVT_DLLPUBLIC FormattedFieldCellController final : public EditCellController
+    {
+    public:
+        FormattedFieldCellController( FormattedControlBase* _pFormatted );
+
+        virtual void CommitModifications() override;
+    };
+
+    //= EditBrowserHeader
+    class SVT_DLLPUBLIC EditBrowserHeader : public BrowserHeader
+    {
+    public:
+        EditBrowserHeader( BrowseBox* pParent, WinBits nWinBits = WB_BUTTONSTYLE )
+            :BrowserHeader(pParent, nWinBits){}
+
+    protected:
+        virtual void DoubleClick() override;
+    };
+
+
+    //= EditBrowseBox
+    class EditBrowseBoxImpl;
+    class SVT_DLLPUBLIC EditBrowseBox: public BrowseBox
+    {
+        friend class EditBrowserHeader;
+
+        enum BrowseInfo
+        {
+            COLSELECT   =   1,
+            ROWSELECT   =   2,
+            ROWCHANGE   =   4,
+            COLCHANGE   =   8
+        };
+
+    public:
+        enum RowStatus
+        {
+            CLEAN               =   0,
+            CURRENT             =   1,
+            CURRENTNEW          =   2,
+            MODIFIED            =   3,
+            NEW                 =   4,
+            DELETED             =   5,
+            PRIMARYKEY          =   6,
+            CURRENT_PRIMARYKEY  =   7,
+            FILTER              =   8,
+            HEADERFOOTER        =   9
+        };
+
+    private:
+        EditBrowseBox(EditBrowseBox const &) = delete;
+        EditBrowseBox& operator=(EditBrowseBox const &) = delete;
+
+        class BrowserMouseEventPtr
+        {
+            std::unique_ptr<BrowserMouseEvent> pEvent;
+            bool               bDown;
+
+        public:
+            BrowserMouseEventPtr()
+                : bDown(false)
+            {
+            }
+
+            bool Is() const {return pEvent != nullptr;}
+            bool IsDown() const {return bDown;}
+            const BrowserMouseEvent* operator->() const {return pEvent.get();}
+
+            SVT_DLLPUBLIC void Clear();
+            void Set(const BrowserMouseEvent* pEvt, bool bIsDown);
+        } aMouseEvent;
+
+        CellControllerRef        aController,
+                                 aOldController;
+
+        ImplSVEvent * nStartEvent, * nEndEvent, * nCellModifiedEvent;     // event ids
+        VclPtr<vcl::Window> m_pFocusWhileRequest;
+            // In ActivateCell, we grab the focus asynchronously, but if between requesting activation
+            // and the asynchronous event the focus has changed, we won't grab it for ourself.
+
+        sal_Int32   nPaintRow;  // row being painted
+        sal_Int32   nEditRow;
+        sal_uInt16  nEditCol;
+
+        bool            bHasFocus : 1;
+        mutable bool    bPaintStatus : 1;   // paint a status (image) in the handle column
+        bool            bActiveBeforeTracking;
+
+        VclPtr<CheckBoxControl> pCheckBoxPaint;
+
+        EditBrowseBoxFlags  m_nBrowserFlags;
+        std::unique_ptr< EditBrowseBoxImpl> m_aImpl;
+
+    protected:
+        VclPtr<BrowserHeader>  pHeader;
+
+        BrowserMouseEventPtr& getMouseEvent() { return aMouseEvent; }
+
+    protected:
+        BrowserHeader*  GetHeaderBar() const {return pHeader;}
+
+        virtual VclPtr<BrowserHeader> CreateHeaderBar(BrowseBox* pParent) override;
+
+        // if you want to have an own header ...
+        virtual VclPtr<BrowserHeader> imp_CreateHeaderBar(BrowseBox* pParent);
+
+        virtual void ColumnMoved(sal_uInt16 nId) override;
+        virtual void ColumnResized(sal_uInt16 nColId) override;
+        virtual void Resize() override;
+        virtual void ArrangeControls(sal_uInt16& nX, sal_uInt16 nY);
+        virtual bool SeekRow(sal_Int32 nRow) override;
+
+        virtual void GetFocus() override;
+        virtual void LoseFocus() override;
+        virtual void KeyInput(const KeyEvent& rEvt) override;
+        virtual void MouseButtonDown(const BrowserMouseEvent& rEvt) override;
+        virtual void MouseButtonUp(const BrowserMouseEvent& rEvt) override;
+        virtual void StateChanged( StateChangedType nType ) override;
+        virtual void DataChanged( const DataChangedEvent& rDCEvt ) override;
+
+        using BrowseBox::MouseButtonUp;
+        using BrowseBox::MouseButtonDown;
+
+        virtual bool PreNotify(NotifyEvent& rNEvt ) override;
+        virtual bool EventNotify(NotifyEvent& rNEvt) override;
+
+        virtual void EndScroll() override;
+
+        // should be used instead of GetFieldRectPixel, 'cause this method here takes into account the borders
+        tools::Rectangle GetCellRect(sal_Int32 nRow, sal_uInt16 nColId, bool bRelToBrowser = true) const;
+        virtual sal_uInt32 GetTotalCellWidth(sal_Int32 nRow, sal_uInt16 nColId);
+        sal_uInt32 GetAutoColumnWidth(sal_uInt16 nColId);
+
+        virtual void PaintStatusCell(OutputDevice& rDev, const tools::Rectangle& rRect) const;
+        virtual void PaintCell(OutputDevice& rDev, const tools::Rectangle& rRect, sal_uInt16 nColId) const = 0;
+
+        virtual RowStatus GetRowStatus(sal_Int32 nRow) const;
+
+        virtual void    RowHeightChanged() override;
+
+        // callbacks for the data window
+        virtual void    ImplStartTracking() override;
+        virtual void    ImplEndTracking() override;
+
+        // when changing a row:
+        // CursorMoving:    cursor is being moved, but GetCurRow() still provides the old row
+        virtual bool CursorMoving(sal_Int32 nNewRow, sal_uInt16 nNewCol);
+
+        // cursor has been moved
+        virtual void CursorMoved() override;
+
+        virtual void CellModified();        // called whenever a cell has been modified
+        virtual bool SaveModified();    // called whenever a cell should be left, and it's content should be saved
+                                            // return sal_False prevents leaving the cell
+        virtual bool SaveRow();         // commit the current row
+
+        virtual bool IsModified() const {return aController.is() && aController->IsValueChangedFromSaved();}
+
+        virtual CellController* GetController(sal_Int32 nRow, sal_uInt16 nCol);
+        virtual void InitController(CellControllerRef& rController, sal_Int32 nRow, sal_uInt16 nCol);
+        static void ResizeController(CellControllerRef const & rController, const tools::Rectangle&);
+        virtual void DoubleClick(const BrowserMouseEvent&) override;
+
+        void ActivateCell() { ActivateCell(GetCurRow(), GetCurColumnId()); }
+
+        // retrieve the image for the row status
+        Image GetImage(RowStatus) const;
+
+        // inserting columns
+        // if you don't set a width, this will be calculated automatically
+        // if the id isn't set the smallest unused will do it ...
+        virtual sal_uInt16 AppendColumn(const OUString& rName, sal_uInt16 nWidth, sal_uInt16 nPos = HEADERBAR_APPEND, sal_uInt16 nId = sal_uInt16(-1));
+
+        // called whenever (Shift)Tab or Enter is pressed. If true is returned, these keys
+        // result in traveling to the next or to th previous cell
+        virtual bool IsTabAllowed(bool bForward) const;
+
+        virtual bool IsCursorMoveAllowed(sal_Int32 nNewRow, sal_uInt16 nNewColId) const override;
+
+        void    PaintTristate(const tools::Rectangle& rRect, const TriState& eState, bool _bEnabled=true) const;
+
+        void AsynchGetFocus();
+            // secure starting of StartEditHdl
+
+    public:
+        EditBrowseBox(vcl::Window* pParent, EditBrowseBoxFlags nBrowserFlags, WinBits nBits, BrowserMode nMode = BrowserMode::NONE );
+        virtual ~EditBrowseBox() override;
+        virtual void dispose() override;
+
+        bool IsEditing() const {return aController.is();}
+        void InvalidateStatusCell(sal_Int32 nRow) {RowModified(nRow, 0);}
+        void InvalidateHandleColumn();
+
+        // late construction
+        virtual void Init();
+        virtual void RemoveRows();
+        virtual void Dispatch(sal_uInt16 nId);
+
+        const CellControllerRef& Controller() const { return aController; }
+        EditBrowseBoxFlags  GetBrowserFlags() const { return m_nBrowserFlags; }
+        void                SetBrowserFlags(EditBrowseBoxFlags nFlags);
+
+        virtual void ActivateCell(sal_Int32 nRow, sal_uInt16 nCol, bool bSetCellFocus = true);
+        virtual void DeactivateCell(bool bUpdate = true);
+        // Children ---------------------------------------------------------------
+
+        /** @return  The count of additional controls of the control area. */
+        virtual sal_Int32 GetAccessibleControlCount() const override;
+
+        /** Creates the accessible object of an additional control.
+            @param nIndex
+                The 0-based index of the control.
+            @return
+                The XAccessible interface of the specified control. */
+        virtual css::uno::Reference< css::accessibility::XAccessible >
+        CreateAccessibleControl( sal_Int32 nIndex ) override;
+
+        /** Sets focus to current cell of the data table. */
+        virtual void GrabTableFocus() override;
+
+        virtual tools::Rectangle GetFieldCharacterBounds(sal_Int32 _nRow,sal_Int32 _nColumnPos,sal_Int32 nIndex) override;
+        virtual sal_Int32 GetFieldIndexAtPoint(sal_Int32 _nRow,sal_Int32 _nColumnPos,const Point& _rPoint) override;
+
+        virtual bool ProcessKey(const KeyEvent& rEvt) override;
+
+        virtual void ChildFocusIn() override;
+        virtual void ChildFocusOut() override;
+
+        css::uno::Reference< css::accessibility::XAccessible > CreateAccessibleCheckBoxCell(sal_Int32 _nRow, sal_uInt16 _nColumnPos,const TriState& eState);
+        bool ControlHasFocus() const;
+    protected:
+        // creates the accessible which wraps the active cell
+        void    implCreateActiveAccessible( );
+
+    private:
+        virtual void PaintField(vcl::RenderContext& rDev, const tools::Rectangle& rRect,
+                                sal_uInt16 nColumnId ) const override;
+        using Control::ImplInitSettings;
+        SVT_DLLPRIVATE void ImplInitSettings( bool bFont, bool bForeground, bool bBackground );
+        SVT_DLLPRIVATE void DetermineFocus( const GetFocusFlags _nGetFocusFlags = GetFocusFlags::NONE);
+        inline void EnableAndShow() const;
+
+        SVT_DLLPRIVATE void implActivateCellOnMouseEvent(const BrowserMouseEvent& _rEvt, bool _bUp);
+
+        DECL_DLLPRIVATE_LINK( ModifyHdl, LinkParamNone*, void );
+        DECL_DLLPRIVATE_LINK( StartEditHdl, void*, void );
+        DECL_DLLPRIVATE_LINK( EndEditHdl, void*, void );
+        DECL_DLLPRIVATE_LINK( CellModifiedHdl, void*, void );
+    };
+
+
+}   // namespace svt
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */