// Emit is a wrapper around g_signal_emitv() and emits the signal
// specified by the string s to an Object. Arguments to callback
// functions connected to this signal must be specified in args. Emit()
// returns an interface{} which must be type asserted as the Go
// equivalent type to the return value for native C callback.
//
// Note that this code is unsafe in that the types of values in args are
// not checked against whether they are suitable for the callback.
func (v *Object) Emit(s string, args ...interface{}) (interface{}, error) {
cstr := C.CString(s)
defer C.free(unsafe.Pointer(cstr))
// Create array of this instance and arguments
valv := C.alloc_gvalue_list(C.int(len(args)) + 1)
defer C.free(unsafe.Pointer(valv))
// Add args and valv
val, err := GValue(v)
if err != nil {
return nil, errors.New("Error converting Object to GValue: " + err.Error())
}
C.val_list_insert(valv, C.int(0), val.native())
for i := range args {
val, err := GValue(args[i])
if err != nil {
return nil, fmt.Errorf("Error converting arg %d to GValue: %s", i, err.Error())
}
C.val_list_insert(valv, C.int(i+1), val.native())
}
t := v.TypeFromInstance()
// TODO: use just the signal name
id := C.g_signal_lookup((*C.gchar)(cstr), C.GType(t))
ret, err := ValueAlloc()
if err != nil {
return nil, errors.New("Error creating Value for return value")
}
C.g_signal_emitv(valv, id, C.GQuark(0), ret.native())
return ret.GoValue()
}
func SignalLookup(name string, t Type) (sid SignalId, detail Quark) {
st := strings.SplitN(name, "::", 2)
if len(st) == 2 {
detail = QuarkFromString(st[1])
}
s := C.CString(st[0])
sid = SignalId(C.g_signal_lookup((*C.gchar)(s), t.g()))
defer C.free(unsafe.Pointer(s))
return
}
func SignalLookup(name string, objectType GType) uint32 {
n := GString(name)
defer n.Free()
s := C.g_signal_lookup((*C.gchar)(n.GetPtr()), C.GType(objectType))
return uint32(s)
}
