Debian Codegraph @

toolkit/source/controls/table/tablecontrol_impl.hxx

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