svtools/source/table/tablecontrol_impl.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_SOURCE_TABLE_TABLECONTROL_IMPL_HXX
  21 #define INCLUDED_SVTOOLS_SOURCE_TABLE_TABLECONTROL_IMPL_HXX
  22
  23 #include <svtools/table/tablemodel.hxx>
  24 #include "table/tablecontrolinterface.hxx"
  25
  26 #include "svtaccessiblefactory.hxx"
  27
  28 #include <vcl/seleng.hxx>
  29
  30 #include <vector>
  31
  32 #include <boost/scoped_ptr.hpp>
  33
  34 class ScrollBar;
  35 class ScrollBarBox;
  36
  37 namespace svt { namespace table
  38 {
  39     struct MutableColumnMetrics : protected ColumnMetrics
  40     {
  41         MutableColumnMetrics()
  42             :ColumnMetrics()
  43         {
  44         }
  45
  46         MutableColumnMetrics( long const i_startPixel, long const i_endPixel )
  47             :ColumnMetrics( i_startPixel, i_endPixel )
  48         {
  49         }
  50
  51         long getStart() const { return nStartPixel; }
  52         long getEnd() const { return nEndPixel; }
  53
  54         void setEnd( long const i_end ) { nEndPixel = i_end; }
  55         void move( long const i_offset ) { nStartPixel += i_offset; nEndPixel += i_offset; }
  56
  57         long getWidth() const { return nEndPixel - nStartPixel; }
  58
  59         ColumnMetrics const & operator()() { return *this; }
  60     };
  61
  62     struct ColumnInfoPositionLess
  63     {
  64         bool operator()( MutableColumnMetrics const& i_lhs, MutableColumnMetrics const& i_rhs )
  65         {
  66             return i_lhs.getEnd() < i_rhs.getStart();
  67         }
  68     };
  69
  70     typedef ::std::vector< MutableColumnMetrics >    ColumnPositions;
  71
  72     class TableControl;
  73     class TableDataWindow;
  74     class TableFunctionSet;
  75
  76
  77     //= TableControl_Impl
  78
  79     class TableControl_Impl :public ITableControl
  80                             ,public ITableModelListener
  81     {
  82         friend class TableGeometry;
  83         friend class TableRowGeometry;
  84         friend class TableColumnGeometry;
  85         friend class SuspendInvariants;
  86
  87     private:
  88         /// the control whose impl-instance we implemnt
  89         TableControl&           m_rAntiImpl;
  90         /// the model of the table control
  91         PTableModel             m_pModel;
  92         /// the input handler to use, usually the input handler as provided by ->m_pModel
  93         PTableInputHandler      m_pInputHandler;
  94         /// info about the widths of our columns
  95         ColumnPositions         m_aColumnWidths;
  96
  97         /// the height of a single row in the table, measured in pixels
  98         long                    m_nRowHeightPixel;
  99         /// the height of the column header row in the table, measured in pixels
 100         long                    m_nColHeaderHeightPixel;
 101         /// the width of the row header column in the table, measured in pixels
 102         long                    m_nRowHeaderWidthPixel;
 103
 104         /// the number of columns in the table control. Cached model value.
 105         TableSize               m_nColumnCount;
 106
 107         /// the number of rows in the table control. Cached model value.
 108         TableSize               m_nRowCount;
 109
 110         ColPos                  m_nCurColumn;
 111         RowPos                  m_nCurRow;
 112         ColPos                  m_nLeftColumn;
 113         RowPos                  m_nTopRow;
 114
 115         sal_Int32               m_nCursorHidden;
 116
 117         /** the window to contain all data content, including header bars
 118
 119             The window's upper left corner is at position (0,0), relative to the
 120             table control, which is the direct parent of the data window.
 121         */
 122         VclPtr<TableDataWindow> m_pDataWindow;
 123         /// the vertical scrollbar, if any
 124         VclPtr<ScrollBar>       m_pVScroll;
 125         /// the horizontal scrollbar, if any
 126         VclPtr<ScrollBar>       m_pHScroll;
 127         VclPtr<ScrollBarBox>    m_pScrollCorner;
 128         //selection engine - for determining selection range, e.g. single, multiple
 129         SelectionEngine*        m_pSelEngine;
 130         //vector which contains the selected rows
 131         std::vector<RowPos>     m_aSelectedRows;
 132         //part of selection engine
 133         TableFunctionSet*       m_pTableFunctionSet;
 134         //part of selection engine
 135         RowPos                  m_nAnchor;
 136         bool                    m_bUpdatingColWidths;
 137
 138         Link<>                  m_aSelectHdl;
 139
 140         AccessibleFactoryAccess     m_aFactoryAccess;
 141         IAccessibleTableControl*    m_pAccessibleTable;
 142
 143     public:
 144         void        setModel( PTableModel _pModel );
 145
 146         inline  const PTableInputHandler&   getInputHandler() const { return m_pInputHandler; }
 147
 148         inline  RowPos  getCurRow() const           { return m_nCurRow; }
 149         inline  void    setCurRow( RowPos i_curRow ){ m_nCurRow = i_curRow; }
 150
 151         RowPos  getAnchor() const { return m_nAnchor; }
 152         void    setAnchor( RowPos const i_anchor ) { m_nAnchor = i_anchor; }
 153
 154         inline  RowPos  getTopRow() const       { return m_nTopRow; }
 155         inline  ColPos  getLeftColumn() const { return m_nLeftColumn; }
 156
 157         inline  const TableControl&   getAntiImpl() const { return m_rAntiImpl; }
 158         inline        TableControl&   getAntiImpl()       { return m_rAntiImpl; }
 159
 160     public:
 161         TableControl_Impl( TableControl& _rAntiImpl );
 162         virtual ~TableControl_Impl();
 163
 164         /** to be called when the anti-impl instance has been resized
 165         */
 166         void    onResize();
 167
 168         /** paints the table control content which intersects with the given rectangle
 169         */
 170         void    doPaintContent(vcl::RenderContext& rRenderContext, const Rectangle& _rUpdateRect);
 171
 172         /** moves the cursor to the cell with the given coordinates
 173
 174             To ease the caller's code, the coordinates must not necessarily denote a
 175             valid position. If they don't, <FALSE/> will be returned.
 176         */
 177         bool    goTo( ColPos _nColumn, RowPos _nRow );
 178
 179         /** ensures that the given coordinate is visible
 180             @param _nColumn
 181                 the column position which should be visible. Must be non-negative, and smaller
 182                 than the column count.
 183             @param _nRow
 184                 the row position which should be visibleMust be non-negative, and smaller
 185                 than the row count.
 186             @param _bAcceptPartialVisibility
 187                 <TRUE/> if it's okay that the given cooordinate is only partially visible
 188         */
 189         void    ensureVisible( ColPos _nColumn, RowPos _nRow, bool _bAcceptPartialVisibility );
 190
 191         /** retrieves the content of the given cell, converted to a string
 192         */
 193         OUString getCellContentAsString( RowPos const i_row, ColPos const i_col );
 194
 195         /** returns the position of the current row in the selection vector */
 196         static int getRowSelectedNumber(const ::std::vector<RowPos>& selectedRows, RowPos current);
 197
 198         void invalidateRect(const Rectangle &rInvalidateRect);
 199
 200         /** ??? */
 201         void    invalidateSelectedRegion( RowPos _nPrevRow, RowPos _nCurRow );
 202
 203         /** invalidates the part of the data window which is covered by the given rows
 204             @param i_firstRow
 205                 the index of the first row to include in the invalidation
 206             @param i_lastRow
 207                 the index of the last row to include in the invalidation, or ROW_INVALID if the invalidation
 208                 should happen down to the bottom of the data window.
 209         */
 210         void    invalidateRowRange( RowPos const i_firstRow, RowPos const i_lastRow );
 211
 212         /** invalidates the part of the data window which is covered by the given row
 213         */
 214         void    invalidateRow( RowPos const i_row ) { invalidateRowRange( i_row, i_row ); }
 215
 216         /** invalidates all selected rows
 217         */
 218         void    invalidateSelectedRows();
 219
 220         void    checkCursorPosition();
 221
 222         bool    hasRowSelection() const { return !m_aSelectedRows.empty(); }
 223         size_t  getSelectedRowCount() const { return m_aSelectedRows.size(); }
 224         RowPos  getSelectedRowIndex( size_t const i_selectionIndex ) const;
 225
 226         /** removes the given row index from m_aSelectedRows
 227
 228             @return
 229                 <TRUE/> if and only if the row was previously marked as selected
 230         */
 231         bool        markRowAsDeselected( RowPos const i_rowIndex );
 232
 233         /** marks the given row as selectged, by putting it into m_aSelectedRows
 234             @return
 235                 <TRUE/> if and only if the row was previously <em>not</em> marked as selected
 236         */
 237         bool        markRowAsSelected( RowPos const i_rowIndex );
 238
 239         /** marks all rows as deselected
 240             @return
 241                 <TRUE/> if and only if the selection actually changed by this operation
 242         */
 243         bool        markAllRowsAsDeselected();
 244
 245         /** marks all rows as selected
 246             @return
 247                 <FALSE/> if and only if all rows were selected already.
 248         */
 249         bool        markAllRowsAsSelected();
 250
 251         void        setSelectHandler( Link<> const & i_selectHandler ) { m_aSelectHdl = i_selectHandler; }
 252         Link<> const& getSelectHandler() const { return m_aSelectHdl; }
 253
 254         void commitAccessibleEvent( sal_Int16 const i_eventID, const com::sun::star::uno::Any& i_newValue, const com::sun::star::uno::Any& i_oldValue );
 255         void commitCellEvent( sal_Int16 const i_eventID, const com::sun::star::uno::Any& i_newValue, const com::sun::star::uno::Any& i_oldValue );
 256         void commitTableEvent( sal_Int16 const i_eventID, const com::sun::star::uno::Any& i_newValue, const com::sun::star::uno::Any& i_oldValue );
 257
 258         // ITableControl
 259         virtual void                hideCursor() SAL_OVERRIDE;
 260         virtual void                showCursor() SAL_OVERRIDE;
 261         virtual bool                dispatchAction( TableControlAction _eAction ) SAL_OVERRIDE;
 262         virtual SelectionEngine*    getSelEngine() SAL_OVERRIDE;
 263         virtual PTableModel         getModel() const SAL_OVERRIDE;
 264         virtual ColPos              getCurrentColumn() const SAL_OVERRIDE;
 265         virtual RowPos              getCurrentRow() const SAL_OVERRIDE;
 266         virtual bool                activateCell( ColPos const i_col, RowPos const i_row ) SAL_OVERRIDE;
 267         virtual ::Size              getTableSizePixel() const SAL_OVERRIDE;
 268         virtual void                setPointer( Pointer const & i_pointer ) SAL_OVERRIDE;
 269         virtual void                captureMouse() SAL_OVERRIDE;
 270         virtual void                releaseMouse() SAL_OVERRIDE;
 271         virtual void                invalidate( TableArea const i_what ) SAL_OVERRIDE;
 272         virtual long                pixelWidthToAppFont( long const i_pixels ) const SAL_OVERRIDE;
 273         virtual void                hideTracking() SAL_OVERRIDE;
 274         virtual void                showTracking( Rectangle const & i_location, sal_uInt16 const i_flags ) SAL_OVERRIDE;
 275         RowPos                      getRowAtPoint( const Point& rPoint ) const;
 276         ColPos                      getColAtPoint( const Point& rPoint ) const;
 277         virtual TableCell           hitTest( const Point& rPoint ) const SAL_OVERRIDE;
 278         virtual ColumnMetrics       getColumnMetrics( ColPos const i_column ) const SAL_OVERRIDE;
 279         virtual bool                isRowSelected( RowPos i_row ) const SAL_OVERRIDE;
 280
 281
 282         long                        appFontWidthToPixel( long const i_appFontUnits ) const;
 283
 284         TableDataWindow&        getDataWindow()       { return *m_pDataWindow; }
 285         const TableDataWindow&  getDataWindow() const { return *m_pDataWindow; }
 286         ScrollBar* getHorzScrollbar() { return m_pHScroll; }
 287         ScrollBar* getVertScrollbar() { return m_pVScroll; }
 288
 289         Rectangle calcHeaderRect( bool bColHeader );
 290         Rectangle calcHeaderCellRect( bool bColHeader, sal_Int32 nPos );
 291         Rectangle calcTableRect();
 292         Rectangle calcCellRect( sal_Int32 nRow, sal_Int32 nCol );
 293
 294         // A11Y
 295         ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible >
 296                         getAccessible( vcl::Window& i_parentWindow );
 297         void            disposeAccessible();
 298
 299         inline bool     isAccessibleAlive() const { return impl_isAccessibleAlive(); }
 300
 301         // ITableModelListener
 302         virtual void    rowsInserted( RowPos first, RowPos last ) SAL_OVERRIDE;
 303         virtual void    rowsRemoved( RowPos first, RowPos last ) SAL_OVERRIDE;
 304         virtual void    columnInserted( ColPos const i_colIndex ) SAL_OVERRIDE;
 305         virtual void    columnRemoved( ColPos const i_colIndex ) SAL_OVERRIDE;
 306         virtual void    allColumnsRemoved() SAL_OVERRIDE;
 307         virtual void    cellsUpdated( ColPos const i_firstCol, ColPos i_lastCol, RowPos const i_firstRow, RowPos const i_lastRow ) SAL_OVERRIDE;
 308         virtual void    columnChanged( ColPos const i_column, ColumnAttributeGroup const i_attributeGroup ) SAL_OVERRIDE;
 309         virtual void    tableMetricsChanged() SAL_OVERRIDE;
 310
 311     private:
 312         bool            impl_isAccessibleAlive() const;
 313         void            impl_commitAccessibleEvent(
 314                             sal_Int16 const i_eventID,
 315                             ::com::sun::star::uno::Any const & i_newValue,
 316                             ::com::sun::star::uno::Any const & i_oldValue
 317                         );
 318
 319         /** toggles the cursor visibility
 320
 321             The method is not bound to the classes public invariants, as it's used in
 322             situations where the they must not necessarily be fulfilled.
 323         */
 324         void        impl_ni_doSwitchCursor( bool _bOn );
 325
 326         /** returns the number of visible rows.
 327
 328             @param _bAcceptPartialRow
 329                 specifies whether a possible only partially visible last row is
 330                 counted, too.
 331         */
 332         TableSize   impl_getVisibleRows( bool _bAcceptPartialRow ) const;
 333
 334         /** returns the number of visible columns
 335
 336             The value may change with different horizontal scroll positions, as
 337             different columns have different widths. For instance, if your control is
 338             100 pixels wide, and has three columns of width 50, 50, 100, respectively,
 339             then this method will return either "2" or "1", depending on which column
 340             is the first visible one.
 341
 342             @param _bAcceptPartialRow
 343                 specifies whether a possible only partially visible last row is
 344                 counted, too.
 345         */
 346         TableSize   impl_getVisibleColumns( bool _bAcceptPartialCol ) const;
 347
 348         /** determines the rectangle occupied by the given cell
 349         */
 350         void        impl_getCellRect( ColPos _nColumn, RowPos _nRow, Rectangle& _rCellRect ) const;
 351
 352         /** updates all cached model values
 353
 354             The method is not bound to the classes public invariants, as it's used in
 355             situations where the they must not necessarily be fulfilled.
 356         */
 357         void        impl_ni_updateCachedModelValues();
 358
 359         /** updates the cached table metrics (row height etc.)
 360         */
 361         void        impl_ni_updateCachedTableMetrics();
 362
 363         /** does a relayout of the table control
 364
 365             Column widths, and consequently the availability of the vertical and horizontal scrollbar, are updated
 366             with a call to this method.
 367
 368             @param i_assumeInflexibleColumnsUpToIncluding
 369                 the index of a column up to which all columns should be considered as inflexible, or
 370                 <code>COL_INVALID</code>.
 371         */
 372         void        impl_ni_relayout( ColPos const i_assumeInflexibleColumnsUpToIncluding = COL_INVALID );
 373
 374         /** calculates the new width of our columns, taking into account their min and max widths, and their relative
 375             flexibility.
 376
 377             @param i_assumeInflexibleColumnsUpToIncluding
 378                 the index of a column up to which all columns should be considered as inflexible, or
 379                 <code>COL_INVALID</code>.
 380
 381             @param i_assumeVerticalScrollbar
 382                 controls whether or not we should assume the presence of a vertical scrollbar. If <true/>, and
 383                 if the model has a VerticalScrollbarVisibility != ScrollbarShowNever, the method will leave
 384                 space for a vertical scrollbar.
 385
 386             @return
 387                 the overall width of the grid, which is available for columns
 388         */
 389         long        impl_ni_calculateColumnWidths(
 390                         ColPos const i_assumeInflexibleColumnsUpToIncluding,
 391                         bool const i_assumeVerticalScrollbar,
 392                         ::std::vector< long >& o_newColWidthsPixel
 393                     ) const;
 394
 395         /** positions all child windows, e.g. the both scrollbars, the corner window, and the data window
 396         */
 397         void        impl_ni_positionChildWindows(
 398                         Rectangle const & i_dataCellPlayground,
 399                         bool const i_verticalScrollbar,
 400                         bool const i_horizontalScrollbar
 401                     );
 402
 403         /** scrolls the view by the given number of rows
 404
 405             The method is not bound to the classes public invariants, as it's used in
 406             situations where the they must not necessarily be fulfilled.
 407
 408             @return
 409                 the number of rows by which the viewport was scrolled. This may differ
 410                 from the given numbers to scroll in case the begin or the end of the
 411                 row range were reached.
 412         */
 413         TableSize   impl_ni_ScrollRows( TableSize _nRowDelta );
 414
 415         /** equivalent to impl_ni_ScrollRows, but checks the instances invariants beforehand (in a non-product build only)
 416         */
 417         TableSize   impl_scrollRows( TableSize const i_rowDelta );
 418
 419         /** scrolls the view by the given number of columns
 420
 421             The method is not bound to the classes public invariants, as it's used in
 422             situations where the they must not necessarily be fulfilled.
 423
 424             @return
 425                 the number of columns by which the viewport was scrolled. This may differ
 426                 from the given numbers to scroll in case the begin or the end of the
 427                 column range were reached.
 428         */
 429         TableSize   impl_ni_ScrollColumns( TableSize _nColumnDelta );
 430
 431         /** equivalent to impl_ni_ScrollColumns, but checks the instances invariants beforehand (in a non-product build only)
 432         */
 433         TableSize   impl_scrollColumns( TableSize const i_columnDelta );
 434
 435         /** retrieves the area occupied by the totality of (at least partially) visible cells
 436
 437             The returned area includes row and column headers. Also, it takes into
 438             account the fact that there might be less columns than would normally
 439             find room in the control.
 440
 441             As a result of respecting the partial visibility of rows and columns,
 442             the returned area might be larger than the data window's output size.
 443         */
 444         Rectangle   impl_getAllVisibleCellsArea() const;
 445
 446         /** retrieves the area occupied by all (at least partially) visible data cells.
 447
 448             Effectively, the returned area is the same as returned by ->impl_getAllVisibleCellsArea,
 449             minus the row and column header areas.
 450         */
 451         Rectangle   impl_getAllVisibleDataCellArea() const;
 452
 453         /** retrieves the column which covers the given ordinate
 454         */
 455         ColPos      impl_getColumnForOrdinate( long const i_ordinate ) const;
 456
 457         /** retrieves the row which covers the given abscissa
 458         */
 459         RowPos      impl_getRowForAbscissa( long const i_abscissa ) const;
 460
 461         /// invalidates the window area occupied by the given column
 462         void        impl_invalidateColumn( ColPos const i_column );
 463
 464         DECL_LINK( OnScroll, ScrollBar* );
 465         DECL_LINK( OnUpdateScrollbars, void* );
 466     };
 467
 468     //see seleng.hxx, seleng.cxx, FunctionSet overridables, part of selection engine
 469     class TableFunctionSet : public FunctionSet
 470     {
 471     private:
 472         TableControl_Impl*  m_pTableControl;
 473         RowPos              m_nCurrentRow;
 474
 475     public:
 476         TableFunctionSet(TableControl_Impl* _pTableControl);
 477         virtual ~TableFunctionSet();
 478
 479        virtual void BeginDrag() SAL_OVERRIDE;
 480        virtual void CreateAnchor() SAL_OVERRIDE;
 481        virtual void DestroyAnchor() SAL_OVERRIDE;
 482        virtual bool SetCursorAtPoint(const Point& rPoint, bool bDontSelectAtCursor) SAL_OVERRIDE;
 483        virtual bool IsSelectionAtPoint( const Point& rPoint ) SAL_OVERRIDE;
 484        virtual void DeselectAtPoint( const Point& rPoint ) SAL_OVERRIDE;
 485        virtual void DeselectAll() SAL_OVERRIDE;
 486     };
 487
 488
 489
 490 } } // namespace svt::table
 491
 492
 493 #endif // INCLUDED_SVTOOLS_SOURCE_TABLE_TABLECONTROL_IMPL_HXX
 494
 495 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */