1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
// Same copyright and license as the rest of the files in this project
// This file contains accelerator related functions and structures
package gtk
// #include <gtk/gtk.h>
// #include "gtk.go.h"
import "C"
import (
"unsafe"
"github.com/gotk3/gotk3/gdk"
"github.com/gotk3/gotk3/glib"
)
/*
* GtkMenu
*/
// Menu is a representation of GTK's GtkMenu.
type Menu struct {
MenuShell
}
// IMenu is an interface type implemented by all structs embedding
// a Menu. It is meant to be used as an argument type for wrapper
// functions that wrap around a C GTK function taking a
// GtkMenu.
type IMenu interface {
toMenu() *C.GtkMenu
toWidget() *C.GtkWidget
}
// native() returns a pointer to the underlying GtkMenu.
func (v *Menu) native() *C.GtkMenu {
if v == nil || v.GObject == nil {
return nil
}
p := unsafe.Pointer(v.GObject)
return C.toGtkMenu(p)
}
func (v *Menu) toMenu() *C.GtkMenu {
if v == nil {
return nil
}
return v.native()
}
func marshalMenu(p uintptr) (interface{}, error) {
c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p)))
obj := glib.Take(unsafe.Pointer(c))
return wrapMenu(obj), nil
}
func wrapMenu(obj *glib.Object) *Menu {
if obj == nil {
return nil
}
return &Menu{MenuShell{Container{Widget{glib.InitiallyUnowned{obj}}}}}
}
// MenuNew() is a wrapper around gtk_menu_new().
func MenuNew() (*Menu, error) {
c := C.gtk_menu_new()
if c == nil {
return nil, nilPtrErr
}
return wrapMenu(glib.Take(unsafe.Pointer(c))), nil
}
// GtkMenuNewFromModel is a wrapper around gtk_menu_new_from_model().
func GtkMenuNewFromModel(model *glib.MenuModel) (*Menu, error) {
c := C.gtk_menu_new_from_model(C.toGMenuModel(unsafe.Pointer(model.Native())))
if c == nil {
return nil, nilPtrErr
}
return wrapMenu(glib.Take(unsafe.Pointer(c))), nil
}
// SetScreen is a wrapper around gtk_menu_set_screen().
func (v *Menu) SetScreen(screen *gdk.Screen) {
C.gtk_menu_set_screen(v.native(), (*C.GdkScreen)(unsafe.Pointer(screen.Native())))
}
// Attach is a wrapper around gtk_menu_attach().
func (v *Menu) Attach(child IWidget, l, r, t, b uint) {
C.gtk_menu_attach(
v.native(),
child.toWidget(),
C.guint(l),
C.guint(r),
C.guint(t),
C.guint(b))
}
// SetMonitor() is a wrapper around gtk_menu_set_monitor().
func (v *Menu) SetMonitor(monitor_num int) {
C.gtk_menu_set_monitor(v.native(), C.gint(monitor_num))
}
// GetMonitor() is a wrapper around gtk_menu_get_monitor().
func (v *Menu) GetMonitor() int {
return int(C.gtk_menu_get_monitor(v.native()))
}
// ReorderChild() is a wrapper around gtk_menu_reorder_child().
func (v *Menu) ReorderChild(child IWidget, position int) {
C.gtk_menu_reorder_child(v.native(), child.toWidget(), C.gint(position))
}
// SetReserveToggleSize() is a wrapper around gtk_menu_set_reserve_toggle_size().
func (v *Menu) SetReserveToggleSize(reserve bool) {
C.gtk_menu_set_reserve_toggle_size(v.native(), gbool(reserve))
}
// GetReserveToggleSize() is a wrapper around gtk_menu_get_reserve_toggle_size().
func (v *Menu) GetReserveToggleSize() bool {
return gobool(C.gtk_menu_get_reserve_toggle_size(v.native()))
}
// Popdown() is a wrapper around gtk_menu_popdown().
func (v *Menu) Popdown() {
C.gtk_menu_popdown(v.native())
}
// TODO
/*
gtk_menu_reposition () require 'GtkMenuPositionFunc' (according to its position function.)
*/
// GetActive() is a wrapper around gtk_menu_get_active().
func (v *Menu) GetActive() (*Menu, error) {
c := C.gtk_menu_get_active(v.native())
if c == nil {
return nil, nilPtrErr
}
return wrapMenu(glib.Take(unsafe.Pointer(c))), nil
}
// SetActive() is a wrapper around gtk_menu_set_active().
func (v *Menu) SetActive(index uint) {
C.gtk_menu_set_active(v.native(), C.guint(index))
}
// TODO
/*
void
gtk_menu_attach_to_widget (GtkMenu *menu,
GtkWidget *attach_widget,
GtkMenuDetachFunc detacher);
void
gtk_menu_detach (GtkMenu *menu);
*/
// GetAttachWidget() is a wrapper around gtk_menu_get_attach_widget().
func (v *Menu) GetAttachWidget() (IWidget, error) {
c := C.gtk_menu_get_attach_widget(v.native())
if c == nil {
return nil, nilPtrErr
}
return castWidget(c)
}
// TODO
/*
GList *
gtk_menu_get_for_attach_widget (GtkWidget *widget);
*/
|
