svtools/inc/table/tablecontrolinterface.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_INC_TABLE_TABLECONTROLINTERFACE_HXX
  21 #define INCLUDED_SVTOOLS_INC_TABLE_TABLECONTROLINTERFACE_HXX
  22
  23 #include <sal/types.h>
  24 #include <vcl/event.hxx>
  25 #include <vcl/seleng.hxx>
  26
  27 #include <svtools/table/tabletypes.hxx>
  28 #include <svtools/table/tablemodel.hxx>
  29
  30 class Pointer;
  31
  32
  33 namespace svt { namespace table
  34 {
  35
  36
  37     //= TableControlAction
  38
  39     enum TableControlAction
  40     {
  41         /// moves the cursor in the table control one row up, if possible, by keeping the current column
  42         cursorUp,
  43         /// moves the cursor in the table control one row down, if possible, by keeping the current column
  44         cursorDown,
  45         /// moves the cursor in the table control one column to the left, if possible, by keeping the current row
  46         cursorLeft,
  47         /// moves the cursor in the table control one column to the right, if possible, by keeping the current row
  48         cursorRight,
  49         /// moves the cursor to the beginning of the current line
  50         cursorToLineStart,
  51         /// moves the cursor to the end of the current line
  52         cursorToLineEnd,
  53         /// moves the cursor to the first row, keeping the current column
  54         cursorToFirstLine,
  55         /// moves the cursor to the last row, keeping the current column
  56         cursorToLastLine,
  57         /// moves the cursor one page up, keeping the current column
  58         cursorPageUp,
  59         /// moves the cursor one page down, keeping the current column
  60         cursorPageDown,
  61         /// moves the cursor to the top-most, left-most cell
  62         cursorTopLeft,
  63         /// moves the cursor to the bottom-most, right-most cell
  64         cursorBottomRight,
  65         /// selects the row, where the actual cursor is
  66         cursorSelectRow,
  67         /// selects the rows, above the actual cursor is
  68         cursorSelectRowUp,
  69         /// selects the row, beneath the actual cursor is
  70         cursorSelectRowDown,
  71         /// selects the row, from the actual cursor till top
  72         cursorSelectRowAreaTop,
  73         /// selects the row, from the actual cursor till bottom
  74         cursorSelectRowAreaBottom,
  75
  76         /// invalid and final enumeration value, not to be actually used
  77         invalidTableControlAction
  78     };
  79
  80
  81     //= TableCellArea
  82
  83     enum TableCellArea
  84     {
  85         CellContent,
  86         ColumnDivider
  87     };
  88
  89
  90     //= TableCell
  91
  92     struct TableCell
  93     {
  94         ColPos const    nColumn;
  95         RowPos const    nRow;
  96         TableCellArea   eArea;
  97
  98         TableCell( ColPos const i_column, RowPos const i_row )
  99             :nColumn( i_column )
 100             ,nRow( i_row )
 101             ,eArea( CellContent )
 102         {
 103         }
 104     };
 105
 106
 107     //= ColumnMetrics
 108
 109     struct ColumnMetrics
 110     {
 111         /** the start of the column, in pixels. Might be negative, in case the column is scrolled out of the visible
 112             area. Note: see below.
 113         */
 114         long    nStartPixel;
 115
 116         /** the end of the column, in pixels, plus 1. Effectively, this is the accumulated width of a all columns
 117             up to the current one.
 118
 119             Huh? Earlier you said that the nStartPixel of columns
 120             scrolled out (to the left) of the visible area is
 121             negative. Also, where is the promise that there is no gap
 122             between columns? The above claim would be true only if the
 123             first column always started at zero, and there is never a
 124             gap. So these doc comments are inconsistent. How
 125             surprising.
 126         */
 127         long    nEndPixel;
 128
 129         ColumnMetrics()
 130             :nStartPixel(0)
 131             ,nEndPixel(0)
 132         {
 133         }
 134
 135         ColumnMetrics( long const i_start, long const i_end )
 136             :nStartPixel( i_start )
 137             ,nEndPixel( i_end )
 138         {
 139         }
 140     };
 141
 142
 143     //= TableArea
 144
 145     enum class TableArea
 146     {
 147         ColumnHeaders,
 148         RowHeaders,
 149         All
 150     };
 151
 152
 153     //= ITableControl
 154
 155     /** defines a callback interface to be implemented by a concrete table control
 156     */
 157     class SAL_NO_VTABLE ITableControl
 158     {
 159     public:
 160         /** hides the cell cursor
 161
 162             The method cares for successive calls, that is, for every call to
 163             ->hideCursor(), you need one call to ->showCursor. Only if the number
 164             of both calls matches, the cursor is really shown.
 165
 166             @see showCursor
 167         */
 168         virtual void    hideCursor() = 0;
 169
 170         /** shows the cell cursor
 171
 172             @see hideCursor
 173         */
 174         virtual void    showCursor() = 0;
 175
 176         /** dispatches an action to the table control
 177
 178             @return
 179                 <TRUE/> if the action could be dispatched successfully, <FALSE/> otherwise. Usual
 180                 failure conditions include some other instance vetoing the action, or impossibility
 181                 to execute the action at all (for instance moving up one row when already positioned
 182                 on the very first row).
 183
 184             @see TableControlAction
 185         */
 186         virtual bool    dispatchAction( TableControlAction _eAction ) = 0;
 187
 188         /** returns selection engine*/
 189         virtual SelectionEngine* getSelEngine() = 0;
 190
 191         /** returns the table model
 192
 193             The returned model is guaranteed to not be <NULL/>.
 194         */
 195         virtual PTableModel getModel() const = 0;
 196
 197         /// returns the index of the currently active column
 198         virtual ColPos  getCurrentColumn() const = 0;
 199
 200         /// returns the index of the currently active row
 201         virtual RowPos  getCurrentRow() const = 0;
 202
 203         /// activates the given cell
 204         virtual void    activateCell( ColPos const i_col, RowPos const i_row ) = 0;
 205
 206         /// retrieves the size of the table window, in pixels
 207         virtual ::Size  getTableSizePixel() const = 0;
 208
 209         /// sets a new mouse pointer for the table window
 210         virtual void    setPointer( Pointer const & i_pointer ) = 0;
 211
 212         /// captures the mouse to the table window
 213         virtual void    captureMouse() = 0;
 214
 215         /// releases the mouse, after it had previously been captured
 216         virtual void    releaseMouse() = 0;
 217
 218         /// invalidates the table window
 219         virtual void    invalidate( TableArea const i_what ) = 0;
 220
 221         /// calculates a width, given in pixels, into a AppFont-based width
 222         virtual long    pixelWidthToAppFont( long const i_pixels ) const = 0;
 223
 224         /// shows a tracking rectangle
 225         virtual void    showTracking( tools::Rectangle const & i_location, ShowTrackFlags const i_flags ) = 0;
 226
 227         /// hides a prviously shown tracking rectangle
 228         virtual void    hideTracking() = 0;
 229
 230         /// does a hit test for the given pixel coordinates
 231         virtual TableCell       hitTest( const Point& rPoint ) const = 0;
 232
 233         /// retrieves the metrics for a given column
 234         virtual ColumnMetrics   getColumnMetrics( ColPos const i_column ) const = 0;
 235
 236         /// determines whether a given row is selected
 237         virtual bool isRowSelected( RowPos _nRow ) const = 0;
 238
 239         virtual ~ITableControl() {};
 240     };
 241
 242
 243 } } // namespace svt::table
 244
 245
 246 #endif // INCLUDED_SVTOOLS_INC_TABLE_TABLECONTROLINTERFACE_HXX
 247
 248 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */