include/svx/gridctrl.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 #ifndef INCLUDED_SVX_GRIDCTRL_HXX
  20 #define INCLUDED_SVX_GRIDCTRL_HXX
  21
  22 #include <com/sun/star/util/Date.hpp>
  23
  24 #include <tools/ref.hxx>
  25 #include <svtools/editbrowsebox.hxx>
  26 #include <svtools/recorditemwindow.hxx>
  27 #include <osl/mutex.hxx>
  28 #include <svx/svxdllapi.h>
  29 #include <o3tl/typed_flags_set.hxx>
  30 #include <memory>
  31 #include <vector>
  32
  33 namespace comphelper { class OPropertyChangeMultiplexer; }
  34 namespace com::sun::star::beans { struct PropertyChangeEvent; }
  35 namespace com::sun::star::container { class XIndexAccess; }
  36 namespace com::sun::star::sdbc { class XRowSet; }
  37 namespace com::sun::star::sdb { class XRowsChangeListener; }
  38 namespace com::sun::star::uno { class XComponentContext; }
  39 namespace com::sun::star::util { class XNumberFormatter; }
  40 namespace weld { class Menu; }
  41
  42 class CursorWrapper;
  43
  44 bool CompareBookmark(const css::uno::Any& aLeft, const css::uno::Any& aRight);
  45
  46 namespace svxform
  47 {
  48     class DataColumn;
  49 }
  50
  51 enum class GridRowStatus
  52 {
  53     Clean,
  54     Modified,
  55     Deleted,
  56     Invalid
  57 };
  58
  59
  60 // DbGridRow, description of rows
  61
  62
  63 class SAL_DLLPUBLIC_RTTI DbGridRow final : public SvRefBase
  64 {
  65     css::uno::Any  m_aBookmark;        // Bookmark of the row, can be set
  66     ::std::vector< std::unique_ptr<::svxform::DataColumn> >
  67                                 m_aVariants;
  68     GridRowStatus               m_eStatus;
  69     bool                        m_bIsNew;
  70                                                     // row is no longer valid
  71                                                     // is removed on the next positioning
  72 public:
  73     DbGridRow();
  74     DbGridRow(CursorWrapper* pCur, bool bPaintCursor);
  75     void SetState(CursorWrapper* pCur, bool bPaintCursor);
  76
  77     virtual ~DbGridRow() override;
  78
  79     bool HasField(sal_uInt32 nPos) const { return nPos < m_aVariants.size(); }
  80     const ::svxform::DataColumn& GetField(sal_uInt32 nPos) const { return *m_aVariants[ nPos ]; }
  81
  82     void            SetStatus(GridRowStatus _eStat) { m_eStatus = _eStat; }
  83     GridRowStatus   GetStatus() const               { return m_eStatus; }
  84     void            SetNew(bool _bNew)              { m_bIsNew = _bNew; }
  85     bool            IsNew() const                   { return m_bIsNew; }
  86
  87     const css::uno::Any& GetBookmark() const { return m_aBookmark; }
  88
  89     bool    IsValid() const { return m_eStatus == GridRowStatus::Clean || m_eStatus == GridRowStatus::Modified; }
  90     bool    IsModified() const { return m_eStatus == GridRowStatus::Modified; }
  91 };
  92
  93 typedef tools::SvRef<DbGridRow> DbGridRowRef;
  94
  95
  96 // DbGridControl
  97
  98 class DbGridColumn;
  99
 100 class FmGridListener
 101 {
 102 public:
 103     virtual void selectionChanged() = 0;
 104     virtual void columnChanged() = 0;
 105
 106 protected:
 107     ~FmGridListener() {}
 108 };
 109
 110 #define GRID_COLUMN_NOT_FOUND   SAL_MAX_UINT16
 111
 112
 113 // InitWindowFacet, describing which aspect of a column's Window to (re-)initialize
 114
 115 enum class InitWindowFacet
 116 {
 117     Font        = 0x01,
 118     Foreground  = 0x02,
 119     Background  = 0x04,
 120     WritingMode = 0x08,
 121     All         = 0x0F
 122 };
 123 namespace o3tl
 124 {
 125     template<> struct typed_flags<InitWindowFacet> : is_typed_flags<InitWindowFacet, 0x0f> {};
 126 }
 127
 128
 129 // these options are or'ed and indicate, which of the single
 130 // features can be released, default is readonly which means 0
 131 enum class DbGridControlOptions
 132 {
 133     Readonly    = 0x00,
 134     Insert      = 0x01,
 135     Update      = 0x02,
 136     Delete      = 0x04
 137 };
 138 namespace o3tl
 139 {
 140     template<> struct typed_flags<DbGridControlOptions> : is_typed_flags<DbGridControlOptions, 0x07> {};
 141 }
 142
 143 //  StatusIds for Controls of the Bar
 144 //  important for invalidation
 145 enum class DbGridControlNavigationBarState
 146 {
 147     NONE,
 148     Text,
 149     Absolute,
 150     Of,
 151     Count,
 152     First,
 153     Next,
 154     Prev,
 155     Last,
 156     New,
 157     Undo // related to SID_FM_RECORD_UNDO
 158 };
 159
 160 class FmXGridSourcePropListener;
 161 class DisposeListenerGridBridge;
 162
 163 // NavigationBar
 164 class NavigationBar final : public InterimItemWindow
 165 {
 166     class AbsolutePos final : public RecordItemWindowBase
 167     {
 168     public:
 169         AbsolutePos(std::unique_ptr<weld::Entry> xEntry, NavigationBar* pBar);
 170
 171         virtual bool DoKeyInput(const KeyEvent& rEvt) override;
 172         virtual void PositionFired(sal_Int64 nRecord) override;
 173
 174         weld::Entry* GetWidget() { return m_xWidget.get(); }
 175     private:
 176         VclPtr<NavigationBar> m_xParent;
 177     };
 178
 179     friend class NavigationBar::AbsolutePos;
 180
 181     //  additional controls
 182     std::unique_ptr<weld::Label> m_xRecordText;
 183     std::unique_ptr<AbsolutePos> m_xAbsolute;         // absolute positioning
 184     std::unique_ptr<weld::Label> m_xRecordOf;
 185     std::unique_ptr<weld::Label> m_xRecordCount;
 186
 187     std::unique_ptr<weld::Button> m_xFirstBtn;        // Button for 'go to the first record'
 188     std::unique_ptr<weld::Button> m_xPrevBtn;         // Button for 'go to the previous record'
 189     std::unique_ptr<weld::Button> m_xNextBtn;         // Button for 'go to the next record'
 190     std::unique_ptr<weld::Button> m_xLastBtn;         // Button for 'go to the last record'
 191     std::unique_ptr<weld::Button> m_xNewBtn;          // Button for 'go to a new record'
 192
 193     std::shared_ptr<weld::ButtonPressRepeater> m_xPrevRepeater;
 194     std::shared_ptr<weld::ButtonPressRepeater> m_xNextRepeater;
 195
 196     sal_Int32            m_nCurrentPos;
 197
 198     bool                 m_bPositioning;     // protect PositionDataSource against recursion
 199
 200 public:
 201     NavigationBar(vcl::Window* pParent);
 202     virtual ~NavigationBar() override;
 203     virtual void dispose() override;
 204
 205     // Status methods for Controls
 206     void InvalidateAll(sal_Int32 nCurrentPos, bool bAll = false);
 207     void InvalidateState(DbGridControlNavigationBarState nWhich) {SetState(nWhich);}
 208     void SetState(DbGridControlNavigationBarState nWhich);
 209     bool GetState(DbGridControlNavigationBarState nWhich) const;
 210     sal_uInt16 ArrangeControls();
 211
 212 private:
 213
 214     DECL_LINK(OnClick, weld::Button&, void);
 215
 216     void PositionDataSource(sal_Int32 nRecord);
 217 };
 218
 219 class SVXCORE_DLLPUBLIC DbGridControl : public svt::EditBrowseBox
 220 {
 221     friend class FmXGridSourcePropListener;
 222     friend class GridFieldValueListener;
 223     friend class DisposeListenerGridBridge;
 224
 225 public:
 226
 227     friend class NavigationBar;
 228
 229 private:
 230     Link<DbGridControlNavigationBarState,int>    m_aMasterStateProvider;
 231     Link<DbGridControlNavigationBarState,bool>   m_aMasterSlotExecutor;
 232
 233     css::uno::Reference< css::util::XNumberFormatter >    m_xFormatter;
 234     css::uno::Reference< css::uno::XComponentContext >    m_xContext;
 235
 236     std::vector< std::unique_ptr<DbGridColumn> > m_aColumns;         // Column description
 237     VclPtr<NavigationBar>   m_aBar;
 238     DbGridRowRef    m_xDataRow;         // Row which can be modified
 239                                         // comes from the data cursor
 240     DbGridRowRef    m_xSeekRow,         // Row to which the iterator can set
 241                                         // comes from the data cursor
 242
 243                     m_xEmptyRow;        // record set to insert
 244
 245     ImplSVEvent *   m_nAsynAdjustEvent;
 246
 247     // if we modify the row for the new record, we automatically insert a "new new row".
 248     // But if somebody else inserts a new record into the data source, we have to do the same.
 249     // For that reason we have to listen to some properties of our data source.
 250     rtl::Reference<::comphelper::OPropertyChangeMultiplexer>  m_pDataSourcePropMultiplexer;
 251     FmXGridSourcePropListener*                      m_pDataSourcePropListener;
 252     css::uno::Reference< css::sdb::XRowsChangeListener>
 253                                                     m_xRowSetListener; // get notification when rows were changed
 254
 255     void*                                           m_pFieldListeners;
 256         // property listeners for field values
 257
 258     std::unique_ptr<DisposeListenerGridBridge>      m_pCursorDisposeListener;
 259         // need to know about the disposing of the seek cursor
 260         // construct analogous to the data source proplistener/multiplexer above :
 261         // DisposeListenerGridBridge is a bridge from FmXDisposeListener which I don't want to be derived from
 262
 263     FmGridListener*                                 m_pGridListener;
 264
 265 protected:
 266     std::unique_ptr<CursorWrapper> m_pDataCursor;      // Cursor for Updates
 267     std::unique_ptr<CursorWrapper> m_pSeekCursor;      // Cursor for Seeking
 268
 269 private:
 270     // iteration variables
 271     DbGridRowRef        m_xCurrentRow;
 272     DbGridRowRef        m_xPaintRow;        // Row to be displayed
 273     sal_Int32           m_nSeekPos;         // Position of the SeekCursor
 274     sal_Int32           m_nTotalCount;      // is set when the data cursor finished counting the
 275                                             // records. Initial value is -1
 276     osl::Mutex          m_aDestructionSafety;
 277     osl::Mutex          m_aAdjustSafety;
 278
 279     css::util::Date
 280                         m_aNullDate;        // NullDate of the Numberformatter;
 281
 282     BrowserMode         m_nMode;
 283     sal_Int32           m_nCurrentPos;      // Current position;
 284     ImplSVEvent *       m_nDeleteEvent;     // EventId for asynchronous deletion of rows
 285     DbGridControlOptions m_nOptions;        // What is the able to do (Insert, Update, Delete)
 286                                             // default readonly
 287     DbGridControlOptions m_nOptionMask;     // the mask of options to be enabled in setDataSource
 288                                             // (with respect to the data source capabilities)
 289                                             // defaults to (insert | update | delete)
 290     sal_uInt16          m_nLastColId;
 291     sal_Int32           m_nLastRowId;
 292
 293     bool                m_bDesignMode : 1;      // default = sal_False
 294     bool                m_bRecordCountFinal : 1;
 295     bool                m_bNavigationBar      : 1;
 296
 297     bool                m_bSynchDisplay : 1;
 298     bool                m_bHandle : 1;
 299     bool                m_bFilterMode : 1;
 300     bool                m_bWantDestruction : 1;
 301     bool                m_bPendingAdjustRows : 1;   // if an async adjust is pending, is it for AdjustRows or AdjustDataSource ?
 302     bool                m_bHideScrollbars : 1;
 303
 304 protected:
 305     bool                m_bUpdating : 1;            // are any updates being executed right now?
 306
 307 protected:
 308     virtual bool SeekRow(sal_Int32 nRow) override;
 309     virtual void VisibleRowsChanged( sal_Int32 nNewTopRow, sal_uInt16 nNumRows) override;
 310     virtual void PaintCell(OutputDevice& rDev, const tools::Rectangle& rRect, sal_uInt16 nColId) const override;
 311     virtual RowStatus GetRowStatus(sal_Int32 nRow) const override;
 312     virtual bool CursorMoving(sal_Int32 nNewRow, sal_uInt16 nNewCol) override;
 313     virtual void CursorMoved() override;
 314     virtual void ArrangeControls(sal_uInt16& nX, sal_uInt16 nY) override;
 315     virtual sal_uInt32 GetTotalCellWidth(sal_Int32 nRow, sal_uInt16 nColId) override;
 316     virtual void Command(const CommandEvent& rEvt) override;
 317     virtual bool PreNotify(NotifyEvent& rEvt) override;
 318     virtual void KeyInput(const KeyEvent& rEvt) override;
 319     virtual void StateChanged( StateChangedType nType ) override;
 320     virtual void DataChanged( const DataChangedEvent& rDCEvt ) override;
 321     virtual void Select() override;
 322
 323     virtual ::svt::CellController* GetController(sal_Int32 nRow, sal_uInt16 nCol) override;
 324
 325     virtual void CellModified() override;
 326     virtual bool SaveModified() override;
 327     virtual bool IsModified() const override;
 328
 329     virtual sal_uInt16 AppendColumn(const OUString& rName, sal_uInt16 nWidth, sal_uInt16 nPos = HEADERBAR_APPEND, sal_uInt16 nId = sal_uInt16(-1)) override;
 330     void RemoveColumn(sal_uInt16 nId);
 331     std::unique_ptr<DbGridColumn> CreateColumn(sal_uInt16 nId);
 332     virtual void ColumnMoved(sal_uInt16 nId) override;
 333     virtual bool SaveRow() override;
 334     virtual bool IsTabAllowed(bool bForward) const override;
 335
 336     /// hide a column
 337     virtual void    HideColumn(sal_uInt16 nId);
 338     /// show a column
 339     virtual void    ShowColumn(sal_uInt16 nId);
 340
 341     /** This is called before executing a context menu for a row. rMenu contains the initial entries
 342         handled by this base class' method (which always has to be called).
 343         Derived classes may alter the menu in any way and handle any additional entries in
 344         PostExecuteColumnContextMenu.
 345         All disabled entries will be removed before executing the menu, so be careful with separators
 346         near entries you probably wish to disable ...
 347     */
 348     virtual void PreExecuteRowContextMenu(weld::Menu& rMenu);
 349     /** After executing the context menu for a row this method is called.
 350     */
 351     virtual void PostExecuteRowContextMenu(const OString& rExecutionResult);
 352
 353     /// @throws css::uno::RuntimeException
 354     void DataSourcePropertyChanged(const css::beans::PropertyChangeEvent& evt);
 355
 356     void FieldValueChanged(sal_uInt16 _nId);
 357     void FieldListenerDisposing(sal_uInt16 _nId);
 358
 359     void disposing(sal_uInt16 _nId);
 360
 361     // own overridables
 362     /// called when the current row changed
 363     virtual void onRowChange();
 364     /// called when the current column changed
 365     virtual void onColumnChange();
 366
 367     // DragSourceHelper overridables
 368     virtual void StartDrag( sal_Int8 nAction, const Point& rPosPixel ) override;
 369
 370     void    executeRowContextMenu(const Point& _rPreferredPos);
 371
 372 public:
 373     DbGridControl(
 374         css::uno::Reference< css::uno::XComponentContext > const & _rxContext,
 375         vcl::Window* pParent,
 376         WinBits nBits);
 377
 378     virtual ~DbGridControl() override;
 379     virtual void dispose() override;
 380
 381     virtual void Init() override;
 382     virtual void InitColumnsByFields(const css::uno::Reference< css::container::XIndexAccess >& xFields) = 0;
 383     virtual void RemoveRows() override;
 384
 385     /** GetCellText returns the text at the given position
 386         @param  _nRow
 387             the number of the row
 388         @param  _nColId
 389             the ID of the column
 390         @return
 391             the text out of the cell
 392     */
 393     virtual OUString  GetCellText(sal_Int32 _nRow, sal_uInt16 _nColId) const override;
 394
 395     void RemoveRows(bool bNewCursor);
 396
 397     const css::uno::Reference< css::util::XNumberFormatter >& getNumberFormatter() const {return m_xFormatter;}
 398
 399     // the data source
 400     // the options can restrict but not extend the update abilities
 401     void setDataSource(const css::uno::Reference< css::sdbc::XRowSet >& rCursor,
 402         DbGridControlOptions nOpts = DbGridControlOptions::Insert | DbGridControlOptions::Update | DbGridControlOptions::Delete);
 403     virtual void Dispatch(sal_uInt16 nId) override;
 404
 405     CursorWrapper* getDataSource() const {return m_pDataCursor.get();}
 406     const std::vector< std::unique_ptr<DbGridColumn> >& GetColumns() const {return m_aColumns;}
 407
 408     void EnableHandle(bool bEnable);
 409     bool HasHandle() const {return m_bHandle;}
 410     void InsertHandleColumn();
 411
 412     // which position does the column with the id in the View have, the handle column doesn't count
 413     sal_uInt16 GetViewColumnPos( sal_uInt16 nId ) const { sal_uInt16 nPos = GetColumnPos(nId); return (nPos==BROWSER_INVALIDID) ? GRID_COLUMN_NOT_FOUND : nPos-1; }
 414
 415     // which position does the column with the id in m_aColumns have, that means the css::sdbcx::Container
 416     // returned from the GetColumns (may be different from the position returned by GetViewColumnPos
 417     // if there are hidden columns)
 418     sal_uInt16 GetModelColumnPos( sal_uInt16 nId ) const;
 419
 420     // the number of columns in the model
 421     sal_uInt16 GetViewColCount() const { return ColCount() - 1; }
 422     sal_uInt16 GetModelColCount() const { return static_cast<sal_uInt16>(m_aColumns.size()); }
 423     // reverse to GetViewColumnPos: Id of position, the first non-handle column has position 0
 424     sal_uInt16 GetColumnIdFromViewPos( sal_uInt16 nPos ) const { return GetColumnId(nPos + 1); }
 425     sal_uInt16 GetColumnIdFromModelPos( sal_uInt16 nPos ) const;
 426
 427     virtual void SetDesignMode(bool bMode);
 428     bool IsDesignMode() const {return m_bDesignMode;}
 429     bool IsOpen() const {return m_pSeekCursor != nullptr;}
 430
 431     void SetFilterMode(bool bMode);
 432     bool IsFilterMode() const {return m_bFilterMode;}
 433     bool IsFilterRow(sal_Int32 nRow) const {return m_bFilterMode && nRow == 0;}
 434
 435     void EnableNavigationBar(bool bEnable);
 436     bool HasNavigationBar() const {return m_bNavigationBar;}
 437
 438     DbGridControlOptions GetOptions() const {return m_nOptions;}
 439     NavigationBar& GetNavigationBar() {return *m_aBar;}
 440     DbGridControlOptions SetOptions(DbGridControlOptions nOpt);
 441         // The new options are interpreted with respect to the current data source. If it is unable
 442         // to update, to insert or to restore, the according options are ignored. If the grid isn't
 443         // connected to a data source, all options except OPT_READONLY are ignored.
 444
 445     const css::util::Date&   getNullDate() const {return m_aNullDate;}
 446
 447     // positioning
 448     void MoveToPosition(sal_uInt32 nPos);
 449     void MoveToFirst();
 450     void MoveToNext();
 451     void MoveToPrev();
 452     void MoveToLast();
 453     void AppendNew();
 454
 455     // adjustment of the cursors in case the data cursor has been
 456     // moved from the outside.
 457     // the flag indicates if an adjustment of the row count should be
 458     // done as well
 459     void AdjustDataSource(bool bFull = false);
 460     void Undo();
 461
 462     virtual void BeginCursorAction();
 463     virtual void EndCursorAction();
 464
 465     // is the current line being updated
 466     bool IsUpdating() const {return m_bUpdating;}
 467
 468     void RowRemoved( sal_Int32 nRow, sal_Int32 nNumRows = 1, bool bDoPaint = true );
 469     void RowInserted( sal_Int32 nRow, sal_Int32 nNumRows = 1, bool bDoPaint = true );
 470     void RowModified( sal_Int32 nRow );
 471
 472     void resetCurrentRow();
 473
 474     bool getDisplaySynchron() const { return m_bSynchDisplay; }
 475     void setDisplaySynchron(bool bSync);
 476         // when set to sal_False, the display is no longer in sync with the current cursor position
 477         // (means that in AdjustDataSource we are jumping to a row not belonging to CursorPosition)
 478         // when using this, you should know what you are doing, because for example entering data
 479         // in a row in the display that is not in sync with the position of the cursor can be very critical
 480
 481     const DbGridRowRef& GetCurrentRow() const {return m_xCurrentRow;}
 482
 483     void SetStateProvider(const Link<DbGridControlNavigationBarState,int>& rProvider) { m_aMasterStateProvider = rProvider; }
 484         // if this link is set the given provider will be asked for the state of my items.
 485         // the return values are interpreted as follows :
 486         // <0 -> not specified (use default mechanism to determine the state)
 487         // ==0 -> the item is disabled
 488         // >0 -> the item is enabled
 489     void SetSlotExecutor(const Link<DbGridControlNavigationBarState,bool>& rExecutor) { m_aMasterSlotExecutor = rExecutor; }
 490         // analogous : if this link is set, all nav-bar slots will be routed through it when executed
 491         // if the handler returns nonzero, no further handling of the slot occurs
 492
 493     void EnablePermanentCursor(bool bEnable);
 494     bool IsPermanentCursorEnabled() const;
 495
 496     /** forces both scrollbars to be hidden
 497
 498         For the horizontal scrollbar, this is overruled by enabling the navigation bar: A navigation
 499         bar <b>always</b> implies a horizontal scroll bar
 500         @seealso EnableNavigationBar
 501     */
 502     void        ForceHideScrollbars();
 503
 504     const css::uno::Reference< css::uno::XComponentContext >&
 505         getContext() const { return m_xContext; }
 506
 507     /// returns <TRUE/> if the text of the given cell can be copied into the clipboard
 508     bool    canCopyCellText(sal_Int32 _nRow, sal_uInt16 _nColId);
 509     /// copies the text of the given cell into the clipboard
 510     void        copyCellText(sal_Int32 _nRow, sal_uInt16 _nColId);
 511
 512     // select in listener handling
 513     void                        setGridListener( FmGridListener* _pListener ) { m_pGridListener = _pListener; }
 514
 515     // helper class to grant access to selected methods from within the DbCellControl class
 516     struct GrantControlAccess final
 517     {
 518         friend class DbCellControl;
 519         friend class RowSetEventListener;
 520         GrantControlAccess() { }
 521     };
 522
 523     /// called when a controller needs to be re-initialized
 524     void refreshController(sal_uInt16 _nColId, GrantControlAccess _aAccess);
 525
 526     CursorWrapper* GetSeekCursor(GrantControlAccess /*_aAccess*/) const    { return m_pSeekCursor.get(); }
 527     const DbGridRowRef& GetSeekRow(GrantControlAccess /*_aAccess*/) const  { return m_xSeekRow;    }
 528     void  SetSeekPos(sal_Int32 nPos,GrantControlAccess /*_aAccess*/) {m_nSeekPos = nPos;}
 529
 530     /**
 531         @return
 532             The count of additional controls of the control area.
 533     */
 534     virtual sal_Int32 GetAccessibleControlCount() const override;
 535
 536     /** Creates the accessible object of an additional control.
 537         @param _nIndex
 538             The 0-based index of the control.
 539         @return
 540             The XAccessible interface of the specified control.
 541     */
 542     virtual css::uno::Reference<
 543         css::accessibility::XAccessible >
 544     CreateAccessibleControl( sal_Int32 _nIndex ) override;
 545
 546     // IAccessibleTableProvider
 547     /** Creates the accessible object of a data table cell.
 548         @param nRow  The row index of the cell.
 549         @param nColumnId  The column ID of the cell.
 550         @return  The XAccessible interface of the specified cell. */
 551     virtual css::uno::Reference<
 552         css::accessibility::XAccessible >
 553     CreateAccessibleCell( sal_Int32 nRow, sal_uInt16 nColumnId ) override;
 554
 555 protected:
 556     void RecalcRows(sal_Int32 nNewTopRow, sal_uInt16 nLinesOnScreen, bool bUpdateCursor);
 557     bool SeekCursor(sal_Int32 nRow, bool bAbsolute = false);
 558     void RemoveColumns();       // cleaning of own structures
 559     void AdjustRows();
 560     sal_Int32 AlignSeekCursor();
 561     bool SetCurrent(sal_Int32 nNewRow);
 562
 563     OUString GetCurrentRowCellText(DbGridColumn const * pCol,const DbGridRowRef& _rRow) const;
 564     virtual void DeleteSelectedRows();
 565     static bool IsValid(const DbGridRowRef& _xRow) { return _xRow.is() && _xRow->IsValid(); }
 566
 567     // row which is currently being appended
 568     bool IsCurrentAppending() const;
 569
 570     // empty row for insertion
 571     bool IsInsertionRow(sal_Int32 nRow) const;
 572
 573     void  SetSeekPos(sal_Int32 nPos) {m_nSeekPos = nPos;}
 574     sal_Int32 GetCurrentPos() const {return m_nCurrentPos;}
 575     sal_Int32 GetSeekPos() const {return m_nSeekPos;}
 576     sal_Int32 GetTotalCount() const {return m_nTotalCount;}
 577
 578     const DbGridRowRef& GetEmptyRow() const { return m_xEmptyRow;   }
 579     const DbGridRowRef& GetSeekRow() const  { return m_xSeekRow;    }
 580     const DbGridRowRef& GetPaintRow() const { return m_xPaintRow;   }
 581
 582     void ConnectToFields();
 583     void DisconnectFromFields();
 584
 585     void implAdjustInSolarThread(bool _bRows);
 586         // calls AdjustRows or AdjustDataSource, synchron if the caller is running in the solar thread, else asynchron
 587
 588 protected:
 589     void ImplInitWindow( const InitWindowFacet _eInitWhat );
 590     DECL_DLLPRIVATE_LINK(OnDelete, void*, void);
 591
 592     DECL_DLLPRIVATE_LINK(OnAsyncAdjust, void*, void);
 593         // if the param is != NULL, AdjustRows will be called, else AdjustDataSource
 594
 595 private:
 596     using BrowseBox::InsertHandleColumn;
 597 };
 598
 599 #endif // INCLUDED_SVX_GRIDCTRL_HXX
 600
 601 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */