svtools/source/brwbox/ebbcontrols.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: ebbcontrols.cxx,v $
  10  * $Revision: 1.13 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svtools.hxx"
  33 #include <svtools/editbrowsebox.hxx>
  34 #include <vcl/decoview.hxx>
  35 #include <svtools/fmtfield.hxx>
  36 #include <svtools/xtextedt.hxx>
  37
  38 #include <algorithm>
  39
  40 // .......................................................................
  41 namespace svt
  42 {
  43 // .......................................................................
  44
  45     TYPEINIT0(CellController);
  46     TYPEINIT1(EditCellController, CellController);
  47     TYPEINIT1(SpinCellController, CellController);
  48     TYPEINIT1(CheckBoxCellController, CellController);
  49     TYPEINIT1(ComboBoxCellController, CellController);
  50     TYPEINIT1(ListBoxCellController, CellController);
  51
  52     TYPEINIT1( FormattedFieldCellController, EditCellController );
  53
  54     //==================================================================
  55     //= ComboBoxControl
  56     //==================================================================
  57     ComboBoxControl::ComboBoxControl(Window* pParent, WinBits nWinStyle)
  58                    :ComboBox(pParent, nWinStyle|WB_DROPDOWN|WB_NOBORDER)
  59     {
  60         EnableAutoSize(sal_False);
  61         EnableAutocomplete(sal_True);
  62         SetDropDownLineCount(5);
  63     }
  64
  65     //------------------------------------------------------------------
  66     long ComboBoxControl::PreNotify( NotifyEvent& rNEvt )
  67     {
  68         switch (rNEvt.GetType())
  69         {
  70             case EVENT_KEYINPUT:
  71                 if (!IsInDropDown())
  72                 {
  73                     const KeyEvent *pEvt = rNEvt.GetKeyEvent();
  74                     const KeyCode rKey = pEvt->GetKeyCode();
  75
  76                     if ((rKey.GetCode() == KEY_UP || rKey.GetCode() == KEY_DOWN) &&
  77                         (!pEvt->GetKeyCode().IsShift() && pEvt->GetKeyCode().IsMod1()))
  78                     {
  79                         // select next resp. previous entry
  80                         int nPos = GetEntryPos(GetText());
  81                         nPos = nPos + (rKey.GetCode() == KEY_DOWN ? 1 : -1);
  82                         if (nPos < 0)
  83                             nPos = 0;
  84                         if (nPos >= GetEntryCount())
  85                             nPos = GetEntryCount() - 1;
  86                         SetText(GetEntry(sal::static_int_cast< USHORT >(nPos)));
  87                         return 1;
  88                     }
  89                 }
  90                 break;
  91         }
  92         return ComboBox::PreNotify(rNEvt);
  93     }
  94
  95     //==================================================================
  96     //= ComboBoxCellController
  97     //==================================================================
  98     //------------------------------------------------------------------
  99     ComboBoxCellController::ComboBoxCellController(ComboBoxControl* pWin)
 100                              :CellController(pWin)
 101     {
 102     }
 103
 104     //------------------------------------------------------------------
 105     sal_Bool ComboBoxCellController::MoveAllowed(const KeyEvent& rEvt) const
 106     {
 107         ComboBoxControl& rBox = GetComboBox();
 108         switch (rEvt.GetKeyCode().GetCode())
 109         {
 110             case KEY_END:
 111             case KEY_RIGHT:
 112             {
 113                 Selection aSel = rBox.GetSelection();
 114                 return !aSel && aSel.Max() == rBox.GetText().Len();
 115             }
 116             case KEY_HOME:
 117             case KEY_LEFT:
 118             {
 119                 Selection aSel = rBox.GetSelection();
 120                 return !aSel && aSel.Min() == 0;
 121             }
 122             case KEY_UP:
 123             case KEY_DOWN:
 124                 if (rBox.IsInDropDown())
 125                     return sal_False;
 126                 if (!rEvt.GetKeyCode().IsShift() &&
 127                      rEvt.GetKeyCode().IsMod1())
 128                     return sal_False;
 129                 // drop down the list box
 130                 else if (rEvt.GetKeyCode().IsMod2() && rEvt.GetKeyCode().GetCode() == KEY_DOWN)
 131                     return sal_False;
 132             case KEY_PAGEUP:
 133             case KEY_PAGEDOWN:
 134             case KEY_RETURN:
 135                 if (rBox.IsInDropDown())
 136                     return sal_False;
 137             default:
 138                 return sal_True;
 139         }
 140     }
 141
 142     //------------------------------------------------------------------
 143     sal_Bool ComboBoxCellController::IsModified() const
 144     {
 145         return GetComboBox().GetSavedValue() != GetComboBox().GetText();
 146     }
 147
 148     //------------------------------------------------------------------
 149     void ComboBoxCellController::ClearModified()
 150     {
 151         GetComboBox().SaveValue();
 152     }
 153
 154     //------------------------------------------------------------------
 155     void ComboBoxCellController::SetModifyHdl(const Link& rLink)
 156     {
 157         GetComboBox().SetModifyHdl(rLink);
 158     }
 159
 160     //==================================================================
 161     //= ListBoxControl
 162     //==================================================================
 163     //------------------------------------------------------------------
 164     ListBoxControl::ListBoxControl(Window* pParent, WinBits nWinStyle)
 165                   :ListBox(pParent, nWinStyle|WB_DROPDOWN|WB_NOBORDER)
 166     {
 167         EnableAutoSize(sal_False);
 168         EnableMultiSelection(sal_False);
 169         SetDropDownLineCount(20);
 170     }
 171
 172     //------------------------------------------------------------------
 173     long ListBoxControl::PreNotify( NotifyEvent& rNEvt )
 174     {
 175         switch (rNEvt.GetType())
 176         {
 177             case EVENT_KEYINPUT:
 178                 if (!IsInDropDown())
 179                 {
 180                     const KeyEvent *pEvt = rNEvt.GetKeyEvent();
 181                     const KeyCode rKey = pEvt->GetKeyCode();
 182
 183                     if ((rKey.GetCode() == KEY_UP || rKey.GetCode() == KEY_DOWN) &&
 184                         (!pEvt->GetKeyCode().IsShift() && pEvt->GetKeyCode().IsMod1()))
 185                     {
 186                         // select next resp. previous entry
 187                         int nPos = GetSelectEntryPos();
 188                         nPos = nPos + (rKey.GetCode() == KEY_DOWN ? 1 : -1);
 189                         if (nPos < 0)
 190                             nPos = 0;
 191                         if (nPos >= GetEntryCount())
 192                             nPos = GetEntryCount() - 1;
 193                         SelectEntryPos(sal::static_int_cast< USHORT >(nPos));
 194                         Select();       // for calling Modify
 195                         return 1;
 196                     }
 197                     else if (GetParent()->PreNotify(rNEvt))
 198                         return 1;
 199                 }
 200                 break;
 201         }
 202         return ListBox::PreNotify(rNEvt);
 203     }
 204
 205     //==================================================================
 206     //= ListBoxCellController
 207     //==================================================================
 208     //------------------------------------------------------------------
 209     ListBoxCellController::ListBoxCellController(ListBoxControl* pWin)
 210                              :CellController(pWin)
 211     {
 212     }
 213
 214     //------------------------------------------------------------------
 215     sal_Bool ListBoxCellController::MoveAllowed(const KeyEvent& rEvt) const
 216     {
 217         ListBoxControl& rBox = GetListBox();
 218         switch (rEvt.GetKeyCode().GetCode())
 219         {
 220             case KEY_UP:
 221             case KEY_DOWN:
 222                 if (!rEvt.GetKeyCode().IsShift() &&
 223                      rEvt.GetKeyCode().IsMod1())
 224                     return sal_False;
 225                 // drop down the list box
 226                 else
 227                     if (rEvt.GetKeyCode().IsMod2() && rEvt.GetKeyCode().GetCode() == KEY_DOWN)
 228                         return sal_False;
 229             case KEY_PAGEUP:
 230             case KEY_PAGEDOWN:
 231                 if (rBox.IsTravelSelect())
 232                     return sal_False;
 233             default:
 234                 return sal_True;
 235         }
 236     }
 237
 238     //------------------------------------------------------------------
 239     sal_Bool ListBoxCellController::IsModified() const
 240     {
 241         return GetListBox().GetSelectEntryPos() != GetListBox().GetSavedValue();
 242     }
 243
 244     //------------------------------------------------------------------
 245     void ListBoxCellController::ClearModified()
 246     {
 247         GetListBox().SaveValue();
 248     }
 249
 250     //------------------------------------------------------------------
 251     void ListBoxCellController::SetModifyHdl(const Link& rLink)
 252     {
 253         GetListBox().SetSelectHdl(rLink);
 254     }
 255
 256     //==================================================================
 257     //= CheckBoxControl
 258     //==================================================================
 259     //------------------------------------------------------------------
 260     CheckBoxControl::CheckBoxControl(Window* pParent, WinBits nWinStyle)
 261                    :Control(pParent, nWinStyle)
 262     {
 263         const Wallpaper& rParentBackground = pParent->GetBackground();
 264         if ( (pParent->GetStyle() & WB_CLIPCHILDREN) || rParentBackground.IsFixed() )
 265             SetBackground( rParentBackground );
 266         else
 267         {
 268             SetPaintTransparent( sal_True );
 269             SetBackground();
 270         }
 271
 272         EnableChildTransparentMode();
 273
 274         pBox = new TriStateBox(this,WB_CENTER|WB_VCENTER);
 275         pBox->EnableChildTransparentMode();
 276         pBox->SetPaintTransparent( sal_True );
 277         pBox->SetClickHdl( LINK( this, CheckBoxControl, OnClick ) );
 278         pBox->Show();
 279     }
 280
 281     //------------------------------------------------------------------
 282     CheckBoxControl::~CheckBoxControl()
 283     {
 284         delete pBox;
 285     }
 286
 287     //------------------------------------------------------------------
 288     IMPL_LINK( CheckBoxControl, OnClick, void*, EMPTYARG )
 289     {
 290         m_aClickLink.Call(pBox);
 291         return m_aModifyLink.Call(pBox);
 292     }
 293
 294     //------------------------------------------------------------------
 295     void CheckBoxControl::Resize()
 296     {
 297         Control::Resize();
 298         pBox->SetPosSizePixel(Point(0,0),GetSizePixel());
 299     }
 300
 301     //------------------------------------------------------------------------------
 302     void CheckBoxControl::DataChanged( const DataChangedEvent& _rEvent )
 303     {
 304         if ( _rEvent.GetType() == DATACHANGED_SETTINGS )
 305             pBox->SetSettings( GetSettings() );
 306     }
 307
 308     //------------------------------------------------------------------------------
 309     void CheckBoxControl::StateChanged( StateChangedType nStateChange )
 310     {
 311         Control::StateChanged(nStateChange);
 312         if ( nStateChange == STATE_CHANGE_ZOOM )
 313             pBox->SetZoom(GetZoom());
 314     }
 315
 316     //------------------------------------------------------------------
 317     void CheckBoxControl::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize, ULONG nFlags )
 318     {
 319         pBox->Draw(pDev,rPos,rSize,nFlags);
 320     }
 321
 322     //------------------------------------------------------------------
 323     void CheckBoxControl::GetFocus()
 324     {
 325         pBox->GrabFocus();
 326     }
 327
 328     //------------------------------------------------------------------
 329     void CheckBoxControl::Paint(const Rectangle& rClientRect)
 330     {
 331         Control::Paint(rClientRect);
 332         if (HasFocus())
 333             ShowFocus(aFocusRect);
 334     }
 335
 336     //------------------------------------------------------------------
 337     long CheckBoxControl::PreNotify(NotifyEvent& rEvt)
 338     {
 339         switch (rEvt.GetType())
 340         {
 341             case EVENT_GETFOCUS:
 342                 ShowFocus(aFocusRect);
 343                 break;
 344             case EVENT_LOSEFOCUS:
 345                 HideFocus();
 346         }
 347         return Control::PreNotify(rEvt);
 348     }
 349
 350     //==================================================================
 351     //= CheckBoxCellController
 352     //==================================================================
 353     //------------------------------------------------------------------
 354     sal_Bool CheckBoxCellController::WantMouseEvent() const
 355     {
 356         return sal_True;
 357     }
 358
 359     //------------------------------------------------------------------
 360     CheckBox& CheckBoxCellController::GetCheckBox() const
 361     {
 362         return ((CheckBoxControl &)GetWindow()).GetBox();
 363     }
 364
 365     //------------------------------------------------------------------
 366     sal_Bool CheckBoxCellController::IsModified() const
 367     {
 368         return GetCheckBox().GetSavedValue() != GetCheckBox().GetState();
 369     }
 370
 371     //------------------------------------------------------------------
 372     void CheckBoxCellController::ClearModified()
 373     {
 374         GetCheckBox().SaveValue();
 375     }
 376
 377     //------------------------------------------------------------------
 378     void CheckBoxCellController::SetModifyHdl(const Link& rLink)
 379     {
 380         ((CheckBoxControl &)GetWindow()).SetModifyHdl(rLink);
 381     }
 382
 383     //==================================================================
 384     //= MultiLineEditImplementation
 385     //==================================================================
 386     //------------------------------------------------------------------
 387     String MultiLineEditImplementation::GetText( LineEnd aSeparator ) const
 388     {
 389         return const_cast< MultiLineEditImplementation* >( this )->GetEditWindow().GetText( aSeparator );
 390     }
 391
 392     //------------------------------------------------------------------
 393     String MultiLineEditImplementation::GetSelected( LineEnd aSeparator ) const
 394     {
 395         return const_cast< MultiLineEditImplementation* >( this )->GetEditWindow().GetSelected( aSeparator );
 396     }
 397
 398     //==================================================================
 399     //= EditCellController
 400     //==================================================================
 401     //------------------------------------------------------------------
 402     EditCellController::EditCellController( Edit* _pEdit )
 403         :CellController( _pEdit )
 404         ,m_pEditImplementation( new EditImplementation( *_pEdit ) )
 405         ,m_bOwnImplementation( TRUE )
 406     {
 407     }
 408
 409     //------------------------------------------------------------------
 410     EditCellController::EditCellController( MultiLineTextCell* _pEdit )
 411         :CellController( _pEdit )
 412         ,m_pEditImplementation( new MultiLineEditImplementation( *_pEdit ) )
 413         ,m_bOwnImplementation( TRUE )
 414     {
 415     }
 416
 417     //------------------------------------------------------------------
 418     EditCellController::EditCellController( IEditImplementation* _pImplementation )
 419         :CellController( &_pImplementation->GetControl() )
 420         ,m_pEditImplementation( _pImplementation )
 421         ,m_bOwnImplementation( FALSE )
 422     {
 423     }
 424
 425     //-----------------------------------------------------------------------------
 426     EditCellController::~EditCellController( )
 427     {
 428         if ( m_bOwnImplementation )
 429             DELETEZ( m_pEditImplementation );
 430     }
 431
 432     //-----------------------------------------------------------------------------
 433     void EditCellController::SetModified()
 434     {
 435         m_pEditImplementation->SetModified();
 436     }
 437
 438     //-----------------------------------------------------------------------------
 439     void EditCellController::ClearModified()
 440     {
 441         m_pEditImplementation->ClearModified();
 442     }
 443
 444     //------------------------------------------------------------------
 445     sal_Bool EditCellController::MoveAllowed(const KeyEvent& rEvt) const
 446     {
 447         sal_Bool bResult;
 448         switch (rEvt.GetKeyCode().GetCode())
 449         {
 450             case KEY_END:
 451             case KEY_RIGHT:
 452             {
 453                 Selection aSel = m_pEditImplementation->GetSelection();
 454                 bResult = !aSel && aSel.Max() == m_pEditImplementation->GetText( LINEEND_LF ).Len();
 455             }   break;
 456             case KEY_HOME:
 457             case KEY_LEFT:
 458             {
 459                 Selection aSel = m_pEditImplementation->GetSelection();
 460                 bResult = !aSel && aSel.Min() == 0;
 461             }   break;
 462             default:
 463                 bResult = sal_True;
 464         }
 465         return bResult;
 466     }
 467
 468     //------------------------------------------------------------------
 469     sal_Bool EditCellController::IsModified() const
 470     {
 471         return m_pEditImplementation->IsModified();
 472     }
 473
 474     //------------------------------------------------------------------
 475     void EditCellController::SetModifyHdl(const Link& rLink)
 476     {
 477         m_pEditImplementation->SetModifyHdl(rLink);
 478     }
 479
 480     //==================================================================
 481     //= SpinCellController
 482     //==================================================================
 483     //------------------------------------------------------------------
 484     SpinCellController::SpinCellController(SpinField* pWin)
 485                          :CellController(pWin)
 486     {
 487     }
 488
 489     //-----------------------------------------------------------------------------
 490     void SpinCellController::SetModified()
 491     {
 492         GetSpinWindow().SetModifyFlag();
 493     }
 494
 495     //-----------------------------------------------------------------------------
 496     void SpinCellController::ClearModified()
 497     {
 498         GetSpinWindow().ClearModifyFlag();
 499     }
 500
 501     //------------------------------------------------------------------
 502     sal_Bool SpinCellController::MoveAllowed(const KeyEvent& rEvt) const
 503     {
 504         sal_Bool bResult;
 505         switch (rEvt.GetKeyCode().GetCode())
 506         {
 507             case KEY_END:
 508             case KEY_RIGHT:
 509             {
 510                 Selection aSel = GetSpinWindow().GetSelection();
 511                 bResult = !aSel && aSel.Max() == GetSpinWindow().GetText().Len();
 512             }   break;
 513             case KEY_HOME:
 514             case KEY_LEFT:
 515             {
 516                 Selection aSel = GetSpinWindow().GetSelection();
 517                 bResult = !aSel && aSel.Min() == 0;
 518             }   break;
 519             default:
 520                 bResult = sal_True;
 521         }
 522         return bResult;
 523     }
 524
 525     //------------------------------------------------------------------
 526     sal_Bool SpinCellController::IsModified() const
 527     {
 528         return GetSpinWindow().IsModified();
 529     }
 530
 531     //------------------------------------------------------------------
 532     void SpinCellController::SetModifyHdl(const Link& rLink)
 533     {
 534         GetSpinWindow().SetModifyHdl(rLink);
 535     }
 536
 537     //==================================================================
 538     //= FormattedFieldCellController
 539     //==================================================================
 540     //------------------------------------------------------------------
 541     FormattedFieldCellController::FormattedFieldCellController( FormattedField* _pFormatted )
 542         :EditCellController( _pFormatted )
 543     {
 544     }
 545
 546     //------------------------------------------------------------------
 547     void FormattedFieldCellController::CommitModifications()
 548     {
 549         static_cast< FormattedField& >( GetWindow() ).Commit();
 550     }
 551
 552     //==================================================================
 553     //= MultiLineTextCell
 554     //==================================================================
 555     //------------------------------------------------------------------
 556     void MultiLineTextCell::Modify()
 557     {
 558         GetTextEngine()->SetModified( TRUE );
 559         MultiLineEdit::Modify();
 560     }
 561
 562     //------------------------------------------------------------------
 563     BOOL MultiLineTextCell::dispatchKeyEvent( const KeyEvent& _rEvent )
 564     {
 565         Selection aOldSelection( GetSelection() );
 566
 567         BOOL bWasModified = IsModified();
 568         ClearModifyFlag( );
 569
 570         BOOL bHandled = GetTextView()->KeyInput( _rEvent );
 571
 572         BOOL bIsModified = IsModified();
 573         if ( bWasModified && !bIsModified )
 574             // not sure whether this can really happen
 575             SetModifyFlag();
 576
 577         if ( bHandled ) // the view claimed it handled the key input
 578         {
 579             // unfortunately, KeyInput also returns <TRUE/> (means "I handled this key input")
 580             // when nothing really changed. Let's care for this.
 581             Selection aNewSelection( GetSelection() );
 582             if  (  aNewSelection != aOldSelection   // selection changed
 583                 || bIsModified                      // or some other modification
 584                 )
 585                 return TRUE;
 586         }
 587         return FALSE;
 588     }
 589
 590     //------------------------------------------------------------------
 591     long MultiLineTextCell::PreNotify( NotifyEvent& rNEvt )
 592     {
 593         if ( rNEvt.GetType() == EVENT_KEYINPUT )
 594         {
 595             if ( IsWindowOrChild( rNEvt.GetWindow() ) )
 596             {
 597                 // give the text view a chance to handle the keys
 598                 // this is necessary since a lot of keys which are normally handled
 599                 // by this view (in KeyInput) are intercepted by the EditBrowseBox,
 600                 // which uses them for other reasons. An example is the KeyUp key,
 601                 // which is used by both the text view and the edit browse box
 602
 603                 const KeyEvent* pKeyEvent = rNEvt.GetKeyEvent();
 604                 const KeyCode&  rKeyCode  = pKeyEvent->GetKeyCode();
 605                 USHORT nCode = rKeyCode.GetCode();
 606
 607                 if ( ( nCode == KEY_RETURN ) && ( rKeyCode.GetModifier() == KEY_MOD1 ) )
 608                 {
 609                     KeyEvent aEvent( pKeyEvent->GetCharCode(),
 610                         KeyCode( KEY_RETURN ),
 611                         pKeyEvent->GetRepeat()
 612                     );
 613                     if ( dispatchKeyEvent( aEvent ) )
 614                         return 1;
 615                 }
 616
 617                 if ( ( nCode != KEY_TAB ) && ( nCode != KEY_RETURN ) )   // everything but tab and enter
 618                 {
 619                     if ( dispatchKeyEvent( *pKeyEvent ) )
 620                         return 1;
 621                 }
 622             }
 623         }
 624         return MultiLineEdit::PreNotify( rNEvt );
 625     }
 626
 627 // .......................................................................
 628 }       // namespace svt
 629 // .......................................................................
 630
 631