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
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#pragma once
#include <table/tabletypes.hxx>
#include <rtl/ustring.hxx>
#include <memory>
namespace com :: sun :: star :: uno { class Any; }
namespace tools { class Rectangle; }
namespace vcl { class Window; }
class OutputDevice;
class StyleSettings;
namespace vcl {
typedef OutputDevice RenderContext;
};
namespace svt { namespace table
{
//= ITableRenderer
/** interface to implement by components rendering a ->TableControl
*/
class SAL_NO_VTABLE ITableRenderer
{
public:
/** paints a (part of) header area
There are two header areas in a table control:
<ul><li>The row containing all column headers, i.e. <em>above</em> all rows containing the data</li>
<li>The column containing all row headers. i.e. <em>left of</em> all columns containing the data</li>
</ul>
A header area is more than the union of the single column/row headers.
First, there might be less columns than fit into the view - in this case, right
beside the right-most column, there's still room which belongs to the column header
area, but is not occupied by any particular column header.<br/>
An equivalent statement holds for the row header area, if there are fewer rows than
fit into the view.
Second, if the table control has both a row header and a column header,
the intersection between those both belongs to both the column header area and the
row header area, but not to any particular column or row header.
There are two flags specifying whether the to-be-painted area is part of the column
and/or row header area.
<ul><li>If both are <TRUE/>, the intersection of both areas is to be painted.</li>
<li>If ->_bIsColHeaderArea is <TRUE/> and ->_bIsRowHeaderArea is <FALSE/>,
then ->_rArea denotes the column header area <em>excluding</em> the
intersection between row and column header area.</li>
<li>Equivalently for ->_bIsColHeaderArea being <FALSE/> and ->_bIsRowHeaderArea
being <TRUE/></li>
</ul>
Note that it's not possible for both ->_bIsColHeaderArea and ->_bIsRowHeaderArea
to be <FALSE/> at the same time.
@param _rDevice
the device to paint onto
@param _rArea
the area to paint into
@param _bIsColHeaderArea
<TRUE/> if and only if ->_rArea is part of the column header area.
@param _bIsRowHeaderArea
<TRUE/> if and only if ->_rArea is part of the row header area.
@param _rStyle
the style to be used for drawing
*/
virtual void PaintHeaderArea(
vcl::RenderContext& _rDevice, const tools::Rectangle& _rArea,
bool _bIsColHeaderArea, bool _bIsRowHeaderArea,
const StyleSettings& _rStyle ) = 0;
/** paints the header for a given column
@param _nCol
the index of the column to paint
@param _rDevice
denotes the device to paint onto
@param _rArea
the are into which the column header should be painted
@param _rStyle
the style to be used for drawing
*/
virtual void PaintColumnHeader( ColPos _nCol,
vcl::RenderContext& _rDevice, const tools::Rectangle& _rArea,
const StyleSettings& _rStyle ) = 0;
/** prepares a row for painting
Painting a table means painting rows as necessary, in an increasing
order. The assumption is that retrieving data for two different rows
is (potentially) more expensive than retrieving data for two different
columns. Thus, the renderer will get the chance to "seek" to a certain
row, and then has to render all cells in this row, before another
row is going to be painted.
@param _nRow
the row which is going to be painted. The renderer should
at least remember this row, since subsequent calls to
->PaintRowHeader(), ->PaintCell(), and ->FinishRow() will
not pass this parameter again.
However, the renderer is also allowed to render any
cell-independent content of this row.
@param i_hasControlFocus
<TRUE/> if and only if the table control currently has the focus
@param _bSelected
<TRUE/> if and only if the row to be prepared is
selected currently.
@param _rDevice
denotes the device to paint onto
@param _rRowArea
the are into which the row should be painted. This excludes
the row header area, if applicable.
@param _rStyle
the style to be used for drawing
*/
virtual void PrepareRow( RowPos _nRow, bool i_hasControlFocus, bool _bSelected,
vcl::RenderContext& _rDevice, const tools::Rectangle& _rRowArea,
const StyleSettings& _rStyle ) = 0;
/** paints the header of a row
The row to be painted is denoted by the most recent call to
->PrepareRow.
@param _rDevice
denotes the device to paint onto
@param _rArea
the are into which the row header should be painted
@param _rStyle
the style to be used for drawing
*/
virtual void PaintRowHeader(
vcl::RenderContext& _rDevice, tools::Rectangle const & _rArea,
StyleSettings const & _rStyle ) = 0;
/** paints a certain cell
The row to be painted is denoted by the most recent call to
->PrepareRow.
@param _bSelected
<TRUE/> if and only if the cell to be painted is
selected currently. This is the case if either
the row or the column of the cell is currently selected.
<br/>
Note that this flag is equal to the respective flag in the
previous ->PrepareRow call, it's passed here for convenience
only.
@param i_hasControlFocus
<TRUE/> if and only if the table control currently has the focus
<br/>
Note that this flag is equal to the respective flag in the
previous ->PrepareRow call, it's passed here for convenience
only.
@param _rDevice
denotes the device to paint onto
@param _rArea
the are into which the cell should be painted
@param _rStyle
the style to be used for drawing
*/
virtual void PaintCell( ColPos const i_col,
bool i_hasControlFocus, bool _bSelected,
vcl::RenderContext& _rDevice, const tools::Rectangle& _rArea,
const StyleSettings& _rStyle ) = 0;
/** draws a cell cursor in the given rectangle
The cell cursor is used to indicate the active/current cell
of a table control.
*/
virtual void ShowCellCursor( vcl::Window& _rView, const tools::Rectangle& _rCursorRect) = 0;
/** hides the cell cursor previously drawn into the given rectangle
The cell cursor is used to indicate the active/current cell
of a table control.
*/
virtual void HideCellCursor( vcl::Window& _rView ) = 0;
/** checks whether a given cell content fits into a given target area on a given device.
@param i_targetDevice
denotes the target device for the assumed rendering operation
@param i_targetArea
denotes the area within the target device for the assumed rendering operation.
@return
<TRUE/> if and only if the given cell content could be rendered into the given device and the
given area.
*/
virtual bool FitsIntoCell(
css::uno::Any const & i_cellContent,
OutputDevice& i_targetDevice, tools::Rectangle const & i_targetArea
) const = 0;
/** attempts to format the content of the given cell as string
@param i_cellValue
the value for which an attempt for a string conversion should be made
@param o_cellString
the cell content, formatted as string
@return
<TRUE/> if and only if the content could be formatted as string
*/
virtual bool GetFormattedCellString(
css::uno::Any const & i_cellValue,
OUString & o_cellString
) const = 0;
/// deletes the renderer instance
virtual ~ITableRenderer() { }
};
typedef std::shared_ptr< ITableRenderer > PTableRenderer;
} } // namespace svt::table
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
