func (a *area) Repaint(r image.Rectangle) {
r = image.Rect(0, 0, a.width, a.height).Intersect(r)
if r.Empty() {
return
}
C.gtk_widget_queue_draw_area(a.widget, C.gint(r.Min.X), C.gint(r.Min.Y), C.gint(r.Dx()), C.gint(r.Dy()))
}
func DumpUnionInfo(info *C.GIUnionInfo) {
nFields := C.g_union_info_get_n_fields(info)
p("%d fields\n", nFields)
for i := C.gint(0); i < nFields; i++ {
field := C.g_union_info_get_field(info, i)
DumpFieldInfo(field)
}
nMethods := C.g_union_info_get_n_methods(info)
p("%d methods\n", nMethods)
for i := C.gint(0); i < nMethods; i++ {
method := C.g_union_info_get_method(info, i)
DumpFunctionInfo(method)
}
isDiscriminated := C.g_union_info_is_discriminated(info) == C.gboolean(1)
p("is discriminated %v\n", isDiscriminated)
if isDiscriminated {
offset := C.g_union_info_get_discriminator_offset(info)
p("discriminated offset %d\n", offset)
discriminatedType := C.g_union_info_get_discriminator_type(info)
p("discriminated type %d\n", discriminatedType)
DumpTypeInfo(discriminatedType)
for i := C.gint(0); i < nFields; i++ {
discriminator := C.g_union_info_get_discriminator(info, i)
DumpConstantInfo(discriminator)
}
}
size := C.g_union_info_get_size(info)
p("size %d bytes\n", size)
align := C.g_union_info_get_alignment(info)
p("alignment %d bytes\n", align)
}
func CreateWindow(title string, width int, height int) unsafe.Pointer {
Logger.Println("CreateWindow")
// Create window.
window := C.gtk_window_new(C.GTK_WINDOW_TOPLEVEL)
// Default size.
C.gtk_window_set_default_size(C.ToGtkWindow(window),
C.gint(width), C.gint(height))
// Center.
C.gtk_window_set_position(C.ToGtkWindow(window), C.GTK_WIN_POS_CENTER)
// Title.
csTitle := C.CString(title)
defer C.free(unsafe.Pointer(csTitle))
C.gtk_window_set_title(C.ToGtkWindow(window), (*C.gchar)(csTitle))
// TODO: focus
// g_signal_connect(window, "focus", G_CALLBACK(&HandleFocus), NULL);
// CEF requires a container. Embedding browser in a top
// level window fails.
vbox := C.gtk_vbox_new(0, 0)
C.gtk_container_add(C.ToGtkContainer(window), vbox)
// Show.
C.gtk_widget_show_all(window)
return unsafe.Pointer(vbox)
}
// GDK_AVAILABLE_IN_3_2
// GtkWidget *gtk_grid_get_child_at (GtkGrid *grid,
// gint left,
// gint top);
func (g *Grid) GetChildAt(left, top int32) *Widget {
ret := C.gtk_grid_get_child_at(g.c, C.gint(left), C.gint(top))
if ret == nil {
return nil
}
return &Widget{ret}
}
// GetIterAtPosition is a wrapper around gtk_text_view_get_iter_at_position().
func (v *TextView) GetIterAtPosition(x, y int) (*TextIter, int) {
var iter TextIter
var trailing C.gint
iiter := (C.GtkTextIter)(iter)
C.gtk_text_view_get_iter_at_position(v.native(), &iiter, &trailing, C.gint(x), C.gint(y))
return &iter, int(trailing)
}
func startGui(width, height int, title string, port int) {
C.gtk_init(nil, nil) //gtk.Init(nil)
window := C.window
window = C.gtk_window_new(C.GTK_WINDOW_TOPLEVEL)
C.gtk_window_set_title(C.to_GtkWindow(window), C.to_gcharptr(C.CString(title)))
C.connect_destroy(window)
vbox := C.gtk_hbox_new(0, 1)
C.webview = C._new_webkit()
C.gtk_container_add(C.to_GtkContainer(vbox), C.webview)
C.loadUri(C.webview, C.to_gcharptr(C.CString(fmt.Sprintf("http://127.0.0.1:%d", port))))
C.gtk_container_add(C.to_GtkContainer(window), vbox)
C.gtk_widget_set_size_request(window, C.gint(width), C.gint(height))
C.gtk_widget_show(vbox)
C.gtk_widget_show(window) //Window.ShowAll()
C.gtk_widget_show(C.webview)
/*
This only matters if proxy is stupid!
proxy := os.Getenv("HTTP_PROXY")
if len(proxy) > 0 {
ptr := C.CString(uri)
C.proxyshit(ptr)
C.free(ptr)
}
*/
C.gtk_main() //gtk.GtkMain()
}
func newWindow(title string, width int, height int, control Control) *window {
widget := C.gtk_window_new(C.GTK_WINDOW_TOPLEVEL)
ctitle := togstr(title)
defer freegstr(ctitle)
w := &window{
widget: widget,
wc: (*C.GtkContainer)(unsafe.Pointer(widget)),
bin: (*C.GtkBin)(unsafe.Pointer(widget)),
window: (*C.GtkWindow)(unsafe.Pointer(widget)),
closing: newEvent(),
}
C.gtk_window_set_title(w.window, ctitle)
g_signal_connect(
C.gpointer(unsafe.Pointer(w.window)),
"delete-event",
C.GCallback(C.windowClosing),
C.gpointer(unsafe.Pointer(w)))
C.gtk_window_resize(w.window, C.gint(width), C.gint(height))
w.container = newContainer(control)
w.container.setParent(&controlParent{w.wc})
// for dialogs; otherwise, they will be modal to all windows, not just this one
w.group = C.gtk_window_group_new()
C.gtk_window_group_add_window(w.group, w.window)
return w
}
func toGValue(v interface{}) *C.GValue {
value := C.gvalue_new()
switch reflect.TypeOf(v).Kind() {
case reflect.String:
C.g_value_init(value, C.G_TYPE_STRING)
cStr := C.CString(v.(string))
defer C.free(unsafe.Pointer(cStr))
C.g_value_set_string(value, (*C.gchar)(unsafe.Pointer(cStr)))
case reflect.Int:
C.g_value_init(value, C.G_TYPE_INT)
C.g_value_set_int(value, C.gint(v.(int)))
case reflect.Struct:
switch rv := v.(type) {
case Fraction:
C.g_value_init(value, C.gst_fraction_get_type())
C.gst_value_set_fraction(value, C.gint(rv.N), C.gint(rv.D))
default:
p("unknown struct type %v\n", v)
panic("fixme") //TODO
}
case reflect.Ptr:
switch reflect.TypeOf(v) {
case gstCapsType:
C.g_value_init(value, C.gst_caps_get_type())
C.gst_value_set_caps(value, v.(*C.GstCaps))
default:
panic(fmt.Sprintf("unknown type %v", v)) //TODO
}
default:
panic(fmt.Sprintf("unknown type %v", v)) //TODO
}
return value
}
/*
Creates a new, empty animation.
*/
func PixbufSimpleAnimNew(width int, height int, rate float32) (return__ *PixbufSimpleAnim) {
var __cgo__return__ interface{}
__cgo__return__ = C.gdk_pixbuf_simple_anim_new(C.gint(width), C.gint(height), C.gfloat(rate))
if __cgo__return__ != nil {
return__ = NewPixbufSimpleAnimFromCPointer(unsafe.Pointer(reflect.ValueOf(__cgo__return__).Pointer()))
}
return
}
func draw_selections(viewp, bufferp, crp unsafe.Pointer, mark_pairs []unsafe.Pointer) {
view := (*C.GtkTextView)(viewp)
buffer := (*C.GtkTextBuffer)(bufferp)
cr := (*C.cairo_t)(crp)
var alloc C.GtkAllocation
C.gtk_widget_get_allocation((*C.GtkWidget)(viewp), &alloc)
n := len(mark_pairs)
var start_mark, stop_mark *C.GtkTextMark
var location C.GdkRectangle
var iter C.GtkTextIter
var x, y C.gint
var dx, dy C.double
for i := 0; i < n; i += 2 {
start_mark = (*C.GtkTextMark)(mark_pairs[i])
C.gtk_text_buffer_get_iter_at_mark(buffer, &iter, start_mark)
C.gtk_text_view_get_iter_location(view, &iter, &location)
C.gtk_text_view_buffer_to_window_coords(view, C.GTK_TEXT_WINDOW_WIDGET, C.gint(location.x), C.gint(location.y), &x, &y)
if C.int(x) > alloc.width || C.int(y) > alloc.height || x < 0 || y < 0 {
continue
}
dx = C.double(x)
dy = C.double(y)
C.cairo_set_source_rgb(cr, 1, 0, 0)
C.cairo_move_to(cr, dx, dy)
C.cairo_set_line_width(cr, 2)
C.cairo_line_to(cr, dx+6, dy)
C.cairo_stroke(cr)
C.cairo_move_to(cr, dx, dy)
C.cairo_set_line_width(cr, 1)
C.cairo_line_to(cr, dx, dy+C.double(location.height))
C.cairo_stroke(cr)
stop_mark = (*C.GtkTextMark)(mark_pairs[i+1])
C.gtk_text_buffer_get_iter_at_mark(buffer, &iter, stop_mark)
C.gtk_text_view_get_iter_location(view, &iter, &location)
C.gtk_text_view_buffer_to_window_coords(view, C.GTK_TEXT_WINDOW_WIDGET, C.gint(location.x), C.gint(location.y), &x, &y)
if C.int(x) > alloc.width || C.int(y) > alloc.height || x < 0 || y < 0 {
continue
}
dx = C.double(x)
dy = C.double(y)
C.cairo_set_source_rgb(cr, 0, 1, 0)
C.cairo_move_to(cr, dx, dy)
C.cairo_set_line_width(cr, 1)
C.cairo_line_to(cr, dx, dy+C.double(location.height))
C.cairo_stroke(cr)
C.cairo_move_to(cr, dx, dy+C.double(location.height))
C.cairo_set_line_width(cr, 2)
C.cairo_line_to(cr, dx-6, dy+C.double(location.height))
C.cairo_stroke(cr)
}
}
// TranslateCoordinates is a wrapper around gtk_widget_translate_coordinates().
func (v *Widget) TranslateCoordinates(dest IWidget, srcX, srcY int) (destX, destY int, e error) {
cdest := nullableWidget(dest)
var cdestX, cdestY C.gint
c := C.gtk_widget_translate_coordinates(v.native(), cdest, C.gint(srcX), C.gint(srcY), &cdestX, &cdestY)
if !gobool(c) {
return 0, 0, errors.New("translate coordinates failed")
}
return int(cdestX), int(cdestY), nil
}
func finishNewTable(b *tablebase, ty reflect.Type) Table {
widget := C.gtk_tree_view_new()
t := &table{
scroller: newScroller(widget, true, true, false), // natively scrollable; has a border; no overlay
tablebase: b,
treeview: (*C.GtkTreeView)(unsafe.Pointer(widget)),
crtocol: make(map[*C.GtkCellRendererToggle]int),
selected: newEvent(),
}
model := C.newTableModel(unsafe.Pointer(t))
t.model = model
t.modelgtk = (*C.GtkTreeModel)(unsafe.Pointer(model))
t.selection = C.gtk_tree_view_get_selection(t.treeview)
g_signal_connect(
C.gpointer(unsafe.Pointer(t.selection)),
"changed",
C.GCallback(C.tableSelectionChanged),
C.gpointer(unsafe.Pointer(t)))
C.gtk_tree_view_set_model(t.treeview, t.modelgtk)
for i := 0; i < ty.NumField(); i++ {
colname := ty.Field(i).Tag.Get("uicolumn")
if colname == "" {
colname = ty.Field(i).Name
}
cname := togstr(colname)
switch {
case ty.Field(i).Type == reflect.TypeOf((*image.RGBA)(nil)):
// can't use GDK_TYPE_PIXBUF here because it's a macro that expands to a function and cgo hates that
t.types = append(t.types, C.gdk_pixbuf_get_type())
C.tableAppendColumn(t.treeview, C.gint(i), cname,
C.gtk_cell_renderer_pixbuf_new(), attribPixbuf)
case ty.Field(i).Type.Kind() == reflect.Bool:
t.types = append(t.types, C.G_TYPE_BOOLEAN)
cr := C.gtk_cell_renderer_toggle_new()
crt := (*C.GtkCellRendererToggle)(unsafe.Pointer(cr))
t.crtocol[crt] = i
g_signal_connect(C.gpointer(unsafe.Pointer(cr)),
"toggled",
C.GCallback(C.goTableModel_toggled),
C.gpointer(unsafe.Pointer(t)))
C.tableAppendColumn(t.treeview, C.gint(i), cname,
cr, attribActive)
default:
t.types = append(t.types, C.G_TYPE_STRING)
C.tableAppendColumn(t.treeview, C.gint(i), cname,
C.gtk_cell_renderer_text_new(), attribText)
}
freegstr(cname) // free now (not deferred) to conserve memory
}
// and for some GtkTreeModel boilerplate
t.nColumns = C.gint(ty.NumField())
return t
}
func (v *GdkWindow) Invalidate(rect *Rectangle, invalidate_children bool) {
if rect != nil {
var _rect C.GdkRectangle
_rect.x = C.gint(rect.X)
_rect.y = C.gint(rect.Y)
_rect.width = C.gint(rect.Width)
_rect.height = C.gint(rect.Height)
C.gdk_window_invalidate_rect(v.Window, &_rect, bool2gboolean(invalidate_children))
} else {
C.gdk_window_invalidate_rect(v.Window, nil, bool2gboolean(invalidate_children))
}
}
// AddPalette() is a wrapper around gtk_color_chooser_add_palette().
func (v *ColorChooser) AddPalette(orientation Orientation, colors_per_line int, colors []*gdk.RGBA) {
n_colors := len(colors)
var c_colors []C.GdkRGBA
for _, c := range colors {
c_colors = append(c_colors, *(*C.GdkRGBA)(unsafe.Pointer(c.Native())))
}
C.gtk_color_chooser_add_palette(
v.native(),
C.GtkOrientation(orientation),
C.gint(colors_per_line),
C.gint(n_colors),
&c_colors[0],
)
}
// Insert is a wrapper around gtk_combo_box_text_insert().
func (v *ComboBoxText) Insert(position int, id, text string) {
cid := C.CString(id)
ctext := C.CString(text)
defer C.free(unsafe.Pointer(cid))
defer C.free(unsafe.Pointer(ctext))
C.gtk_combo_box_text_insert(v.native(), C.gint(position), (*C.gchar)(cid), (*C.gchar)(ctext))
}
// MenuItemNewFromModel is a wrapper around g_menu_item_new_from_model().
func MenuItemNewFromModel(model *MenuModel, index int) *MenuItem {
c := C.g_menu_item_new_from_model(model.native(), C.gint(index))
if c == nil {
return nil
}
return wrapMenuItem(wrapObject(unsafe.Pointer(c)))
}
// GetIcon takes the name of an icon and a size as arguments. It returns the closest
// matching icon file from the theme.
func (t GTKTheme) GetIcon(name string, size int) string {
// TODO: User-specified flags.
var flags C.GtkIconLookupFlags
// Lookup the icon.
cName := C.CString(name)
defer C.free(unsafe.Pointer(cName))
iconInfo := C.gtk_icon_theme_lookup_icon(t.theme, (*C.gchar)(cName), C.gint(size), flags)
// Check the lookup was successful.
if iconInfo == nil {
return ""
}
// gtk_icon_info_free is deprecated, but we seem to have issues using g_object_unref.
defer C.gtk_icon_info_free(iconInfo)
//defer C.g_object_unref(C.gpointer(iconInfo))
// Check the icon's filename.
cFilename := C.gtk_icon_info_get_filename(iconInfo)
if cFilename == nil {
return ""
}
filename := C.GoString((*C.char)(cFilename))
return filename
}
func DumpCallableInfo(info *C.GICallableInfo) {
throwsError := C.g_callable_info_can_throw_gerror(info) == C.gboolean(1)
p("can throws error %v\n", throwsError)
nArgs := C.g_callable_info_get_n_args(info)
for i := C.gint(0); i < nArgs; i++ {
argInfo := C.g_callable_info_get_arg(info, i)
DumpArgInfo(argInfo)
}
returnOwnership := C.g_callable_info_get_caller_owns(info)
p("return value ownership %s\n", TransferGetName(returnOwnership))
returnType := C.g_callable_info_get_return_type(info)
defer C.g_base_info_unref(asBaseInfo(returnType))
p("return type %v\n", returnType)
DumpTypeInfo(returnType)
isMethod := C.g_callable_info_is_method(info) == C.gboolean(1)
p("is method %v\n", isMethod)
var iter C.GIAttributeIter
var key, value *C.char
for C.g_callable_info_iterate_return_attributes(info, &iter, &key, &value) == C.gboolean(1) {
p("Attr %s = %s\n", C.GoString(key), C.GoString(value))
}
mayReturnNull := C.g_callable_info_may_return_null(info) == C.gboolean(1)
p("may return null %v\n", mayReturnNull)
skipReturn := C.g_callable_info_skip_return(info) == C.gboolean(1)
p("skip return %v\n", skipReturn)
}
/*
Creates a new pixbuf by loading an image from an input stream.
The file format is detected automatically. If %NULL is returned, then
@error will be set. The @cancellable can be used to abort the operation
from another thread. If the operation was cancelled, the error
%G_IO_ERROR_CANCELLED will be returned. Other possible errors are in
the #GDK_PIXBUF_ERROR and %G_IO_ERROR domains.
The image will be scaled to fit in the requested size, optionally
preserving the image's aspect ratio.
When preserving the aspect ratio, a @width of -1 will cause the image to be
scaled to the exact given height, and a @height of -1 will cause the image
to be scaled to the exact given width. If both @width and @height are
given, this function will behave as if the smaller of the two values
is passed as -1.
When not preserving aspect ratio, a @width or @height of -1 means to not
scale the image at all in that dimension.
The stream is not closed.
*/
func PixbufNewFromStreamAtScale(stream *C.GInputStream, width int, height int, preserve_aspect_ratio bool, cancellable *C.GCancellable) (return__ *Pixbuf, __err__ error) {
__cgo__preserve_aspect_ratio := C.gboolean(0)
if preserve_aspect_ratio {
__cgo__preserve_aspect_ratio = C.gboolean(1)
}
var __cgo_error__ *C.GError
var __cgo__return__ interface{}
__cgo__return__ = C.gdk_pixbuf_new_from_stream_at_scale(stream, C.gint(width), C.gint(height), __cgo__preserve_aspect_ratio, cancellable, &__cgo_error__)
if __cgo__return__ != nil {
return__ = NewPixbufFromCPointer(unsafe.Pointer(reflect.ValueOf(__cgo__return__).Pointer()))
}
if __cgo_error__ != nil {
__err__ = errors.New(C.GoString((*C.char)(unsafe.Pointer(__cgo_error__.message))))
}
return
}
// GetColumn() is a wrapper around gtk_tree_view_get_column().
func (v *TreeView) GetColumn(n int) *TreeViewColumn {
c := C.gtk_tree_view_get_column(v.native(), C.gint(n))
if c == nil {
return nil
}
return wrapTreeViewColumn(wrapObject(unsafe.Pointer(c)))
}
// GetRowAtY is a wrapper around gtk_list_box_get_row_at_y().
func (v *ListBox) GetRowAtY(y int) *ListBoxRow {
c := C.gtk_list_box_get_row_at_y(v.native(), C.gint(y))
if c == nil {
return nil
}
return wrapListBoxRow(wrapObject(unsafe.Pointer(c)))
}
//export goTableModel_getRowCount
func goTableModel_getRowCount(data unsafe.Pointer) C.gint {
t := (*table)(data)
t.RLock()
defer t.RUnlock()
d := reflect.Indirect(reflect.ValueOf(t.data))
return C.gint(d.Len())
}
// GetLineAtY is a wrapper around gtk_text_view_get_line_at_y().
func (v *TextView) GetLineAtY(y int) (*TextIter, int) {
var iter TextIter
var line_top C.gint
iiter := (C.GtkTextIter)(iter)
C.gtk_text_view_get_line_at_y(v.native(), &iiter, C.gint(y), &line_top)
return &iter, int(line_top)
}
// g_enum_info_get_value
func (ei *EnumInfo) Value(n int) *ValueInfo {
cptr := (*C.GIBaseInfo)(C.g_enum_info_get_value((*C.GIEnumInfo)(ei.c), C.gint(n)))
if cptr == nil {
return nil
}
ptr := &BaseInfo{cptr}
return (*ValueInfo)(unsafe.Pointer(_SetBaseInfoFinalizer(ptr)))
}
/*
Creates a new cursor from a pixbuf.
Not all GDK backends support RGBA cursors. If they are not
supported, a monochrome approximation will be displayed.
The functions gdk_display_supports_cursor_alpha() and
gdk_display_supports_cursor_color() can be used to determine
whether RGBA cursors are supported;
gdk_display_get_default_cursor_size() and
gdk_display_get_maximal_cursor_size() give information about
cursor sizes.
If @x or @y are `-1`, the pixbuf must have
options named “x_hot” and “y_hot”, resp., containing
integer values between `0` and the width resp. height of
the pixbuf. (Since: 3.0)
On the X backend, support for RGBA cursors requires a
sufficently new version of the X Render extension.
*/
func CursorNewFromPixbuf(display IsDisplay, pixbuf *C.GdkPixbuf, x int, y int) (return__ *Cursor) {
var __cgo__return__ interface{}
__cgo__return__ = C.gdk_cursor_new_from_pixbuf(display.GetDisplayPointer(), pixbuf, C.gint(x), C.gint(y))
if __cgo__return__ != nil {
return__ = NewCursorFromCPointer(unsafe.Pointer(reflect.ValueOf(__cgo__return__).Pointer()))
}
return
}
func cListInt(value []int) *C.gint {
var clist *C.gint
clist = (*C.gint)(C.malloc(C.size_t(int(unsafe.Sizeof(*clist)) * len(value))))
for k, v := range value {
(*(*[999999]C.gint)(unsafe.Pointer(clist)))[k] = C.gint(v)
}
return clist
}
// Insert is a wrapper around g_menu_insert().
func (v *Menu) Insert(position int, label, detailed_action string) {
cstr1 := (*C.gchar)(C.CString(label))
defer C.free(unsafe.Pointer(cstr1))
cstr2 := (*C.gchar)(C.CString(detailed_action))
defer C.free(unsafe.Pointer(cstr2))
C.g_menu_insert(v.native(), C.gint(position), cstr1, cstr2)
}
func NewHBox(homogeneous bool, spacing int) *HBox {
b := new(HBox)
var h C.gboolean
if homogeneous {
h = 1
}
b.SetPtr(glib.Pointer(C.gtk_hbox_new(h, C.gint(spacing))))
return b
}
// GetItemLink is a wrapper around g_menu_model_get_item_link().
func (v *MenuModel) GetItemLink(index int, link string) *MenuModel {
cstr := (*C.gchar)(C.CString(link))
defer C.free(unsafe.Pointer(cstr))
c := C.g_menu_model_get_item_link(v.native(), C.gint(index), cstr)
if c == nil {
return nil
}
return wrapMenuModel(wrapObject(unsafe.Pointer(c)))
}
func DumpEnumInfo(info *C.GIEnumInfo) {
nValues := C.g_enum_info_get_n_values(info)
p("%d values\n", nValues)
for i := C.gint(0); i < nValues; i++ {
valueInfo := C.g_enum_info_get_value(info, i)
DumpValueInfo(valueInfo)
}
nMethods := C.g_enum_info_get_n_methods(info)
p("%d methods\n", nMethods)
for i := C.gint(0); i < nMethods; i++ {
f := C.g_enum_info_get_method(info, i)
DumpFunctionInfo(f)
}
storageType := C.g_enum_info_get_storage_type(info)
p("%s\n", fromGStr(C.g_type_tag_to_string(storageType)))
errorDomain := fromGStr(C.g_enum_info_get_error_domain(info))
p("error domain %s\n", errorDomain)
}