andlabs-ui/callbacks_unix.go

// +build !windows,!darwin,!plan9

// 16 february 2014

package ui

import (
	"unsafe"
)

/*
cgo doesn't support calling Go functions by default; we have to mark them for export. Not a problem, except arguments to GTK+ callbacks depend on the callback itself. Since we're generating callback functions as simple closures of one type, this file will wrap the generated callbacks in the appropriate callback type. We pass the actual generated pointer to the extra data parameter of the callback.

while we're at it the callback for our idle function will be handled here too
*/

// #include "gtk_unix.h"
// extern gboolean our_window_delete_event_callback(GtkWidget *, GdkEvent *, gpointer);
// extern gboolean our_window_configure_event_callback(GtkWidget *, GdkEvent *, gpointer);
// extern void our_button_clicked_callback(GtkButton *, gpointer);
// /* because cgo is flaky with macros; static inline because we have //exports */
// static inline void gSignalConnect(GtkWidget *widget, char *signal, GCallback callback, void *data) { g_signal_connect(widget, signal, callback, data); }
import "C"

//export our_window_delete_event_callback
func our_window_delete_event_callback(widget *C.GtkWidget, event *C.GdkEvent, what C.gpointer) C.gboolean {
	// called when the user tries to close the window
	s := (*sysData)(unsafe.Pointer(what))
	return togbool(!s.close())		// ! because TRUE means don't close
}

var window_delete_event_callback = C.GCallback(C.our_window_delete_event_callback)

//export our_window_configure_event_callback
func our_window_configure_event_callback(widget *C.GtkWidget, event *C.GdkEvent, what C.gpointer) C.gboolean {
	// called when the window is resized
	s := (*sysData)(unsafe.Pointer(what))
	if s.container != nil && s.allocate != nil { // wait for init
		width, height := gtk_window_get_size(s.widget)
		// top-left is (0,0) here
		s.resizeWindow(width, height)
	}
	// no need to manually redraw everything: since we use gtk_widget_set_size_request(), that queues both resize and redraw for us (thanks Company in irc.gimp.net/#gtk+)
	return C.FALSE // continue the event chain
}

var window_configure_event_callback = C.GCallback(C.our_window_configure_event_callback)

//export our_button_clicked_callback
func our_button_clicked_callback(button *C.GtkButton, what C.gpointer) {
	// called when the user clicks a button
	s := (*sysData)(unsafe.Pointer(what))
	s.event()
}

var button_clicked_callback = C.GCallback(C.our_button_clicked_callback)

// this is the type of the signals fields in classData; here to avoid needing to import C
type callbackMap map[string]C.GCallback

// this is what actually connects a signal
func g_signal_connect(obj *C.GtkWidget, sig string, callback C.GCallback, sysData *sysData) {
	csig := C.CString(sig)
	defer C.free(unsafe.Pointer(csig))
	C.gSignalConnect(obj, csig, callback, unsafe.Pointer(sysData))
}

func g_signal_connect_pointer(obj *C.GtkWidget, sig string, callback C.GCallback, p unsafe.Pointer) {
	csig := C.CString(sig)
	defer C.free(unsafe.Pointer(csig))
	C.gSignalConnect(obj, csig, callback, p)
}