svtools/source/brwbox/ebbcontrols.cxx

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18
  19 #include <svtools/editbrowsebox.hxx>
  20 #include <vcl/svapp.hxx>
  21
  22 namespace svt
  23 {
  24     //= ComboBoxControl
  25     ComboBoxControl::ComboBoxControl(BrowserDataWin* pParent)
  26         : ControlBase(pParent, u"svt/ui/combocontrol.ui"_ustr, u"ComboControl"_ustr)
  27         , m_xWidget(m_xBuilder->weld_combo_box(u"combobox"_ustr))
  28     {
  29         InitControlBase(m_xWidget.get());
  30         m_xWidget->set_entry_width_chars(1); // so a smaller than default width can be used
  31         m_xWidget->connect_changed(LINK(this, ComboBoxControl, SelectHdl));
  32         m_xWidget->connect_key_press(LINK(this, ControlBase, KeyInputHdl));
  33         m_xWidget->connect_key_release(LINK(this, ControlBase, KeyReleaseHdl));
  34         m_xWidget->connect_focus_in(LINK(this, ControlBase, FocusInHdl));
  35         m_xWidget->connect_focus_out(LINK(this, ControlBase, FocusOutHdl));
  36         m_xWidget->connect_mouse_press(LINK(this, ControlBase, MousePressHdl));
  37         m_xWidget->connect_mouse_release(LINK(this, ControlBase, MouseReleaseHdl));
  38         m_xWidget->connect_mouse_move(LINK(this, ControlBase, MouseMoveHdl));
  39     }
  40
  41     void ComboBoxControl::SetPointFont(const vcl::Font& rFont)
  42     {
  43         m_xWidget->set_entry_font(rFont);
  44     }
  45
  46     void ComboBoxControl::dispose()
  47     {
  48         m_xWidget.reset();
  49         ControlBase::dispose();
  50     }
  51
  52     IMPL_LINK_NOARG(ComboBoxControl, SelectHdl, weld::ComboBox&, void)
  53     {
  54         CallModifyHdls();
  55     }
  56
  57     //= ComboBoxCellController
  58     ComboBoxCellController::ComboBoxCellController(ComboBoxControl* pWin)
  59                              :CellController(pWin)
  60     {
  61         static_cast<ComboBoxControl&>(GetWindow()).SetModifyHdl(LINK(this, ComboBoxCellController, ModifyHdl));
  62     }
  63
  64     IMPL_LINK_NOARG(ComboBoxCellController, ModifyHdl, LinkParamNone*, void)
  65     {
  66         callModifyHdl();
  67     }
  68
  69     bool ComboBoxCellController::MoveAllowed(const KeyEvent& rEvt) const
  70     {
  71         weld::ComboBox& rBox = GetComboBox();
  72         switch (rEvt.GetKeyCode().GetCode())
  73         {
  74             case KEY_END:
  75             case KEY_RIGHT:
  76             {
  77                 int nStartPos, nEndPos;
  78                 bool bNoSelection = rBox.get_entry_selection_bounds(nStartPos, nEndPos);
  79                 return bNoSelection && nEndPos == rBox.get_active_text().getLength();
  80             }
  81             case KEY_HOME:
  82             case KEY_LEFT:
  83             {
  84                 int nStartPos, nEndPos;
  85                 bool bNoSelection = rBox.get_entry_selection_bounds(nStartPos, nEndPos);
  86                 return bNoSelection && nStartPos == 0;
  87             }
  88             case KEY_UP:
  89             case KEY_DOWN:
  90                 if (rBox.get_popup_shown())
  91                     return false;
  92                 if (!rEvt.GetKeyCode().IsShift() &&
  93                      rEvt.GetKeyCode().IsMod1())
  94                     return false;
  95                 // drop down the list box
  96                 else if (rEvt.GetKeyCode().IsMod2() && rEvt.GetKeyCode().GetCode() == KEY_DOWN)
  97                     return false;
  98                 [[fallthrough]];
  99             case KEY_PAGEUP:
 100             case KEY_PAGEDOWN:
 101             case KEY_RETURN:
 102                 if (rBox.get_popup_shown())
 103                     return false;
 104                 [[fallthrough]];
 105             default:
 106                 return true;
 107         }
 108     }
 109
 110     bool ComboBoxCellController::IsValueChangedFromSaved() const
 111     {
 112         return GetComboBox().get_value_changed_from_saved();
 113     }
 114
 115     void ComboBoxCellController::SaveValue()
 116     {
 117         GetComboBox().save_value();
 118     }
 119
 120     //= ListBoxControl
 121     ListBoxControl::ListBoxControl(BrowserDataWin* pParent)
 122         : ControlBase(pParent, u"svt/ui/listcontrol.ui"_ustr, u"ListControl"_ustr)
 123         , m_xWidget(m_xBuilder->weld_combo_box(u"listbox"_ustr))
 124     {
 125         InitControlBase(m_xWidget.get());
 126         m_xWidget->set_size_request(42, -1); // so a later narrow size request can stick
 127         m_xWidget->connect_changed(LINK(this, ListBoxControl, SelectHdl));
 128         m_xWidget->connect_key_press(LINK(this, ControlBase, KeyInputHdl));
 129         m_xWidget->connect_key_release(LINK(this, ControlBase, KeyReleaseHdl));
 130         m_xWidget->connect_focus_in(LINK(this, ControlBase, FocusInHdl));
 131         m_xWidget->connect_focus_out(LINK(this, ControlBase, FocusOutHdl));
 132         m_xWidget->connect_mouse_press(LINK(this, ControlBase, MousePressHdl));
 133         m_xWidget->connect_mouse_release(LINK(this, ControlBase, MouseReleaseHdl));
 134         m_xWidget->connect_mouse_move(LINK(this, ControlBase, MouseMoveHdl));
 135     }
 136
 137     void ListBoxControl::SetPointFont(const vcl::Font& rFont)
 138     {
 139         m_xWidget->set_font(rFont);
 140     }
 141
 142     void ListBoxControl::dispose()
 143     {
 144         m_xWidget.reset();
 145         ControlBase::dispose();
 146     }
 147
 148     IMPL_LINK_NOARG(ListBoxControl, SelectHdl, weld::ComboBox&, void)
 149     {
 150         CallModifyHdls();
 151     }
 152
 153     //= ListBoxCellController
 154     ListBoxCellController::ListBoxCellController(ListBoxControl* pWin)
 155                              :CellController(pWin)
 156     {
 157         static_cast<ListBoxControl&>(GetWindow()).SetModifyHdl(LINK(this, ListBoxCellController, ListBoxSelectHdl));
 158     }
 159
 160     bool ListBoxCellController::MoveAllowed(const KeyEvent& rEvt) const
 161     {
 162         const weld::ComboBox& rBox = GetListBox();
 163         switch (rEvt.GetKeyCode().GetCode())
 164         {
 165             case KEY_UP:
 166             case KEY_DOWN:
 167                 if (!rEvt.GetKeyCode().IsShift() &&
 168                      rEvt.GetKeyCode().IsMod1())
 169                     return false;
 170                 // drop down the list box
 171                 else
 172                     if (rEvt.GetKeyCode().IsMod2() && rEvt.GetKeyCode().GetCode() == KEY_DOWN)
 173                         return false;
 174                 [[fallthrough]];
 175             case KEY_PAGEUP:
 176             case KEY_PAGEDOWN:
 177                 if (rBox.get_popup_shown())
 178                     return false;
 179                 [[fallthrough]];
 180             default:
 181                 return true;
 182         }
 183     }
 184
 185     bool ListBoxCellController::IsValueChangedFromSaved() const
 186     {
 187         return GetListBox().get_value_changed_from_saved();
 188     }
 189
 190     void ListBoxCellController::SaveValue()
 191     {
 192         GetListBox().save_value();
 193     }
 194
 195     IMPL_LINK_NOARG(ListBoxCellController, ListBoxSelectHdl, LinkParamNone*, void)
 196     {
 197         callModifyHdl();
 198     }
 199
 200     //= CheckBoxControl
 201     CheckBoxControl::CheckBoxControl(BrowserDataWin* pParent)
 202         : ControlBase(pParent, u"svt/ui/checkboxcontrol.ui"_ustr, u"CheckBoxControl"_ustr)
 203         , m_xBox(m_xBuilder->weld_check_button(u"checkbox"_ustr))
 204     {
 205         m_aModeState.bTriStateEnabled = true;
 206         InitControlBase(m_xBox.get());
 207         m_xBox->connect_key_press(LINK(this, ControlBase, KeyInputHdl));
 208         m_xBox->connect_key_release(LINK(this, ControlBase, KeyReleaseHdl));
 209         m_xBox->connect_focus_in(LINK(this, ControlBase, FocusInHdl));
 210         m_xBox->connect_focus_out(LINK(this, ControlBase, FocusOutHdl));
 211         m_xBox->connect_mouse_press(LINK(this, ControlBase, MousePressHdl));
 212         m_xBox->connect_mouse_release(LINK(this, ControlBase, MouseReleaseHdl));
 213         m_xBox->connect_mouse_move(LINK(this, ControlBase, MouseMoveHdl));
 214         m_xBox->connect_toggled(LINK(this, CheckBoxControl, OnToggle));
 215     }
 216
 217     void CheckBoxControl::SetPointFont(const vcl::Font& /*rFont*/)
 218     {
 219     }
 220
 221     void CheckBoxControl::EnableTriState( bool bTriState )
 222     {
 223         if (m_aModeState.bTriStateEnabled != bTriState)
 224         {
 225             m_aModeState.bTriStateEnabled = bTriState;
 226
 227             if (!m_aModeState.bTriStateEnabled && GetState() == TRISTATE_INDET)
 228                 SetState(TRISTATE_FALSE);
 229         }
 230     }
 231
 232     void CheckBoxControl::SetState(TriState eState)
 233     {
 234         if (!m_aModeState.bTriStateEnabled && (eState == TRISTATE_INDET))
 235             eState = TRISTATE_FALSE;
 236         m_aModeState.eState = eState;
 237         m_xBox->set_state(eState);
 238     }
 239
 240     CheckBoxControl::~CheckBoxControl()
 241     {
 242         disposeOnce();
 243     }
 244
 245     void CheckBoxControl::dispose()
 246     {
 247         m_xBox.reset();
 248         ControlBase::dispose();
 249     }
 250
 251     void CheckBoxControl::Clicked()
 252     {
 253         // if tristate is enabled, m_aModeState will take care of setting the
 254         // next state in the sequence via TriStateEnabled::ButtonToggled
 255         if (!m_aModeState.bTriStateEnabled)
 256             m_xBox->set_active(!m_xBox->get_active());
 257         OnToggle(*m_xBox);
 258     }
 259
 260     IMPL_LINK_NOARG(CheckBoxControl, OnToggle, weld::Toggleable&, void)
 261     {
 262         m_aModeState.ButtonToggled(*m_xBox);
 263         m_aToggleLink.Call(*m_xBox);
 264         CallModifyHdls();
 265     }
 266
 267     //= CheckBoxCellController
 268     CheckBoxCellController::CheckBoxCellController(CheckBoxControl* pWin)
 269         : CellController(pWin)
 270     {
 271         static_cast<CheckBoxControl &>(GetWindow()).SetModifyHdl( LINK(this, CheckBoxCellController, ModifyHdl) );
 272     }
 273
 274     void CheckBoxCellController::ActivatingMouseEvent(const BrowserMouseEvent& rEvt, bool /*bUp*/)
 275     {
 276         CheckBoxControl& rControl = static_cast<CheckBoxControl&>(GetWindow());
 277         rControl.GrabFocus();
 278
 279         // we have to adjust the position of the event relative to the controller's window
 280         Point aPos = rEvt.GetPosPixel() - rEvt.GetRect().TopLeft();
 281
 282         Size aControlSize = rControl.GetSizePixel();
 283         Size aBoxSize = rControl.GetBox().get_preferred_size();
 284         tools::Rectangle aHotRect(Point((aControlSize.Width() - aBoxSize.Width()) / 2,
 285                                         (aControlSize.Height() - aBoxSize.Height()) / 2),
 286                                   aBoxSize);
 287
 288         // we want the initial mouse event to act as if it was performed on the checkbox
 289         if (aHotRect.Contains(aPos))
 290             rControl.Clicked();
 291     }
 292
 293     weld::CheckButton& CheckBoxCellController::GetCheckBox() const
 294     {
 295         return static_cast<CheckBoxControl &>(GetWindow()).GetBox();
 296     }
 297
 298     bool CheckBoxCellController::IsValueChangedFromSaved() const
 299     {
 300         return GetCheckBox().get_state_changed_from_saved();
 301     }
 302
 303     void CheckBoxCellController::SaveValue()
 304     {
 305         GetCheckBox().save_state();
 306     }
 307
 308     IMPL_LINK_NOARG(CheckBoxCellController, ModifyHdl, LinkParamNone*, void)
 309     {
 310         callModifyHdl();
 311     }
 312
 313     //= MultiLineEditImplementation
 314     OUString MultiLineEditImplementation::GetText(LineEnd eSeparator) const
 315     {
 316         weld::TextView& rEntry = m_rEdit.get_widget();
 317         return convertLineEnd(rEntry.get_text(), eSeparator);
 318     }
 319
 320     OUString MultiLineEditImplementation::GetSelected(LineEnd eSeparator) const
 321     {
 322         int nStartPos, nEndPos;
 323         weld::TextView& rEntry = m_rEdit.get_widget();
 324         rEntry.get_selection_bounds(nStartPos, nEndPos);
 325         return convertLineEnd(rEntry.get_text().copy(nStartPos, nEndPos - nStartPos), eSeparator);
 326     }
 327
 328     IMPL_LINK_NOARG(MultiLineEditImplementation, ModifyHdl, weld::TextView&, void)
 329     {
 330         CallModifyHdls();
 331     }
 332
 333     EditCellController::EditCellController( IEditImplementation* _pImplementation )
 334         :CellController( &_pImplementation->GetControl() )
 335         ,m_pEditImplementation( _pImplementation )
 336         ,m_bOwnImplementation( false )
 337     {
 338         m_pEditImplementation->SetModifyHdl( LINK(this, EditCellController, ModifyHdl) );
 339     }
 340
 341     IMPL_LINK_NOARG(EntryImplementation, ModifyHdl, weld::Entry&, void)
 342     {
 343         CallModifyHdls();
 344     }
 345
 346     ControlBase::ControlBase(BrowserDataWin* pParent, const OUString& rUIXMLDescription, const OUString& rID)
 347         : InterimItemWindow(pParent, rUIXMLDescription, rID)
 348     {
 349     }
 350
 351     void ControlBase::SetEditableReadOnly(bool /*bReadOnly*/)
 352     {
 353         // expected to be overridden for Entry, TextView or the editable entry part of a ComboBox
 354     }
 355
 356     EditControlBase::EditControlBase(BrowserDataWin* pParent)
 357         : ControlBase(pParent, u"svt/ui/thineditcontrol.ui"_ustr, u"EditControl"_ustr) // *thin*editcontrol has no frame/border
 358         , m_pEntry(nullptr) // inheritors are expected to call InitEditControlBase
 359     {
 360     }
 361
 362     void EditControlBase::InitEditControlBase(weld::Entry* pEntry)
 363     {
 364         InitControlBase(pEntry);
 365         m_pEntry = pEntry;
 366         m_pEntry->show();
 367         m_pEntry->set_width_chars(1); // so a smaller than default width can be used
 368         connect_focus_in(LINK(this, ControlBase, FocusInHdl));   // need to chain with pattern handler
 369         connect_focus_out(LINK(this, ControlBase, FocusOutHdl)); // need to chain with pattern handler
 370         connect_key_press(LINK(this, ControlBase, KeyInputHdl)); // need to chain with pattern handler
 371         m_pEntry->connect_key_release(LINK(this, ControlBase, KeyReleaseHdl));
 372         m_pEntry->connect_mouse_press(LINK(this, ControlBase, MousePressHdl));
 373         m_pEntry->connect_mouse_release(LINK(this, ControlBase, MouseReleaseHdl));
 374         m_pEntry->connect_mouse_move(LINK(this, ControlBase, MouseMoveHdl));
 375     }
 376
 377     bool ControlBase::ProcessKey(const KeyEvent& rKEvt)
 378     {
 379         return static_cast<BrowserDataWin*>(GetParent())->GetParent()->ProcessKey(rKEvt);
 380     }
 381
 382     IMPL_LINK(ControlBase, KeyInputHdl, const KeyEvent&, rKEvt, bool)
 383     {
 384         m_aKeyInputHdl.Call(rKEvt);
 385         return ProcessKey(rKEvt);
 386     }
 387
 388     IMPL_LINK(ControlBase, KeyReleaseHdl, const KeyEvent&, rKEvt, bool)
 389     {
 390         m_aKeyReleaseHdl.Call(rKEvt);
 391         return false;
 392     }
 393
 394     IMPL_LINK_NOARG(ControlBase, FocusInHdl, weld::Widget&, void)
 395     {
 396         m_aFocusInHdl.Call(nullptr);
 397         static_cast<BrowserDataWin*>(GetParent())->GetParent()->ChildFocusIn();
 398     }
 399
 400     IMPL_LINK_NOARG(ControlBase, FocusOutHdl, weld::Widget&, void)
 401     {
 402         m_aFocusOutHdl.Call(nullptr);
 403         static_cast<BrowserDataWin*>(GetParent())->GetParent()->ChildFocusOut();
 404     }
 405
 406     IMPL_LINK(ControlBase, MousePressHdl, const MouseEvent&, rEvent, bool)
 407     {
 408         m_aMousePressHdl.Call(rEvent);
 409         return false;
 410     }
 411
 412     IMPL_LINK(ControlBase, MouseReleaseHdl, const MouseEvent&, rEvent, bool)
 413     {
 414         m_aMouseReleaseHdl.Call(rEvent);
 415         return false;
 416     }
 417
 418     IMPL_LINK(ControlBase, MouseMoveHdl, const MouseEvent&, rEvent, bool)
 419     {
 420         m_aMouseMoveHdl.Call(rEvent);
 421         return false;
 422     }
 423
 424     void EditControlBase::dispose()
 425     {
 426         m_pEntry = nullptr;
 427         ControlBase::dispose();
 428     }
 429
 430     EditControl::EditControl(BrowserDataWin* pParent)
 431         : EditControlBase(pParent)
 432         , m_xWidget(m_xBuilder->weld_entry(u"entry"_ustr))
 433     {
 434         InitEditControlBase(m_xWidget.get());
 435     }
 436
 437     void EditControl::dispose()
 438     {
 439         m_xWidget.reset();
 440         EditControlBase::dispose();
 441     }
 442
 443     FormattedControlBase::FormattedControlBase(BrowserDataWin* pParent, bool bSpinVariant)
 444         : EditControlBase(pParent)
 445         , m_bSpinVariant(bSpinVariant)
 446         , m_xEntry(m_xBuilder->weld_entry(u"entry"_ustr))
 447         , m_xSpinButton(m_xBuilder->weld_formatted_spin_button(u"spinbutton"_ustr))
 448     {
 449     }
 450
 451     void FormattedControlBase::InitFormattedControlBase()
 452     {
 453         InitEditControlBase(m_bSpinVariant ? m_xSpinButton.get() : m_xEntry.get());
 454     }
 455
 456     void FormattedControlBase::connect_changed(const Link<weld::Entry&, void>& rLink)
 457     {
 458         get_formatter().connect_changed(rLink);
 459     }
 460
 461     void FormattedControlBase::connect_focus_in(const Link<weld::Widget&, void>& rLink)
 462     {
 463         get_widget().connect_focus_in(rLink);
 464     }
 465
 466     void FormattedControlBase::connect_focus_out(const Link<weld::Widget&, void>& rLink)
 467     {
 468         get_formatter().connect_focus_out(rLink);
 469     }
 470
 471     void FormattedControlBase::connect_key_press(const Link<const KeyEvent&, bool>& rLink)
 472     {
 473         get_widget().connect_key_press(rLink);
 474     }
 475
 476     weld::EntryFormatter& FormattedControlBase::get_formatter()
 477     {
 478         return *m_xEntryFormatter;
 479     }
 480
 481     void FormattedControlBase::dispose()
 482     {
 483         m_xEntryFormatter.reset();
 484         m_xSpinButton.reset();
 485         m_xEntry.reset();
 486         EditControlBase::dispose();
 487     }
 488
 489     FormattedControl::FormattedControl(BrowserDataWin* pParent, bool bSpinVariant)
 490         : FormattedControlBase(pParent, bSpinVariant)
 491     {
 492         if (bSpinVariant)
 493             m_xEntryFormatter.reset(new weld::EntryFormatter(*m_xSpinButton));
 494         else
 495             m_xEntryFormatter.reset(new weld::EntryFormatter(*m_xEntry));
 496         InitFormattedControlBase();
 497     }
 498
 499     DoubleNumericControl::DoubleNumericControl(BrowserDataWin* pParent, bool bSpinVariant)
 500         : FormattedControlBase(pParent, bSpinVariant)
 501     {
 502         if (bSpinVariant)
 503             m_xEntryFormatter.reset(new weld::DoubleNumericFormatter(*m_xSpinButton));
 504         else
 505             m_xEntryFormatter.reset(new weld::DoubleNumericFormatter(*m_xEntry));
 506         InitFormattedControlBase();
 507     }
 508
 509     LongCurrencyControl::LongCurrencyControl(BrowserDataWin* pParent, bool bSpinVariant)
 510         : FormattedControlBase(pParent, bSpinVariant)
 511     {
 512         if (bSpinVariant)
 513             m_xEntryFormatter.reset(new weld::LongCurrencyFormatter(*m_xSpinButton));
 514         else
 515             m_xEntryFormatter.reset(new weld::LongCurrencyFormatter(*m_xEntry));
 516         InitFormattedControlBase();
 517     }
 518
 519     TimeControl::TimeControl(BrowserDataWin* pParent, bool bSpinVariant)
 520         : FormattedControlBase(pParent, bSpinVariant)
 521     {
 522         if (bSpinVariant)
 523             m_xEntryFormatter.reset(new weld::TimeFormatter(*m_xSpinButton));
 524         else
 525             m_xEntryFormatter.reset(new weld::TimeFormatter(*m_xEntry));
 526         InitFormattedControlBase();
 527     }
 528
 529     DateControl::DateControl(BrowserDataWin* pParent, bool bDropDown)
 530         : FormattedControlBase(pParent, false)
 531         , m_xMenuButton(m_xBuilder->weld_menu_button(u"button"_ustr))
 532         , m_xCalendarBuilder(Application::CreateBuilder(m_xMenuButton.get(), u"svt/ui/datewindow.ui"_ustr))
 533         , m_xTopLevel(m_xCalendarBuilder->weld_widget(u"date_popup_window"_ustr))
 534         , m_xCalendar(m_xCalendarBuilder->weld_calendar(u"date_picker"_ustr))
 535         , m_xExtras(m_xCalendarBuilder->weld_widget(u"extras"_ustr))
 536         , m_xTodayBtn(m_xCalendarBuilder->weld_button(u"today"_ustr))
 537         , m_xNoneBtn(m_xCalendarBuilder->weld_button(u"none"_ustr))
 538     {
 539         m_xEntryFormatter.reset(new weld::DateFormatter(*m_xEntry));
 540         InitFormattedControlBase();
 541
 542         m_xMenuButton->set_popover(m_xTopLevel.get());
 543         m_xMenuButton->set_visible(bDropDown);
 544         m_xMenuButton->connect_toggled(LINK(this, DateControl, ToggleHdl));
 545
 546         m_xExtras->show();
 547
 548         m_xTodayBtn->connect_clicked(LINK(this, DateControl, ImplClickHdl));
 549         m_xNoneBtn->connect_clicked(LINK(this, DateControl, ImplClickHdl));
 550
 551         m_xCalendar->connect_activated(LINK(this, DateControl, ActivateHdl));
 552     }
 553
 554     IMPL_LINK(DateControl, ImplClickHdl, weld::Button&, rBtn, void)
 555     {
 556         m_xMenuButton->set_active(false);
 557         get_widget().grab_focus();
 558
 559         if (&rBtn == m_xTodayBtn.get())
 560         {
 561             Date aToday(Date::SYSTEM);
 562             SetDate(aToday);
 563         }
 564         else if (&rBtn == m_xNoneBtn.get())
 565         {
 566             get_widget().set_text(OUString());
 567         }
 568     }
 569
 570     IMPL_LINK(DateControl, ToggleHdl, weld::Toggleable&, rButton, void)
 571     {
 572         if (rButton.get_active())
 573             m_xCalendar->set_date(static_cast<weld::DateFormatter&>(get_formatter()).GetDate());
 574     }
 575
 576     IMPL_LINK_NOARG(DateControl, ActivateHdl, weld::Calendar&, void)
 577     {
 578         if (m_xMenuButton->get_active())
 579             m_xMenuButton->set_active(false);
 580         static_cast<weld::DateFormatter&>(get_formatter()).SetDate(m_xCalendar->get_date());
 581     }
 582
 583     void DateControl::SetDate(const Date& rDate)
 584     {
 585         static_cast<weld::DateFormatter&>(get_formatter()).SetDate(rDate);
 586         m_xCalendar->set_date(rDate);
 587     }
 588
 589     void DateControl::SetEditableReadOnly(bool bReadOnly)
 590     {
 591         FormattedControlBase::SetEditableReadOnly(bReadOnly);
 592         m_xMenuButton->set_sensitive(!bReadOnly);
 593     }
 594
 595     void DateControl::dispose()
 596     {
 597         m_xTodayBtn.reset();
 598         m_xNoneBtn.reset();
 599         m_xExtras.reset();
 600         m_xCalendar.reset();
 601         m_xTopLevel.reset();
 602         m_xCalendarBuilder.reset();
 603         m_xMenuButton.reset();
 604         FormattedControlBase::dispose();
 605     }
 606
 607     PatternControl::PatternControl(BrowserDataWin* pParent)
 608         : EditControlBase(pParent)
 609         , m_xWidget(m_xBuilder->weld_entry(u"entry"_ustr))
 610     {
 611         m_xEntryFormatter.reset(new weld::PatternFormatter(*m_xWidget));
 612         InitEditControlBase(m_xWidget.get());
 613     }
 614
 615     void PatternControl::connect_changed(const Link<weld::Entry&, void>& rLink)
 616     {
 617         m_xEntryFormatter->connect_changed(rLink);
 618     }
 619
 620     void PatternControl::connect_focus_in(const Link<weld::Widget&, void>& rLink)
 621     {
 622         m_xEntryFormatter->connect_focus_in(rLink);
 623     }
 624
 625     void PatternControl::connect_focus_out(const Link<weld::Widget&, void>& rLink)
 626     {
 627         m_xEntryFormatter->connect_focus_out(rLink);
 628     }
 629
 630     void PatternControl::connect_key_press(const Link<const KeyEvent&, bool>& rLink)
 631     {
 632         m_xEntryFormatter->connect_key_press(rLink);
 633     }
 634
 635     void PatternControl::dispose()
 636     {
 637         m_xEntryFormatter.reset();
 638         m_xWidget.reset();
 639         EditControlBase::dispose();
 640     }
 641
 642     EditCellController::EditCellController(EditControlBase* pEdit)
 643         : CellController(pEdit)
 644         , m_pEditImplementation(new EntryImplementation(*pEdit))
 645         , m_bOwnImplementation(true)
 646     {
 647         m_pEditImplementation->SetModifyHdl( LINK(this, EditCellController, ModifyHdl) );
 648     }
 649
 650     EditCellController::~EditCellController( )
 651     {
 652         if ( m_bOwnImplementation )
 653             delete m_pEditImplementation;
 654     }
 655
 656     void EditCellController::SaveValue()
 657     {
 658         m_pEditImplementation->SaveValue();
 659     }
 660
 661     bool EditCellController::MoveAllowed(const KeyEvent& rEvt) const
 662     {
 663         bool bResult;
 664         switch (rEvt.GetKeyCode().GetCode())
 665         {
 666             case KEY_END:
 667             case KEY_RIGHT:
 668             {
 669                 Selection aSel = m_pEditImplementation->GetSelection();
 670                 bResult = !aSel && aSel.Max() == m_pEditImplementation->GetText( LINEEND_LF ).getLength();
 671                 break;
 672             }
 673             case KEY_HOME:
 674             case KEY_LEFT:
 675             {
 676                 Selection aSel = m_pEditImplementation->GetSelection();
 677                 bResult = !aSel && aSel.Min() == 0;
 678                 break;
 679             }
 680             case KEY_DOWN:
 681             {
 682                 bResult = !m_pEditImplementation->CanDown();
 683                 break;
 684             }
 685             case KEY_UP:
 686             {
 687                 bResult = !m_pEditImplementation->CanUp();
 688                 break;
 689             }
 690             default:
 691                 bResult = true;
 692         }
 693         return bResult;
 694     }
 695
 696     bool EditCellController::IsValueChangedFromSaved() const
 697     {
 698         return m_pEditImplementation->IsValueChangedFromSaved();
 699     }
 700
 701     IMPL_LINK_NOARG(EditCellController, ModifyHdl, LinkParamNone*, void)
 702     {
 703         callModifyHdl();
 704     }
 705
 706     //= FormattedFieldCellController
 707     FormattedFieldCellController::FormattedFieldCellController( FormattedControlBase* _pFormatted )
 708         : EditCellController(_pFormatted)
 709     {
 710     }
 711
 712     void FormattedFieldCellController::CommitModifications()
 713     {
 714         static_cast<FormattedControl&>(GetWindow()).get_formatter().Commit();
 715     }
 716
 717     MultiLineTextCell::MultiLineTextCell(BrowserDataWin* pParent)
 718         : ControlBase(pParent, u"svt/ui/textviewcontrol.ui"_ustr, u"TextViewControl"_ustr)
 719         , m_xWidget(m_xBuilder->weld_text_view(u"textview"_ustr))
 720     {
 721         InitControlBase(m_xWidget.get());
 722         m_xWidget->connect_key_press(LINK(this, ControlBase, KeyInputHdl));
 723         m_xWidget->connect_key_release(LINK(this, ControlBase, KeyReleaseHdl));
 724         m_xWidget->connect_focus_in(LINK(this, ControlBase, FocusInHdl));
 725         m_xWidget->connect_focus_out(LINK(this, ControlBase, FocusOutHdl));
 726         m_xWidget->connect_mouse_press(LINK(this, ControlBase, MousePressHdl));
 727         m_xWidget->connect_mouse_release(LINK(this, ControlBase, MouseReleaseHdl));
 728         m_xWidget->connect_mouse_move(LINK(this, ControlBase, MouseMoveHdl));
 729         // so any the natural size doesn't have an effect
 730         m_xWidget->set_size_request(1, 1);
 731     }
 732
 733     void MultiLineTextCell::GetFocus()
 734     {
 735         if (m_xWidget)
 736             m_xWidget->select_region(-1, 0);
 737         ControlBase::GetFocus();
 738     }
 739
 740     void MultiLineTextCell::dispose()
 741     {
 742         m_xWidget.reset();
 743         ControlBase::dispose();
 744     }
 745
 746     bool MultiLineTextCell::ProcessKey(const KeyEvent& rKEvt)
 747     {
 748         bool bSendToDataWindow = true;
 749
 750         sal_uInt16 nCode  = rKEvt.GetKeyCode().GetCode();
 751         bool bShift = rKEvt.GetKeyCode().IsShift();
 752         bool bCtrl = rKEvt.GetKeyCode().IsMod1();
 753         bool bAlt =  rKEvt.GetKeyCode().IsMod2();
 754
 755         if (!bAlt && !bCtrl && !bShift)
 756         {
 757             switch (nCode)
 758             {
 759                 case KEY_DOWN:
 760                     bSendToDataWindow = !m_xWidget->can_move_cursor_with_down();
 761                     break;
 762                 case KEY_UP:
 763                     bSendToDataWindow = !m_xWidget->can_move_cursor_with_up();
 764                     break;
 765             }
 766         }
 767
 768         if (bSendToDataWindow)
 769             return ControlBase::ProcessKey(rKEvt);
 770         return false;
 771     }
 772 }   // namespace svt
 773
 774 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */