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/glib"
12 "github.com/bnema/puregotk/v4/gobject"
13 "github.com/bnema/puregotk/v4/gobject/types"
14)
15
16// The virtual table for `GtkSorter`.
17type SorterClass struct {
18 _ structs.HostLayout
19
20 ParentClass gobject.ObjectClass
21
22 xCompare uintptr
23
24 xGetOrder uintptr
25
26 xGtkReserved1 uintptr
27
28 xGtkReserved2 uintptr
29
30 xGtkReserved3 uintptr
31
32 xGtkReserved4 uintptr
33
34 xGtkReserved5 uintptr
35
36 xGtkReserved6 uintptr
37
38 xGtkReserved7 uintptr
39
40 xGtkReserved8 uintptr
41}
42
43func (x *SorterClass) GoPointer() uintptr {
44 return uintptr(unsafe.Pointer(x))
45}
46
47// OverrideCompare sets the "compare" callback function.
48// Compare two items. See gtk_sorter_compare() for details.
49func (x *SorterClass) OverrideCompare(cb func(*Sorter, *gobject.Object, *gobject.Object) Ordering) {
50 if cb == nil {
51 x.xCompare = 0
52 } else {
53 x.xCompare = purego.NewCallback(func(SelfVarp uintptr, Item1Varp uintptr, Item2Varp uintptr) Ordering {
54 return cb(SorterNewFromInternalPtr(SelfVarp), gobject.ObjectNewFromInternalPtr(Item1Varp), gobject.ObjectNewFromInternalPtr(Item2Varp))
55 })
56 }
57}
58
59// GetCompare gets the "compare" callback function.
60// Compare two items. See gtk_sorter_compare() for details.
61func (x *SorterClass) GetCompare() func(*Sorter, *gobject.Object, *gobject.Object) Ordering {
62 if x.xCompare == 0 {
63 return nil
64 }
65 var rawCallback func(SelfVarp uintptr, Item1Varp uintptr, Item2Varp uintptr) Ordering
66 purego.RegisterFunc(&rawCallback, x.xCompare)
67 return func(SelfVar *Sorter, Item1Var *gobject.Object, Item2Var *gobject.Object) Ordering {
68 return rawCallback(SelfVar.GoPointer(), Item1Var.GoPointer(), Item2Var.GoPointer())
69 }
70}
71
72// OverrideGetOrder sets the "get_order" callback function.
73// Get the `GtkSorderOrder` that applies to the current sorter.
74//
75// If unimplemented, it returns %GTK_SORTER_ORDER_PARTIAL.
76func (x *SorterClass) OverrideGetOrder(cb func(*Sorter) SorterOrder) {
77 if cb == nil {
78 x.xGetOrder = 0
79 } else {
80 x.xGetOrder = purego.NewCallback(func(SelfVarp uintptr) SorterOrder {
81 return cb(SorterNewFromInternalPtr(SelfVarp))
82 })
83 }
84}
85
86// GetGetOrder gets the "get_order" callback function.
87// Get the `GtkSorderOrder` that applies to the current sorter.
88//
89// If unimplemented, it returns %GTK_SORTER_ORDER_PARTIAL.
90func (x *SorterClass) GetGetOrder() func(*Sorter) SorterOrder {
91 if x.xGetOrder == 0 {
92 return nil
93 }
94 var rawCallback func(SelfVarp uintptr) SorterOrder
95 purego.RegisterFunc(&rawCallback, x.xGetOrder)
96 return func(SelfVar *Sorter) SorterOrder {
97 return rawCallback(SelfVar.GoPointer())
98 }
99}
100
101// OverrideGtkReserved1 sets the "_gtk_reserved1" callback function.
102func (x *SorterClass) OverrideGtkReserved1(cb func()) {
103 if cb == nil {
104 x.xGtkReserved1 = 0
105 } else {
106 x.xGtkReserved1 = purego.NewCallback(func() {
107 cb()
108 })
109 }
110}
111
112// GetGtkReserved1 gets the "_gtk_reserved1" callback function.
113func (x *SorterClass) GetGtkReserved1() func() {
114 if x.xGtkReserved1 == 0 {
115 return nil
116 }
117 var rawCallback func()
118 purego.RegisterFunc(&rawCallback, x.xGtkReserved1)
119 return func() {
120 rawCallback()
121 }
122}
123
124// OverrideGtkReserved2 sets the "_gtk_reserved2" callback function.
125func (x *SorterClass) OverrideGtkReserved2(cb func()) {
126 if cb == nil {
127 x.xGtkReserved2 = 0
128 } else {
129 x.xGtkReserved2 = purego.NewCallback(func() {
130 cb()
131 })
132 }
133}
134
135// GetGtkReserved2 gets the "_gtk_reserved2" callback function.
136func (x *SorterClass) GetGtkReserved2() func() {
137 if x.xGtkReserved2 == 0 {
138 return nil
139 }
140 var rawCallback func()
141 purego.RegisterFunc(&rawCallback, x.xGtkReserved2)
142 return func() {
143 rawCallback()
144 }
145}
146
147// OverrideGtkReserved3 sets the "_gtk_reserved3" callback function.
148func (x *SorterClass) OverrideGtkReserved3(cb func()) {
149 if cb == nil {
150 x.xGtkReserved3 = 0
151 } else {
152 x.xGtkReserved3 = purego.NewCallback(func() {
153 cb()
154 })
155 }
156}
157
158// GetGtkReserved3 gets the "_gtk_reserved3" callback function.
159func (x *SorterClass) GetGtkReserved3() func() {
160 if x.xGtkReserved3 == 0 {
161 return nil
162 }
163 var rawCallback func()
164 purego.RegisterFunc(&rawCallback, x.xGtkReserved3)
165 return func() {
166 rawCallback()
167 }
168}
169
170// OverrideGtkReserved4 sets the "_gtk_reserved4" callback function.
171func (x *SorterClass) OverrideGtkReserved4(cb func()) {
172 if cb == nil {
173 x.xGtkReserved4 = 0
174 } else {
175 x.xGtkReserved4 = purego.NewCallback(func() {
176 cb()
177 })
178 }
179}
180
181// GetGtkReserved4 gets the "_gtk_reserved4" callback function.
182func (x *SorterClass) GetGtkReserved4() func() {
183 if x.xGtkReserved4 == 0 {
184 return nil
185 }
186 var rawCallback func()
187 purego.RegisterFunc(&rawCallback, x.xGtkReserved4)
188 return func() {
189 rawCallback()
190 }
191}
192
193// OverrideGtkReserved5 sets the "_gtk_reserved5" callback function.
194func (x *SorterClass) OverrideGtkReserved5(cb func()) {
195 if cb == nil {
196 x.xGtkReserved5 = 0
197 } else {
198 x.xGtkReserved5 = purego.NewCallback(func() {
199 cb()
200 })
201 }
202}
203
204// GetGtkReserved5 gets the "_gtk_reserved5" callback function.
205func (x *SorterClass) GetGtkReserved5() func() {
206 if x.xGtkReserved5 == 0 {
207 return nil
208 }
209 var rawCallback func()
210 purego.RegisterFunc(&rawCallback, x.xGtkReserved5)
211 return func() {
212 rawCallback()
213 }
214}
215
216// OverrideGtkReserved6 sets the "_gtk_reserved6" callback function.
217func (x *SorterClass) OverrideGtkReserved6(cb func()) {
218 if cb == nil {
219 x.xGtkReserved6 = 0
220 } else {
221 x.xGtkReserved6 = purego.NewCallback(func() {
222 cb()
223 })
224 }
225}
226
227// GetGtkReserved6 gets the "_gtk_reserved6" callback function.
228func (x *SorterClass) GetGtkReserved6() func() {
229 if x.xGtkReserved6 == 0 {
230 return nil
231 }
232 var rawCallback func()
233 purego.RegisterFunc(&rawCallback, x.xGtkReserved6)
234 return func() {
235 rawCallback()
236 }
237}
238
239// OverrideGtkReserved7 sets the "_gtk_reserved7" callback function.
240func (x *SorterClass) OverrideGtkReserved7(cb func()) {
241 if cb == nil {
242 x.xGtkReserved7 = 0
243 } else {
244 x.xGtkReserved7 = purego.NewCallback(func() {
245 cb()
246 })
247 }
248}
249
250// GetGtkReserved7 gets the "_gtk_reserved7" callback function.
251func (x *SorterClass) GetGtkReserved7() func() {
252 if x.xGtkReserved7 == 0 {
253 return nil
254 }
255 var rawCallback func()
256 purego.RegisterFunc(&rawCallback, x.xGtkReserved7)
257 return func() {
258 rawCallback()
259 }
260}
261
262// OverrideGtkReserved8 sets the "_gtk_reserved8" callback function.
263func (x *SorterClass) OverrideGtkReserved8(cb func()) {
264 if cb == nil {
265 x.xGtkReserved8 = 0
266 } else {
267 x.xGtkReserved8 = purego.NewCallback(func() {
268 cb()
269 })
270 }
271}
272
273// GetGtkReserved8 gets the "_gtk_reserved8" callback function.
274func (x *SorterClass) GetGtkReserved8() func() {
275 if x.xGtkReserved8 == 0 {
276 return nil
277 }
278 var rawCallback func()
279 purego.RegisterFunc(&rawCallback, x.xGtkReserved8)
280 return func() {
281 rawCallback()
282 }
283}
284
285// Describes changes in a sorter in more detail and allows users
286// to optimize resorting.
287type SorterChange int
288
289var xSorterChangeGLibType func() types.GType
290
291func SorterChangeGLibType() types.GType {
292 return xSorterChangeGLibType()
293}
294
295const (
296
297 // The sorter change cannot be described
298 // by any of the other enumeration values
299 SorterChangeDifferentValue SorterChange = 0
300 // The sort order was inverted. Comparisons
301 // that returned %GTK_ORDERING_SMALLER now return %GTK_ORDERING_LARGER
302 // and vice versa. Other comparisons return the same values as before.
303 SorterChangeInvertedValue SorterChange = 1
304 // The sorter is less strict: Comparisons
305 // may now return %GTK_ORDERING_EQUAL that did not do so before.
306 SorterChangeLessStrictValue SorterChange = 2
307 // The sorter is more strict: Comparisons
308 // that did return %GTK_ORDERING_EQUAL may not do so anymore.
309 SorterChangeMoreStrictValue SorterChange = 3
310)
311
312// Describes the type of order that a `GtkSorter` may produce.
313type SorterOrder int
314
315var xSorterOrderGLibType func() types.GType
316
317func SorterOrderGLibType() types.GType {
318 return xSorterOrderGLibType()
319}
320
321const (
322
323 // A partial order. Any `GtkOrdering` is possible.
324 SorterOrderPartialValue SorterOrder = 0
325 // No order, all elements are considered equal.
326 // gtk_sorter_compare() will only return %GTK_ORDERING_EQUAL.
327 SorterOrderNoneValue SorterOrder = 1
328 // A total order. gtk_sorter_compare() will only
329 // return %GTK_ORDERING_EQUAL if an item is compared with itself. Two
330 // different items will never cause this value to be returned.
331 SorterOrderTotalValue SorterOrder = 2
332)
333
334// Describes sorting criteria for a [class@Gtk.SortListModel].
335//
336// Its primary user is [class@Gtk.SortListModel]
337//
338// The model will use a sorter to determine the order in which
339// its items should appear by calling [method@Gtk.Sorter.compare]
340// for pairs of items.
341//
342// Sorters may change their sorting behavior through their lifetime.
343// In that case, they will emit the [signal@Gtk.Sorter::changed] signal
344// to notify that the sort order is no longer valid and should be updated
345// by calling gtk_sorter_compare() again.
346//
347// GTK provides various pre-made sorter implementations for common sorting
348// operations. [class@Gtk.ColumnView] has built-in support for sorting lists
349// via the [property@Gtk.ColumnViewColumn:sorter] property, where the user can
350// change the sorting by clicking on list headers.
351//
352// Of course, in particular for large lists, it is also possible to subclass
353// `GtkSorter` and provide one's own sorter.
354type Sorter struct {
355 gobject.Object
356}
357
358var xSorterGLibType func() types.GType
359
360func SorterGLibType() types.GType {
361 return xSorterGLibType()
362}
363
364func SorterNewFromInternalPtr(ptr uintptr) *Sorter {
365 cls := &Sorter{}
366 cls.Ptr = ptr
367 return cls
368}
369
370var xSorterChanged func(uintptr, SorterChange)
371
372// Notifies all users of the sorter that it has changed.
373//
374// This emits the [signal@Gtk.Sorter::changed] signal. Users
375// of the sorter should then update the sort order via
376// [method@Gtk.Sorter.compare].
377//
378// Depending on the @change parameter, it may be possible to
379// update the sort order without a full resorting. Refer to
380// the [enum@Gtk.SorterChange] documentation for details.
381//
382// This function is intended for implementers of `GtkSorter`
383// subclasses and should not be called from other functions.
384func (x *Sorter) Changed(ChangeVar SorterChange) {
385
386 xSorterChanged(x.GoPointer(), ChangeVar)
387
388}
389
390var xSorterCompare func(uintptr, uintptr, uintptr) Ordering
391
392// Compares two given items according to the sort order implemented
393// by the sorter.
394//
395// Sorters implement a partial order:
396//
397// - It is reflexive, ie a = a
398// - It is antisymmetric, ie if a < b and b < a, then a = b
399// - It is transitive, ie given any 3 items with a ≤ b and b ≤ c,
400// then a ≤ c
401//
402// The sorter may signal it conforms to additional constraints
403// via the return value of [method@Gtk.Sorter.get_order].
404func (x *Sorter) Compare(Item1Var *gobject.Object, Item2Var *gobject.Object) Ordering {
405
406 cret := xSorterCompare(x.GoPointer(), Item1Var.GoPointer(), Item2Var.GoPointer())
407 return cret
408}
409
410var xSorterGetOrder func(uintptr) SorterOrder
411
412// Gets the order that @self conforms to.
413//
414// See [enum@Gtk.SorterOrder] for details
415// of the possible return values.
416//
417// This function is intended to allow optimizations.
418func (x *Sorter) GetOrder() SorterOrder {
419
420 cret := xSorterGetOrder(x.GoPointer())
421 return cret
422}
423
424func (c *Sorter) GoPointer() uintptr {
425 if c == nil {
426 return 0
427 }
428 return c.Ptr
429}
430
431func (c *Sorter) SetGoPointer(ptr uintptr) {
432 c.Ptr = ptr
433}
434
435// Emitted whenever the sorter changed.
436//
437// Users of the sorter should then update the sort order
438// again via gtk_sorter_compare().
439//
440// [class@Gtk.SortListModel] handles this signal automatically.
441//
442// Depending on the @change parameter, it may be possible to update
443// the sort order without a full resorting. Refer to the
444// [enum@Gtk.SorterChange] documentation for details.
445func (x *Sorter) ConnectChanged(cb *func(Sorter, SorterChange)) uint {
446 cbPtr := uintptr(unsafe.Pointer(cb))
447 if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
448 handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
449 glib.SaveHandlerMapping(handlerID, cbPtr)
450 return handlerID
451 }
452
453 fcb := func(clsPtr uintptr, ChangeVarp SorterChange) {
454 fa := Sorter{}
455 fa.Ptr = clsPtr
456 cbFn := *cb
457
458 cbFn(fa, ChangeVarp)
459
460 }
461 cbRefPtr := purego.NewCallback(fcb)
462 glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
463 handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
464 glib.SaveHandlerMapping(handlerID, cbPtr)
465 return handlerID
466}
467
468func init() {
469 core.SetPackageName("GTK", "gtk4")
470 core.SetSharedLibraries("GTK", []string{"libgtk-4.so.1"})
471 var libs []uintptr
472 for _, libPath := range core.GetPaths("GTK") {
473 lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
474 if err != nil {
475 panic(err)
476 }
477 libs = append(libs, lib)
478 }
479
480 core.PuregoSafeRegister(&xSorterChangeGLibType, libs, "gtk_sorter_change_get_type")
481
482 core.PuregoSafeRegister(&xSorterOrderGLibType, libs, "gtk_sorter_order_get_type")
483
484 core.PuregoSafeRegister(&xSorterGLibType, libs, "gtk_sorter_get_type")
485
486 core.PuregoSafeRegister(&xSorterChanged, libs, "gtk_sorter_changed")
487 core.PuregoSafeRegister(&xSorterCompare, libs, "gtk_sorter_compare")
488 core.PuregoSafeRegister(&xSorterGetOrder, libs, "gtk_sorter_get_order")
489
490}