include/svtools/editbrowsebox.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_SVTOOLS_EDITBROWSEBOX_HXX
  21 #define INCLUDED_SVTOOLS_EDITBROWSEBOX_HXX
  22 #define SVTOOLS_IN_EDITBROWSEBOX_HXX
  23
  24 #include <svtools/svtdllapi.h>
  25 #include <tools/ref.hxx>
  26 #include <tools/rtti.hxx>
  27 #include <vcl/window.hxx>
  28 #include <vcl/combobox.hxx>
  29 #include <vcl/lstbox.hxx>
  30 #include <vcl/spinfld.hxx>
  31
  32 #include <vcl/button.hxx>
  33 #include <svtools/brwbox.hxx>
  34 #include <vcl/timer.hxx>
  35 #include <svtools/brwhead.hxx>
  36 #include <svtools/svmedit.hxx>
  37 #include <vcl/svapp.hxx>
  38 #include <o3tl/typed_flags_set.hxx>
  39
  40
  41 // EditBrowseBoxFlags (EBBF)
  42
  43 enum class EditBrowseBoxFlags
  44 {
  45     NONE                       = 0x0000,
  46 /** if this bit is _not_ set, the handle column will be invalidated upon
  47     changing the row in the browse box.  This is for forcing the row picture to
  48     be repainted. If you do not have row pictures or text, you don't need this
  49     invalidation, then you would specify this bit to prevent flicker
  50 */
  51     NO_HANDLE_COLUMN_CONTENT   = 0x0001,
  52 /** set this bit to activate the cell on a MouseButtonDown, not a MouseButtonUp event
  53  */
  54     ACTIVATE_ON_BUTTONDOWN     = 0x0002,
  55 /** if this bit is set and EditBrowseBoxFlags::NO_HANDLE_COLUMN_CONTENT is _not_ set, the handle
  56     column is drawn with the text contained in column 0 instead of an image
  57 */
  58     HANDLE_COLUMN_TEXT         = 0x0004,
  59
  60 /** If this bit is set, tab traveling is somewhat modified<br/>
  61     If the control gets the focus because the user pressed the TAB key, then the
  62     first or last cell (depending on whether the traveling was cycling forward or backward)
  63     gets activated.
  64     @see Window::GetGetFocusFlags
  65     @see GETFOCUS_*
  66 */
  67     SMART_TAB_TRAVEL           = 0x0008,
  68
  69 };
  70 namespace o3tl
  71 {
  72     template<> struct typed_flags<EditBrowseBoxFlags> : is_typed_flags<EditBrowseBoxFlags, 0x0f> {};
  73 }
  74
  75
  76 class Edit;
  77 class SpinField;
  78 class FormattedField;
  79
  80
  81 namespace svt
  82 {
  83     class SVT_DLLPUBLIC CellController : public SvRefBase
  84     {
  85         friend class EditBrowseBox;
  86
  87     protected:
  88         VclPtr<Control>  pWindow;
  89         bool        bSuspended;     // <true> if the window is hidden and disabled
  90
  91     public:
  92         TYPEINFO();
  93
  94         CellController(Control* pW);
  95         virtual ~CellController();
  96
  97         Control& GetWindow() const { return *const_cast< CellController* >( this )->pWindow; }
  98
  99         virtual void SetModified();
 100         virtual void ClearModified() = 0;
 101         virtual bool IsModified() const = 0;
 102
 103         // commit any current changes. Especially, do any reformatting you need (from input formatting
 104         // to output formatting) here
 105         virtual void CommitModifications();
 106
 107         // suspending the controller is not culmulative!
 108                 void        suspend( );
 109                 void        resume( );
 110         inline  bool        isSuspended( ) const { return bSuspended; }
 111
 112     protected:
 113         virtual bool MoveAllowed(const KeyEvent& rEvt) const;
 114         virtual void SetModifyHdl(const Link<>& rLink) = 0;
 115         virtual bool WantMouseEvent() const;
 116     };
 117
 118     typedef tools::SvRef<CellController> CellControllerRef;
 119
 120
 121     //= IEditImplementation
 122
 123     class SVT_DLLPUBLIC IEditImplementation
 124     {
 125     public:
 126         virtual ~IEditImplementation() = 0;
 127
 128         virtual Control&            GetControl() = 0;
 129
 130         virtual OUString            GetText( LineEnd aSeparator ) const = 0;
 131         virtual void                SetText( const OUString& _rStr ) = 0;
 132
 133         virtual bool                IsReadOnly() const = 0;
 134         virtual void                SetReadOnly( bool bReadOnly ) = 0;
 135
 136         virtual sal_Int32           GetMaxTextLen() const = 0;
 137         virtual void                SetMaxTextLen( sal_Int32 _nMaxLen ) = 0;
 138
 139         virtual Selection           GetSelection() const = 0;
 140         virtual void                SetSelection( const Selection& _rSelection ) = 0;
 141
 142         virtual void                ReplaceSelected( const OUString& _rStr ) = 0;
 143         virtual void                DeleteSelected() = 0;
 144         virtual OUString            GetSelected( LineEnd aSeparator ) const = 0;
 145
 146         virtual void                SetModified() = 0;
 147         virtual bool                IsModified() const = 0;
 148         virtual void                ClearModified() = 0;
 149         virtual void                SetModifyHdl( const Link<>& _rLink ) = 0;
 150     };
 151
 152
 153     //= GenericEditImplementation
 154
 155     template <class EDIT>
 156     class GenericEditImplementation : public IEditImplementation
 157     {
 158         EDIT&   m_rEdit;
 159     public:
 160         GenericEditImplementation( EDIT& _rEdit );
 161
 162         EDIT& GetEditWindow() { return static_cast< EDIT& >( GetControl() ); }
 163
 164         virtual Control&            GetControl() SAL_OVERRIDE;
 165
 166         virtual OUString            GetText( LineEnd aSeparator ) const SAL_OVERRIDE;
 167         virtual void                SetText( const OUString& _rStr ) SAL_OVERRIDE;
 168
 169         virtual bool                IsReadOnly() const SAL_OVERRIDE;
 170         virtual void                SetReadOnly( bool bReadOnly ) SAL_OVERRIDE;
 171
 172         virtual sal_Int32           GetMaxTextLen() const SAL_OVERRIDE;
 173         virtual void                SetMaxTextLen( sal_Int32 _nMaxLen ) SAL_OVERRIDE;
 174
 175         virtual Selection           GetSelection() const SAL_OVERRIDE;
 176         virtual void                SetSelection( const Selection& _rSelection ) SAL_OVERRIDE;
 177
 178         virtual void                ReplaceSelected( const OUString& _rStr ) SAL_OVERRIDE;
 179         virtual void                DeleteSelected() SAL_OVERRIDE;
 180         virtual OUString            GetSelected( LineEnd aSeparator ) const SAL_OVERRIDE;
 181
 182         virtual void                SetModified() SAL_OVERRIDE;
 183         virtual bool                IsModified() const SAL_OVERRIDE;
 184         virtual void                ClearModified() SAL_OVERRIDE;
 185         virtual void                SetModifyHdl( const Link<>& _rLink ) SAL_OVERRIDE;
 186     };
 187
 188     #include <svtools/editimplementation.hxx>
 189
 190
 191     //= MultiLineTextCell
 192
 193     /** a multi line edit which can be used in a cell of a EditBrowseBox
 194     */
 195     class SVT_DLLPUBLIC MultiLineTextCell : public MultiLineEdit
 196     {
 197     public:
 198         MultiLineTextCell( vcl::Window* _pParent, WinBits _nStyle )
 199             :MultiLineEdit( _pParent, _nStyle )
 200         {
 201         }
 202
 203     protected:
 204         // Window overridables
 205         virtual bool PreNotify( NotifyEvent& rNEvt ) SAL_OVERRIDE;
 206
 207         // MultiLineEdit overridables
 208         virtual void Modify() SAL_OVERRIDE;
 209
 210     private:
 211         bool         dispatchKeyEvent( const KeyEvent& _rEvent );
 212     };
 213
 214
 215     //= concrete edit implementations
 216
 217     typedef GenericEditImplementation< Edit >             EditImplementation;
 218
 219     typedef GenericEditImplementation< MultiLineTextCell >  MultiLineEditImplementation_Base;
 220     class SVT_DLLPUBLIC MultiLineEditImplementation : public MultiLineEditImplementation_Base
 221     {
 222     public:
 223         MultiLineEditImplementation( MultiLineTextCell& _rEdit ) : MultiLineEditImplementation_Base( _rEdit )
 224         {
 225         }
 226
 227         virtual OUString GetText( LineEnd aSeparator ) const SAL_OVERRIDE;
 228         virtual OUString GetSelected( LineEnd aSeparator ) const SAL_OVERRIDE;
 229     };
 230
 231
 232     //= EditCellController
 233
 234     class SVT_DLLPUBLIC EditCellController : public CellController
 235     {
 236         IEditImplementation*    m_pEditImplementation;
 237         bool                    m_bOwnImplementation;   // did we create m_pEditImplementation?
 238
 239     public:
 240         TYPEINFO_OVERRIDE();
 241         EditCellController( Edit* _pEdit );
 242         EditCellController( IEditImplementation* _pImplementation );
 243         virtual ~EditCellController( );
 244
 245         const IEditImplementation* GetEditImplementation( ) const { return m_pEditImplementation; }
 246               IEditImplementation* GetEditImplementation( )       { return m_pEditImplementation; }
 247
 248         virtual void SetModified() SAL_OVERRIDE;
 249         virtual bool IsModified() const SAL_OVERRIDE;
 250         virtual void ClearModified() SAL_OVERRIDE;
 251
 252     protected:
 253         virtual bool MoveAllowed(const KeyEvent& rEvt) const SAL_OVERRIDE;
 254         virtual void SetModifyHdl(const Link<>& rLink) SAL_OVERRIDE;
 255     };
 256
 257
 258     //= SpinCellController
 259
 260     class SVT_DLLPUBLIC SpinCellController : public CellController
 261     {
 262     public:
 263         TYPEINFO_OVERRIDE();
 264         SpinCellController(SpinField* pSpinField);
 265         const SpinField& GetSpinWindow() const { return static_cast<const SpinField &>(GetWindow()); }
 266         SpinField& GetSpinWindow() { return static_cast<SpinField &>(GetWindow()); }
 267
 268         virtual void SetModified() SAL_OVERRIDE;
 269         virtual bool IsModified() const SAL_OVERRIDE;
 270         virtual void ClearModified() SAL_OVERRIDE;
 271
 272     protected:
 273         virtual bool MoveAllowed(const KeyEvent& rEvt) const SAL_OVERRIDE;
 274         virtual void SetModifyHdl(const Link<>& rLink) SAL_OVERRIDE;
 275     };
 276
 277
 278     //= CheckBoxControl
 279
 280     class SVT_DLLPUBLIC CheckBoxControl : public Control
 281     {
 282         VclPtr<CheckBox>   pBox;
 283         Rectangle   aFocusRect;
 284         Link<>      m_aClickLink,m_aModifyLink;
 285
 286     public:
 287         CheckBoxControl(vcl::Window* pParent, WinBits nWinStyle = 0);
 288         virtual ~CheckBoxControl();
 289         virtual void dispose() SAL_OVERRIDE;
 290
 291         virtual void GetFocus() SAL_OVERRIDE;
 292         virtual bool PreNotify(NotifyEvent& rEvt) SAL_OVERRIDE;
 293         virtual void Paint(vcl::RenderContext& rRenderContext, const Rectangle& rClientRect) SAL_OVERRIDE;
 294         virtual void Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize, sal_uLong nFlags ) SAL_OVERRIDE;
 295         virtual void StateChanged( StateChangedType nStateChange ) SAL_OVERRIDE;
 296         virtual void DataChanged( const DataChangedEvent& _rEvent ) SAL_OVERRIDE;
 297         virtual void Resize() SAL_OVERRIDE;
 298
 299         void SetClickHdl(const Link<>& rHdl) {m_aClickLink = rHdl;}
 300         const Link<>& GetClickHdl() const {return m_aClickLink;}
 301
 302         void SetModifyHdl(const Link<>& rHdl) {m_aModifyLink = rHdl;}
 303         const Link<>& GetModifyHdl() const {return m_aModifyLink;}
 304
 305         CheckBox&   GetBox() {return *pBox;};
 306
 307     private:
 308         DECL_LINK( OnClick, void* );
 309     };
 310
 311
 312     //= CheckBoxCellController
 313
 314     class SVT_DLLPUBLIC CheckBoxCellController : public CellController
 315     {
 316     public:
 317         TYPEINFO_OVERRIDE();
 318
 319         CheckBoxCellController(CheckBoxControl* pWin):CellController(pWin){}
 320         CheckBox& GetCheckBox() const;
 321
 322         virtual bool IsModified() const SAL_OVERRIDE;
 323         virtual void ClearModified() SAL_OVERRIDE;
 324
 325     protected:
 326         virtual void SetModifyHdl(const Link<>& rLink) SAL_OVERRIDE;
 327         virtual bool WantMouseEvent() const SAL_OVERRIDE;
 328     };
 329
 330
 331     //= ComboBoxControl
 332
 333     class SVT_DLLPUBLIC ComboBoxControl : public ComboBox
 334     {
 335         friend class ComboBoxCellController;
 336
 337     public:
 338         ComboBoxControl(vcl::Window* pParent, WinBits nWinStyle = 0);
 339
 340     protected:
 341         virtual bool PreNotify( NotifyEvent& rNEvt ) SAL_OVERRIDE;
 342     };
 343
 344
 345     //= ComboBoxCellController
 346
 347     class SVT_DLLPUBLIC ComboBoxCellController : public CellController
 348     {
 349     public:
 350         TYPEINFO_OVERRIDE();
 351
 352         ComboBoxCellController(ComboBoxControl* pParent);
 353         ComboBoxControl& GetComboBox() const { return static_cast<ComboBoxControl &>(GetWindow()); }
 354
 355         virtual bool IsModified() const SAL_OVERRIDE;
 356         virtual void ClearModified() SAL_OVERRIDE;
 357
 358     protected:
 359         virtual bool MoveAllowed(const KeyEvent& rEvt) const SAL_OVERRIDE;
 360         virtual void SetModifyHdl(const Link<>& rLink) SAL_OVERRIDE;
 361     };
 362
 363
 364     //= ListBoxControl
 365
 366     class SVT_DLLPUBLIC ListBoxControl : public ListBox
 367     {
 368         friend class ListBoxCellController;
 369
 370     public:
 371         ListBoxControl(vcl::Window* pParent, WinBits nWinStyle = 0);
 372
 373     protected:
 374         virtual bool PreNotify( NotifyEvent& rNEvt ) SAL_OVERRIDE;
 375     };
 376
 377
 378     //= ListBoxCellController
 379
 380     class SVT_DLLPUBLIC ListBoxCellController : public CellController
 381     {
 382     public:
 383         TYPEINFO_OVERRIDE();
 384
 385         ListBoxCellController(ListBoxControl* pParent);
 386         const ListBoxControl& GetListBox() const { return static_cast<const ListBoxControl &>(GetWindow()); }
 387         ListBoxControl& GetListBox() { return static_cast<ListBoxControl &>(GetWindow()); }
 388
 389         virtual bool IsModified() const SAL_OVERRIDE;
 390         virtual void ClearModified() SAL_OVERRIDE;
 391
 392     protected:
 393         virtual bool MoveAllowed(const KeyEvent& rEvt) const SAL_OVERRIDE;
 394         virtual void SetModifyHdl(const Link<>& rLink) SAL_OVERRIDE;
 395     };
 396
 397
 398     //= FormattedFieldCellController
 399
 400     class SVT_DLLPUBLIC FormattedFieldCellController : public EditCellController
 401     {
 402     public:
 403         TYPEINFO_OVERRIDE();
 404         FormattedFieldCellController( FormattedField* _pFormatted );
 405
 406         virtual void CommitModifications() SAL_OVERRIDE;
 407     };
 408
 409
 410     //= EditBrowserHeader
 411
 412     class SVT_DLLPUBLIC EditBrowserHeader : public BrowserHeader
 413     {
 414     public:
 415         EditBrowserHeader( BrowseBox* pParent, WinBits nWinBits = WB_BUTTONSTYLE )
 416             :BrowserHeader(pParent, nWinBits){}
 417
 418     protected:
 419         virtual void DoubleClick() SAL_OVERRIDE;
 420     };
 421
 422
 423     //= EditBrowseBox
 424
 425     class EditBrowseBoxImpl;
 426     class SVT_DLLPUBLIC EditBrowseBox: public BrowseBox
 427     {
 428         friend class EditBrowserHeader;
 429
 430         enum BrowseInfo
 431         {
 432             COLSELECT   =   1,
 433             ROWSELECT   =   2,
 434             ROWCHANGE   =   4,
 435             COLCHANGE   =   8
 436         };
 437
 438     public:
 439         enum RowStatus
 440         {
 441             CLEAN               =   0,
 442             CURRENT             =   1,
 443             CURRENTNEW          =   2,
 444             MODIFIED            =   3,
 445             NEW                 =   4,
 446             DELETED             =   5,
 447             PRIMARYKEY          =   6,
 448             CURRENT_PRIMARYKEY  =   7,
 449             FILTER              =   8,
 450             HEADERFOOTER        =   9
 451         };
 452
 453     private:
 454         EditBrowseBox(EditBrowseBox&) SAL_DELETED_FUNCTION;
 455         EditBrowseBox& operator=(EditBrowseBox&) SAL_DELETED_FUNCTION;
 456
 457         class BrowserMouseEventPtr
 458         {
 459             BrowserMouseEvent* pEvent;
 460             bool               bDown;
 461
 462         public:
 463             BrowserMouseEventPtr()
 464                 : pEvent(NULL)
 465                 , bDown(false)
 466             {
 467             }
 468             ~BrowserMouseEventPtr(){Clear();}
 469
 470             bool Is() const {return pEvent != NULL;}
 471             bool IsDown() const {return bDown;}
 472             const BrowserMouseEvent* operator->() const {return pEvent;}
 473             const BrowserMouseEvent& operator*() const {return *pEvent;}
 474
 475             SVT_DLLPUBLIC void Clear();
 476             void Set(const BrowserMouseEvent* pEvt, bool bIsDown);
 477         } aMouseEvent;
 478
 479         CellControllerRef        aController,
 480                                  aOldController;
 481
 482         ImplSVEvent * nStartEvent, * nEndEvent, * nCellModifiedEvent;     // event ids
 483         VclPtr<vcl::Window> m_pFocusWhileRequest;
 484             // In ActivateCell, we grab the focus asynchronously, but if between requesting activation
 485             // and the asynchornous event the focus has changed, we won't grab it for ourself.
 486
 487         long    nPaintRow;  // row being painted
 488         long    nEditRow, nOldEditRow;
 489         sal_uInt16  nEditCol, nOldEditCol;
 490
 491         bool            bHasFocus : 1;
 492         mutable bool    bPaintStatus : 1;   // paint a status (image) in the handle column
 493         bool            bActiveBeforeTracking;
 494
 495         VclPtr<CheckBoxControl> pCheckBoxPaint;
 496
 497         EditBrowseBoxFlags  m_nBrowserFlags;
 498         ImageList   m_aStatusImages;
 499         ::std::unique_ptr< EditBrowseBoxImpl> m_aImpl;
 500
 501     protected:
 502         VclPtr<BrowserHeader>  pHeader;
 503
 504         bool isGetCellFocusPending() const { return nStartEvent != 0; }
 505         void cancelGetCellFocus() { if (nStartEvent) Application::RemoveUserEvent(nStartEvent); nStartEvent = 0; }
 506         void forceGetCellFocus() { cancelGetCellFocus(); LINK(this, EditBrowseBox, StartEditHdl).Call((void*)NULL); }
 507
 508         BrowserMouseEventPtr& getMouseEvent() { return aMouseEvent; }
 509
 510     protected:
 511         BrowserHeader*  GetHeaderBar() const {return pHeader;}
 512
 513         virtual VclPtr<BrowserHeader> CreateHeaderBar(BrowseBox* pParent) SAL_OVERRIDE;
 514
 515         // if you want to have an own header ...
 516         virtual VclPtr<BrowserHeader> imp_CreateHeaderBar(BrowseBox* pParent);
 517
 518         virtual void ColumnMoved(sal_uInt16 nId) SAL_OVERRIDE;
 519         virtual void ColumnResized(sal_uInt16 nColId) SAL_OVERRIDE;
 520         virtual void Resize() SAL_OVERRIDE;
 521         virtual void ArrangeControls(sal_uInt16& nX, sal_uInt16 nY);
 522         virtual bool SeekRow(long nRow) SAL_OVERRIDE;
 523
 524         virtual void GetFocus() SAL_OVERRIDE;
 525         virtual void LoseFocus() SAL_OVERRIDE;
 526         virtual void KeyInput(const KeyEvent& rEvt) SAL_OVERRIDE;
 527         virtual void MouseButtonDown(const BrowserMouseEvent& rEvt) SAL_OVERRIDE;
 528         virtual void MouseButtonUp(const BrowserMouseEvent& rEvt) SAL_OVERRIDE;
 529         virtual void StateChanged( StateChangedType nType ) SAL_OVERRIDE;
 530         virtual void DataChanged( const DataChangedEvent& rDCEvt ) SAL_OVERRIDE;
 531
 532         using BrowseBox::MouseButtonUp;
 533         using BrowseBox::MouseButtonDown;
 534
 535         virtual bool PreNotify(NotifyEvent& rNEvt ) SAL_OVERRIDE;
 536         virtual bool Notify(NotifyEvent& rNEvt) SAL_OVERRIDE;
 537
 538         virtual void EndScroll() SAL_OVERRIDE;
 539
 540         // should be used instead of GetFieldRectPixel, 'cause this method here takes into account the borders
 541         Rectangle GetCellRect(long nRow, sal_uInt16 nColId, bool bRelToBrowser = true) const;
 542         virtual sal_uInt32 GetTotalCellWidth(long nRow, sal_uInt16 nColId);
 543         virtual sal_uInt32 GetAutoColumnWidth(sal_uInt16 nColId);
 544
 545         virtual void PaintStatusCell(OutputDevice& rDev, const Rectangle& rRect) const;
 546         virtual void PaintCell(OutputDevice& rDev, const Rectangle& rRect, sal_uInt16 nColId) const = 0;
 547
 548         virtual RowStatus GetRowStatus(long nRow) const;
 549
 550         virtual void    RowHeightChanged() SAL_OVERRIDE;
 551
 552         // callbacks for the data window
 553         virtual void    ImplStartTracking() SAL_OVERRIDE;
 554         virtual void    ImplTracking() SAL_OVERRIDE;
 555         virtual void    ImplEndTracking() SAL_OVERRIDE;
 556
 557         // when changing a row:
 558         // CursorMoving:    cursor is being moved, but GetCurRow() still provides the old row
 559         virtual bool CursorMoving(long nNewRow, sal_uInt16 nNewCol);
 560
 561         // cursor has been moved
 562         virtual void CursorMoved() SAL_OVERRIDE;
 563
 564         virtual void CellModified();        // called whenever a cell has been modified
 565         virtual bool SaveModified();    // called whenever a cell should be left, and it's content should be saved
 566                                             // return sal_False prevents leaving the cell
 567         virtual bool SaveRow();         // commit the current row
 568
 569         virtual bool IsModified() const {return aController.Is() && aController->IsModified();}
 570
 571         virtual CellController* GetController(long nRow, sal_uInt16 nCol);
 572         virtual void InitController(CellControllerRef& rController, long nRow, sal_uInt16 nCol);
 573         virtual void ResizeController(CellControllerRef& rController, const Rectangle&);
 574         virtual void ReleaseController(CellControllerRef& pController, long nRow, sal_uInt16 nCol);
 575         virtual void DoubleClick(const BrowserMouseEvent&) SAL_OVERRIDE;
 576
 577         void ActivateCell() { ActivateCell(GetCurRow(), GetCurColumnId()); }
 578
 579         // retrieve the image for the row status
 580         virtual Image GetImage(RowStatus) const;
 581
 582         // inserting columns
 583         // if you don't set a width, this will be calculated automatically
 584         // if the id isn't set the smallest unused will do it ...
 585         virtual sal_uInt16 AppendColumn(const OUString& rName, sal_uInt16 nWidth = 0, sal_uInt16 nPos = HEADERBAR_APPEND, sal_uInt16 nId = (sal_uInt16)-1);
 586
 587         // called whenever (Shift)Tab or Enter is pressed. If true is returned, these keys
 588         // result in traveling to the next or to th previous cell
 589         virtual bool IsTabAllowed(bool bForward) const;
 590
 591         virtual bool IsCursorMoveAllowed(long nNewRow, sal_uInt16 nNewColId) const SAL_OVERRIDE;
 592
 593         void    PaintTristate(OutputDevice& rDev, const Rectangle& rRect, const TriState& eState, bool _bEnabled=true) const;
 594
 595         void AsynchGetFocus();
 596             // secure starting of StartEditHdl
 597
 598     public:
 599         EditBrowseBox(vcl::Window* pParent, EditBrowseBoxFlags nBrowserFlags = EditBrowseBoxFlags::NONE, WinBits nBits = WB_TABSTOP, BrowserMode nMode = BrowserMode::NONE );
 600         EditBrowseBox(vcl::Window* pParent, const ResId& rId, EditBrowseBoxFlags nBrowserFlags = EditBrowseBoxFlags::NONE, BrowserMode nMode = BrowserMode::NONE );
 601         virtual ~EditBrowseBox();
 602         virtual void dispose() SAL_OVERRIDE;
 603
 604         bool IsEditing() const {return aController.Is();}
 605         void InvalidateStatusCell(long nRow) {RowModified(nRow, 0);}
 606         void InvalidateHandleColumn();
 607
 608         // late construction
 609         virtual void Init();
 610         virtual void RemoveRows();
 611         virtual void Dispatch(sal_uInt16 nId);
 612
 613         CellControllerRef Controller() const { return aController; }
 614         EditBrowseBoxFlags  GetBrowserFlags() const { return m_nBrowserFlags; }
 615         void                SetBrowserFlags(EditBrowseBoxFlags nFlags);
 616
 617         virtual void ActivateCell(long nRow, sal_uInt16 nCol, bool bSetCellFocus = true);
 618         virtual void DeactivateCell(bool bUpdate = true);
 619         // Children ---------------------------------------------------------------
 620
 621         /** Creates the accessible object of a data table cell.
 622         @param nRow
 623             The row index of the cell.
 624         @param nColumnId
 625             The column ID of the cell.
 626         @return
 627             The XAccessible interface of the specified cell. */
 628         virtual ::com::sun::star::uno::Reference<
 629             ::com::sun::star::accessibility::XAccessible >
 630         CreateAccessibleCell( sal_Int32 nRow, sal_uInt16 nColumnPos ) SAL_OVERRIDE;
 631
 632         /** @return  The count of additional controls of the control area. */
 633         virtual sal_Int32 GetAccessibleControlCount() const SAL_OVERRIDE;
 634
 635         /** Creates the accessible object of an additional control.
 636             @param nIndex
 637                 The 0-based index of the control.
 638             @return
 639                 The XAccessible interface of the specified control. */
 640         virtual ::com::sun::star::uno::Reference<
 641             ::com::sun::star::accessibility::XAccessible >
 642         CreateAccessibleControl( sal_Int32 nIndex ) SAL_OVERRIDE;
 643
 644         /** Creates the accessible object of a column header.
 645             @param nColumnId
 646                 The column ID of the header.
 647             @return
 648                 The XAccessible interface of the specified column header. */
 649         virtual ::com::sun::star::uno::Reference<
 650             ::com::sun::star::accessibility::XAccessible >
 651         CreateAccessibleRowHeader( sal_Int32 _nRow ) SAL_OVERRIDE;
 652
 653         /** Sets focus to current cell of the data table. */
 654         virtual void GrabTableFocus() SAL_OVERRIDE;
 655
 656         virtual Rectangle GetFieldCharacterBounds(sal_Int32 _nRow,sal_Int32 _nColumnPos,sal_Int32 nIndex) SAL_OVERRIDE;
 657         virtual sal_Int32 GetFieldIndexAtPoint(sal_Int32 _nRow,sal_Int32 _nColumnPos,const Point& _rPoint) SAL_OVERRIDE;
 658
 659         ::com::sun::star::uno::Reference<
 660             ::com::sun::star::accessibility::XAccessible > CreateAccessibleCheckBoxCell(long _nRow, sal_uInt16 _nColumnPos,const TriState& eState);
 661     protected:
 662         // creates the accessible which wraps the active cell
 663         void    implCreateActiveAccessible( );
 664
 665     private:
 666         virtual void PaintField(OutputDevice& rDev, const Rectangle& rRect,
 667                                 sal_uInt16 nColumnId ) const SAL_OVERRIDE;
 668         using Control::ImplInitSettings;
 669         SVT_DLLPRIVATE void ImplInitSettings( bool bFont, bool bForeground, bool bBackground );
 670         SVT_DLLPRIVATE void DetermineFocus( const sal_uInt16 _nGetFocusFlags = 0);
 671         static inline void HideAndDisable(CellControllerRef& rController);
 672         inline void EnableAndShow() const;
 673
 674         SVT_DLLPRIVATE void implActivateCellOnMouseEvent(const BrowserMouseEvent& _rEvt, bool _bUp);
 675         SVT_DLLPRIVATE void impl_construct();
 676
 677         DECL_DLLPRIVATE_LINK(ModifyHdl, void* );
 678         DECL_DLLPRIVATE_LINK(StartEditHdl, void* );
 679         DECL_DLLPRIVATE_LINK(EndEditHdl, void* );
 680         DECL_DLLPRIVATE_LINK(CellModifiedHdl, void* );
 681     };
 682
 683
 684 }   // namespace svt
 685
 686
 687 #undef SVTOOLS_IN_EDITBROWSEBOX_HXX
 688 #endif // INCLUDED_SVTOOLS_EDITBROWSEBOX_HXX
 689
 690 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */