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, "svt/ui/combocontrol.ui", "ComboControl")
  27         , m_xWidget(m_xBuilder->weld_combo_box("combobox"))
  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, "svt/ui/listcontrol.ui", "ListControl")
 123         , m_xWidget(m_xBuilder->weld_combo_box("listbox"))
 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, "svt/ui/checkboxcontrol.ui", "CheckBoxControl")
 203         , m_xBox(m_xBuilder->weld_check_button("checkbox"))
 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, "svt/ui/thineditcontrol.ui", "EditControl") // *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("entry"))
 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("entry"))
 447         , m_xSpinButton(m_xBuilder->weld_formatted_spin_button("spinbutton"))
 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("button"))
 532         , m_xCalendarBuilder(Application::CreateBuilder(m_xMenuButton.get(), "svt/ui/datewindow.ui"))
 533         , m_xTopLevel(m_xCalendarBuilder->weld_widget("date_popup_window"))
 534         , m_xCalendar(m_xCalendarBuilder->weld_calendar("date"))
 535         , m_xExtras(m_xCalendarBuilder->weld_widget("extras"))
 536         , m_xTodayBtn(m_xCalendarBuilder->weld_button("today"))
 537         , m_xNoneBtn(m_xCalendarBuilder->weld_button("none"))
 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::dispose()
 590     {
 591         m_xTodayBtn.reset();
 592         m_xNoneBtn.reset();
 593         m_xExtras.reset();
 594         m_xCalendar.reset();
 595         m_xTopLevel.reset();
 596         m_xCalendarBuilder.reset();
 597         m_xMenuButton.reset();
 598         FormattedControlBase::dispose();
 599     }
 600
 601     PatternControl::PatternControl(BrowserDataWin* pParent)
 602         : EditControlBase(pParent)
 603         , m_xWidget(m_xBuilder->weld_entry("entry"))
 604     {
 605         m_xEntryFormatter.reset(new weld::PatternFormatter(*m_xWidget));
 606         InitEditControlBase(m_xWidget.get());
 607     }
 608
 609     void PatternControl::connect_changed(const Link<weld::Entry&, void>& rLink)
 610     {
 611         m_xEntryFormatter->connect_changed(rLink);
 612     }
 613
 614     void PatternControl::connect_focus_in(const Link<weld::Widget&, void>& rLink)
 615     {
 616         m_xEntryFormatter->connect_focus_in(rLink);
 617     }
 618
 619     void PatternControl::connect_focus_out(const Link<weld::Widget&, void>& rLink)
 620     {
 621         m_xEntryFormatter->connect_focus_out(rLink);
 622     }
 623
 624     void PatternControl::connect_key_press(const Link<const KeyEvent&, bool>& rLink)
 625     {
 626         m_xEntryFormatter->connect_key_press(rLink);
 627     }
 628
 629     void PatternControl::dispose()
 630     {
 631         m_xEntryFormatter.reset();
 632         m_xWidget.reset();
 633         EditControlBase::dispose();
 634     }
 635
 636     EditCellController::EditCellController(EditControlBase* pEdit)
 637         : CellController(pEdit)
 638         , m_pEditImplementation(new EntryImplementation(*pEdit))
 639         , m_bOwnImplementation(true)
 640     {
 641         m_pEditImplementation->SetModifyHdl( LINK(this, EditCellController, ModifyHdl) );
 642     }
 643
 644     EditCellController::~EditCellController( )
 645     {
 646         if ( m_bOwnImplementation )
 647             delete m_pEditImplementation;
 648     }
 649
 650     void EditCellController::SaveValue()
 651     {
 652         m_pEditImplementation->SaveValue();
 653     }
 654
 655     bool EditCellController::MoveAllowed(const KeyEvent& rEvt) const
 656     {
 657         bool bResult;
 658         switch (rEvt.GetKeyCode().GetCode())
 659         {
 660             case KEY_END:
 661             case KEY_RIGHT:
 662             {
 663                 Selection aSel = m_pEditImplementation->GetSelection();
 664                 bResult = !aSel && aSel.Max() == m_pEditImplementation->GetText( LINEEND_LF ).getLength();
 665                 break;
 666             }
 667             case KEY_HOME:
 668             case KEY_LEFT:
 669             {
 670                 Selection aSel = m_pEditImplementation->GetSelection();
 671                 bResult = !aSel && aSel.Min() == 0;
 672                 break;
 673             }
 674             case KEY_DOWN:
 675             {
 676                 bResult = !m_pEditImplementation->CanDown();
 677                 break;
 678             }
 679             case KEY_UP:
 680             {
 681                 bResult = !m_pEditImplementation->CanUp();
 682                 break;
 683             }
 684             default:
 685                 bResult = true;
 686         }
 687         return bResult;
 688     }
 689
 690     bool EditCellController::IsValueChangedFromSaved() const
 691     {
 692         return m_pEditImplementation->IsValueChangedFromSaved();
 693     }
 694
 695     IMPL_LINK_NOARG(EditCellController, ModifyHdl, LinkParamNone*, void)
 696     {
 697         callModifyHdl();
 698     }
 699
 700     //= FormattedFieldCellController
 701     FormattedFieldCellController::FormattedFieldCellController( FormattedControlBase* _pFormatted )
 702         : EditCellController(_pFormatted)
 703     {
 704     }
 705
 706     void FormattedFieldCellController::CommitModifications()
 707     {
 708         static_cast<FormattedControl&>(GetWindow()).get_formatter().Commit();
 709     }
 710
 711     MultiLineTextCell::MultiLineTextCell(BrowserDataWin* pParent)
 712         : ControlBase(pParent, "svt/ui/textviewcontrol.ui", "TextViewControl")
 713         , m_xWidget(m_xBuilder->weld_text_view("textview"))
 714     {
 715         InitControlBase(m_xWidget.get());
 716         m_xWidget->connect_key_press(LINK(this, ControlBase, KeyInputHdl));
 717         m_xWidget->connect_key_release(LINK(this, ControlBase, KeyReleaseHdl));
 718         m_xWidget->connect_focus_in(LINK(this, ControlBase, FocusInHdl));
 719         m_xWidget->connect_focus_out(LINK(this, ControlBase, FocusOutHdl));
 720         m_xWidget->connect_mouse_press(LINK(this, ControlBase, MousePressHdl));
 721         m_xWidget->connect_mouse_release(LINK(this, ControlBase, MouseReleaseHdl));
 722         m_xWidget->connect_mouse_move(LINK(this, ControlBase, MouseMoveHdl));
 723         // so any the natural size doesn't have an effect
 724         m_xWidget->set_size_request(1, 1);
 725     }
 726
 727     void MultiLineTextCell::GetFocus()
 728     {
 729         if (m_xWidget)
 730             m_xWidget->select_region(-1, 0);
 731         ControlBase::GetFocus();
 732     }
 733
 734     void MultiLineTextCell::dispose()
 735     {
 736         m_xWidget.reset();
 737         ControlBase::dispose();
 738     }
 739
 740     bool MultiLineTextCell::ProcessKey(const KeyEvent& rKEvt)
 741     {
 742         bool bSendToDataWindow = true;
 743
 744         sal_uInt16 nCode  = rKEvt.GetKeyCode().GetCode();
 745         bool bShift = rKEvt.GetKeyCode().IsShift();
 746         bool bCtrl = rKEvt.GetKeyCode().IsMod1();
 747         bool bAlt =  rKEvt.GetKeyCode().IsMod2();
 748
 749         if (!bAlt && !bCtrl && !bShift)
 750         {
 751             switch (nCode)
 752             {
 753                 case KEY_DOWN:
 754                     bSendToDataWindow = !m_xWidget->can_move_cursor_with_down();
 755                     break;
 756                 case KEY_UP:
 757                     bSendToDataWindow = !m_xWidget->can_move_cursor_with_up();
 758                     break;
 759             }
 760         }
 761
 762         if (bSendToDataWindow)
 763             return ControlBase::ProcessKey(rKEvt);
 764         return false;
 765     }
 766 }   // namespace svt
 767
 768 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */