774 lines
26 KiB
C++
774 lines
26 KiB
C++
/*
|
|
* 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, u"svt/ui/combocontrol.ui"_ustr, u"ComboControl"_ustr)
|
|
, m_xWidget(m_xBuilder->weld_combo_box(u"combobox"_ustr))
|
|
{
|
|
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, u"svt/ui/listcontrol.ui"_ustr, u"ListControl"_ustr)
|
|
, m_xWidget(m_xBuilder->weld_combo_box(u"listbox"_ustr))
|
|
{
|
|
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, u"svt/ui/checkboxcontrol.ui"_ustr, u"CheckBoxControl"_ustr)
|
|
, m_xBox(m_xBuilder->weld_check_button(u"checkbox"_ustr))
|
|
{
|
|
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, u"svt/ui/thineditcontrol.ui"_ustr, u"EditControl"_ustr) // *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(u"entry"_ustr))
|
|
{
|
|
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(u"entry"_ustr))
|
|
, m_xSpinButton(m_xBuilder->weld_formatted_spin_button(u"spinbutton"_ustr))
|
|
{
|
|
}
|
|
|
|
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(u"button"_ustr))
|
|
, m_xCalendarBuilder(Application::CreateBuilder(m_xMenuButton.get(), u"svt/ui/datewindow.ui"_ustr))
|
|
, m_xTopLevel(m_xCalendarBuilder->weld_widget(u"date_popup_window"_ustr))
|
|
, m_xCalendar(m_xCalendarBuilder->weld_calendar(u"date_picker"_ustr))
|
|
, m_xExtras(m_xCalendarBuilder->weld_widget(u"extras"_ustr))
|
|
, m_xTodayBtn(m_xCalendarBuilder->weld_button(u"today"_ustr))
|
|
, m_xNoneBtn(m_xCalendarBuilder->weld_button(u"none"_ustr))
|
|
{
|
|
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::SetEditableReadOnly(bool bReadOnly)
|
|
{
|
|
FormattedControlBase::SetEditableReadOnly(bReadOnly);
|
|
m_xMenuButton->set_sensitive(!bReadOnly);
|
|
}
|
|
|
|
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(u"entry"_ustr))
|
|
{
|
|
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, u"svt/ui/textviewcontrol.ui"_ustr, u"TextViewControl"_ustr)
|
|
, m_xWidget(m_xBuilder->weld_text_view(u"textview"_ustr))
|
|
{
|
|
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: */
|