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/decoview.hxx>
  21 #include <vcl/fmtfield.hxx>
  22 #include <vcl/xtextedt.hxx>
  23 #include <vcl/textview.hxx>
  24
  25 #include <algorithm>
  26
  27
  28 namespace svt
  29 {
  30
  31
  32     //= ComboBoxControl
  33
  34     ComboBoxControl::ComboBoxControl(vcl::Window* pParent)
  35                    :ComboBox(pParent, WB_DROPDOWN|WB_NOBORDER)
  36     {
  37         EnableAutoSize(false);
  38         EnableAutocomplete(true);
  39         SetDropDownLineCount(5);
  40     }
  41
  42
  43     bool ComboBoxControl::PreNotify( NotifyEvent& rNEvt )
  44     {
  45         if (rNEvt.GetType() == MouseNotifyEvent::KEYINPUT && !IsInDropDown())
  46         {
  47             const KeyEvent *pEvt = rNEvt.GetKeyEvent();
  48             const vcl::KeyCode rKey = pEvt->GetKeyCode();
  49
  50             if ((rKey.GetCode() == KEY_UP || rKey.GetCode() == KEY_DOWN) &&
  51                 (!pEvt->GetKeyCode().IsShift() && pEvt->GetKeyCode().IsMod1()))
  52             {
  53                 // select next resp. previous entry
  54                 sal_Int32 nPos = GetEntryPos(GetText());
  55                 int nDir = (rKey.GetCode() == KEY_DOWN ? 1 : -1);
  56                 if (!((nPos == 0 && nDir == -1) || (nPos >= GetEntryCount() && nDir == 1)))
  57                 {
  58                     nPos += nDir;
  59                     SetText(GetEntry(nPos));
  60                 }
  61                 return true;
  62             }
  63         }
  64         return ComboBox::PreNotify(rNEvt);
  65     }
  66
  67     //= ComboBoxCellController
  68     ComboBoxCellController::ComboBoxCellController(ComboBoxControl* pWin)
  69                              :CellController(pWin)
  70     {
  71         GetComboBox().SetModifyHdl( LINK(this, ComboBoxCellController, ModifyHdl) );
  72     }
  73
  74     IMPL_LINK_NOARG(ComboBoxCellController, ModifyHdl, Edit&, void)
  75     {
  76         callModifyHdl();
  77     }
  78
  79
  80     bool ComboBoxCellController::MoveAllowed(const KeyEvent& rEvt) const
  81     {
  82         ComboBoxControl& rBox = GetComboBox();
  83         switch (rEvt.GetKeyCode().GetCode())
  84         {
  85             case KEY_END:
  86             case KEY_RIGHT:
  87             {
  88                 Selection aSel = rBox.GetSelection();
  89                 return !aSel && aSel.Max() == rBox.GetText().getLength();
  90             }
  91             case KEY_HOME:
  92             case KEY_LEFT:
  93             {
  94                 Selection aSel = rBox.GetSelection();
  95                 return !aSel && aSel.Min() == 0;
  96             }
  97             case KEY_UP:
  98             case KEY_DOWN:
  99                 if (rBox.IsInDropDown())
 100                     return false;
 101                 if (!rEvt.GetKeyCode().IsShift() &&
 102                      rEvt.GetKeyCode().IsMod1())
 103                     return false;
 104                 // drop down the list box
 105                 else if (rEvt.GetKeyCode().IsMod2() && rEvt.GetKeyCode().GetCode() == KEY_DOWN)
 106                     return false;
 107                 [[fallthrough]];
 108             case KEY_PAGEUP:
 109             case KEY_PAGEDOWN:
 110             case KEY_RETURN:
 111                 if (rBox.IsInDropDown())
 112                     return false;
 113                 [[fallthrough]];
 114             default:
 115                 return true;
 116         }
 117     }
 118
 119
 120     bool ComboBoxCellController::IsModified() const
 121     {
 122         return GetComboBox().IsValueChangedFromSaved();
 123     }
 124
 125     void ComboBoxCellController::ClearModified()
 126     {
 127         GetComboBox().SaveValue();
 128     }
 129
 130     //= ListBoxControl
 131     ListBoxControl::ListBoxControl(vcl::Window* pParent)
 132                   :ListBox(pParent, WB_DROPDOWN|WB_NOBORDER)
 133     {
 134         EnableAutoSize(false);
 135         EnableMultiSelection(false);
 136         SetDropDownLineCount(20);
 137     }
 138
 139     bool ListBoxControl::PreNotify( NotifyEvent& rNEvt )
 140     {
 141         if (rNEvt.GetType() == MouseNotifyEvent::KEYINPUT && !IsInDropDown())
 142         {
 143             const KeyEvent *pEvt = rNEvt.GetKeyEvent();
 144             const vcl::KeyCode rKey = pEvt->GetKeyCode();
 145
 146             if ((rKey.GetCode() == KEY_UP || rKey.GetCode() == KEY_DOWN) &&
 147                 (!pEvt->GetKeyCode().IsShift() && pEvt->GetKeyCode().IsMod1()))
 148             {
 149                 // select next resp. previous entry
 150                 sal_Int32 nPos = GetSelectedEntryPos();
 151                 int nDir = (rKey.GetCode() == KEY_DOWN ? 1 : -1);
 152                 if (!((nPos == 0 && nDir == -1) || (nPos >= GetEntryCount() && nDir == 1)))
 153                 {
 154                     nPos += nDir;
 155                     SelectEntryPos(nPos);
 156                 }
 157                 Select();   // for calling Modify
 158                 return true;
 159             }
 160             else if (GetParent()->PreNotify(rNEvt))
 161                 return true;
 162         }
 163         return ListBox::PreNotify(rNEvt);
 164     }
 165
 166     //= ListBoxCellController
 167     ListBoxCellController::ListBoxCellController(ListBoxControl* pWin)
 168                              :CellController(pWin)
 169     {
 170         GetListBox().SetSelectHdl(LINK(this, ListBoxCellController, ListBoxSelectHdl));
 171     }
 172
 173
 174     bool ListBoxCellController::MoveAllowed(const KeyEvent& rEvt) const
 175     {
 176         const ListBoxControl& rBox = GetListBox();
 177         switch (rEvt.GetKeyCode().GetCode())
 178         {
 179             case KEY_UP:
 180             case KEY_DOWN:
 181                 if (!rEvt.GetKeyCode().IsShift() &&
 182                      rEvt.GetKeyCode().IsMod1())
 183                     return false;
 184                 // drop down the list box
 185                 else
 186                     if (rEvt.GetKeyCode().IsMod2() && rEvt.GetKeyCode().GetCode() == KEY_DOWN)
 187                         return false;
 188                 [[fallthrough]];
 189             case KEY_PAGEUP:
 190             case KEY_PAGEDOWN:
 191                 if (rBox.IsTravelSelect())
 192                     return false;
 193                 [[fallthrough]];
 194             default:
 195                 return true;
 196         }
 197     }
 198
 199
 200     bool ListBoxCellController::IsModified() const
 201     {
 202         return GetListBox().IsValueChangedFromSaved();
 203     }
 204
 205
 206     void ListBoxCellController::ClearModified()
 207     {
 208         GetListBox().SaveValue();
 209     }
 210
 211
 212     IMPL_LINK_NOARG(ListBoxCellController, ListBoxSelectHdl, ListBox&, void)
 213     {
 214         callModifyHdl();
 215     }
 216
 217
 218     //= CheckBoxControl
 219
 220
 221     CheckBoxControl::CheckBoxControl(vcl::Window* pParent)
 222                    :Control(pParent, 0)
 223     {
 224         const Wallpaper& rParentBackground = pParent->GetBackground();
 225         if ( (pParent->GetStyle() & WB_CLIPCHILDREN) || rParentBackground.IsFixed() )
 226             SetBackground( rParentBackground );
 227         else
 228         {
 229             SetPaintTransparent( true );
 230             SetBackground();
 231         }
 232
 233         EnableChildTransparentMode();
 234
 235         pBox = VclPtr<TriStateBox>::Create(this,WB_CENTER|WB_VCENTER);
 236         pBox->SetLegacyNoTextAlign( true );
 237         pBox->EnableChildTransparentMode();
 238         pBox->SetPaintTransparent( true );
 239         pBox->SetClickHdl( LINK( this, CheckBoxControl, OnClick ) );
 240         pBox->Show();
 241     }
 242
 243
 244     CheckBoxControl::~CheckBoxControl()
 245     {
 246         disposeOnce();
 247     }
 248
 249     void CheckBoxControl::dispose()
 250     {
 251         pBox.disposeAndClear();
 252         Control::dispose();
 253     }
 254
 255
 256     IMPL_LINK_NOARG(CheckBoxControl, OnClick, Button*, void)
 257     {
 258         m_aClickLink.Call(pBox);
 259         m_aModifyLink.Call(nullptr);
 260     }
 261
 262
 263     void CheckBoxControl::Resize()
 264     {
 265         Control::Resize();
 266         pBox->SetPosSizePixel(Point(0,0),GetSizePixel());
 267     }
 268
 269
 270     void CheckBoxControl::DataChanged( const DataChangedEvent& _rEvent )
 271     {
 272         if ( _rEvent.GetType() == DataChangedEventType::SETTINGS )
 273             pBox->SetSettings( GetSettings() );
 274     }
 275
 276
 277     void CheckBoxControl::StateChanged( StateChangedType nStateChange )
 278     {
 279         Control::StateChanged(nStateChange);
 280         if ( nStateChange == StateChangedType::Zoom )
 281             pBox->SetZoom(GetZoom());
 282     }
 283
 284
 285     void CheckBoxControl::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize, DrawFlags nFlags )
 286     {
 287         pBox->Draw(pDev,rPos,rSize,nFlags);
 288     }
 289
 290
 291     void CheckBoxControl::GetFocus()
 292     {
 293         if (pBox)
 294             pBox->GrabFocus();
 295     }
 296
 297
 298     void CheckBoxControl::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rClientRect)
 299     {
 300         Control::Paint(rRenderContext, rClientRect);
 301         if (HasFocus())
 302             ShowFocus(tools::Rectangle());
 303     }
 304
 305
 306     bool CheckBoxControl::PreNotify(NotifyEvent& rEvt)
 307     {
 308         switch (rEvt.GetType())
 309         {
 310             case MouseNotifyEvent::GETFOCUS:
 311                 ShowFocus(tools::Rectangle());
 312                 break;
 313             case MouseNotifyEvent::LOSEFOCUS:
 314                 HideFocus();
 315                 break;
 316             default:
 317                 break;
 318         }
 319         return Control::PreNotify(rEvt);
 320     }
 321
 322
 323     //= CheckBoxCellController
 324
 325
 326     CheckBoxCellController::CheckBoxCellController(CheckBoxControl* pWin)
 327         : CellController(pWin)
 328     {
 329         static_cast<CheckBoxControl &>(GetWindow()).SetModifyHdl( LINK(this, CheckBoxCellController, ModifyHdl) );
 330     }
 331
 332     bool CheckBoxCellController::WantMouseEvent() const
 333     {
 334         return true;
 335     }
 336
 337
 338     CheckBox& CheckBoxCellController::GetCheckBox() const
 339     {
 340         return static_cast<CheckBoxControl &>(GetWindow()).GetBox();
 341     }
 342
 343
 344     bool CheckBoxCellController::IsModified() const
 345     {
 346         return GetCheckBox().IsValueChangedFromSaved();
 347     }
 348
 349
 350     void CheckBoxCellController::ClearModified()
 351     {
 352         GetCheckBox().SaveValue();
 353     }
 354
 355
 356     IMPL_LINK_NOARG(CheckBoxCellController, ModifyHdl, LinkParamNone*, void)
 357     {
 358         callModifyHdl();
 359     }
 360
 361     //= MultiLineEditImplementation
 362
 363
 364     OUString MultiLineEditImplementation::GetText( LineEnd aSeparator ) const
 365     {
 366         return const_cast< MultiLineEditImplementation* >( this )->GetEditWindow().GetText( aSeparator );
 367     }
 368
 369
 370     OUString MultiLineEditImplementation::GetSelected( LineEnd aSeparator ) const
 371     {
 372         return const_cast< MultiLineEditImplementation* >( this )->GetEditWindow().GetSelected( aSeparator );
 373     }
 374
 375
 376     //= EditCellController
 377
 378
 379     EditCellController::EditCellController( Edit* _pEdit )
 380         :CellController( _pEdit )
 381         ,m_pEditImplementation( new EditImplementation( *_pEdit ) )
 382         ,m_bOwnImplementation( true )
 383     {
 384         m_pEditImplementation->SetModifyHdl( LINK(this, EditCellController, ModifyHdl) );
 385     }
 386
 387
 388     EditCellController::EditCellController( IEditImplementation* _pImplementation )
 389         :CellController( &_pImplementation->GetControl() )
 390         ,m_pEditImplementation( _pImplementation )
 391         ,m_bOwnImplementation( false )
 392     {
 393         m_pEditImplementation->SetModifyHdl( LINK(this, EditCellController, ModifyHdl) );
 394     }
 395
 396
 397     EditCellController::~EditCellController( )
 398     {
 399         if ( m_bOwnImplementation )
 400             DELETEZ( m_pEditImplementation );
 401     }
 402
 403
 404     void EditCellController::SetModified()
 405     {
 406         m_pEditImplementation->SetModified();
 407     }
 408
 409
 410     void EditCellController::ClearModified()
 411     {
 412         m_pEditImplementation->ClearModified();
 413     }
 414
 415
 416     bool EditCellController::MoveAllowed(const KeyEvent& rEvt) const
 417     {
 418         bool bResult;
 419         switch (rEvt.GetKeyCode().GetCode())
 420         {
 421             case KEY_END:
 422             case KEY_RIGHT:
 423             {
 424                 Selection aSel = m_pEditImplementation->GetSelection();
 425                 bResult = !aSel && aSel.Max() == m_pEditImplementation->GetText( LINEEND_LF ).getLength();
 426             }   break;
 427             case KEY_HOME:
 428             case KEY_LEFT:
 429             {
 430                 Selection aSel = m_pEditImplementation->GetSelection();
 431                 bResult = !aSel && aSel.Min() == 0;
 432             }   break;
 433             default:
 434                 bResult = true;
 435         }
 436         return bResult;
 437     }
 438
 439
 440     bool EditCellController::IsModified() const
 441     {
 442         return m_pEditImplementation->IsModified();
 443     }
 444
 445
 446     IMPL_LINK_NOARG(EditCellController, ModifyHdl, Edit&, void)
 447     {
 448         callModifyHdl();
 449     }
 450
 451     //= SpinCellController
 452
 453
 454     SpinCellController::SpinCellController(SpinField* pWin)
 455                          :CellController(pWin)
 456     {
 457         GetSpinWindow().SetModifyHdl( LINK(this, SpinCellController, ModifyHdl) );
 458     }
 459
 460
 461     void SpinCellController::SetModified()
 462     {
 463         GetSpinWindow().SetModifyFlag();
 464     }
 465
 466
 467     void SpinCellController::ClearModified()
 468     {
 469         GetSpinWindow().ClearModifyFlag();
 470     }
 471
 472
 473     bool SpinCellController::MoveAllowed(const KeyEvent& rEvt) const
 474     {
 475         bool bResult;
 476         switch (rEvt.GetKeyCode().GetCode())
 477         {
 478             case KEY_END:
 479             case KEY_RIGHT:
 480             {
 481                 Selection aSel = GetSpinWindow().GetSelection();
 482                 bResult = !aSel && aSel.Max() == GetSpinWindow().GetText().getLength();
 483             }   break;
 484             case KEY_HOME:
 485             case KEY_LEFT:
 486             {
 487                 Selection aSel = GetSpinWindow().GetSelection();
 488                 bResult = !aSel && aSel.Min() == 0;
 489             }   break;
 490             default:
 491                 bResult = true;
 492         }
 493         return bResult;
 494     }
 495
 496
 497     bool SpinCellController::IsModified() const
 498     {
 499         return GetSpinWindow().IsModified();
 500     }
 501
 502     IMPL_LINK_NOARG(SpinCellController, ModifyHdl, Edit&, void)
 503     {
 504         callModifyHdl();
 505     }
 506
 507     //= FormattedFieldCellController
 508
 509
 510     FormattedFieldCellController::FormattedFieldCellController( FormattedField* _pFormatted )
 511         :EditCellController( _pFormatted )
 512     {
 513     }
 514
 515
 516     void FormattedFieldCellController::CommitModifications()
 517     {
 518         static_cast< FormattedField& >( GetWindow() ).Commit();
 519     }
 520
 521
 522     //= MultiLineTextCell
 523
 524
 525     void MultiLineTextCell::Modify()
 526     {
 527         GetTextEngine()->SetModified( true );
 528         MultiLineEdit::Modify();
 529     }
 530
 531
 532     bool MultiLineTextCell::dispatchKeyEvent( const KeyEvent& _rEvent )
 533     {
 534         Selection aOldSelection( GetSelection() );
 535
 536         bool bWasModified = IsModified();
 537         ClearModifyFlag( );
 538
 539         bool bHandled = GetTextView()->KeyInput( _rEvent );
 540
 541         bool bIsModified = IsModified();
 542         if ( bWasModified && !bIsModified )
 543             // not sure whether this can really happen
 544             SetModifyFlag();
 545
 546         if ( bHandled ) // the view claimed it handled the key input
 547         {
 548             // unfortunately, KeyInput also returns <TRUE/> (means "I handled this key input")
 549             // when nothing really changed. Let's care for this.
 550             Selection aNewSelection( GetSelection() );
 551             if  (  aNewSelection != aOldSelection   // selection changed
 552                 || bIsModified                      // or some other modification
 553                 )
 554                 return true;
 555         }
 556         return false;
 557     }
 558
 559
 560     bool MultiLineTextCell::PreNotify( NotifyEvent& rNEvt )
 561     {
 562         if ( rNEvt.GetType() == MouseNotifyEvent::KEYINPUT )
 563         {
 564             if ( IsWindowOrChild( rNEvt.GetWindow() ) )
 565             {
 566                 // give the text view a chance to handle the keys
 567                 // this is necessary since a lot of keys which are normally handled
 568                 // by this view (in KeyInput) are intercepted by the EditBrowseBox,
 569                 // which uses them for other reasons. An example is the KeyUp key,
 570                 // which is used by both the text view and the edit browse box
 571
 572                 const KeyEvent* pKeyEvent = rNEvt.GetKeyEvent();
 573                 const vcl::KeyCode& rKeyCode = pKeyEvent->GetKeyCode();
 574                 sal_uInt16 nCode = rKeyCode.GetCode();
 575
 576                 if ( ( nCode == KEY_RETURN ) && ( rKeyCode.GetModifier() == KEY_MOD1 ) )
 577                 {
 578                     KeyEvent aEvent( pKeyEvent->GetCharCode(),
 579                         vcl::KeyCode( KEY_RETURN ),
 580                         pKeyEvent->GetRepeat()
 581                     );
 582                     if ( dispatchKeyEvent( aEvent ) )
 583                         return true;
 584                 }
 585
 586                 if ( ( nCode != KEY_TAB ) && ( nCode != KEY_RETURN ) )   // everything but tab and enter
 587                 {
 588                     if ( dispatchKeyEvent( *pKeyEvent ) )
 589                         return true;
 590                 }
 591             }
 592         }
 593         return MultiLineEdit::PreNotify( rNEvt );
 594     }
 595
 596
 597 }   // namespace svt
 598
 599
 600 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */