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
|
package gtk
// #include <gtk/gtk.h>
// #include "gtk.go.h"
import "C"
import (
"unsafe"
"github.com/gotk3/gotk3/gdk"
"github.com/gotk3/gotk3/glib"
)
func init() {
tm := []glib.TypeMarshaler{
{glib.Type(C.gtk_color_chooser_get_type()), marshalColorChooser},
{glib.Type(C.gtk_color_chooser_dialog_get_type()), marshalColorChooserDialog},
}
glib.RegisterGValueMarshalers(tm)
WrapMap["GtkColorChooser"] = wrapColorChooser
WrapMap["GtkColorChooserDialog"] = wrapColorChooserDialog
}
/*
* GtkColorChooser
*/
// ColorChooser is a representation of GTK's GtkColorChooser GInterface.
type ColorChooser struct {
*glib.Object
}
// IColorChooser is an interface type implemented by all structs
// embedding an ColorChooser. It is meant to be used as an argument type
// for wrapper functions that wrap around a C GTK function taking a
// GtkColorChooser.
type IColorChooser interface {
toColorChooser() *C.GtkColorChooser
}
// native returns a pointer to the underlying GtkColorChooser.
func (v *ColorChooser) native() *C.GtkColorChooser {
if v == nil || v.GObject == nil {
return nil
}
p := unsafe.Pointer(v.GObject)
return C.toGtkColorChooser(p)
}
func marshalColorChooser(p uintptr) (interface{}, error) {
c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p)))
obj := glib.Take(unsafe.Pointer(c))
return wrapColorChooser(obj), nil
}
func wrapColorChooser(obj *glib.Object) *ColorChooser {
if obj == nil {
return nil
}
return &ColorChooser{obj}
}
func (v *ColorChooser) toColorChooser() *C.GtkColorChooser {
if v == nil {
return nil
}
return v.native()
}
// GetRGBA() is a wrapper around gtk_color_chooser_get_rgba().
func (v *ColorChooser) GetRGBA() *gdk.RGBA {
gdkColor := gdk.NewRGBA()
C.gtk_color_chooser_get_rgba(v.native(), (*C.GdkRGBA)(unsafe.Pointer(gdkColor.Native())))
return gdkColor
}
// SetRGBA() is a wrapper around gtk_color_chooser_set_rgba().
func (v *ColorChooser) SetRGBA(gdkColor *gdk.RGBA) {
C.gtk_color_chooser_set_rgba(v.native(), (*C.GdkRGBA)(unsafe.Pointer(gdkColor.Native())))
}
// GetUseAlpha() is a wrapper around gtk_color_chooser_get_use_alpha().
func (v *ColorChooser) GetUseAlpha() bool {
return gobool(C.gtk_color_chooser_get_use_alpha(v.native()))
}
// SetUseAlpha() is a wrapper around gtk_color_chooser_set_use_alpha().
func (v *ColorChooser) SetUseAlpha(use_alpha bool) {
C.gtk_color_chooser_set_use_alpha(v.native(), gbool(use_alpha))
}
// 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],
)
}
/*
* GtkColorChooserDialog
*/
// ColorChooserDialog is a representation of GTK's GtkColorChooserDialog.
type ColorChooserDialog struct {
Dialog
// Interfaces
ColorChooser
}
// native returns a pointer to the underlying GtkColorChooserButton.
func (v *ColorChooserDialog) native() *C.GtkColorChooserDialog {
if v == nil || v.GObject == nil {
return nil
}
p := unsafe.Pointer(v.GObject)
return C.toGtkColorChooserDialog(p)
}
func marshalColorChooserDialog(p uintptr) (interface{}, error) {
c := C.g_value_get_object((*C.GValue)(unsafe.Pointer(p)))
return wrapColorChooserDialog(glib.Take(unsafe.Pointer(c))), nil
}
func wrapColorChooserDialog(obj *glib.Object) *ColorChooserDialog {
if obj == nil {
return nil
}
dialog := wrapDialog(obj)
cc := wrapColorChooser(obj)
return &ColorChooserDialog{*dialog, *cc}
}
// ColorChooserDialogNew() is a wrapper around gtk_color_chooser_dialog_new().
func ColorChooserDialogNew(title string, parent IWindow) (*ColorChooserDialog, error) {
cstr := C.CString(title)
defer C.free(unsafe.Pointer(cstr))
var w *C.GtkWindow = nil
if parent != nil {
w = parent.toWindow()
}
c := C.gtk_color_chooser_dialog_new((*C.gchar)(cstr), w)
if c == nil {
return nil, nilPtrErr
}
return wrapColorChooserDialog(glib.Take(unsafe.Pointer(c))), nil
}
/*
* GtkColorChooserWidget
*/
// TODO:
// gtk_color_chooser_widget_new().
|
