summaryrefslogtreecommitdiff
path: root/svtools/source/table/tablecontrol_impl.hxx
blob: 053766d928413019f1273864d30ac7d8d8c62a23 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
/*************************************************************************
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * Copyright 2000, 2010 Oracle and/or its affiliates.
 *
 * OpenOffice.org - a multi-platform office productivity suite
 *
 * This file is part of OpenOffice.org.
 *
 * OpenOffice.org is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * OpenOffice.org is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details
 * (a copy is included in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with OpenOffice.org.  If not, see
 * <http://www.openoffice.org/license.html>
 * for a copy of the LGPLv3 License.
 *
************************************************************************/

#ifndef SVTOOLS_TABLECONTROL_IMPL_HXX
#define SVTOOLS_TABLECONTROL_IMPL_HXX

#ifndef SVTOOLS_INC_TABLE_TABLEMODEL_HXX
#include <svtools/table/tablemodel.hxx>
#endif

#ifndef SVTOOLS_INC_TABLE_ABSTRACTTABLECONTROL_HXX
#include <svtools/table/abstracttablecontrol.hxx>
#endif

#include <svtools/table/tablemodel.hxx>
#include <vector>
#include <vcl/seleng.hxx>


class ScrollBar;
class ScrollBarBox;

//........................................................................
namespace svt { namespace table
{
//........................................................................

    typedef ::std::vector< long >   ArrayOfLong;

    class TableControl;
    class TableDataWindow;
    class TableFunctionSet;

    //====================================================================
    //= TableControl_Impl
    //====================================================================
    class TableControl_Impl : public IAbstractTableControl
    {
        friend class TableGeometry;
        friend class TableRowGeometry;
        friend class TableColumnGeometry;
        friend class SuspendInvariants;
    friend class TableFunctionSet;
    private:
        /// the control whose impl-instance we implemnt
        TableControl&           m_rAntiImpl;
        /// the model of the table control
        PTableModel             m_pModel;
        /// the input handler to use, usually the input handler as provided by ->m_pModel
        PTableInputHandler      m_pInputHandler;
        /// the widths of the single columns, measured in pixel
        ArrayOfLong             m_aColumnWidthsPixel;
        /** the accumulated widths of the single columns, i.e. their exclusive right borders,
            <strong<not</strong> counting the space for a possible row header column
        */
        ArrayOfLong             m_aAccColumnWidthsPixel;

    ArrayOfLong     m_aVisibleColumnWidthsPixel;
        /// the height of a single row in the table, measured in pixels
        long                    m_nRowHeightPixel;
        /// the height of the column header row in the table, measured in pixels
        long                    m_nColHeaderHeightPixel;
        /// the width of the row header column in the table, measured in pixels
        long                    m_nRowHeaderWidthPixel;

        /// the number of columns in the table control. Cached model value.
        TableSize               m_nColumnCount;
        /// the number of rows in the table control. Cached model value.
        TableSize               m_nRowCount;

        ColPos                  m_nCurColumn;
        RowPos                  m_nCurRow;
        ColPos                  m_nLeftColumn;
        RowPos                  m_nTopRow;

        sal_Int32               m_nCursorHidden;

        /** the window to contain all data content, including header bars

            The window's upper left corner is at position (0,0), relative to the
            table control, which is the direct parent of the data window.
        */
        TableDataWindow*        m_pDataWindow;
        /// the vertical scrollbar, if any
        ScrollBar*              m_pVScroll;
        /// the horizontal scrollbar, if any
        ScrollBar*          m_pHScroll;
        ScrollBarBox*           m_pScrollCorner;
    //selection engine - for determining selection range, e.g. single, multiple
    SelectionEngine*        m_pSelEngine;
    //vector which contains the selected rows
    std::vector<RowPos>     m_nRowSelected;
    //part of selection engine
    TableFunctionSet*       m_pTableFunctionSet;
    //part of selection engine
    RowPos              m_nAnchor;
    bool            m_bResizing;
    ColPos          m_nResizingColumn;
    bool            m_bResizingGrid;
    rtl::OUString   m_aTooltipText;

#if DBG_UTIL
    #define INV_SCROLL_POSITION     1
        /** represents a bitmask of invariants to check

            Actually, impl_checkInvariants checks more invariants than denoted in this
            bit mask, but only those present here can be disabled temporarily.
        */
        sal_Int32           m_nRequiredInvariants;
#endif

