1// Package gobject was automatically generated by github.com/bnema/puregotk DO NOT EDIT
2package gobject
3
4import (
5 "unsafe"
6
7 "github.com/ebitengine/purego"
8
9 "github.com/bnema/puregotk/pkg/core"
10 "github.com/bnema/puregotk/v4/glib"
11 "github.com/bnema/puregotk/v4/gobject/types"
12)
13
14// `GSignalGroup` manages a collection of signals on a `GObject`.
15//
16// `GSignalGroup` simplifies the process of connecting many signals to a `GObject`
17// as a group. As such there is no API to disconnect a signal from the group.
18//
19// In particular, this allows you to:
20//
21// - Change the target instance, which automatically causes disconnection
22// of the signals from the old instance and connecting to the new instance.
23// - Block and unblock signals as a group
24// - Ensuring that blocked state transfers across target instances.
25//
26// One place you might want to use such a structure is with `GtkTextView` and
27// `GtkTextBuffer`. Often times, you'll need to connect to many signals on
28// `GtkTextBuffer` from a `GtkTextView` subclass. This allows you to create a
29// signal group during instance construction, simply bind the
30// `GtkTextView:buffer` property to `GSignalGroup:target` and connect
31// all the signals you need. When the `GtkTextView:buffer` property changes
32// all of the signals will be transitioned correctly.
33type SignalGroup struct {
34 Object
35}
36
37var xSignalGroupGLibType func() types.GType
38
39func SignalGroupGLibType() types.GType {
40 return xSignalGroupGLibType()
41}
42
43func SignalGroupNewFromInternalPtr(ptr uintptr) *SignalGroup {
44 cls := &SignalGroup{}
45 cls.Ptr = ptr
46 return cls
47}
48
49var xNewSignalGroup func(types.GType) uintptr
50
51// Creates a new #GSignalGroup for target instances of @target_type.
52func NewSignalGroup(TargetTypeVar types.GType) *SignalGroup {
53 var cls *SignalGroup
54
55 cret := xNewSignalGroup(TargetTypeVar)
56
57 if cret == 0 {
58 return nil
59 }
60 cls = &SignalGroup{}
61 cls.Ptr = cret
62 return cls
63}
64
65var xSignalGroupBlock func(uintptr)
66
67// Blocks all signal handlers managed by @self so they will not
68// be called during any signal emissions. Must be unblocked exactly
69// the same number of times it has been blocked to become active again.
70//
71// This blocked state will be kept across changes of the target instance.
72func (x *SignalGroup) Block() {
73
74 xSignalGroupBlock(x.GoPointer())
75
76}
77
78var xSignalGroupConnect func(uintptr, string, uintptr, uintptr)
79
80// Connects @c_handler to the signal @detailed_signal
81// on the target instance of @self.
82//
83// You cannot connect a signal handler after #GSignalGroup:target has been set.
84func (x *SignalGroup) Connect(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr) {
85
86 var CHandlerVarRef uintptr
87 if CHandlerVar != nil {
88 CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
89 if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
90 CHandlerVarRef = cbRefPtr
91 } else {
92 fcb := func() {
93 cbFn := *CHandlerVar
94 cbFn()
95 }
96 CHandlerVarRef = purego.NewCallback(fcb)
97 glib.SaveCallbackWithClosure(CHandlerVarPtr, CHandlerVarRef, CHandlerVar)
98 }
99 }
100
101 xSignalGroupConnect(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar)
102
103}
104
105var xSignalGroupConnectAfter func(uintptr, string, uintptr, uintptr)
106
107// Connects @c_handler to the signal @detailed_signal
108// on the target instance of @self.
109//
110// The @c_handler will be called after the default handler of the signal.
111//
112// You cannot connect a signal handler after #GSignalGroup:target has been set.
113func (x *SignalGroup) ConnectAfter(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr) {
114
115 var CHandlerVarRef uintptr
116 if CHandlerVar != nil {
117 CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
118 if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
119 CHandlerVarRef = cbRefPtr
120 } else {
121 fcb := func() {
122 cbFn := *CHandlerVar
123 cbFn()
124 }
125 CHandlerVarRef = purego.NewCallback(fcb)
126 glib.SaveCallbackWithClosure(CHandlerVarPtr, CHandlerVarRef, CHandlerVar)
127 }
128 }
129
130 xSignalGroupConnectAfter(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar)
131
132}
133
134var xSignalGroupConnectClosure func(uintptr, string, *Closure, bool)
135
136// Connects @closure to the signal @detailed_signal on #GSignalGroup:target.
137//
138// You cannot connect a signal handler after #GSignalGroup:target has been set.
139func (x *SignalGroup) ConnectClosure(DetailedSignalVar string, ClosureVar *Closure, AfterVar bool) {
140
141 xSignalGroupConnectClosure(x.GoPointer(), DetailedSignalVar, ClosureVar, AfterVar)
142
143}
144
145var xSignalGroupConnectData func(uintptr, string, uintptr, uintptr, uintptr, ConnectFlags)
146
147// Connects @c_handler to the signal @detailed_signal
148// on the target instance of @self.
149//
150// You cannot connect a signal handler after #GSignalGroup:target has been set.
151func (x *SignalGroup) ConnectData(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr, NotifyVar *ClosureNotify, FlagsVar ConnectFlags) {
152
153 var CHandlerVarRef uintptr
154 if CHandlerVar != nil {
155 CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
156 if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
157 CHandlerVarRef = cbRefPtr
158 } else {
159 fcb := func() {
160 cbFn := *CHandlerVar
161 cbFn()
162 }
163 CHandlerVarRef = purego.NewCallback(fcb)
164 glib.SaveCallbackWithClosure(CHandlerVarPtr, CHandlerVarRef, CHandlerVar)
165 }
166 }
167
168 var NotifyVarRef uintptr
169 if NotifyVar != nil {
170 NotifyVarPtr := uintptr(unsafe.Pointer(NotifyVar))
171 if cbRefPtr, ok := glib.GetCallback(NotifyVarPtr); ok {
172 NotifyVarRef = cbRefPtr
173 } else {
174 fcb := func(arg0 uintptr, arg1 *Closure) {
175 cbFn := *NotifyVar
176 cbFn(arg0, arg1)
177 }
178 NotifyVarRef = purego.NewCallback(fcb)
179 glib.SaveCallbackWithClosure(NotifyVarPtr, NotifyVarRef, NotifyVar)
180 }
181 }
182
183 xSignalGroupConnectData(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar, NotifyVarRef, FlagsVar)
184
185}
186
187var xSignalGroupConnectObject func(uintptr, string, uintptr, uintptr, ConnectFlags)
188
189// Connects @c_handler to the signal @detailed_signal on #GSignalGroup:target.
190//
191// Ensures that the @object stays alive during the call to @c_handler
192// by temporarily adding a reference count. When the @object is destroyed
193// the signal handler will automatically be removed.
194//
195// You cannot connect a signal handler after #GSignalGroup:target has been set.
196func (x *SignalGroup) ConnectObject(DetailedSignalVar string, CHandlerVar *Callback, ObjectVar uintptr, FlagsVar ConnectFlags) {
197
198 var CHandlerVarRef uintptr
199 if CHandlerVar != nil {
200 CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
201 if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
202 CHandlerVarRef = cbRefPtr
203 } else {
204 fcb := func() {
205 cbFn := *CHandlerVar
206 cbFn()
207 }
208 CHandlerVarRef = purego.NewCallback(fcb)
209 glib.SaveCallbackWithClosure(CHandlerVarPtr, CHandlerVarRef, CHandlerVar)
210 }
211 }
212
213 xSignalGroupConnectObject(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, ObjectVar, FlagsVar)
214
215}
216
217var xSignalGroupConnectSwapped func(uintptr, string, uintptr, uintptr)
218
219// Connects @c_handler to the signal @detailed_signal
220// on the target instance of @self.
221//
222// The instance on which the signal is emitted and @data
223// will be swapped when calling @c_handler.
224//
225// You cannot connect a signal handler after #GSignalGroup:target has been set.
226func (x *SignalGroup) ConnectSwapped(DetailedSignalVar string, CHandlerVar *Callback, DataVar uintptr) {
227
228 var CHandlerVarRef uintptr
229 if CHandlerVar != nil {
230 CHandlerVarPtr := uintptr(unsafe.Pointer(CHandlerVar))
231 if cbRefPtr, ok := glib.GetCallback(CHandlerVarPtr); ok {
232 CHandlerVarRef = cbRefPtr
233 } else {
234 fcb := func() {
235 cbFn := *CHandlerVar
236 cbFn()
237 }
238 CHandlerVarRef = purego.NewCallback(fcb)
239 glib.SaveCallbackWithClosure(CHandlerVarPtr, CHandlerVarRef, CHandlerVar)
240 }
241 }
242
243 xSignalGroupConnectSwapped(x.GoPointer(), DetailedSignalVar, CHandlerVarRef, DataVar)
244
245}
246
247var xSignalGroupDupTarget func(uintptr) uintptr
248
249// Gets the target instance used when connecting signals.
250func (x *SignalGroup) DupTarget() *Object {
251 var cls *Object
252
253 cret := xSignalGroupDupTarget(x.GoPointer())
254
255 if cret == 0 {
256 return nil
257 }
258 cls = &Object{}
259 cls.Ptr = cret
260 return cls
261}
262
263var xSignalGroupSetTarget func(uintptr, uintptr)
264
265// Sets the target instance used when connecting signals. Any signal
266// that has been registered with g_signal_group_connect_object() or
267// similar functions will be connected to this object.
268//
269// If the target instance was previously set, signals will be
270// disconnected from that object prior to connecting to @target.
271func (x *SignalGroup) SetTarget(TargetVar *Object) {
272
273 xSignalGroupSetTarget(x.GoPointer(), TargetVar.GoPointer())
274
275}
276
277var xSignalGroupUnblock func(uintptr)
278
279// Unblocks all signal handlers managed by @self so they will be
280// called again during any signal emissions unless it is blocked
281// again. Must be unblocked exactly the same number of times it
282// has been blocked to become active again.
283func (x *SignalGroup) Unblock() {
284
285 xSignalGroupUnblock(x.GoPointer())
286
287}
288
289func (c *SignalGroup) GoPointer() uintptr {
290 if c == nil {
291 return 0
292 }
293 return c.Ptr
294}
295
296func (c *SignalGroup) SetGoPointer(ptr uintptr) {
297 c.Ptr = ptr
298}
299
300// This signal is emitted when #GSignalGroup:target is set to a new value
301// other than %NULL. It is similar to #GObject::notify on `target` except it
302// will not emit when #GSignalGroup:target is %NULL and also allows for
303// receiving the #GObject without a data-race.
304func (x *SignalGroup) ConnectBind(cb *func(SignalGroup, uintptr)) uint {
305 cbPtr := uintptr(unsafe.Pointer(cb))
306 if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
307 handlerID := SignalConnect(x.GoPointer(), "bind", cbRefPtr)
308 glib.SaveHandlerMapping(handlerID, cbPtr)
309 return handlerID
310 }
311
312 fcb := func(clsPtr uintptr, InstanceVarp uintptr) {
313 fa := SignalGroup{}
314 fa.Ptr = clsPtr
315 cbFn := *cb
316
317 cbFn(fa, InstanceVarp)
318
319 }
320 cbRefPtr := purego.NewCallback(fcb)
321 glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
322 handlerID := SignalConnect(x.GoPointer(), "bind", cbRefPtr)
323 glib.SaveHandlerMapping(handlerID, cbPtr)
324 return handlerID
325}
326
327// This signal is emitted when the target instance of @self is set to a
328// new #GObject.
329//
330// This signal will only be emitted if the previous target of @self is
331// non-%NULL.
332func (x *SignalGroup) ConnectUnbind(cb *func(SignalGroup)) uint {
333 cbPtr := uintptr(unsafe.Pointer(cb))
334 if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
335 handlerID := SignalConnect(x.GoPointer(), "unbind", cbRefPtr)
336 glib.SaveHandlerMapping(handlerID, cbPtr)
337 return handlerID
338 }
339
340 fcb := func(clsPtr uintptr) {
341 fa := SignalGroup{}
342 fa.Ptr = clsPtr
343 cbFn := *cb
344
345 cbFn(fa)
346
347 }
348 cbRefPtr := purego.NewCallback(fcb)
349 glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
350 handlerID := SignalConnect(x.GoPointer(), "unbind", cbRefPtr)
351 glib.SaveHandlerMapping(handlerID, cbPtr)
352 return handlerID
353}
354
355func init() {
356 core.SetPackageName("GOBJECT", "gobject-2.0")
357 core.SetSharedLibraries("GOBJECT", []string{"libgobject-2.0.so.0"})
358 var libs []uintptr
359 for _, libPath := range core.GetPaths("GOBJECT") {
360 lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
361 if err != nil {
362 panic(err)
363 }
364 libs = append(libs, lib)
365 }
366
367 core.PuregoSafeRegister(&xSignalGroupGLibType, libs, "g_signal_group_get_type")
368
369 core.PuregoSafeRegister(&xNewSignalGroup, libs, "g_signal_group_new")
370
371 core.PuregoSafeRegister(&xSignalGroupBlock, libs, "g_signal_group_block")
372 core.PuregoSafeRegister(&xSignalGroupConnect, libs, "g_signal_group_connect")
373 core.PuregoSafeRegister(&xSignalGroupConnectAfter, libs, "g_signal_group_connect_after")
374 core.PuregoSafeRegister(&xSignalGroupConnectClosure, libs, "g_signal_group_connect_closure")
375 core.PuregoSafeRegister(&xSignalGroupConnectData, libs, "g_signal_group_connect_data")
376 core.PuregoSafeRegister(&xSignalGroupConnectObject, libs, "g_signal_group_connect_object")
377 core.PuregoSafeRegister(&xSignalGroupConnectSwapped, libs, "g_signal_group_connect_swapped")
378 core.PuregoSafeRegister(&xSignalGroupDupTarget, libs, "g_signal_group_dup_target")
379 core.PuregoSafeRegister(&xSignalGroupSetTarget, libs, "g_signal_group_set_target")
380 core.PuregoSafeRegister(&xSignalGroupUnblock, libs, "g_signal_group_unblock")
381
382}