// AlignmentNew is a wrapper around gtk_alignment_new().
func AlignmentNew(xalign, yalign, xscale, yscale float32) (*Alignment, error) {
c := C.gtk_alignment_new(C.gfloat(xalign), C.gfloat(yalign), C.gfloat(xscale),
C.gfloat(yscale))
if c == nil {
return nil, nilPtrErr
}
obj := wrapObject(unsafe.Pointer(c))
return wrapAlignment(obj), nil
}
func (v *GObject) Set(name string, value interface{}) {
ptr := C.CString(name)
defer C.free_string(ptr)
if _, ok := value.(WrappedObject); ok {
value = value.(WrappedObject).GetInternalValue()
}
if _, ok := value.(GObject); ok {
value = value.(GObject).Object
}
if _, ok := value.(GValue); ok {
value = value.(GValue).Value
}
switch value.(type) {
case bool:
bval := gbool(value.(bool))
C._g_object_set_addr(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(&bval))
case byte:
bval := C.gchar(value.(byte))
C._g_object_set_addr(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(&bval))
//C._g_object_set(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(reflect.ValueOf(C.gchar(value.(byte))).UnsafeAddr()))
case int:
ival := C.int(value.(int))
C._g_object_set_addr(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(&ival))
case uint:
uval := C.guint(value.(uint))
C._g_object_set_addr(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(&uval))
//C._g_object_set(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(reflect.ValueOf(C.guint(value.(uint))).UnsafeAddr()))
case float32:
f32val := C.gfloat(value.(float32))
C._g_object_set_addr(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(&f32val))
//C._g_object_set(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(reflect.ValueOf(C.gfloat(value.(float64))).UnsafeAddr()))
case float64:
f64val := C.gfloat(value.(float64))
C._g_object_set_addr(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(&f64val))
//C._g_object_set(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(reflect.ValueOf(C.gfloat(value.(float64))).UnsafeAddr()))
case string:
pval := C.CString(value.(string))
defer C.free_string(pval)
C._g_object_set_addr(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(&pval))
default:
if pv, ok := value.(*[0]uint8); ok {
C._g_object_set_ptr(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(pv))
} else {
av := reflect.ValueOf(value)
if av.Kind() == reflect.Ptr {
C._g_object_set_ptr(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(av.Pointer()))
} else if av.CanAddr() {
C._g_object_set_addr(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(av.UnsafeAddr()))
} else {
C._g_object_set_addr(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(&value))
}
}
}
}
/*
Modifies saturation and optionally pixelates @src, placing the result in
@dest. @src and @dest may be the same pixbuf with no ill effects. If
@saturation is 1.0 then saturation is not changed. If it's less than 1.0,
saturation is reduced (the image turns toward grayscale); if greater than
1.0, saturation is increased (the image gets more vivid colors). If @pixelate
is %TRUE, then pixels are faded in a checkerboard pattern to create a
pixelated image. @src and @dest must have the same image format, size, and
rowstride.
*/
func (self *TraitPixbuf) SaturateAndPixelate(dest IsPixbuf, saturation float32, pixelate bool) {
__cgo__pixelate := C.gboolean(0)
if pixelate {
__cgo__pixelate = C.gboolean(1)
}
C.gdk_pixbuf_saturate_and_pixelate(self.CPointer, dest.GetPixbufPointer(), C.gfloat(saturation), __cgo__pixelate)
return
}
/*
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
}
// Set value to i
func (v *Value) Set(i interface{}) {
if vg, ok := i.(ValueGetter); ok {
vg.Value().Copy(v)
return
}
// Other types
r := reflect.ValueOf(i)
switch r.Kind() {
case reflect.Invalid:
C.g_value_reset(v.g())
case reflect.Bool:
C.g_value_set_boolean(v.g(), gBoolean(r.Bool()))
case reflect.Int:
C.g_value_set_long(v.g(), C.glong(i.(int)))
case reflect.Int8:
C.g_value_set_schar(v.g(), C.gint8(i.(int8)))
case reflect.Int32:
C.g_value_set_int(v.g(), C.gint(i.(int32)))
case reflect.Int64:
C.g_value_set_int64(v.g(), C.gint64(i.(int64)))
case reflect.Uint:
C.g_value_set_ulong(v.g(), C.gulong(i.(uint)))
case reflect.Uint8:
C.g_value_set_uchar(v.g(), C.guchar(i.(uint8)))
case reflect.Uint32:
C.g_value_set_uint(v.g(), C.guint(i.(uint32)))
case reflect.Uint64:
C.g_value_set_uint64(v.g(), C.guint64(i.(uint64)))
case reflect.Float32:
C.g_value_set_float(v.g(), C.gfloat(i.(float32)))
case reflect.Float64:
C.g_value_set_double(v.g(), C.gdouble(i.(float64)))
case reflect.Ptr:
C.g_value_set_pointer(v.g(), C.gpointer(r.Pointer()))
case reflect.String:
C.g_value_set_static_string(v.g(), (*C.gchar)(C.CString(r.String())))
default:
panic("Can't represent Go value in Glib type system.")
}
}
func (self *Button) SetAlignment(xalign, yalign float32) {
C.gtk_button_set_alignment(self.object, C.gfloat(xalign), C.gfloat(yalign))
}
// pointerVal attempts to return an unsafe.Pointer for value.
// Not all types are understood, in which case a nil Pointer
// is returned.
func pointerVal(value interface{}) unsafe.Pointer {
var p unsafe.Pointer
switch v := value.(type) {
case bool:
c := gbool(v)
p = unsafe.Pointer(&c)
case int8:
c := C.gint8(v)
p = unsafe.Pointer(&c)
case int16:
c := C.gint16(v)
p = unsafe.Pointer(&c)
case int32:
c := C.gint32(v)
p = unsafe.Pointer(&c)
case int64:
c := C.gint64(v)
p = unsafe.Pointer(&c)
case int:
c := C.gint(v)
p = unsafe.Pointer(&c)
case uint8:
c := C.guchar(v)
p = unsafe.Pointer(&c)
case uint16:
c := C.guint16(v)
p = unsafe.Pointer(&c)
case uint32:
c := C.guint32(v)
p = unsafe.Pointer(&c)
case uint64:
c := C.guint64(v)
p = unsafe.Pointer(&c)
case uint:
c := C.guint(v)
p = unsafe.Pointer(&c)
case uintptr:
p = unsafe.Pointer(C.gpointer(v))
case float32:
c := C.gfloat(v)
p = unsafe.Pointer(&c)
case float64:
c := C.gdouble(v)
p = unsafe.Pointer(&c)
case string:
cstr := C.CString(v)
defer C.free(unsafe.Pointer(cstr))
p = unsafe.Pointer(cstr)
default:
if pv, ok := value.(unsafe.Pointer); ok {
p = pv
} else {
val := reflect.ValueOf(value)
switch val.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16,
reflect.Int32, reflect.Int64:
c := C.int(val.Int())
p = unsafe.Pointer(&c)
case reflect.Uintptr, reflect.Ptr, reflect.UnsafePointer:
p = unsafe.Pointer(C.gpointer(val.Pointer()))
}
}
}
return p
}
// SetFloat is a wrapper around g_value_set_float().
func (v *Value) SetFloat(val float32) {
C.g_value_set_float(v.native(), C.gfloat(val))
}
func gtk_misc_set_alignment(widget *C.GtkWidget, x float64, y float64) {
C.gtk_misc_set_alignment((*C.GtkMisc)(unsafe.Pointer(widget)), C.gfloat(x), C.gfloat(y))
}
func GFloat(val interface{}) *GValue {
fl := val.(float32)
gf := C.gfloat(fl)
return CreateCGValue(G_TYPE_FLOAT, unsafe.Pointer(&gf))
}
// SetAlignment is a wrapper around gtk_misc_set_alignment().
func (v *Misc) SetAlignment(xAlign, yAlign float32) {
C.gtk_misc_set_alignment(v.native(), C.gfloat(xAlign), C.gfloat(yAlign))
}
func (v *GObject) Set(name string, value interface{}) {
ptr := C.CString(name)
defer C.free_string(ptr)
if _, ok := value.(WrappedObject); ok {
value = value.(WrappedObject).GetInternalValue()
}
if _, ok := value.(GObject); ok {
value = value.(GObject).Object
}
if _, ok := value.(GValue); ok {
value = value.(GValue).Value
}
switch value.(type) {
case bool:
C._g_object_set(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(reflect.NewValue(bool2gboolean(value.(bool))).Addr()))
break
case byte:
C._g_object_set(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(reflect.NewValue(C.gchar(value.(byte))).Addr()))
break
case int:
C._g_object_set(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(reflect.NewValue(C.gint(value.(int))).Addr()))
break
case uint:
C._g_object_set(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(reflect.NewValue(C.guint(value.(uint))).Addr()))
break
case float:
C._g_object_set(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(reflect.NewValue(C.gfloat(value.(float))).Addr()))
break
case string:
{
pval := C.CString(value.(string))
defer C.free_string(pval)
C._g_object_set(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(reflect.NewValue(pval).Addr()))
}
break
default:
C._g_object_set(C.gpointer(v.Object), C.to_gcharptr(ptr), unsafe.Pointer(reflect.NewValue(value).Addr()))
break
}
}
func FromLua(code string) map[string]unsafe.Pointer {
lua := lgo.NewLua()
bindings := make(map[string]unsafe.Pointer)
processActorArgs := func(actor *C.ClutterActor, args map[interface{}]interface{}) unsafe.Pointer {
pointer := unsafe.Pointer(actor)
var minFilter, magFilter *C.ClutterScalingFilter
var scaleX C.gdouble = 1.0
var scaleY C.gdouble = 1.0
var translationX, translationY, translationZ C.gfloat
for k, v := range args {
switch key := k.(type) {
case string:
switch key {
case "id":
bindings[v.(string)] = pointer
case "bgcolor", "background_color":
C.clutter_actor_set_background_color(actor, NewColorFromString(v.(string)))
case "clip_rect":
clip := (*C.ClutterRect)(v.(unsafe.Pointer))
C.clutter_actor_set_clip(actor,
C.gfloat(clip.origin.x),
C.gfloat(clip.origin.y),
C.gfloat(clip.size.width),
C.gfloat(clip.size.height))
case "content":
C.clutter_actor_set_content(actor, (*C.ClutterContent)(v.(unsafe.Pointer)))
case "content_gravity":
switch v.(string) {
case "top-left":
C.clutter_actor_set_content_gravity(actor, C.CLUTTER_CONTENT_GRAVITY_TOP_LEFT)
case "top":
C.clutter_actor_set_content_gravity(actor, C.CLUTTER_CONTENT_GRAVITY_TOP)
case "top-right":
C.clutter_actor_set_content_gravity(actor, C.CLUTTER_CONTENT_GRAVITY_TOP_RIGHT)
case "left":
C.clutter_actor_set_content_gravity(actor, C.CLUTTER_CONTENT_GRAVITY_LEFT)
case "center":
C.clutter_actor_set_content_gravity(actor, C.CLUTTER_CONTENT_GRAVITY_CENTER)
case "right":
C.clutter_actor_set_content_gravity(actor, C.CLUTTER_CONTENT_GRAVITY_RIGHT)
case "bottom-left":
C.clutter_actor_set_content_gravity(actor, C.CLUTTER_CONTENT_GRAVITY_BOTTOM_LEFT)
case "bottom":
C.clutter_actor_set_content_gravity(actor, C.CLUTTER_CONTENT_GRAVITY_BOTTOM)
case "bottom-right":
C.clutter_actor_set_content_gravity(actor, C.CLUTTER_CONTENT_GRAVITY_BOTTOM_RIGHT)
case "resize-fill":
C.clutter_actor_set_content_gravity(actor, C.CLUTTER_CONTENT_GRAVITY_RESIZE_FILL)
case "resize-aspect":
C.clutter_actor_set_content_gravity(actor, C.CLUTTER_CONTENT_GRAVITY_RESIZE_ASPECT)
default:
log.Fatalf("unknown content gravity: %s", v.(string))
}
case "content_repeat":
switch v.(string) {
case "none":
C.clutter_actor_set_content_repeat(actor, C.CLUTTER_REPEAT_NONE)
case "x", "x-axis":
C.clutter_actor_set_content_repeat(actor, C.CLUTTER_REPEAT_X_AXIS)
case "y", "y-axis":
C.clutter_actor_set_content_repeat(actor, C.CLUTTER_REPEAT_Y_AXIS)
case "both":
C.clutter_actor_set_content_repeat(actor, C.CLUTTER_REPEAT_BOTH)
default:
log.Fatalf("unknown content repeat: %s", v.(string))
}
case "x", "fixed_x":
C.clutter_actor_set_x(actor, C.gfloat(v.(float64)))
case "y", "fixed_y":
C.clutter_actor_set_y(actor, C.gfloat(v.(float64)))
case "height":
C.clutter_actor_set_height(actor, C.gfloat(v.(float64)))
case "layout", "layout_manager":
C.clutter_actor_set_layout_manager(actor, (*C.ClutterLayoutManager)(v.(unsafe.Pointer)))
case "mag_filter", "magnification_filter":
magFilter = (*C.ClutterScalingFilter)(v.(unsafe.Pointer))
C.clutter_actor_set_content_scaling_filters(actor, *minFilter, *magFilter)
case "margin_bottom":
C.clutter_actor_set_margin_bottom(actor, C.gfloat(v.(float64)))
case "margin_left":
C.clutter_actor_set_margin_left(actor, C.gfloat(v.(float64)))
case "margin_right":
C.clutter_actor_set_margin_right(actor, C.gfloat(v.(float64)))
case "margin_top":
C.clutter_actor_set_margin_top(actor, C.gfloat(v.(float64)))
//TODO min height
//TODO min width
case "min_filter", "minification_filter":
minFilter = (*C.ClutterScalingFilter)(v.(unsafe.Pointer))
C.clutter_actor_set_content_scaling_filters(actor, *minFilter, *magFilter)
case "name":
C.clutter_actor_set_name(actor, toGStr(v.(string)))
//TODO natural height
//TODO natural width
case "offscreen_redirect":
switch v.(string) {
case "auto", "automatic-for-opacity":
C.clutter_actor_set_offscreen_redirect(actor, C.CLUTTER_OFFSCREEN_REDIRECT_AUTOMATIC_FOR_OPACITY)
case "always":
C.clutter_actor_set_offscreen_redirect(actor, C.CLUTTER_OFFSCREEN_REDIRECT_ALWAYS)
default:
log.Fatalf("unknown offscreen redirect option: %s", v.(string))
}
case "opacity":
C.clutter_actor_set_opacity(actor, C.guint8(uint8(v.(float64))))
case "pivot_point":
point := (*C.ClutterPoint)(v.(unsafe.Pointer))
C.clutter_actor_set_pivot_point(actor, C.gfloat(point.x), C.gfloat(point.y))
case "pivot_point_z":
C.clutter_actor_set_pivot_point_z(actor, C.gfloat(v.(float64)))
case "position":
point := (*C.ClutterPoint)(v.(unsafe.Pointer))
C.clutter_actor_set_position(actor, C.gfloat(point.x), C.gfloat(point.y))
case "reactive":
b := C.FALSE
if v.(bool) {
b = C.TRUE
}
C.clutter_actor_set_reactive(actor, C.gboolean(b))
case "request_mode":
switch v.(string) {
case "height", "height_for_width":
C.clutter_actor_set_request_mode(actor, C.CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
case "width", "width_for_height":
C.clutter_actor_set_request_mode(actor, C.CLUTTER_REQUEST_WIDTH_FOR_HEIGHT)
default:
log.Fatalf("unknown request mode: %s", v.(string))
}
case "rotation_angle_x":
C.clutter_actor_set_rotation_angle(actor, C.CLUTTER_X_AXIS, C.gdouble(v.(float64)))
case "rotation_angle_y":
C.clutter_actor_set_rotation_angle(actor, C.CLUTTER_Y_AXIS, C.gdouble(v.(float64)))
case "rotation_angle_z":
C.clutter_actor_set_rotation_angle(actor, C.CLUTTER_Z_AXIS, C.gdouble(v.(float64)))
case "scale_x":
scaleX = C.gdouble(v.(float64))
C.clutter_actor_set_scale(actor, scaleX, scaleY)
case "scale_y":
scaleY = C.gdouble(v.(float64))
C.clutter_actor_set_scale(actor, scaleX, scaleY)
case "scale_z":
C.clutter_actor_set_scale_z(actor, C.gdouble(v.(float64)))
case "size":
size := (*C.ClutterSize)(v.(unsafe.Pointer))
C.clutter_actor_set_size(actor, C.gfloat(size.width), C.gfloat(size.height))
case "text_direction", "text_dir":
switch v.(string) {
case "default":
C.clutter_actor_set_text_direction(actor, C.CLUTTER_TEXT_DIRECTION_DEFAULT)
case "left", "left-to-right", "ltr":
C.clutter_actor_set_text_direction(actor, C.CLUTTER_TEXT_DIRECTION_LTR)
case "right", "right-to-left", "rtl":
C.clutter_actor_set_text_direction(actor, C.CLUTTER_TEXT_DIRECTION_RTL)
default:
log.Fatalf("unknown text direction: %s", v.(string))
}
//TODO transform
case "translation_x":
translationX = C.gfloat(v.(float64))
C.clutter_actor_set_translation(actor, translationX, translationY, translationZ)
case "translation_y":
translationY = C.gfloat(v.(float64))
C.clutter_actor_set_translation(actor, translationX, translationY, translationZ)
case "translation_z":
translationZ = C.gfloat(v.(float64))
C.clutter_actor_set_translation(actor, translationX, translationY, translationZ)
case "visible":
if v.(bool) {
C.clutter_actor_show(actor)
} else {
C.clutter_actor_hide(actor)
}
case "width":
C.clutter_actor_set_width(actor, C.gfloat(v.(float64)))
case "x_align":
switch v.(string) {
case "fill":
C.clutter_actor_set_x_align(actor, C.CLUTTER_ACTOR_ALIGN_FILL)
case "start":
C.clutter_actor_set_x_align(actor, C.CLUTTER_ACTOR_ALIGN_START)
case "center":
C.clutter_actor_set_x_align(actor, C.CLUTTER_ACTOR_ALIGN_CENTER)
case "end":
C.clutter_actor_set_x_align(actor, C.CLUTTER_ACTOR_ALIGN_END)
default:
log.Fatalf("unknown x align: %s", v.(string))
}
case "x_expand":
b := C.FALSE
if v.(bool) {
b = C.TRUE
}
C.clutter_actor_set_x_expand(actor, C.gboolean(b))
case "y_align":
switch v.(string) {
case "fill":
C.clutter_actor_set_y_align(actor, C.CLUTTER_ACTOR_ALIGN_FILL)
case "start":
C.clutter_actor_set_y_align(actor, C.CLUTTER_ACTOR_ALIGN_START)
case "center":
C.clutter_actor_set_y_align(actor, C.CLUTTER_ACTOR_ALIGN_CENTER)
case "end":
C.clutter_actor_set_y_align(actor, C.CLUTTER_ACTOR_ALIGN_END)
default:
log.Fatalf("unknown y align: %s", v.(string))
}
case "y_expand":
b := C.FALSE
if v.(bool) {
b = C.TRUE
}
C.clutter_actor_set_y_expand(actor, C.gboolean(b))
case "z", "z_position":
C.clutter_actor_set_z_position(actor, C.gfloat(v.(float64)))
}
case float64:
switch value := v.(type) {
case unsafe.Pointer:
//TODO add tests
if IsActor(value) { // actor child
C.clutter_actor_add_child(actor, (*C.ClutterActor)(value))
} else if IsAction(value) { // action
C.clutter_actor_add_action(actor, (*C.ClutterAction)(value))
} else if IsConstraint(value) { // constraint
C.clutter_actor_add_constraint(actor, (*C.ClutterConstraint)(value))
} else if IsEffect(value) { // effect
C.clutter_actor_add_effect(actor, (*C.ClutterEffect)(value))
} else {
log.Fatalf("unknown subelement type")
}
}
}
}
return pointer
}
processBoxArgs := func(box *C.ClutterLayoutManager, args map[string]interface{}) {
//TODO
}
lua.RegisterFunctions(map[string]interface{}{
// actors
"Actor": func(args map[interface{}]interface{}) unsafe.Pointer {
actor := C.clutter_actor_new()
return processActorArgs(actor, args)
},
"Stage": func(args map[interface{}]interface{}) unsafe.Pointer {
window := C.gtk_window_new(C.GTK_WINDOW_TOPLEVEL)
embed := C.gtk_clutter_embed_new()
C.gtk_container_add((*C.GtkContainer)(unsafe.Pointer(window)), embed)
actor := C.gtk_clutter_embed_get_stage((*C.GtkClutterEmbed)(unsafe.Pointer(embed)))
C.clutter_actor_show(actor)
C.gtk_widget_show_all((*C.GtkWidget)(unsafe.Pointer(window)))
pointer := processActorArgs(actor, args)
stage := (*C.ClutterStage)(unsafe.Pointer(actor))
for k, v := range args {
//TODO other properties
switch key := k.(type) {
case string:
switch key {
case "title":
C.clutter_stage_set_title(stage, toGStr(v.(string)))
}
}
}
return pointer
},
"Text": func(args map[interface{}]interface{}) unsafe.Pointer {
actor := C.clutter_text_new()
pointer := processActorArgs(actor, args)
text := (*C.ClutterText)(unsafe.Pointer(actor))
for k, v := range args {
//TODO other properties
switch key := k.(type) {
case string:
switch key {
case "text":
C.clutter_text_set_text(text, toGStr(v.(string)))
case "use_markup":
b := C.FALSE
if v.(bool) {
b = C.TRUE
}
C.clutter_text_set_use_markup(text, C.gboolean(b))
case "markup":
C.clutter_text_set_markup(text, toGStr(v.(string)))
case "color":
C.clutter_text_set_color(text, NewColorFromString(v.(string)))
}
case float64:
}
}
return pointer
},
// data structures
"Point": func(args []float64) unsafe.Pointer {
var point C.ClutterPoint
point.x = C.float(args[0])
point.y = C.float(args[1])
return unsafe.Pointer(&point)
},
"Size": func(args []float64) unsafe.Pointer {
var size C.ClutterSize
size.width = C.float(args[0])
size.height = C.float(args[1])
return unsafe.Pointer(&size)
},
"Rect": func(args []float64) unsafe.Pointer {
var rect C.ClutterRect
var point C.ClutterPoint
var size C.ClutterSize
point.x = C.float(args[0])
point.y = C.float(args[1])
size.width = C.float(args[2])
size.height = C.float(args[3])
rect.origin = point
rect.size = size
return unsafe.Pointer(&rect)
},
// contents
"Image": func(args []string) unsafe.Pointer {
//TODO set data
image := C.clutter_image_new()
return unsafe.Pointer(image)
},
// layouts
"Box": func(args map[string]interface{}) unsafe.Pointer {
box := C.clutter_box_layout_new()
processBoxArgs(box, args)
return unsafe.Pointer(box)
},
"HBox": func(args map[string]interface{}) unsafe.Pointer {
box := C.clutter_box_layout_new()
C.clutter_box_layout_set_orientation((*C.ClutterBoxLayout)(unsafe.Pointer(box)), C.CLUTTER_ORIENTATION_HORIZONTAL)
processBoxArgs(box, args)
return unsafe.Pointer(box)
},
"VBox": func(args map[string]interface{}) unsafe.Pointer {
box := C.clutter_box_layout_new()
C.clutter_box_layout_set_orientation((*C.ClutterBoxLayout)(unsafe.Pointer(box)), C.CLUTTER_ORIENTATION_VERTICAL)
processBoxArgs(box, args)
return unsafe.Pointer(box)
},
// effects
"Blur": func(args map[string]interface{}) unsafe.Pointer {
effect := C.clutter_blur_effect_new()
return unsafe.Pointer(effect)
},
// constraints
"Align": func(args map[string]interface{}) unsafe.Pointer {
constraint := C.clutter_align_constraint_new(nil, C.CLUTTER_ALIGN_X_AXIS, 0)
align := (*C.ClutterAlignConstraint)(unsafe.Pointer(constraint))
for key, v := range args {
switch key {
case "source":
C.clutter_align_constraint_set_source(align, (*C.ClutterActor)(bindings[v.(string)]))
case "axis":
switch v.(string) {
case "x", "X":
C.clutter_align_constraint_set_align_axis(align, C.CLUTTER_ALIGN_X_AXIS)
case "y", "Y":
C.clutter_align_constraint_set_align_axis(align, C.CLUTTER_ALIGN_Y_AXIS)
case "both", "BOTH", "Both":
C.clutter_align_constraint_set_align_axis(align, C.CLUTTER_ALIGN_BOTH)
}
case "factor":
C.clutter_align_constraint_set_factor(align, C.gfloat(v.(float64)))
}
}
return unsafe.Pointer(constraint)
},
})
lua.RunString(code)
return bindings
}
// Set() is a wrapper around g_object_set(). However, unlike
// g_object_set(), this function only sets one name value pair. Make
// multiple calls to this function to set multiple properties.
func (v *Object) Set(name string, value interface{}) error {
cstr := C.CString(name)
defer C.free(unsafe.Pointer(cstr))
if _, ok := value.(Object); ok {
value = value.(Object).GObject
}
var p unsafe.Pointer = nil
switch value.(type) {
case bool:
c := gbool(value.(bool))
p = unsafe.Pointer(&c)
case int8:
c := C.gint8(value.(int8))
p = unsafe.Pointer(&c)
case int16:
c := C.gint16(value.(int16))
p = unsafe.Pointer(&c)
case int32:
c := C.gint32(value.(int32))
p = unsafe.Pointer(&c)
case int64:
c := C.gint64(value.(int64))
p = unsafe.Pointer(&c)
case int:
c := C.gint(value.(int))
p = unsafe.Pointer(&c)
case uint8:
c := C.guchar(value.(uint8))
p = unsafe.Pointer(&c)
case uint16:
c := C.guint16(value.(uint16))
p = unsafe.Pointer(&c)
case uint32:
c := C.guint32(value.(uint32))
p = unsafe.Pointer(&c)
case uint64:
c := C.guint64(value.(uint64))
p = unsafe.Pointer(&c)
case uint:
c := C.guint(value.(uint))
p = unsafe.Pointer(&c)
case uintptr:
p = unsafe.Pointer(C.gpointer(value.(uintptr)))
case float32:
c := C.gfloat(value.(float32))
p = unsafe.Pointer(&c)
case float64:
c := C.gdouble(value.(float64))
p = unsafe.Pointer(&c)
case string:
cstr := C.CString(value.(string))
defer C.free(unsafe.Pointer(cstr))
p = unsafe.Pointer(cstr)
default:
if pv, ok := value.(unsafe.Pointer); ok {
p = pv
} else {
// Constants with separate types are not type asserted
// above, so do a runtime check here instead.
val := reflect.ValueOf(value)
switch val.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16,
reflect.Int32, reflect.Int64:
c := C.int(val.Int())
p = unsafe.Pointer(&c)
case reflect.Uintptr:
p = unsafe.Pointer(C.gpointer(val.Pointer()))
}
}
}
// Can't call g_object_set() as it uses a variable arg list, use a
// wrapper instead
if p != nil {
C._g_object_set_one(C.gpointer(v.GObject), (*C.gchar)(cstr), p)
return nil
} else {
return errors.New("Unable to perform type conversion")
}
}
func GlibFloat(f float32) C.gfloat {
return C.gfloat(f)
}
// Set is a wrapper around gtk_alignment_set().
func (v *Alignment) Set(xalign, yalign, xscale, yscale float32) {
C.gtk_alignment_set(v.native(), C.gfloat(xalign), C.gfloat(yalign),
C.gfloat(xscale), C.gfloat(yscale))
}
func (v *WebKitWebView) SetZoomLevel(zoom_level float64) {
C.webkit_web_view_set_zoom_level(v.getWebView(), C.gfloat(zoom_level))
}
func (self *Frame) SetLabelAlign(xalign, yalign float32) {
C.gtk_frame_set_label_align(self.object, C.gfloat(xalign), C.gfloat(yalign))
}