    public:


        PTableModel getModel() const;
        void        setModel( PTableModel _pModel );

        inline  const PTableInputHandler&   getInputHandler() const { return m_pInputHandler; }

        inline  ColPos  getCurColumn() const    { return m_nCurColumn; }
        inline  RowPos  getCurRow() const       { return m_nCurRow; }
        inline  void    setCurRow(RowPos curRow){ m_nCurRow = curRow; }
        inline  RowPos  getTopRow() const       { return m_nTopRow; }
        inline  long    getRowCount() const     { return m_nRowCount; }
        inline  long    getColumnCount() const  { return m_nColumnCount; }

        inline  long    getColHeaderHightPixel() const  { return m_nColHeaderHeightPixel; }

        inline  const TableControl&   getAntiImpl() const { return m_rAntiImpl; }
        inline        TableControl&   getAntiImpl()       { return m_rAntiImpl; }

    public:
        TableControl_Impl( TableControl& _rAntiImpl );
        ~TableControl_Impl();

#if DBG_UTIL
        const sal_Char* impl_checkInvariants() const;
#endif
        /** to be called when the anti-impl instance has been resized
        */
        void    onResize();

        /** paints the table control content which intersects with the given rectangle
        */
        void    doPaintContent( const Rectangle& _rUpdateRect );

        /** moves the cursor to the cell with the given coordinates

            To ease the caller's code, the coordinates must not necessarily denote a
            valid position. If they don't, <FALSE/> will be returned.
        */
        bool    goTo( ColPos _nColumn, RowPos _nRow );

        /** ensures that the given coordinate is visible
            @param _nColumn
                the column position which should be visible. Must be non-negative, and smaller
                than the column count.
            @param _nRow
                the row position which should be visibleMust be non-negative, and smaller
                than the row count.
            @param _bAcceptPartialVisibility
                <TRUE/> if it's okay that the given cooordinate is only partially visible
        */
        void    ensureVisible( ColPos _nColumn, RowPos _nRow, bool _bAcceptPartialVisibility );
    /** returns the row, which contains the input point*/
    virtual RowPos  getCurrentRow (const Point& rPoint);

    void setCursorAtCurrentCell(const Point& rPoint);
    /** checks whether the vector with the selected rows contains the current row*/
    BOOL    isRowSelected(const ::std::vector<RowPos>& selectedRows, RowPos current);

    bool    isRowSelected(RowPos current);
    /** returns the position of the current row in the selection vector */
    int getRowSelectedNumber(const ::std::vector<RowPos>& selectedRows, RowPos current);
    /** _rCellRect contains the region, which should be invalidate after some action e.g. selecting row*/
    void    invalidateSelectedRegion(RowPos _nPrevRow, RowPos _nCurRow, Rectangle& _rCellRect );
    /** to be called when a new row is added to the control*/
    void    invalidateRow(RowPos _nRowPos, Rectangle& _rCellRect );
    /** returns the vector, which contains the selected rows*/
    std::vector<RowPos>& getSelectedRows();
    /** updates the vector, which contains the selected rows after removing the row nRowPos*/
    void    removeSelectedRow(RowPos _nRowPos);
    void    invalidateRows();
    void    clearSelection();
        // IAbstractTableControl
        virtual void    hideCursor();
        virtual void    showCursor();
        virtual bool    dispatchAction( TableControlAction _eAction );
    virtual SelectionEngine* getSelEngine();
    virtual bool isTooltipActive();
    virtual rtl::OUString& setTooltip(const Point& rPoint );
    virtual void resizeColumn(const Point& rPoint);
    virtual bool startResizeColumn(const Point& rPoint);
    virtual bool endResizeColumn(const Point& rPoint);

    TableDataWindow* getDataWindow();
    ScrollBar* getHorzScrollbar();
    ScrollBar* getVertScrollbar();

    ::rtl::OUString convertToString(const ::com::sun::star::uno::Any& _value);
    Rectangle calcHeaderRect(bool bColHeader);
    Rectangle calcTableRect();
    private:
        /** toggles the cursor visibility

            The method is not bound to the classes public invariants, as it's used in
            situations where the they must not necessarily be fullfilled.
        */
        void        impl_ni_doSwitchCursor( bool _bOn );

