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, 768 insertions, 0 deletions

diff --git a/svtools/source/brwbox/ebbcontrols.cxx b/svtools/source/brwbox/ebbcontrols.cxx
new file mode 100644
index 0000000000..45b1a3766e
--- /dev/null
+++ b/svtools/source/brwbox/ebbcontrols.cxx
@@ -0,0 +1,768 @@
+/*
+ * 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 <svtools/editbrowsebox.hxx>
+#include <vcl/svapp.hxx>
+
+namespace svt
+{
+    //= ComboBoxControl
+    ComboBoxControl::ComboBoxControl(BrowserDataWin* pParent)
+        : ControlBase(pParent, "svt/ui/combocontrol.ui", "ComboControl")
+        , m_xWidget(m_xBuilder->weld_combo_box("combobox"))
+    {
+        InitControlBase(m_xWidget.get());
+        m_xWidget->set_entry_width_chars(1); // so a smaller than default width can be used
+        m_xWidget->connect_changed(LINK(this, ComboBoxControl, SelectHdl));
+        m_xWidget->connect_key_press(LINK(this, ControlBase, KeyInputHdl));
+        m_xWidget->connect_key_release(LINK(this, ControlBase, KeyReleaseHdl));
+        m_xWidget->connect_focus_in(LINK(this, ControlBase, FocusInHdl));
+        m_xWidget->connect_focus_out(LINK(this, ControlBase, FocusOutHdl));
+        m_xWidget->connect_mouse_press(LINK(this, ControlBase, MousePressHdl));
+        m_xWidget->connect_mouse_release(LINK(this, ControlBase, MouseReleaseHdl));
+        m_xWidget->connect_mouse_move(LINK(this, ControlBase, MouseMoveHdl));
+    }
+
+    void ComboBoxControl::SetPointFont(const vcl::Font& rFont)
+    {
+        m_xWidget->set_entry_font(rFont);
+    }
+
+    void ComboBoxControl::dispose()
+    {
+        m_xWidget.reset();
+        ControlBase::dispose();
+    }
+
+    IMPL_LINK_NOARG(ComboBoxControl, SelectHdl, weld::ComboBox&, void)
+    {
+        CallModifyHdls();
+    }
+
+    //= ComboBoxCellController
+    ComboBoxCellController::ComboBoxCellController(ComboBoxControl* pWin)
+                             :CellController(pWin)
+    {
+        static_cast<ComboBoxControl&>(GetWindow()).SetModifyHdl(LINK(this, ComboBoxCellController, ModifyHdl));
+    }
+
+    IMPL_LINK_NOARG(ComboBoxCellController, ModifyHdl, LinkParamNone*, void)
+    {
+        callModifyHdl();
+    }
+
+    bool ComboBoxCellController::MoveAllowed(const KeyEvent& rEvt) const
+    {
+        weld::ComboBox& rBox = GetComboBox();
+        switch (rEvt.GetKeyCode().GetCode())
+        {
+            case KEY_END:
+            case KEY_RIGHT:
+            {
+                int nStartPos, nEndPos;
+                bool bNoSelection = rBox.get_entry_selection_bounds(nStartPos, nEndPos);
+                return bNoSelection && nEndPos == rBox.get_active_text().getLength();
+            }
+            case KEY_HOME:
+            case KEY_LEFT:
+            {
+                int nStartPos, nEndPos;
+                bool bNoSelection = rBox.get_entry_selection_bounds(nStartPos, nEndPos);
+                return bNoSelection && nStartPos == 0;
+            }
+            case KEY_UP:
+            case KEY_DOWN:
+                if (rBox.get_popup_shown())
+                    return false;
+                if (!rEvt.GetKeyCode().IsShift() &&
+                     rEvt.GetKeyCode().IsMod1())
+                    return false;
+                // drop down the list box
+                else if (rEvt.GetKeyCode().IsMod2() && rEvt.GetKeyCode().GetCode() == KEY_DOWN)
+                    return false;
+                [[fallthrough]];
+            case KEY_PAGEUP:
+            case KEY_PAGEDOWN:
+            case KEY_RETURN:
+                if (rBox.get_popup_shown())
+                    return false;
+                [[fallthrough]];
+            default:
+                return true;
+        }
+    }
+
+    bool ComboBoxCellController::IsValueChangedFromSaved() const
+    {
+        return GetComboBox().get_value_changed_from_saved();
+    }
+
+    void ComboBoxCellController::SaveValue()
+    {
+        GetComboBox().save_value();
+    }
+
+    //= ListBoxControl
+    ListBoxControl::ListBoxControl(BrowserDataWin* pParent)
+        : ControlBase(pParent, "svt/ui/listcontrol.ui", "ListControl")
+        , m_xWidget(m_xBuilder->weld_combo_box("listbox"))
+    {
+        InitControlBase(m_xWidget.get());
+        m_xWidget->set_size_request(42, -1); // so a later narrow size request can stick
+        m_xWidget->connect_changed(LINK(this, ListBoxControl, SelectHdl));
+        m_xWidget->connect_key_press(LINK(this, ControlBase, KeyInputHdl));
+        m_xWidget->connect_key_release(LINK(this, ControlBase, KeyReleaseHdl));
+        m_xWidget->connect_focus_in(LINK(this, ControlBase, FocusInHdl));
+        m_xWidget->connect_focus_out(LINK(this, ControlBase, FocusOutHdl));
+        m_xWidget->connect_mouse_press(LINK(this, ControlBase, MousePressHdl));
+        m_xWidget->connect_mouse_release(LINK(this, ControlBase, MouseReleaseHdl));
+        m_xWidget->connect_mouse_move(LINK(this, ControlBase, MouseMoveHdl));
+    }
+
+    void ListBoxControl::SetPointFont(const vcl::Font& rFont)
+    {
+        m_xWidget->set_font(rFont);
+    }
+
+    void ListBoxControl::dispose()
+    {
+        m_xWidget.reset();
+        ControlBase::dispose();
+    }
+
+    IMPL_LINK_NOARG(ListBoxControl, SelectHdl, weld::ComboBox&, void)
+    {
+        CallModifyHdls();
+    }
+
+    //= ListBoxCellController
+    ListBoxCellController::ListBoxCellController(ListBoxControl* pWin)
+                             :CellController(pWin)
+    {
+        static_cast<ListBoxControl&>(GetWindow()).SetModifyHdl(LINK(this, ListBoxCellController, ListBoxSelectHdl));
+    }
+
+    bool ListBoxCellController::MoveAllowed(const KeyEvent& rEvt) const
+    {
+        const weld::ComboBox& rBox = GetListBox();
+        switch (rEvt.GetKeyCode().GetCode())
+        {
+            case KEY_UP:
+            case KEY_DOWN:
+                if (!rEvt.GetKeyCode().IsShift() &&
+                     rEvt.GetKeyCode().IsMod1())
+                    return false;
+                // drop down the list box
+                else
+                    if (rEvt.GetKeyCode().IsMod2() && rEvt.GetKeyCode().GetCode() == KEY_DOWN)
+                        return false;
+                [[fallthrough]];
+            case KEY_PAGEUP:
+            case KEY_PAGEDOWN:
+                if (rBox.get_popup_shown())
+                    return false;
+                [[fallthrough]];
+            default:
+                return true;
+        }
+    }
+
+    bool ListBoxCellController::IsValueChangedFromSaved() const
+    {
+        return GetListBox().get_value_changed_from_saved();
+    }
+
+    void ListBoxCellController::SaveValue()
+    {
+        GetListBox().save_value();
+    }
+
+    IMPL_LINK_NOARG(ListBoxCellController, ListBoxSelectHdl, LinkParamNone*, void)
+    {
+        callModifyHdl();
+    }
+
+    //= CheckBoxControl
+    CheckBoxControl::CheckBoxControl(BrowserDataWin* pParent)
+        : ControlBase(pParent, "svt/ui/checkboxcontrol.ui", "CheckBoxControl")
+        , m_xBox(m_xBuilder->weld_check_button("checkbox"))
+    {
+        m_aModeState.bTriStateEnabled = true;
+        InitControlBase(m_xBox.get());
+        m_xBox->connect_key_press(LINK(this, ControlBase, KeyInputHdl));
+        m_xBox->connect_key_release(LINK(this, ControlBase, KeyReleaseHdl));
+        m_xBox->connect_focus_in(LINK(this, ControlBase, FocusInHdl));
+        m_xBox->connect_focus_out(LINK(this, ControlBase, FocusOutHdl));
+        m_xBox->connect_mouse_press(LINK(this, ControlBase, MousePressHdl));
+        m_xBox->connect_mouse_release(LINK(this, ControlBase, MouseReleaseHdl));
+        m_xBox->connect_mouse_move(LINK(this, ControlBase, MouseMoveHdl));
+        m_xBox->connect_toggled(LINK(this, CheckBoxControl, OnToggle));
+    }
+
+    void CheckBoxControl::SetPointFont(const vcl::Font& /*rFont*/)
+    {
+    }
+
+    void CheckBoxControl::EnableTriState( bool bTriState )
+    {
+        if (m_aModeState.bTriStateEnabled != bTriState)
+        {
+            m_aModeState.bTriStateEnabled = bTriState;
+
+            if (!m_aModeState.bTriStateEnabled && GetState() == TRISTATE_INDET)
+                SetState(TRISTATE_FALSE);
+        }
+    }
+
+    void CheckBoxControl::SetState(TriState eState)
+    {
+        if (!m_aModeState.bTriStateEnabled && (eState == TRISTATE_INDET))
+            eState = TRISTATE_FALSE;
+        m_aModeState.eState = eState;
+        m_xBox->set_state(eState);
+    }
+
+    CheckBoxControl::~CheckBoxControl()
+    {
+        disposeOnce();
+    }
+
+    void CheckBoxControl::dispose()
+    {
+        m_xBox.reset();
+        ControlBase::dispose();
+    }
+
+    void CheckBoxControl::Clicked()
+    {
+        // if tristate is enabled, m_aModeState will take care of setting the
+        // next state in the sequence via TriStateEnabled::ButtonToggled
+        if (!m_aModeState.bTriStateEnabled)
+            m_xBox->set_active(!m_xBox->get_active());
+        OnToggle(*m_xBox);
+    }
+
+    IMPL_LINK_NOARG(CheckBoxControl, OnToggle, weld::Toggleable&, void)
+    {
+        m_aModeState.ButtonToggled(*m_xBox);
+        m_aToggleLink.Call(*m_xBox);
+        CallModifyHdls();
+    }
+
+    //= CheckBoxCellController
+    CheckBoxCellController::CheckBoxCellController(CheckBoxControl* pWin)
+        : CellController(pWin)
+    {
+        static_cast<CheckBoxControl &>(GetWindow()).SetModifyHdl( LINK(this, CheckBoxCellController, ModifyHdl) );
+    }
+
+    void CheckBoxCellController::ActivatingMouseEvent(const BrowserMouseEvent& rEvt, bool /*bUp*/)
+    {
+        CheckBoxControl& rControl = static_cast<CheckBoxControl&>(GetWindow());
+        rControl.GrabFocus();
+
+        // we have to adjust the position of the event relative to the controller's window
+        Point aPos = rEvt.GetPosPixel() - rEvt.GetRect().TopLeft();
+
+        Size aControlSize = rControl.GetSizePixel();
+        Size aBoxSize = rControl.GetBox().get_preferred_size();
+        tools::Rectangle aHotRect(Point((aControlSize.Width() - aBoxSize.Width()) / 2,
+                                        (aControlSize.Height() - aBoxSize.Height()) / 2),
+                                  aBoxSize);
+
+        // we want the initial mouse event to act as if it was performed on the checkbox
+        if (aHotRect.Contains(aPos))
+            rControl.Clicked();
+    }
+
+    weld::CheckButton& CheckBoxCellController::GetCheckBox() const
+    {
+        return static_cast<CheckBoxControl &>(GetWindow()).GetBox();
+    }
+
+    bool CheckBoxCellController::IsValueChangedFromSaved() const
+    {
+        return GetCheckBox().get_state_changed_from_saved();
+    }
+
+    void CheckBoxCellController::SaveValue()
+    {
+        GetCheckBox().save_state();
+    }
+
+    IMPL_LINK_NOARG(CheckBoxCellController, ModifyHdl, LinkParamNone*, void)
+    {
+        callModifyHdl();
+    }
+
+    //= MultiLineEditImplementation
+    OUString MultiLineEditImplementation::GetText(LineEnd eSeparator) const
+    {
+        weld::TextView& rEntry = m_rEdit.get_widget();
+        return convertLineEnd(rEntry.get_text(), eSeparator);
+    }
+
+    OUString MultiLineEditImplementation::GetSelected(LineEnd eSeparator) const
+    {
+        int nStartPos, nEndPos;
+        weld::TextView& rEntry = m_rEdit.get_widget();
+        rEntry.get_selection_bounds(nStartPos, nEndPos);
+        return convertLineEnd(rEntry.get_text().copy(nStartPos, nEndPos - nStartPos), eSeparator);
+    }
+
+    IMPL_LINK_NOARG(MultiLineEditImplementation, ModifyHdl, weld::TextView&, void)
+    {
+        CallModifyHdls();
+    }
+
+    EditCellController::EditCellController( IEditImplementation* _pImplementation )
+        :CellController( &_pImplementation->GetControl() )
+        ,m_pEditImplementation( _pImplementation )
+        ,m_bOwnImplementation( false )
+    {
+        m_pEditImplementation->SetModifyHdl( LINK(this, EditCellController, ModifyHdl) );
+    }
+
+    IMPL_LINK_NOARG(EntryImplementation, ModifyHdl, weld::Entry&, void)
+    {
+        CallModifyHdls();
+    }
+
+    ControlBase::ControlBase(BrowserDataWin* pParent, const OUString& rUIXMLDescription, const OUString& rID)
+        : InterimItemWindow(pParent, rUIXMLDescription, rID)
+    {
+    }
+
+    void ControlBase::SetEditableReadOnly(bool /*bReadOnly*/)
+    {
+        // expected to be overridden for Entry, TextView or the editable entry part of a ComboBox
+    }
+
+    EditControlBase::EditControlBase(BrowserDataWin* pParent)
+        : ControlBase(pParent, "svt/ui/thineditcontrol.ui", "EditControl") // *thin*editcontrol has no frame/border
+        , m_pEntry(nullptr) // inheritors are expected to call InitEditControlBase
+    {
+    }
+
+    void EditControlBase::InitEditControlBase(weld::Entry* pEntry)
+    {
+        InitControlBase(pEntry);
+        m_pEntry = pEntry;
+        m_pEntry->show();
+        m_pEntry->set_width_chars(1); // so a smaller than default width can be used
+        connect_focus_in(LINK(this, ControlBase, FocusInHdl));   // need to chain with pattern handler
+        connect_focus_out(LINK(this, ControlBase, FocusOutHdl)); // need to chain with pattern handler
+        connect_key_press(LINK(this, ControlBase, KeyInputHdl)); // need to chain with pattern handler
+        m_pEntry->connect_key_release(LINK(this, ControlBase, KeyReleaseHdl));
+        m_pEntry->connect_mouse_press(LINK(this, ControlBase, MousePressHdl));
+        m_pEntry->connect_mouse_release(LINK(this, ControlBase, MouseReleaseHdl));
+        m_pEntry->connect_mouse_move(LINK(this, ControlBase, MouseMoveHdl));
+    }
+
+    bool ControlBase::ProcessKey(const KeyEvent& rKEvt)
+    {
+        return static_cast<BrowserDataWin*>(GetParent())->GetParent()->ProcessKey(rKEvt);
+    }
+
+    IMPL_LINK(ControlBase, KeyInputHdl, const KeyEvent&, rKEvt, bool)
+    {
+        m_aKeyInputHdl.Call(rKEvt);
+        return ProcessKey(rKEvt);
+    }
+
+    IMPL_LINK(ControlBase, KeyReleaseHdl, const KeyEvent&, rKEvt, bool)
+    {
+        m_aKeyReleaseHdl.Call(rKEvt);
+        return false;
+    }
+
+    IMPL_LINK_NOARG(ControlBase, FocusInHdl, weld::Widget&, void)
+    {
+        m_aFocusInHdl.Call(nullptr);
+        static_cast<BrowserDataWin*>(GetParent())->GetParent()->ChildFocusIn();
+    }
+
+    IMPL_LINK_NOARG(ControlBase, FocusOutHdl, weld::Widget&, void)
+    {
+        m_aFocusOutHdl.Call(nullptr);
+        static_cast<BrowserDataWin*>(GetParent())->GetParent()->ChildFocusOut();
+    }
+
+    IMPL_LINK(ControlBase, MousePressHdl, const MouseEvent&, rEvent, bool)
+    {
+        m_aMousePressHdl.Call(rEvent);
+        return false;
+    }
+
+    IMPL_LINK(ControlBase, MouseReleaseHdl, const MouseEvent&, rEvent, bool)
+    {
+        m_aMouseReleaseHdl.Call(rEvent);
+        return false;
+    }
+
+    IMPL_LINK(ControlBase, MouseMoveHdl, const MouseEvent&, rEvent, bool)
+    {
+        m_aMouseMoveHdl.Call(rEvent);
+        return false;
+    }
+
+    void EditControlBase::dispose()
+    {
+        m_pEntry = nullptr;
+        ControlBase::dispose();
+    }
+
+    EditControl::EditControl(BrowserDataWin* pParent)
+        : EditControlBase(pParent)
+        , m_xWidget(m_xBuilder->weld_entry("entry"))
+    {
+        InitEditControlBase(m_xWidget.get());
+    }
+
+    void EditControl::dispose()
+    {
+        m_xWidget.reset();
+        EditControlBase::dispose();
+    }
+
+    FormattedControlBase::FormattedControlBase(BrowserDataWin* pParent, bool bSpinVariant)
+        : EditControlBase(pParent)
+        , m_bSpinVariant(bSpinVariant)
+        , m_xEntry(m_xBuilder->weld_entry("entry"))
+        , m_xSpinButton(m_xBuilder->weld_formatted_spin_button("spinbutton"))
+    {
+    }
+
+    void FormattedControlBase::InitFormattedControlBase()
+    {
+        InitEditControlBase(m_bSpinVariant ? m_xSpinButton.get() : m_xEntry.get());
+    }
+
+    void FormattedControlBase::connect_changed(const Link<weld::Entry&, void>& rLink)
+    {
+        get_formatter().connect_changed(rLink);
+    }
+
+    void FormattedControlBase::connect_focus_in(const Link<weld::Widget&, void>& rLink)
+    {
+        get_widget().connect_focus_in(rLink);
+    }
+
+    void FormattedControlBase::connect_focus_out(const Link<weld::Widget&, void>& rLink)
+    {
+        get_formatter().connect_focus_out(rLink);
+    }
+
+    void FormattedControlBase::connect_key_press(const Link<const KeyEvent&, bool>& rLink)
+    {
+        get_widget().connect_key_press(rLink);
+    }
+
+    weld::EntryFormatter& FormattedControlBase::get_formatter()
+    {
+        return *m_xEntryFormatter;
+    }
+
+    void FormattedControlBase::dispose()
+    {
+        m_xEntryFormatter.reset();
+        m_xSpinButton.reset();
+        m_xEntry.reset();
+        EditControlBase::dispose();
+    }
+
+    FormattedControl::FormattedControl(BrowserDataWin* pParent, bool bSpinVariant)
+        : FormattedControlBase(pParent, bSpinVariant)
+    {
+        if (bSpinVariant)
+            m_xEntryFormatter.reset(new weld::EntryFormatter(*m_xSpinButton));
+        else
+            m_xEntryFormatter.reset(new weld::EntryFormatter(*m_xEntry));
+        InitFormattedControlBase();
+    }
+
+    DoubleNumericControl::DoubleNumericControl(BrowserDataWin* pParent, bool bSpinVariant)
+        : FormattedControlBase(pParent, bSpinVariant)
+    {
+        if (bSpinVariant)
+            m_xEntryFormatter.reset(new weld::DoubleNumericFormatter(*m_xSpinButton));
+        else
+            m_xEntryFormatter.reset(new weld::DoubleNumericFormatter(*m_xEntry));
+        InitFormattedControlBase();
+    }
+
+    LongCurrencyControl::LongCurrencyControl(BrowserDataWin* pParent, bool bSpinVariant)
+        : FormattedControlBase(pParent, bSpinVariant)
+    {
+        if (bSpinVariant)
+            m_xEntryFormatter.reset(new weld::LongCurrencyFormatter(*m_xSpinButton));
+        else
+            m_xEntryFormatter.reset(new weld::LongCurrencyFormatter(*m_xEntry));
+        InitFormattedControlBase();
+    }
+
+    TimeControl::TimeControl(BrowserDataWin* pParent, bool bSpinVariant)
+        : FormattedControlBase(pParent, bSpinVariant)
+    {
+        if (bSpinVariant)
+            m_xEntryFormatter.reset(new weld::TimeFormatter(*m_xSpinButton));
+        else
+            m_xEntryFormatter.reset(new weld::TimeFormatter(*m_xEntry));
+        InitFormattedControlBase();
+    }
+
+    DateControl::DateControl(BrowserDataWin* pParent, bool bDropDown)
+        : FormattedControlBase(pParent, false)
+        , m_xMenuButton(m_xBuilder->weld_menu_button("button"))
+        , m_xCalendarBuilder(Application::CreateBuilder(m_xMenuButton.get(), "svt/ui/datewindow.ui"))
+        , m_xTopLevel(m_xCalendarBuilder->weld_widget("date_popup_window"))
+        , m_xCalendar(m_xCalendarBuilder->weld_calendar("date_picker"))
+        , m_xExtras(m_xCalendarBuilder->weld_widget("extras"))
+        , m_xTodayBtn(m_xCalendarBuilder->weld_button("today"))
+        , m_xNoneBtn(m_xCalendarBuilder->weld_button("none"))
+    {
+        m_xEntryFormatter.reset(new weld::DateFormatter(*m_xEntry));
+        InitFormattedControlBase();
+
+        m_xMenuButton->set_popover(m_xTopLevel.get());
+        m_xMenuButton->set_visible(bDropDown);
+        m_xMenuButton->connect_toggled(LINK(this, DateControl, ToggleHdl));
+
+        m_xExtras->show();
+
+        m_xTodayBtn->connect_clicked(LINK(this, DateControl, ImplClickHdl));
+        m_xNoneBtn->connect_clicked(LINK(this, DateControl, ImplClickHdl));
+
+        m_xCalendar->connect_activated(LINK(this, DateControl, ActivateHdl));
+    }
+
+    IMPL_LINK(DateControl, ImplClickHdl, weld::Button&, rBtn, void)
+    {
+        m_xMenuButton->set_active(false);
+        get_widget().grab_focus();
+
+        if (&rBtn == m_xTodayBtn.get())
+        {
+            Date aToday(Date::SYSTEM);
+            SetDate(aToday);
+        }
+        else if (&rBtn == m_xNoneBtn.get())
+        {
+            get_widget().set_text(OUString());
+        }
+    }
+
+    IMPL_LINK(DateControl, ToggleHdl, weld::Toggleable&, rButton, void)
+    {
+        if (rButton.get_active())
+            m_xCalendar->set_date(static_cast<weld::DateFormatter&>(get_formatter()).GetDate());
+    }
+
+    IMPL_LINK_NOARG(DateControl, ActivateHdl, weld::Calendar&, void)
+    {
+        if (m_xMenuButton->get_active())
+            m_xMenuButton->set_active(false);
+        static_cast<weld::DateFormatter&>(get_formatter()).SetDate(m_xCalendar->get_date());
+    }
+
+    void DateControl::SetDate(const Date& rDate)
+    {
+        static_cast<weld::DateFormatter&>(get_formatter()).SetDate(rDate);
+        m_xCalendar->set_date(rDate);
+    }
+
+    void DateControl::dispose()
+    {
+        m_xTodayBtn.reset();
+        m_xNoneBtn.reset();
+        m_xExtras.reset();
+        m_xCalendar.reset();
+        m_xTopLevel.reset();
+        m_xCalendarBuilder.reset();
+        m_xMenuButton.reset();
+        FormattedControlBase::dispose();
+    }
+
+    PatternControl::PatternControl(BrowserDataWin* pParent)
+        : EditControlBase(pParent)
+        , m_xWidget(m_xBuilder->weld_entry("entry"))
+    {
+        m_xEntryFormatter.reset(new weld::PatternFormatter(*m_xWidget));
+        InitEditControlBase(m_xWidget.get());
+    }
+
+    void PatternControl::connect_changed(const Link<weld::Entry&, void>& rLink)
+    {
+        m_xEntryFormatter->connect_changed(rLink);
+    }
+
+    void PatternControl::connect_focus_in(const Link<weld::Widget&, void>& rLink)
+    {
+        m_xEntryFormatter->connect_focus_in(rLink);
+    }
+
+    void PatternControl::connect_focus_out(const Link<weld::Widget&, void>& rLink)
+    {
+        m_xEntryFormatter->connect_focus_out(rLink);
+    }
+
+    void PatternControl::connect_key_press(const Link<const KeyEvent&, bool>& rLink)
+    {
+        m_xEntryFormatter->connect_key_press(rLink);
+    }
+
+    void PatternControl::dispose()
+    {
+        m_xEntryFormatter.reset();
+        m_xWidget.reset();
+        EditControlBase::dispose();
+    }
+
+    EditCellController::EditCellController(EditControlBase* pEdit)
+        : CellController(pEdit)
+        , m_pEditImplementation(new EntryImplementation(*pEdit))
+        , m_bOwnImplementation(true)
+    {
+        m_pEditImplementation->SetModifyHdl( LINK(this, EditCellController, ModifyHdl) );
+    }
+
+    EditCellController::~EditCellController( )
+    {
+        if ( m_bOwnImplementation )
+            delete m_pEditImplementation;
+    }
+
+    void EditCellController::SaveValue()
+    {
+        m_pEditImplementation->SaveValue();
+    }
+
+    bool EditCellController::MoveAllowed(const KeyEvent& rEvt) const
+    {
+        bool bResult;
+        switch (rEvt.GetKeyCode().GetCode())
+        {
+            case KEY_END:
+            case KEY_RIGHT:
+            {
+                Selection aSel = m_pEditImplementation->GetSelection();
+                bResult = !aSel && aSel.Max() == m_pEditImplementation->GetText( LINEEND_LF ).getLength();
+                break;
+            }
+            case KEY_HOME:
+            case KEY_LEFT:
+            {
+                Selection aSel = m_pEditImplementation->GetSelection();
+                bResult = !aSel && aSel.Min() == 0;
+                break;
+            }
+            case KEY_DOWN:
+            {
+                bResult = !m_pEditImplementation->CanDown();
+                break;
+            }
+            case KEY_UP:
+            {
+                bResult = !m_pEditImplementation->CanUp();
+                break;
+            }
+            default:
+                bResult = true;
+        }
+        return bResult;
+    }
+
+    bool EditCellController::IsValueChangedFromSaved() const
+    {
+        return m_pEditImplementation->IsValueChangedFromSaved();
+    }
+
+    IMPL_LINK_NOARG(EditCellController, ModifyHdl, LinkParamNone*, void)
+    {
+        callModifyHdl();
+    }
+
+    //= FormattedFieldCellController
+    FormattedFieldCellController::FormattedFieldCellController( FormattedControlBase* _pFormatted )
+        : EditCellController(_pFormatted)
+    {
+    }
+
+    void FormattedFieldCellController::CommitModifications()
+    {
+        static_cast<FormattedControl&>(GetWindow()).get_formatter().Commit();
+    }
+
+    MultiLineTextCell::MultiLineTextCell(BrowserDataWin* pParent)
+        : ControlBase(pParent, "svt/ui/textviewcontrol.ui", "TextViewControl")
+        , m_xWidget(m_xBuilder->weld_text_view("textview"))
+    {
+        InitControlBase(m_xWidget.get());
+        m_xWidget->connect_key_press(LINK(this, ControlBase, KeyInputHdl));
+        m_xWidget->connect_key_release(LINK(this, ControlBase, KeyReleaseHdl));
+        m_xWidget->connect_focus_in(LINK(this, ControlBase, FocusInHdl));
+        m_xWidget->connect_focus_out(LINK(this, ControlBase, FocusOutHdl));
+        m_xWidget->connect_mouse_press(LINK(this, ControlBase, MousePressHdl));
+        m_xWidget->connect_mouse_release(LINK(this, ControlBase, MouseReleaseHdl));
+        m_xWidget->connect_mouse_move(LINK(this, ControlBase, MouseMoveHdl));
+        // so any the natural size doesn't have an effect
+        m_xWidget->set_size_request(1, 1);
+    }
+
+    void MultiLineTextCell::GetFocus()
+    {
+        if (m_xWidget)
+            m_xWidget->select_region(-1, 0);
+        ControlBase::GetFocus();
+    }
+
+    void MultiLineTextCell::dispose()
+    {
+        m_xWidget.reset();
+        ControlBase::dispose();
+    }
+
+    bool MultiLineTextCell::ProcessKey(const KeyEvent& rKEvt)
+    {
+        bool bSendToDataWindow = true;
+
+        sal_uInt16 nCode  = rKEvt.GetKeyCode().GetCode();
+        bool bShift = rKEvt.GetKeyCode().IsShift();
+        bool bCtrl = rKEvt.GetKeyCode().IsMod1();
+        bool bAlt =  rKEvt.GetKeyCode().IsMod2();
+
+        if (!bAlt && !bCtrl && !bShift)
+        {
+            switch (nCode)
+            {
+                case KEY_DOWN:
+                    bSendToDataWindow = !m_xWidget->can_move_cursor_with_down();
+                    break;
+                case KEY_UP:
+                    bSendToDataWindow = !m_xWidget->can_move_cursor_with_up();
+                    break;
+            }
+        }
+
+        if (bSendToDataWindow)
+            return ControlBase::ProcessKey(rKEvt);
+        return false;
+    }
+}   // namespace svt
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */