1// Package gtk was automatically generated by github.com/bnema/puregotk DO NOT EDIT
2package gtk
3
4import (
5 "structs"
6 "unsafe"
7
8 "github.com/ebitengine/purego"
9
10 "github.com/bnema/puregotk/pkg/core"
11 "github.com/bnema/puregotk/v4/gdk"
12 "github.com/bnema/puregotk/v4/glib"
13 "github.com/bnema/puregotk/v4/gobject"
14 "github.com/bnema/puregotk/v4/gobject/types"
15)
16
17type CellRendererClass struct {
18 _ structs.HostLayout
19
20 ParentClass gobject.InitiallyUnownedClass
21
22 xGetRequestMode uintptr
23
24 xGetPreferredWidth uintptr
25
26 xGetPreferredHeightForWidth uintptr
27
28 xGetPreferredHeight uintptr
29
30 xGetPreferredWidthForHeight uintptr
31
32 xGetAlignedArea uintptr
33
34 xSnapshot uintptr
35
36 xActivate uintptr
37
38 xStartEditing uintptr
39
40 xEditingCanceled uintptr
41
42 xEditingStarted uintptr
43
44 Padding [8]uintptr
45}
46
47func (x *CellRendererClass) GoPointer() uintptr {
48 return uintptr(unsafe.Pointer(x))
49}
50
51// OverrideGetRequestMode sets the "get_request_mode" callback function.
52// Called to gets whether the cell renderer prefers
53//
54// a height-for-width layout or a width-for-height layout.
55func (x *CellRendererClass) OverrideGetRequestMode(cb func(*CellRenderer) SizeRequestMode) {
56 if cb == nil {
57 x.xGetRequestMode = 0
58 } else {
59 x.xGetRequestMode = purego.NewCallback(func(CellVarp uintptr) SizeRequestMode {
60 return cb(CellRendererNewFromInternalPtr(CellVarp))
61 })
62 }
63}
64
65// GetGetRequestMode gets the "get_request_mode" callback function.
66// Called to gets whether the cell renderer prefers
67//
68// a height-for-width layout or a width-for-height layout.
69func (x *CellRendererClass) GetGetRequestMode() func(*CellRenderer) SizeRequestMode {
70 if x.xGetRequestMode == 0 {
71 return nil
72 }
73 var rawCallback func(CellVarp uintptr) SizeRequestMode
74 purego.RegisterFunc(&rawCallback, x.xGetRequestMode)
75 return func(CellVar *CellRenderer) SizeRequestMode {
76 return rawCallback(CellVar.GoPointer())
77 }
78}
79
80// OverrideGetPreferredWidth sets the "get_preferred_width" callback function.
81// Called to get a renderer’s natural width.
82func (x *CellRendererClass) OverrideGetPreferredWidth(cb func(*CellRenderer, *Widget, *int, *int)) {
83 if cb == nil {
84 x.xGetPreferredWidth = 0
85 } else {
86 x.xGetPreferredWidth = purego.NewCallback(func(CellVarp uintptr, WidgetVarp uintptr, MinimumSizeVarp *int, NaturalSizeVarp *int) {
87 cb(CellRendererNewFromInternalPtr(CellVarp), WidgetNewFromInternalPtr(WidgetVarp), MinimumSizeVarp, NaturalSizeVarp)
88 })
89 }
90}
91
92// GetGetPreferredWidth gets the "get_preferred_width" callback function.
93// Called to get a renderer’s natural width.
94func (x *CellRendererClass) GetGetPreferredWidth() func(*CellRenderer, *Widget, *int, *int) {
95 if x.xGetPreferredWidth == 0 {
96 return nil
97 }
98 var rawCallback func(CellVarp uintptr, WidgetVarp uintptr, MinimumSizeVarp *int, NaturalSizeVarp *int)
99 purego.RegisterFunc(&rawCallback, x.xGetPreferredWidth)
100 return func(CellVar *CellRenderer, WidgetVar *Widget, MinimumSizeVar *int, NaturalSizeVar *int) {
101 rawCallback(CellVar.GoPointer(), WidgetVar.GoPointer(), MinimumSizeVar, NaturalSizeVar)
102 }
103}
104
105// OverrideGetPreferredHeightForWidth sets the "get_preferred_height_for_width" callback function.
106// Called to get a renderer’s natural height for width.
107func (x *CellRendererClass) OverrideGetPreferredHeightForWidth(cb func(*CellRenderer, *Widget, int, *int, *int)) {
108 if cb == nil {
109 x.xGetPreferredHeightForWidth = 0
110 } else {
111 x.xGetPreferredHeightForWidth = purego.NewCallback(func(CellVarp uintptr, WidgetVarp uintptr, WidthVarp int, MinimumHeightVarp *int, NaturalHeightVarp *int) {
112 cb(CellRendererNewFromInternalPtr(CellVarp), WidgetNewFromInternalPtr(WidgetVarp), WidthVarp, MinimumHeightVarp, NaturalHeightVarp)
113 })
114 }
115}
116
117// GetGetPreferredHeightForWidth gets the "get_preferred_height_for_width" callback function.
118// Called to get a renderer’s natural height for width.
119func (x *CellRendererClass) GetGetPreferredHeightForWidth() func(*CellRenderer, *Widget, int, *int, *int) {
120 if x.xGetPreferredHeightForWidth == 0 {
121 return nil
122 }
123 var rawCallback func(CellVarp uintptr, WidgetVarp uintptr, WidthVarp int, MinimumHeightVarp *int, NaturalHeightVarp *int)
124 purego.RegisterFunc(&rawCallback, x.xGetPreferredHeightForWidth)
125 return func(CellVar *CellRenderer, WidgetVar *Widget, WidthVar int, MinimumHeightVar *int, NaturalHeightVar *int) {
126 rawCallback(CellVar.GoPointer(), WidgetVar.GoPointer(), WidthVar, MinimumHeightVar, NaturalHeightVar)
127 }
128}
129
130// OverrideGetPreferredHeight sets the "get_preferred_height" callback function.
131// Called to get a renderer’s natural height.
132func (x *CellRendererClass) OverrideGetPreferredHeight(cb func(*CellRenderer, *Widget, *int, *int)) {
133 if cb == nil {
134 x.xGetPreferredHeight = 0
135 } else {
136 x.xGetPreferredHeight = purego.NewCallback(func(CellVarp uintptr, WidgetVarp uintptr, MinimumSizeVarp *int, NaturalSizeVarp *int) {
137 cb(CellRendererNewFromInternalPtr(CellVarp), WidgetNewFromInternalPtr(WidgetVarp), MinimumSizeVarp, NaturalSizeVarp)
138 })
139 }
140}
141
142// GetGetPreferredHeight gets the "get_preferred_height" callback function.
143// Called to get a renderer’s natural height.
144func (x *CellRendererClass) GetGetPreferredHeight() func(*CellRenderer, *Widget, *int, *int) {
145 if x.xGetPreferredHeight == 0 {
146 return nil
147 }
148 var rawCallback func(CellVarp uintptr, WidgetVarp uintptr, MinimumSizeVarp *int, NaturalSizeVarp *int)
149 purego.RegisterFunc(&rawCallback, x.xGetPreferredHeight)
150 return func(CellVar *CellRenderer, WidgetVar *Widget, MinimumSizeVar *int, NaturalSizeVar *int) {
151 rawCallback(CellVar.GoPointer(), WidgetVar.GoPointer(), MinimumSizeVar, NaturalSizeVar)
152 }
153}
154
155// OverrideGetPreferredWidthForHeight sets the "get_preferred_width_for_height" callback function.
156// Called to get a renderer’s natural width for height.
157func (x *CellRendererClass) OverrideGetPreferredWidthForHeight(cb func(*CellRenderer, *Widget, int, *int, *int)) {
158 if cb == nil {
159 x.xGetPreferredWidthForHeight = 0
160 } else {
161 x.xGetPreferredWidthForHeight = purego.NewCallback(func(CellVarp uintptr, WidgetVarp uintptr, HeightVarp int, MinimumWidthVarp *int, NaturalWidthVarp *int) {
162 cb(CellRendererNewFromInternalPtr(CellVarp), WidgetNewFromInternalPtr(WidgetVarp), HeightVarp, MinimumWidthVarp, NaturalWidthVarp)
163 })
164 }
165}
166
167// GetGetPreferredWidthForHeight gets the "get_preferred_width_for_height" callback function.
168// Called to get a renderer’s natural width for height.
169func (x *CellRendererClass) GetGetPreferredWidthForHeight() func(*CellRenderer, *Widget, int, *int, *int) {
170 if x.xGetPreferredWidthForHeight == 0 {
171 return nil
172 }
173 var rawCallback func(CellVarp uintptr, WidgetVarp uintptr, HeightVarp int, MinimumWidthVarp *int, NaturalWidthVarp *int)
174 purego.RegisterFunc(&rawCallback, x.xGetPreferredWidthForHeight)
175 return func(CellVar *CellRenderer, WidgetVar *Widget, HeightVar int, MinimumWidthVar *int, NaturalWidthVar *int) {
176 rawCallback(CellVar.GoPointer(), WidgetVar.GoPointer(), HeightVar, MinimumWidthVar, NaturalWidthVar)
177 }
178}
179
180// OverrideGetAlignedArea sets the "get_aligned_area" callback function.
181// Called to get the aligned area used by @cell inside @cell_area.
182func (x *CellRendererClass) OverrideGetAlignedArea(cb func(*CellRenderer, *Widget, CellRendererState, *gdk.Rectangle, *gdk.Rectangle)) {
183 if cb == nil {
184 x.xGetAlignedArea = 0
185 } else {
186 x.xGetAlignedArea = purego.NewCallback(func(CellVarp uintptr, WidgetVarp uintptr, FlagsVarp CellRendererState, CellAreaVarp *gdk.Rectangle, AlignedAreaVarp *gdk.Rectangle) {
187 cb(CellRendererNewFromInternalPtr(CellVarp), WidgetNewFromInternalPtr(WidgetVarp), FlagsVarp, CellAreaVarp, AlignedAreaVarp)
188 })
189 }
190}
191
192// GetGetAlignedArea gets the "get_aligned_area" callback function.
193// Called to get the aligned area used by @cell inside @cell_area.
194func (x *CellRendererClass) GetGetAlignedArea() func(*CellRenderer, *Widget, CellRendererState, *gdk.Rectangle, *gdk.Rectangle) {
195 if x.xGetAlignedArea == 0 {
196 return nil
197 }
198 var rawCallback func(CellVarp uintptr, WidgetVarp uintptr, FlagsVarp CellRendererState, CellAreaVarp *gdk.Rectangle, AlignedAreaVarp *gdk.Rectangle)
199 purego.RegisterFunc(&rawCallback, x.xGetAlignedArea)
200 return func(CellVar *CellRenderer, WidgetVar *Widget, FlagsVar CellRendererState, CellAreaVar *gdk.Rectangle, AlignedAreaVar *gdk.Rectangle) {
201 rawCallback(CellVar.GoPointer(), WidgetVar.GoPointer(), FlagsVar, CellAreaVar, AlignedAreaVar)
202 }
203}
204
205// OverrideSnapshot sets the "snapshot" callback function.
206// Called to snapshot the content of the `GtkCellRenderer`.
207func (x *CellRendererClass) OverrideSnapshot(cb func(*CellRenderer, *Snapshot, *Widget, *gdk.Rectangle, *gdk.Rectangle, CellRendererState)) {
208 if cb == nil {
209 x.xSnapshot = 0
210 } else {
211 x.xSnapshot = purego.NewCallback(func(CellVarp uintptr, SnapshotVarp uintptr, WidgetVarp uintptr, BackgroundAreaVarp *gdk.Rectangle, CellAreaVarp *gdk.Rectangle, FlagsVarp CellRendererState) {
212 cb(CellRendererNewFromInternalPtr(CellVarp), SnapshotNewFromInternalPtr(SnapshotVarp), WidgetNewFromInternalPtr(WidgetVarp), BackgroundAreaVarp, CellAreaVarp, FlagsVarp)
213 })
214 }
215}
216
217// GetSnapshot gets the "snapshot" callback function.
218// Called to snapshot the content of the `GtkCellRenderer`.
219func (x *CellRendererClass) GetSnapshot() func(*CellRenderer, *Snapshot, *Widget, *gdk.Rectangle, *gdk.Rectangle, CellRendererState) {
220 if x.xSnapshot == 0 {
221 return nil
222 }
223 var rawCallback func(CellVarp uintptr, SnapshotVarp uintptr, WidgetVarp uintptr, BackgroundAreaVarp *gdk.Rectangle, CellAreaVarp *gdk.Rectangle, FlagsVarp CellRendererState)
224 purego.RegisterFunc(&rawCallback, x.xSnapshot)
225 return func(CellVar *CellRenderer, SnapshotVar *Snapshot, WidgetVar *Widget, BackgroundAreaVar *gdk.Rectangle, CellAreaVar *gdk.Rectangle, FlagsVar CellRendererState) {
226 rawCallback(CellVar.GoPointer(), SnapshotVar.GoPointer(), WidgetVar.GoPointer(), BackgroundAreaVar, CellAreaVar, FlagsVar)
227 }
228}
229
230// OverrideActivate sets the "activate" callback function.
231// Called to activate the content of the `GtkCellRenderer`.
232func (x *CellRendererClass) OverrideActivate(cb func(*CellRenderer, *gdk.Event, *Widget, string, *gdk.Rectangle, *gdk.Rectangle, CellRendererState) bool) {
233 if cb == nil {
234 x.xActivate = 0
235 } else {
236 x.xActivate = purego.NewCallback(func(CellVarp uintptr, EventVarp uintptr, WidgetVarp uintptr, PathVarp string, BackgroundAreaVarp *gdk.Rectangle, CellAreaVarp *gdk.Rectangle, FlagsVarp CellRendererState) bool {
237 return cb(CellRendererNewFromInternalPtr(CellVarp), gdk.EventNewFromInternalPtr(EventVarp), WidgetNewFromInternalPtr(WidgetVarp), PathVarp, BackgroundAreaVarp, CellAreaVarp, FlagsVarp)
238 })
239 }
240}
241
242// GetActivate gets the "activate" callback function.
243// Called to activate the content of the `GtkCellRenderer`.
244func (x *CellRendererClass) GetActivate() func(*CellRenderer, *gdk.Event, *Widget, string, *gdk.Rectangle, *gdk.Rectangle, CellRendererState) bool {
245 if x.xActivate == 0 {
246 return nil
247 }
248 var rawCallback func(CellVarp uintptr, EventVarp uintptr, WidgetVarp uintptr, PathVarp string, BackgroundAreaVarp *gdk.Rectangle, CellAreaVarp *gdk.Rectangle, FlagsVarp CellRendererState) bool
249 purego.RegisterFunc(&rawCallback, x.xActivate)
250 return func(CellVar *CellRenderer, EventVar *gdk.Event, WidgetVar *Widget, PathVar string, BackgroundAreaVar *gdk.Rectangle, CellAreaVar *gdk.Rectangle, FlagsVar CellRendererState) bool {
251 return rawCallback(CellVar.GoPointer(), EventVar.GoPointer(), WidgetVar.GoPointer(), PathVar, BackgroundAreaVar, CellAreaVar, FlagsVar)
252 }
253}
254
255// OverrideStartEditing sets the "start_editing" callback function.
256// Called to initiate editing the content of the `GtkCellRenderer`.
257func (x *CellRendererClass) OverrideStartEditing(cb func(*CellRenderer, *gdk.Event, *Widget, string, *gdk.Rectangle, *gdk.Rectangle, CellRendererState) *CellEditableBase) {
258 if cb == nil {
259 x.xStartEditing = 0
260 } else {
261 x.xStartEditing = purego.NewCallback(func(CellVarp uintptr, EventVarp uintptr, WidgetVarp uintptr, PathVarp string, BackgroundAreaVarp *gdk.Rectangle, CellAreaVarp *gdk.Rectangle, FlagsVarp CellRendererState) uintptr {
262 ret := cb(CellRendererNewFromInternalPtr(CellVarp), gdk.EventNewFromInternalPtr(EventVarp), WidgetNewFromInternalPtr(WidgetVarp), PathVarp, BackgroundAreaVarp, CellAreaVarp, FlagsVarp)
263 if ret == nil {
264 return 0
265 }
266 return ret.GoPointer()
267 })
268 }
269}
270
271// GetStartEditing gets the "start_editing" callback function.
272// Called to initiate editing the content of the `GtkCellRenderer`.
273func (x *CellRendererClass) GetStartEditing() func(*CellRenderer, *gdk.Event, *Widget, string, *gdk.Rectangle, *gdk.Rectangle, CellRendererState) *CellEditableBase {
274 if x.xStartEditing == 0 {
275 return nil
276 }
277 var rawCallback func(CellVarp uintptr, EventVarp uintptr, WidgetVarp uintptr, PathVarp string, BackgroundAreaVarp *gdk.Rectangle, CellAreaVarp *gdk.Rectangle, FlagsVarp CellRendererState) uintptr
278 purego.RegisterFunc(&rawCallback, x.xStartEditing)
279 return func(CellVar *CellRenderer, EventVar *gdk.Event, WidgetVar *Widget, PathVar string, BackgroundAreaVar *gdk.Rectangle, CellAreaVar *gdk.Rectangle, FlagsVar CellRendererState) *CellEditableBase {
280 rawRet := rawCallback(CellVar.GoPointer(), EventVar.GoPointer(), WidgetVar.GoPointer(), PathVar, BackgroundAreaVar, CellAreaVar, FlagsVar)
281 if rawRet == 0 {
282 return nil
283 }
284 ret := &CellEditableBase{}
285 ret.Ptr = rawRet
286 return ret
287 }
288}
289
290// OverrideEditingCanceled sets the "editing_canceled" callback function.
291// Signal gets emitted when the user cancels the process of editing a cell.
292func (x *CellRendererClass) OverrideEditingCanceled(cb func(*CellRenderer)) {
293 if cb == nil {
294 x.xEditingCanceled = 0
295 } else {
296 x.xEditingCanceled = purego.NewCallback(func(CellVarp uintptr) {
297 cb(CellRendererNewFromInternalPtr(CellVarp))
298 })
299 }
300}
301
302// GetEditingCanceled gets the "editing_canceled" callback function.
303// Signal gets emitted when the user cancels the process of editing a cell.
304func (x *CellRendererClass) GetEditingCanceled() func(*CellRenderer) {
305 if x.xEditingCanceled == 0 {
306 return nil
307 }
308 var rawCallback func(CellVarp uintptr)
309 purego.RegisterFunc(&rawCallback, x.xEditingCanceled)
310 return func(CellVar *CellRenderer) {
311 rawCallback(CellVar.GoPointer())
312 }
313}
314
315// OverrideEditingStarted sets the "editing_started" callback function.
316// Signal gets emitted when a cell starts to be edited.
317func (x *CellRendererClass) OverrideEditingStarted(cb func(*CellRenderer, CellEditable, string)) {
318 if cb == nil {
319 x.xEditingStarted = 0
320 } else {
321 x.xEditingStarted = purego.NewCallback(func(CellVarp uintptr, EditableVarp uintptr, PathVarp string) {
322 cb(CellRendererNewFromInternalPtr(CellVarp), &CellEditableBase{Ptr: EditableVarp}, PathVarp)
323 })
324 }
325}
326
327// GetEditingStarted gets the "editing_started" callback function.
328// Signal gets emitted when a cell starts to be edited.
329func (x *CellRendererClass) GetEditingStarted() func(*CellRenderer, CellEditable, string) {
330 if x.xEditingStarted == 0 {
331 return nil
332 }
333 var rawCallback func(CellVarp uintptr, EditableVarp uintptr, PathVarp string)
334 purego.RegisterFunc(&rawCallback, x.xEditingStarted)
335 return func(CellVar *CellRenderer, EditableVar CellEditable, PathVar string) {
336 rawCallback(CellVar.GoPointer(), EditableVar.GoPointer(), PathVar)
337 }
338}
339
340type CellRendererClassPrivate struct {
341 _ structs.HostLayout
342}
343
344func (x *CellRendererClassPrivate) GoPointer() uintptr {
345 return uintptr(unsafe.Pointer(x))
346}
347
348type CellRendererPrivate struct {
349 _ structs.HostLayout
350}
351
352func (x *CellRendererPrivate) GoPointer() uintptr {
353 return uintptr(unsafe.Pointer(x))
354}
355
356// Tells how a cell is to be rendered.
357type CellRendererState int
358
359var xCellRendererStateGLibType func() types.GType
360
361func CellRendererStateGLibType() types.GType {
362 return xCellRendererStateGLibType()
363}
364
365const (
366
367 // The cell is currently selected, and
368 // probably has a selection colored background to render to.
369 CellRendererSelectedValue CellRendererState = 1
370 // The mouse is hovering over the cell.
371 CellRendererPrelitValue CellRendererState = 2
372 // The cell is drawn in an insensitive manner
373 CellRendererInsensitiveValue CellRendererState = 4
374 // The cell is in a sorted row
375 CellRendererSortedValue CellRendererState = 8
376 // The cell is in the focus row.
377 CellRendererFocusedValue CellRendererState = 16
378 // The cell is in a row that can be expanded
379 CellRendererExpandableValue CellRendererState = 32
380 // The cell is in a row that is expanded
381 CellRendererExpandedValue CellRendererState = 64
382)
383
384// Identifies how the user can interact with a particular cell.
385type CellRendererMode int
386
387var xCellRendererModeGLibType func() types.GType
388
389func CellRendererModeGLibType() types.GType {
390 return xCellRendererModeGLibType()
391}
392
393const (
394
395 // The cell is just for display
396 // and cannot be interacted with. Note that this doesn’t mean that eg. the
397 // row being drawn can’t be selected -- just that a particular element of
398 // it cannot be individually modified.
399 CellRendererModeInertValue CellRendererMode = 0
400 // The cell can be clicked.
401 CellRendererModeActivatableValue CellRendererMode = 1
402 // The cell can be edited or otherwise modified.
403 CellRendererModeEditableValue CellRendererMode = 2
404)
405
406// An object for rendering a single cell
407//
408// The `GtkCellRenderer` is a base class of a set of objects used for
409// rendering a cell to a `cairo_t`. These objects are used primarily by
410// the `GtkTreeView` widget, though they aren’t tied to them in any
411// specific way. It is worth noting that `GtkCellRenderer` is not a
412// `GtkWidget` and cannot be treated as such.
413//
414// The primary use of a `GtkCellRenderer` is for drawing a certain graphical
415// elements on a `cairo_t`. Typically, one cell renderer is used to
416// draw many cells on the screen. To this extent, it isn’t expected that a
417// CellRenderer keep any permanent state around. Instead, any state is set
418// just prior to use using `GObject`s property system. Then, the
419// cell is measured using gtk_cell_renderer_get_preferred_size(). Finally, the cell
420// is rendered in the correct location using gtk_cell_renderer_snapshot().
421//
422// There are a number of rules that must be followed when writing a new
423// `GtkCellRenderer`. First and foremost, it’s important that a certain set
424// of properties will always yield a cell renderer of the same size,
425// barring a style change. The `GtkCellRenderer` also has a number of
426// generic properties that are expected to be honored by all children.
427//
428// Beyond merely rendering a cell, cell renderers can optionally
429// provide active user interface elements. A cell renderer can be
430// “activatable” like `GtkCellRenderer`Toggle,
431// which toggles when it gets activated by a mouse click, or it can be
432// “editable” like `GtkCellRenderer`Text, which
433// allows the user to edit the text using a widget implementing the
434// `GtkCellEditable` interface, e.g. `GtkEntry`.
435// To make a cell renderer activatable or editable, you have to
436// implement the `GtkCellRenderer`Class.activate or
437// `GtkCellRenderer`Class.start_editing virtual functions, respectively.
438//
439// Many properties of `GtkCellRenderer` and its subclasses have a
440// corresponding “set” property, e.g. “cell-background-set” corresponds
441// to “cell-background”. These “set” properties reflect whether a property
442// has been set or not. You should not set them independently.
443type CellRenderer struct {
444 gobject.InitiallyUnowned
445}
446
447var xCellRendererGLibType func() types.GType
448
449func CellRendererGLibType() types.GType {
450 return xCellRendererGLibType()
451}
452
453func CellRendererNewFromInternalPtr(ptr uintptr) *CellRenderer {
454 cls := &CellRenderer{}
455 cls.Ptr = ptr
456 return cls
457}
458
459var xCellRendererActivate func(uintptr, uintptr, uintptr, string, *gdk.Rectangle, *gdk.Rectangle, CellRendererState) bool
460
461// Passes an activate event to the cell renderer for possible processing.
462// Some cell renderers may use events; for example, `GtkCellRendererToggle`
463// toggles when it gets a mouse click.
464func (x *CellRenderer) Activate(EventVar *gdk.Event, WidgetVar *Widget, PathVar string, BackgroundAreaVar *gdk.Rectangle, CellAreaVar *gdk.Rectangle, FlagsVar CellRendererState) bool {
465
466 cret := xCellRendererActivate(x.GoPointer(), EventVar.GoPointer(), WidgetVar.GoPointer(), PathVar, BackgroundAreaVar, CellAreaVar, FlagsVar)
467 return cret
468}
469
470var xCellRendererGetAlignedArea func(uintptr, uintptr, CellRendererState, *gdk.Rectangle, *gdk.Rectangle)
471
472// Gets the aligned area used by @cell inside @cell_area. Used for finding
473// the appropriate edit and focus rectangle.
474func (x *CellRenderer) GetAlignedArea(WidgetVar *Widget, FlagsVar CellRendererState, CellAreaVar *gdk.Rectangle, AlignedAreaVar *gdk.Rectangle) {
475
476 xCellRendererGetAlignedArea(x.GoPointer(), WidgetVar.GoPointer(), FlagsVar, CellAreaVar, AlignedAreaVar)
477
478}
479
480var xCellRendererGetAlignment func(uintptr, *float32, *float32)
481
482// Fills in @xalign and @yalign with the appropriate values of @cell.
483func (x *CellRenderer) GetAlignment(XalignVar *float32, YalignVar *float32) {
484
485 xCellRendererGetAlignment(x.GoPointer(), XalignVar, YalignVar)
486
487}
488
489var xCellRendererGetFixedSize func(uintptr, *int, *int)
490
491// Fills in @width and @height with the appropriate size of @cell.
492func (x *CellRenderer) GetFixedSize(WidthVar *int, HeightVar *int) {
493
494 xCellRendererGetFixedSize(x.GoPointer(), WidthVar, HeightVar)
495
496}
497
498var xCellRendererGetIsExpanded func(uintptr) bool
499
500// Checks whether the given `GtkCellRenderer` is expanded.
501func (x *CellRenderer) GetIsExpanded() bool {
502
503 cret := xCellRendererGetIsExpanded(x.GoPointer())
504 return cret
505}
506
507var xCellRendererGetIsExpander func(uintptr) bool
508
509// Checks whether the given `GtkCellRenderer` is an expander.
510func (x *CellRenderer) GetIsExpander() bool {
511
512 cret := xCellRendererGetIsExpander(x.GoPointer())
513 return cret
514}
515
516var xCellRendererGetPadding func(uintptr, *int, *int)
517
518// Fills in @xpad and @ypad with the appropriate values of @cell.
519func (x *CellRenderer) GetPadding(XpadVar *int, YpadVar *int) {
520
521 xCellRendererGetPadding(x.GoPointer(), XpadVar, YpadVar)
522
523}
524
525var xCellRendererGetPreferredHeight func(uintptr, uintptr, *int, *int)
526
527// Retrieves a renderer’s natural size when rendered to @widget.
528func (x *CellRenderer) GetPreferredHeight(WidgetVar *Widget, MinimumSizeVar *int, NaturalSizeVar *int) {
529
530 xCellRendererGetPreferredHeight(x.GoPointer(), WidgetVar.GoPointer(), MinimumSizeVar, NaturalSizeVar)
531
532}
533
534var xCellRendererGetPreferredHeightForWidth func(uintptr, uintptr, int, *int, *int)
535
536// Retrieves a cell renderers’s minimum and natural height if it were rendered to
537// @widget with the specified @width.
538func (x *CellRenderer) GetPreferredHeightForWidth(WidgetVar *Widget, WidthVar int, MinimumHeightVar *int, NaturalHeightVar *int) {
539
540 xCellRendererGetPreferredHeightForWidth(x.GoPointer(), WidgetVar.GoPointer(), WidthVar, MinimumHeightVar, NaturalHeightVar)
541
542}
543
544var xCellRendererGetPreferredSize func(uintptr, uintptr, *Requisition, *Requisition)
545
546// Retrieves the minimum and natural size of a cell taking
547// into account the widget’s preference for height-for-width management.
548func (x *CellRenderer) GetPreferredSize(WidgetVar *Widget, MinimumSizeVar *Requisition, NaturalSizeVar *Requisition) {
549
550 xCellRendererGetPreferredSize(x.GoPointer(), WidgetVar.GoPointer(), MinimumSizeVar, NaturalSizeVar)
551
552}
553
554var xCellRendererGetPreferredWidth func(uintptr, uintptr, *int, *int)
555
556// Retrieves a renderer’s natural size when rendered to @widget.
557func (x *CellRenderer) GetPreferredWidth(WidgetVar *Widget, MinimumSizeVar *int, NaturalSizeVar *int) {
558
559 xCellRendererGetPreferredWidth(x.GoPointer(), WidgetVar.GoPointer(), MinimumSizeVar, NaturalSizeVar)
560
561}
562
563var xCellRendererGetPreferredWidthForHeight func(uintptr, uintptr, int, *int, *int)
564
565// Retrieves a cell renderers’s minimum and natural width if it were rendered to
566// @widget with the specified @height.
567func (x *CellRenderer) GetPreferredWidthForHeight(WidgetVar *Widget, HeightVar int, MinimumWidthVar *int, NaturalWidthVar *int) {
568
569 xCellRendererGetPreferredWidthForHeight(x.GoPointer(), WidgetVar.GoPointer(), HeightVar, MinimumWidthVar, NaturalWidthVar)
570
571}
572
573var xCellRendererGetRequestMode func(uintptr) SizeRequestMode
574
575// Gets whether the cell renderer prefers a height-for-width layout
576// or a width-for-height layout.
577func (x *CellRenderer) GetRequestMode() SizeRequestMode {
578
579 cret := xCellRendererGetRequestMode(x.GoPointer())
580 return cret
581}
582
583var xCellRendererGetSensitive func(uintptr) bool
584
585// Returns the cell renderer’s sensitivity.
586func (x *CellRenderer) GetSensitive() bool {
587
588 cret := xCellRendererGetSensitive(x.GoPointer())
589 return cret
590}
591
592var xCellRendererGetState func(uintptr, uintptr, CellRendererState) StateFlags
593
594// Translates the cell renderer state to `GtkStateFlags`,
595// based on the cell renderer and widget sensitivity, and
596// the given `GtkCellRenderer`State.
597func (x *CellRenderer) GetState(WidgetVar *Widget, CellStateVar CellRendererState) StateFlags {
598
599 cret := xCellRendererGetState(x.GoPointer(), WidgetVar.GoPointer(), CellStateVar)
600 return cret
601}
602
603var xCellRendererGetVisible func(uintptr) bool
604
605// Returns the cell renderer’s visibility.
606func (x *CellRenderer) GetVisible() bool {
607
608 cret := xCellRendererGetVisible(x.GoPointer())
609 return cret
610}
611
612var xCellRendererIsActivatable func(uintptr) bool
613
614// Checks whether the cell renderer can do something when activated.
615func (x *CellRenderer) IsActivatable() bool {
616
617 cret := xCellRendererIsActivatable(x.GoPointer())
618 return cret
619}
620
621var xCellRendererSetAlignment func(uintptr, float32, float32)
622
623// Sets the renderer’s alignment within its available space.
624func (x *CellRenderer) SetAlignment(XalignVar float32, YalignVar float32) {
625
626 xCellRendererSetAlignment(x.GoPointer(), XalignVar, YalignVar)
627
628}
629
630var xCellRendererSetFixedSize func(uintptr, int, int)
631
632// Sets the renderer size to be explicit, independent of the properties set.
633func (x *CellRenderer) SetFixedSize(WidthVar int, HeightVar int) {
634
635 xCellRendererSetFixedSize(x.GoPointer(), WidthVar, HeightVar)
636
637}
638
639var xCellRendererSetIsExpanded func(uintptr, bool)
640
641// Sets whether the given `GtkCellRenderer` is expanded.
642func (x *CellRenderer) SetIsExpanded(IsExpandedVar bool) {
643
644 xCellRendererSetIsExpanded(x.GoPointer(), IsExpandedVar)
645
646}
647
648var xCellRendererSetIsExpander func(uintptr, bool)
649
650// Sets whether the given `GtkCellRenderer` is an expander.
651func (x *CellRenderer) SetIsExpander(IsExpanderVar bool) {
652
653 xCellRendererSetIsExpander(x.GoPointer(), IsExpanderVar)
654
655}
656
657var xCellRendererSetPadding func(uintptr, int, int)
658
659// Sets the renderer’s padding.
660func (x *CellRenderer) SetPadding(XpadVar int, YpadVar int) {
661
662 xCellRendererSetPadding(x.GoPointer(), XpadVar, YpadVar)
663
664}
665
666var xCellRendererSetSensitive func(uintptr, bool)
667
668// Sets the cell renderer’s sensitivity.
669func (x *CellRenderer) SetSensitive(SensitiveVar bool) {
670
671 xCellRendererSetSensitive(x.GoPointer(), SensitiveVar)
672
673}
674
675var xCellRendererSetVisible func(uintptr, bool)
676
677// Sets the cell renderer’s visibility.
678func (x *CellRenderer) SetVisible(VisibleVar bool) {
679
680 xCellRendererSetVisible(x.GoPointer(), VisibleVar)
681
682}
683
684var xCellRendererSnapshot func(uintptr, uintptr, uintptr, *gdk.Rectangle, *gdk.Rectangle, CellRendererState)
685
686// Invokes the virtual render function of the `GtkCellRenderer`. The three
687// passed-in rectangles are areas in @cr. Most renderers will draw within
688// @cell_area; the xalign, yalign, xpad, and ypad fields of the `GtkCellRenderer`
689// should be honored with respect to @cell_area. @background_area includes the
690// blank space around the cell, and also the area containing the tree expander;
691// so the @background_area rectangles for all cells tile to cover the entire
692// @window.
693func (x *CellRenderer) Snapshot(SnapshotVar *Snapshot, WidgetVar *Widget, BackgroundAreaVar *gdk.Rectangle, CellAreaVar *gdk.Rectangle, FlagsVar CellRendererState) {
694
695 xCellRendererSnapshot(x.GoPointer(), SnapshotVar.GoPointer(), WidgetVar.GoPointer(), BackgroundAreaVar, CellAreaVar, FlagsVar)
696
697}
698
699var xCellRendererStartEditing func(uintptr, uintptr, uintptr, string, *gdk.Rectangle, *gdk.Rectangle, CellRendererState) uintptr
700
701// Starts editing the contents of this @cell, through a new `GtkCellEditable`
702// widget created by the `GtkCellRenderer`Class.start_editing virtual function.
703func (x *CellRenderer) StartEditing(EventVar *gdk.Event, WidgetVar *Widget, PathVar string, BackgroundAreaVar *gdk.Rectangle, CellAreaVar *gdk.Rectangle, FlagsVar CellRendererState) *CellEditableBase {
704 var cls *CellEditableBase
705
706 cret := xCellRendererStartEditing(x.GoPointer(), EventVar.GoPointer(), WidgetVar.GoPointer(), PathVar, BackgroundAreaVar, CellAreaVar, FlagsVar)
707
708 if cret == 0 {
709 return nil
710 }
711 gobject.IncreaseRef(cret)
712 cls = &CellEditableBase{}
713 cls.Ptr = cret
714 return cls
715}
716
717var xCellRendererStopEditing func(uintptr, bool)
718
719// Informs the cell renderer that the editing is stopped.
720// If @canceled is %TRUE, the cell renderer will emit the
721// `GtkCellRenderer`::editing-canceled signal.
722//
723// This function should be called by cell renderer implementations
724// in response to the `GtkCellEditable::editing-done` signal of
725// `GtkCellEditable`.
726func (x *CellRenderer) StopEditing(CanceledVar bool) {
727
728 xCellRendererStopEditing(x.GoPointer(), CanceledVar)
729
730}
731
732func (c *CellRenderer) GoPointer() uintptr {
733 if c == nil {
734 return 0
735 }
736 return c.Ptr
737}
738
739func (c *CellRenderer) SetGoPointer(ptr uintptr) {
740 c.Ptr = ptr
741}
742
743// SetPropertyCellBackground sets the "cell-background" property.
744func (x *CellRenderer) SetPropertyCellBackground(value string) {
745 var v gobject.Value
746 v.Init(gobject.TypeStringVal)
747 v.SetString(&value)
748 x.SetProperty("cell-background", &v)
749}
750
751// SetPropertyCellBackgroundRgba sets the "cell-background-rgba" property.
752// Cell background as a `GdkRGBA`
753func (x *CellRenderer) SetPropertyCellBackgroundRgba(value uintptr) {
754 var v gobject.Value
755 v.Init(gobject.TypePointerVal)
756 v.SetPointer(value)
757 x.SetProperty("cell-background-rgba", &v)
758}
759
760// GetPropertyCellBackgroundRgba gets the "cell-background-rgba" property.
761// Cell background as a `GdkRGBA`
762func (x *CellRenderer) GetPropertyCellBackgroundRgba() uintptr {
763 var v gobject.Value
764 x.GetProperty("cell-background-rgba", &v)
765 return v.GetPointer()
766}
767
768// SetPropertyCellBackgroundSet sets the "cell-background-set" property.
769func (x *CellRenderer) SetPropertyCellBackgroundSet(value bool) {
770 var v gobject.Value
771 v.Init(gobject.TypeBooleanVal)
772 v.SetBoolean(value)
773 x.SetProperty("cell-background-set", &v)
774}
775
776// GetPropertyCellBackgroundSet gets the "cell-background-set" property.
777func (x *CellRenderer) GetPropertyCellBackgroundSet() bool {
778 var v gobject.Value
779 x.GetProperty("cell-background-set", &v)
780 return v.GetBoolean()
781}
782
783// GetPropertyEditing gets the "editing" property.
784func (x *CellRenderer) GetPropertyEditing() bool {
785 var v gobject.Value
786 x.GetProperty("editing", &v)
787 return v.GetBoolean()
788}
789
790// SetPropertyHeight sets the "height" property.
791func (x *CellRenderer) SetPropertyHeight(value int) {
792 var v gobject.Value
793 v.Init(gobject.TypeIntVal)
794 v.SetInt(value)
795 x.SetProperty("height", &v)
796}
797
798// GetPropertyHeight gets the "height" property.
799func (x *CellRenderer) GetPropertyHeight() int {
800 var v gobject.Value
801 x.GetProperty("height", &v)
802 return v.GetInt()
803}
804
805// SetPropertyIsExpanded sets the "is-expanded" property.
806func (x *CellRenderer) SetPropertyIsExpanded(value bool) {
807 var v gobject.Value
808 v.Init(gobject.TypeBooleanVal)
809 v.SetBoolean(value)
810 x.SetProperty("is-expanded", &v)
811}
812
813// GetPropertyIsExpanded gets the "is-expanded" property.
814func (x *CellRenderer) GetPropertyIsExpanded() bool {
815 var v gobject.Value
816 x.GetProperty("is-expanded", &v)
817 return v.GetBoolean()
818}
819
820// SetPropertyIsExpander sets the "is-expander" property.
821func (x *CellRenderer) SetPropertyIsExpander(value bool) {
822 var v gobject.Value
823 v.Init(gobject.TypeBooleanVal)
824 v.SetBoolean(value)
825 x.SetProperty("is-expander", &v)
826}
827
828// GetPropertyIsExpander gets the "is-expander" property.
829func (x *CellRenderer) GetPropertyIsExpander() bool {
830 var v gobject.Value
831 x.GetProperty("is-expander", &v)
832 return v.GetBoolean()
833}
834
835// SetPropertySensitive sets the "sensitive" property.
836func (x *CellRenderer) SetPropertySensitive(value bool) {
837 var v gobject.Value
838 v.Init(gobject.TypeBooleanVal)
839 v.SetBoolean(value)
840 x.SetProperty("sensitive", &v)
841}
842
843// GetPropertySensitive gets the "sensitive" property.
844func (x *CellRenderer) GetPropertySensitive() bool {
845 var v gobject.Value
846 x.GetProperty("sensitive", &v)
847 return v.GetBoolean()
848}
849
850// SetPropertyVisible sets the "visible" property.
851func (x *CellRenderer) SetPropertyVisible(value bool) {
852 var v gobject.Value
853 v.Init(gobject.TypeBooleanVal)
854 v.SetBoolean(value)
855 x.SetProperty("visible", &v)
856}
857
858// GetPropertyVisible gets the "visible" property.
859func (x *CellRenderer) GetPropertyVisible() bool {
860 var v gobject.Value
861 x.GetProperty("visible", &v)
862 return v.GetBoolean()
863}
864
865// SetPropertyWidth sets the "width" property.
866func (x *CellRenderer) SetPropertyWidth(value int) {
867 var v gobject.Value
868 v.Init(gobject.TypeIntVal)
869 v.SetInt(value)
870 x.SetProperty("width", &v)
871}
872
873// GetPropertyWidth gets the "width" property.
874func (x *CellRenderer) GetPropertyWidth() int {
875 var v gobject.Value
876 x.GetProperty("width", &v)
877 return v.GetInt()
878}
879
880// SetPropertyXalign sets the "xalign" property.
881func (x *CellRenderer) SetPropertyXalign(value float32) {
882 var v gobject.Value
883 v.Init(gobject.TypeFloatVal)
884 v.SetFloat(value)
885 x.SetProperty("xalign", &v)
886}
887
888// GetPropertyXalign gets the "xalign" property.
889func (x *CellRenderer) GetPropertyXalign() float32 {
890 var v gobject.Value
891 x.GetProperty("xalign", &v)
892 return v.GetFloat()
893}
894
895// SetPropertyXpad sets the "xpad" property.
896func (x *CellRenderer) SetPropertyXpad(value uint) {
897 var v gobject.Value
898 v.Init(gobject.TypeUintVal)
899 v.SetUint(value)
900 x.SetProperty("xpad", &v)
901}
902
903// GetPropertyXpad gets the "xpad" property.
904func (x *CellRenderer) GetPropertyXpad() uint {
905 var v gobject.Value
906 x.GetProperty("xpad", &v)
907 return v.GetUint()
908}
909
910// SetPropertyYalign sets the "yalign" property.
911func (x *CellRenderer) SetPropertyYalign(value float32) {
912 var v gobject.Value
913 v.Init(gobject.TypeFloatVal)
914 v.SetFloat(value)
915 x.SetProperty("yalign", &v)
916}
917
918// GetPropertyYalign gets the "yalign" property.
919func (x *CellRenderer) GetPropertyYalign() float32 {
920 var v gobject.Value
921 x.GetProperty("yalign", &v)
922 return v.GetFloat()
923}
924
925// SetPropertyYpad sets the "ypad" property.
926func (x *CellRenderer) SetPropertyYpad(value uint) {
927 var v gobject.Value
928 v.Init(gobject.TypeUintVal)
929 v.SetUint(value)
930 x.SetProperty("ypad", &v)
931}
932
933// GetPropertyYpad gets the "ypad" property.
934func (x *CellRenderer) GetPropertyYpad() uint {
935 var v gobject.Value
936 x.GetProperty("ypad", &v)
937 return v.GetUint()
938}
939
940// This signal gets emitted when the user cancels the process of editing a
941// cell. For example, an editable cell renderer could be written to cancel
942// editing when the user presses Escape.
943//
944// See also: gtk_cell_renderer_stop_editing().
945func (x *CellRenderer) ConnectEditingCanceled(cb *func(CellRenderer)) uint {
946 cbPtr := uintptr(unsafe.Pointer(cb))
947 if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
948 handlerID := gobject.SignalConnect(x.GoPointer(), "editing-canceled", cbRefPtr)
949 glib.SaveHandlerMapping(handlerID, cbPtr)
950 return handlerID
951 }
952
953 fcb := func(clsPtr uintptr) {
954 fa := CellRenderer{}
955 fa.Ptr = clsPtr
956 cbFn := *cb
957
958 cbFn(fa)
959
960 }
961 cbRefPtr := purego.NewCallback(fcb)
962 glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
963 handlerID := gobject.SignalConnect(x.GoPointer(), "editing-canceled", cbRefPtr)
964 glib.SaveHandlerMapping(handlerID, cbPtr)
965 return handlerID
966}
967
968// This signal gets emitted when a cell starts to be edited.
969// The intended use of this signal is to do special setup
970// on @editable, e.g. adding a `GtkEntryCompletion` or setting
971// up additional columns in a `GtkComboBox`.
972//
973// See gtk_cell_editable_start_editing() for information on the lifecycle of
974// the @editable and a way to do setup that doesn’t depend on the @renderer.
975//
976// Note that GTK doesn't guarantee that cell renderers will
977// continue to use the same kind of widget for editing in future
978// releases, therefore you should check the type of @editable
979// before doing any specific setup, as in the following example:
980//
981// ```c
982// static void
983// text_editing_started (GtkCellRenderer *cell,
984//
985// GtkCellEditable *editable,
986// const char *path,
987// gpointer data)
988//
989// {
990// if (GTK_IS_ENTRY (editable))
991// {
992// GtkEntry *entry = GTK_ENTRY (editable);
993//
994// // ... create a GtkEntryCompletion
995//
996// gtk_entry_set_completion (entry, completion);
997// }
998// }
999//
1000// ```
1001func (x *CellRenderer) ConnectEditingStarted(cb *func(CellRenderer, uintptr, string)) uint {
1002 cbPtr := uintptr(unsafe.Pointer(cb))
1003 if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
1004 handlerID := gobject.SignalConnect(x.GoPointer(), "editing-started", cbRefPtr)
1005 glib.SaveHandlerMapping(handlerID, cbPtr)
1006 return handlerID
1007 }
1008
1009 fcb := func(clsPtr uintptr, EditableVarp uintptr, PathVarp uintptr) {
1010 fa := CellRenderer{}
1011 fa.Ptr = clsPtr
1012 cbFn := *cb
1013
1014 cbFn(fa, EditableVarp, core.GoString(PathVarp))
1015
1016 }
1017 cbRefPtr := purego.NewCallback(fcb)
1018 glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
1019 handlerID := gobject.SignalConnect(x.GoPointer(), "editing-started", cbRefPtr)
1020 glib.SaveHandlerMapping(handlerID, cbPtr)
1021 return handlerID
1022}
1023
1024func init() {
1025 core.SetPackageName("GTK", "gtk4")
1026 core.SetSharedLibraries("GTK", []string{"libgtk-4.so.1"})
1027 var libs []uintptr
1028 for _, libPath := range core.GetPaths("GTK") {
1029 lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
1030 if err != nil {
1031 panic(err)
1032 }
1033 libs = append(libs, lib)
1034 }
1035
1036 core.PuregoSafeRegister(&xCellRendererStateGLibType, libs, "gtk_cell_renderer_state_get_type")
1037
1038 core.PuregoSafeRegister(&xCellRendererModeGLibType, libs, "gtk_cell_renderer_mode_get_type")
1039
1040 core.PuregoSafeRegister(&xCellRendererGLibType, libs, "gtk_cell_renderer_get_type")
1041
1042 core.PuregoSafeRegister(&xCellRendererActivate, libs, "gtk_cell_renderer_activate")
1043 core.PuregoSafeRegister(&xCellRendererGetAlignedArea, libs, "gtk_cell_renderer_get_aligned_area")
1044 core.PuregoSafeRegister(&xCellRendererGetAlignment, libs, "gtk_cell_renderer_get_alignment")
1045 core.PuregoSafeRegister(&xCellRendererGetFixedSize, libs, "gtk_cell_renderer_get_fixed_size")
1046 core.PuregoSafeRegister(&xCellRendererGetIsExpanded, libs, "gtk_cell_renderer_get_is_expanded")
1047 core.PuregoSafeRegister(&xCellRendererGetIsExpander, libs, "gtk_cell_renderer_get_is_expander")
1048 core.PuregoSafeRegister(&xCellRendererGetPadding, libs, "gtk_cell_renderer_get_padding")
1049 core.PuregoSafeRegister(&xCellRendererGetPreferredHeight, libs, "gtk_cell_renderer_get_preferred_height")
1050 core.PuregoSafeRegister(&xCellRendererGetPreferredHeightForWidth, libs, "gtk_cell_renderer_get_preferred_height_for_width")
1051 core.PuregoSafeRegister(&xCellRendererGetPreferredSize, libs, "gtk_cell_renderer_get_preferred_size")
1052 core.PuregoSafeRegister(&xCellRendererGetPreferredWidth, libs, "gtk_cell_renderer_get_preferred_width")
1053 core.PuregoSafeRegister(&xCellRendererGetPreferredWidthForHeight, libs, "gtk_cell_renderer_get_preferred_width_for_height")
1054 core.PuregoSafeRegister(&xCellRendererGetRequestMode, libs, "gtk_cell_renderer_get_request_mode")
1055 core.PuregoSafeRegister(&xCellRendererGetSensitive, libs, "gtk_cell_renderer_get_sensitive")
1056 core.PuregoSafeRegister(&xCellRendererGetState, libs, "gtk_cell_renderer_get_state")
1057 core.PuregoSafeRegister(&xCellRendererGetVisible, libs, "gtk_cell_renderer_get_visible")
1058 core.PuregoSafeRegister(&xCellRendererIsActivatable, libs, "gtk_cell_renderer_is_activatable")
1059 core.PuregoSafeRegister(&xCellRendererSetAlignment, libs, "gtk_cell_renderer_set_alignment")
1060 core.PuregoSafeRegister(&xCellRendererSetFixedSize, libs, "gtk_cell_renderer_set_fixed_size")
1061 core.PuregoSafeRegister(&xCellRendererSetIsExpanded, libs, "gtk_cell_renderer_set_is_expanded")
1062 core.PuregoSafeRegister(&xCellRendererSetIsExpander, libs, "gtk_cell_renderer_set_is_expander")
1063 core.PuregoSafeRegister(&xCellRendererSetPadding, libs, "gtk_cell_renderer_set_padding")
1064 core.PuregoSafeRegister(&xCellRendererSetSensitive, libs, "gtk_cell_renderer_set_sensitive")
1065 core.PuregoSafeRegister(&xCellRendererSetVisible, libs, "gtk_cell_renderer_set_visible")
1066 core.PuregoSafeRegister(&xCellRendererSnapshot, libs, "gtk_cell_renderer_snapshot")
1067 core.PuregoSafeRegister(&xCellRendererStartEditing, libs, "gtk_cell_renderer_start_editing")
1068 core.PuregoSafeRegister(&xCellRendererStopEditing, libs, "gtk_cell_renderer_stop_editing")
1069
1070}