        /** returns the number of visible rows.

            @param _bAcceptPartialRow
                specifies whether a possible only partially visible last row is
                counted, too.
        */
        TableSize   impl_getVisibleRows( bool _bAcceptPartialRow ) const;

        /** returns the number of visible columns

            The value may change with different horizontal scroll positions, as
            different columns have different widths. For instance, if your control is
            100 pixels wide, and has three columns of width 50, 50, 100, respectively,
            then this method will return either "2" or "1", depending on which column
            is the first visible one.

            @param _bAcceptPartialRow
                specifies whether a possible only partially visible last row is
                counted, too.
        */
        TableSize   impl_getVisibleColumns( bool _bAcceptPartialRow ) const;

        /** determines the rectangle occupied by the given cell
        */
        void        impl_getCellRect( ColPos _nColumn, RowPos _nRow, Rectangle& _rCellRect ) const;

        /** updates all cached model values

            The method is not bound to the classes public invariants, as it's used in
            situations where the they must not necessarily be fullfilled.
        */
        void        impl_ni_updateCachedModelValues();

        /** updates ->m_aColumnWidthsPixel with the current pixel widths of all model columns

            The method takes into account the current zoom factor and map mode of the table
            control, plus any possible COLWIDTH_FIT_TO_VIEW widths in the model columns.

            The method is not bound to the classes public invariants, as it's used in
            situations where the they must not necessarily be fullfilled.
        */
        void        impl_ni_updateColumnWidths();

        /** updates the scrollbars of the control

            The method is not bound to the classes public invariants, as it's used in
            situations where the they must not necessarily be fullfilled.

            This includes both the existence of the scrollbars, and their
            state.
        */
        void        impl_ni_updateScrollbars();

        /** scrolls the view by the given number of rows

            The method is not bound to the classes public invariants, as it's used in
            situations where the they must not necessarily be fullfilled.

            @return
                the number of rows by which the viewport was scrolled. This may differ
                from the given numbers to scroll in case the begin or the end of the
                row range were reached.
        */
        TableSize   impl_ni_ScrollRows( TableSize _nRowDelta );

        /** scrolls the view by the given number of columns

            The method is not bound to the classes public invariants, as it's used in
            situations where the they must not necessarily be fullfilled.

            @return
                the number of columns by which the viewport was scrolled. This may differ
                from the given numbers to scroll in case the begin or the end of the
                column range were reached.
        */
        TableSize   impl_ni_ScrollColumns( TableSize _nRowDelta );
            /** retrieves the area occupied by the totality of (at least partially) visible cells

            The returned area includes row and column headers. Also, it takes into
            account the the fact that there might be less columns than would normally
            find room in the control.

            As a result of respecting the partial visibility of rows and columns,
            the returned area might be larger than the data window's output size.
        */
        void        impl_getAllVisibleCellsArea( Rectangle& _rCellArea ) const;

        /** retrieves the area occupied by all (at least partially) visible data cells.

            Effectively, the returned area is the same as returned by ->impl_getAllVisibleCellsArea,
            minus the row and column header areas.
        */
        void        impl_getAllVisibleDataCellArea( Rectangle& _rCellArea ) const;

        void impl_ni_getAccVisibleColWidths();
        void impl_updateLeftColumn();

        DECL_LINK( OnScroll, ScrollBar* );
    };
    //see seleng.hxx, seleng.cxx, FunctionSet overridables, part of selection engine
    class TableFunctionSet : public FunctionSet
    {
        friend class TableDataWindow;
    private:
        TableControl_Impl* m_pTableControl;
        RowPos m_nCurrentRow;
    public:
        TableFunctionSet(TableControl_Impl* _pTableControl);
        virtual ~TableFunctionSet();

       virtual void BeginDrag();
       virtual void CreateAnchor();
       virtual void DestroyAnchor();
       virtual BOOL SetCursorAtPoint(const Point& rPoint, BOOL bDontSelectAtCursor);
       virtual BOOL IsSelectionAtPoint( const Point& rPoint );
       virtual void DeselectAtPoint( const Point& rPoint );
       virtual void DeselectAll();
    };


//........................................................................
} } // namespace svt::table
//........................................................................

#endif // SVTOOLS_TABLECONTROL_IMPL_HXX