1/* gtkcellrenderer.h
2 * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford <jrb@redhat.com>
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
16 */
17
18#ifndef __GTK_CELL_RENDERER_H__
19#define __GTK_CELL_RENDERER_H__
20
21#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION)
22#error "Only <gtk/gtk.h> can be included directly."
23#endif
24
25#include <gtk/gtkcelleditable.h>
26
27G_BEGIN_DECLS
28
29
30/**
31 * GtkCellRendererState:
32 * @GTK_CELL_RENDERER_SELECTED: The cell is currently selected, and
33 * probably has a selection colored background to render to.
34 * @GTK_CELL_RENDERER_PRELIT: The mouse is hovering over the cell.
35 * @GTK_CELL_RENDERER_INSENSITIVE: The cell is drawn in an insensitive manner
36 * @GTK_CELL_RENDERER_SORTED: The cell is in a sorted row
37 * @GTK_CELL_RENDERER_FOCUSED: The cell is in the focus row.
38 * @GTK_CELL_RENDERER_EXPANDABLE: The cell is in a row that can be expanded
39 * @GTK_CELL_RENDERER_EXPANDED: The cell is in a row that is expanded
40 *
41 * Tells how a cell is to be rendered.
42 */
43typedef enum
44{
45 GTK_CELL_RENDERER_SELECTED = 1 << 0,
46 GTK_CELL_RENDERER_PRELIT = 1 << 1,
47 GTK_CELL_RENDERER_INSENSITIVE = 1 << 2,
48 /* this flag means the cell is in the sort column/row */
49 GTK_CELL_RENDERER_SORTED = 1 << 3,
50 GTK_CELL_RENDERER_FOCUSED = 1 << 4,
51 GTK_CELL_RENDERER_EXPANDABLE = 1 << 5,
52 GTK_CELL_RENDERER_EXPANDED = 1 << 6
53} GtkCellRendererState;
54
55/**
56 * GtkCellRendererMode:
57 * @GTK_CELL_RENDERER_MODE_INERT: The cell is just for display
58 * and cannot be interacted with. Note that this doesn’t mean that eg. the
59 * row being drawn can’t be selected -- just that a particular element of
60 * it cannot be individually modified.
61 * @GTK_CELL_RENDERER_MODE_ACTIVATABLE: The cell can be clicked.
62 * @GTK_CELL_RENDERER_MODE_EDITABLE: The cell can be edited or otherwise modified.
63 *
64 * Identifies how the user can interact with a particular cell.
65 */
66typedef enum
67{
68 GTK_CELL_RENDERER_MODE_INERT,
69 GTK_CELL_RENDERER_MODE_ACTIVATABLE,
70 GTK_CELL_RENDERER_MODE_EDITABLE
71} GtkCellRendererMode;
72
73#define GTK_TYPE_CELL_RENDERER (gtk_cell_renderer_get_type ())
74#define GTK_CELL_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER, GtkCellRenderer))
75#define GTK_CELL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER, GtkCellRendererClass))
76#define GTK_IS_CELL_RENDERER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER))
77#define GTK_IS_CELL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER))
78#define GTK_CELL_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER, GtkCellRendererClass))
79
80typedef struct _GtkCellRenderer GtkCellRenderer;
81typedef struct _GtkCellRendererPrivate GtkCellRendererPrivate;
82typedef struct _GtkCellRendererClass GtkCellRendererClass;
83typedef struct _GtkCellRendererClassPrivate GtkCellRendererClassPrivate;
84
85struct _GtkCellRenderer
86{
87 GInitiallyUnowned parent_instance;
88
89 /*< private >*/
90 GtkCellRendererPrivate *priv;
91};
92
93/**
94 * GtkCellRendererClass:
95 * @get_request_mode: Called to gets whether the cell renderer prefers
96 * a height-for-width layout or a width-for-height layout.
97 * @get_preferred_width: Called to get a renderer’s natural width.
98 * @get_preferred_height_for_width: Called to get a renderer’s natural height for width.
99 * @get_preferred_height: Called to get a renderer’s natural height.
100 * @get_preferred_width_for_height: Called to get a renderer’s natural width for height.
101 * @get_aligned_area: Called to get the aligned area used by @cell inside @cell_area.
102 * @snapshot: Called to snapshot the content of the `GtkCellRenderer`.
103 * @activate: Called to activate the content of the `GtkCellRenderer`.
104 * @start_editing: Called to initiate editing the content of the `GtkCellRenderer`.
105 * @editing_canceled: Signal gets emitted when the user cancels the process of editing a cell.
106 * @editing_started: Signal gets emitted when a cell starts to be edited.
107 */
108struct _GtkCellRendererClass
109{
110 /*< private >*/
111 GInitiallyUnownedClass parent_class;
112
113 /*< public >*/
114
115 /* vtable - not signals */
116 GtkSizeRequestMode (* get_request_mode) (GtkCellRenderer *cell);
117 void (* get_preferred_width) (GtkCellRenderer *cell,
118 GtkWidget *widget,
119 int *minimum_size,
120 int *natural_size);
121 void (* get_preferred_height_for_width) (GtkCellRenderer *cell,
122 GtkWidget *widget,
123 int width,
124 int *minimum_height,
125 int *natural_height);
126 void (* get_preferred_height) (GtkCellRenderer *cell,
127 GtkWidget *widget,
128 int *minimum_size,
129 int *natural_size);
130 void (* get_preferred_width_for_height) (GtkCellRenderer *cell,
131 GtkWidget *widget,
132 int height,
133 int *minimum_width,
134 int *natural_width);
135 void (* get_aligned_area) (GtkCellRenderer *cell,
136 GtkWidget *widget,
137 GtkCellRendererState flags,
138 const GdkRectangle *cell_area,
139 GdkRectangle *aligned_area);
140 void (* snapshot) (GtkCellRenderer *cell,
141 GtkSnapshot *snapshot,
142 GtkWidget *widget,
143 const GdkRectangle *background_area,
144 const GdkRectangle *cell_area,
145 GtkCellRendererState flags);
146 gboolean (* activate) (GtkCellRenderer *cell,
147 GdkEvent *event,
148 GtkWidget *widget,
149 const char *path,
150 const GdkRectangle *background_area,
151 const GdkRectangle *cell_area,
152 GtkCellRendererState flags);
153 GtkCellEditable * (* start_editing) (GtkCellRenderer *cell,
154 GdkEvent *event,
155 GtkWidget *widget,
156 const char *path,
157 const GdkRectangle *background_area,
158 const GdkRectangle *cell_area,
159 GtkCellRendererState flags);
160
161 /* Signals */
162 void (* editing_canceled) (GtkCellRenderer *cell);
163 void (* editing_started) (GtkCellRenderer *cell,
164 GtkCellEditable *editable,
165 const char *path);
166
167 /*< private >*/
168 gpointer padding[8];
169};
170
171GDK_AVAILABLE_IN_ALL
172GType gtk_cell_renderer_get_type (void) G_GNUC_CONST;
173
174GDK_AVAILABLE_IN_ALL
175GtkSizeRequestMode gtk_cell_renderer_get_request_mode (GtkCellRenderer *cell);
176GDK_AVAILABLE_IN_ALL
177void gtk_cell_renderer_get_preferred_width (GtkCellRenderer *cell,
178 GtkWidget *widget,
179 int *minimum_size,
180 int *natural_size);
181GDK_AVAILABLE_IN_ALL
182void gtk_cell_renderer_get_preferred_height_for_width (GtkCellRenderer *cell,
183 GtkWidget *widget,
184 int width,
185 int *minimum_height,
186 int *natural_height);
187GDK_AVAILABLE_IN_ALL
188void gtk_cell_renderer_get_preferred_height (GtkCellRenderer *cell,
189 GtkWidget *widget,
190 int *minimum_size,
191 int *natural_size);
192GDK_AVAILABLE_IN_ALL
193void gtk_cell_renderer_get_preferred_width_for_height (GtkCellRenderer *cell,
194 GtkWidget *widget,
195 int height,
196 int *minimum_width,
197 int *natural_width);
198GDK_AVAILABLE_IN_ALL
199void gtk_cell_renderer_get_preferred_size (GtkCellRenderer *cell,
200 GtkWidget *widget,
201 GtkRequisition *minimum_size,
202 GtkRequisition *natural_size);
203GDK_AVAILABLE_IN_ALL
204void gtk_cell_renderer_get_aligned_area (GtkCellRenderer *cell,
205 GtkWidget *widget,
206 GtkCellRendererState flags,
207 const GdkRectangle *cell_area,
208 GdkRectangle *aligned_area);
209GDK_AVAILABLE_IN_ALL
210void gtk_cell_renderer_snapshot (GtkCellRenderer *cell,
211 GtkSnapshot *snapshot,
212 GtkWidget *widget,
213 const GdkRectangle *background_area,
214 const GdkRectangle *cell_area,
215 GtkCellRendererState flags);
216GDK_AVAILABLE_IN_ALL
217gboolean gtk_cell_renderer_activate (GtkCellRenderer *cell,
218 GdkEvent *event,
219 GtkWidget *widget,
220 const char *path,
221 const GdkRectangle *background_area,
222 const GdkRectangle *cell_area,
223 GtkCellRendererState flags);
224GDK_AVAILABLE_IN_ALL
225GtkCellEditable *gtk_cell_renderer_start_editing (GtkCellRenderer *cell,
226 GdkEvent *event,
227 GtkWidget *widget,
228 const char *path,
229 const GdkRectangle *background_area,
230 const GdkRectangle *cell_area,
231 GtkCellRendererState flags);
232
233GDK_AVAILABLE_IN_ALL
234void gtk_cell_renderer_set_fixed_size (GtkCellRenderer *cell,
235 int width,
236 int height);
237GDK_AVAILABLE_IN_ALL
238void gtk_cell_renderer_get_fixed_size (GtkCellRenderer *cell,
239 int *width,
240 int *height);
241
242GDK_AVAILABLE_IN_ALL
243void gtk_cell_renderer_set_alignment (GtkCellRenderer *cell,
244 float xalign,
245 float yalign);
246GDK_AVAILABLE_IN_ALL
247void gtk_cell_renderer_get_alignment (GtkCellRenderer *cell,
248 float *xalign,
249 float *yalign);
250
251GDK_AVAILABLE_IN_ALL
252void gtk_cell_renderer_set_padding (GtkCellRenderer *cell,
253 int xpad,
254 int ypad);
255GDK_AVAILABLE_IN_ALL
256void gtk_cell_renderer_get_padding (GtkCellRenderer *cell,
257 int *xpad,
258 int *ypad);
259
260GDK_AVAILABLE_IN_ALL
261void gtk_cell_renderer_set_visible (GtkCellRenderer *cell,
262 gboolean visible);
263GDK_AVAILABLE_IN_ALL
264gboolean gtk_cell_renderer_get_visible (GtkCellRenderer *cell);
265
266GDK_AVAILABLE_IN_ALL
267void gtk_cell_renderer_set_sensitive (GtkCellRenderer *cell,
268 gboolean sensitive);
269GDK_AVAILABLE_IN_ALL
270gboolean gtk_cell_renderer_get_sensitive (GtkCellRenderer *cell);
271
272GDK_AVAILABLE_IN_ALL
273gboolean gtk_cell_renderer_is_activatable (GtkCellRenderer *cell);
274
275GDK_AVAILABLE_IN_ALL
276void gtk_cell_renderer_set_is_expander (GtkCellRenderer *cell,
277 gboolean is_expander);
278GDK_AVAILABLE_IN_ALL
279gboolean gtk_cell_renderer_get_is_expander (GtkCellRenderer *cell);
280
281GDK_AVAILABLE_IN_ALL
282void gtk_cell_renderer_set_is_expanded (GtkCellRenderer *cell,
283 gboolean is_expanded);
284GDK_AVAILABLE_IN_ALL
285gboolean gtk_cell_renderer_get_is_expanded (GtkCellRenderer *cell);
286
287
288
289
290/* For use by cell renderer implementations only */
291GDK_AVAILABLE_IN_ALL
292void gtk_cell_renderer_stop_editing (GtkCellRenderer *cell,
293 gboolean canceled);
294
295
296void _gtk_cell_renderer_calc_offset (GtkCellRenderer *cell,
297 const GdkRectangle *cell_area,
298 GtkTextDirection direction,
299 int width,
300 int height,
301 int *x_offset,
302 int *y_offset);
303
304GDK_AVAILABLE_IN_ALL
305GtkStateFlags gtk_cell_renderer_get_state (GtkCellRenderer *cell,
306 GtkWidget *widget,
307 GtkCellRendererState cell_state);
308
309G_END_DECLS
310
311#endif /* __GTK_CELL_RENDERER_H__ */
312

source code of gtk/gtk/gtkcellrenderer.h