allow creating a GValue containing a GType (typically translated from a Julia type)

Author: vtjnash

LICENSE.md

@@ -1,6 +1,6 @@
 The Julia-Gtk bindings are licensed under the MIT License:
 
-> Copyright (c) 2013: Jameson Nash and other contributors:
+> Copyright (c) 2013-2014: Jameson Nash and other contributors:
 > 
 > https://github.com/JuliaLang/Gtk.jl/contributors
 > 

src/GLib/GLib.jl

@@ -2,7 +2,7 @@ module GLib
 import Base: convert, show, showall, showcompact, size, length, getindex, setindex!,
              start, next, done, eltype
 export GObject, GObjectI, GType, @Gtype, @Gabstract
-export Enum, GError, GValue, gvalue, make_gvalue
+export Enum, GError, GValue, gvalue, make_gvalue, g_type
 export GSList, gslist, gslist2, gc_ref, gc_unref, gc_ref_closure
 export signal_connect, signal_emit, signal_handler_disconnect
 export signal_handler_block, signal_handler_unblock

src/GLib/MutableTypes.jl

@@ -42,7 +42,7 @@ Base.unsafe_store!(b::MutableA, x) = (b.x[b.i] = x)
 Base.getindex(b::MutableX) = b.x
 Base.getindex(b::MutableA) = b.x[b.i]
 
-Base.setindex!(b::MutableX, x) = (b.x = x)
-Base.setindex!(b::MutableA, x) = (b.x[b.i] = x)
+Base.setindex!{T}(b::MutableX{T}, x::T) = (b.x = x)
+Base.setindex!{T,N}(b::MutableA{T,N}, x::T) = (b.x[b.i] = x)
 
 end

src/GLib/gerror.jl

@@ -9,7 +9,7 @@ convert(::Type{GError}, err::Ptr{GError}) = GError(err)
 GError(err::Ptr{GError}) = unsafe_load(err)
 function GError(f::Function)
     err = mutable(Ptr{GError})
-    err[] = C_NULL
+    err.x = C_NULL
     if !f(err) || err[] != C_NULL
         gerror = GError(err[])
         emsg = bytestring(gerror.message)

src/GLib/gtype.jl

@@ -34,16 +34,23 @@ const fundamental_types = (
     (:GBoxed,     Ptr{Void},        None,           :boxed),
     (:GParam,     Ptr{GParamSpec},  Ptr{GParamSpec},:param),
     (:GObject,    Ptr{GObject},     GObject,        :object),
-    #(:GType,      Int,              None,           :gtype), # this isn't a fundamental type
     #(:GVariant,  Ptr{GVariant},    GVariant,       :variant),
     )
-# NOTE: in general do not cache ids, except for the fundamental values
+# NOTE: in general do not cache ids, except for these fundamental values
 g_type_from_name(name::Symbol) = ccall((:g_type_from_name,libgobject),GType,(Ptr{Uint8},),name)
-# these constants are used elsewhere
-const gvoid_id = g_type_from_name(:void)
+const fundamental_ids = tuple(Int[g_type_from_name(name) for (name,c,j,f) in fundamental_types]...)
+# this constant is needed elsewhere, but doesn't have a matching Julia type so it can't be used from g_type
 const gboxed_id = g_type_from_name(:GBoxed)
-const gobject_id = g_type_from_name(:GObject)
-const gstring_id = g_type_from_name(:gchararray)
+
+g_type(gtyp::GType) = gtyp
+let jtypes = Expr(:block, :( g_type(::Type{Void}) = $(g_type_from_name(:void)) ))
+    for (i,(name, ctype, juliatype, g_value_fn)) in enumerate(fundamental_types)
+        if juliatype !== None
+            push!(jtypes.args, :( g_type{T<:$juliatype}(::Type{T}) = convert(GType,$(fundamental_ids[i])) ))
+        end
+    end
+    eval(jtypes)
+end
 
 G_TYPE_FROM_CLASS(w::Ptr{Void}) = unsafe_load(convert(Ptr{GType},w))
 G_OBJECT_GET_CLASS(w::GObject) = G_OBJECT_GET_CLASS(w.handle)
@@ -63,9 +70,6 @@ type GObjectAny <: GObjectI
     GObjectAny(handle::Ptr{GObject}) = (handle != C_NULL ? gc_ref(new(handle)) : error("Cannot construct $gname with a NULL pointer"))
 end
 g_type(obj::GObjectI) = g_type(typeof(obj))
-g_type(::Type{GObjectI}) = gobject_id
-g_type(::Type{GObject}) = gobject_id
-g_type(::Type{GObjectAny}) = gobject_id
 
 const gtype_ifaces = Dict{Symbol,Type}()
 const gtype_wrappers = Dict{Symbol,Type}()

src/GLib/gvalues.jl

@@ -6,7 +6,7 @@ immutable GValue
     field3::Uint64
     GValue() = new(0,0,0)
 end
-typealias GV Union(Mutable{GValue}, Vector{GValue}, Ptr{GValue})
+typealias GV Union(Mutable{GValue}, Ptr{GValue})
 Base.zero(::Type{GValue}) = GValue()
 function gvalue{T}(::Type{T})
     v = mutable(GValue())
@@ -21,16 +21,30 @@ end
 function gvalues(xs...)
     v = zeros(GValue, length(xs))
     for (i,x) in enumerate(xs)
+        T = typeof(x)
         gv = mutable(v,i)
-        gv[] = typeof(x) # init type
-        gv[] = x # init value
+        gv[] = T  # init type
+        gv[T] = x # init value
     end
     finalizer(v, (v)->for i = 1:length(v)
             ccall((:g_value_unset,libgobject),Void,(Ptr{GValue},),pointer(v,i))
         end)
     v
 end
 
+function setindex!(dest::GV, src::GV)
+    bool(ccall((:g_value_transform,libgobject),Cint,(Ptr{GValue},Ptr{GValue}),src,dest))
+    src
+end
+
+setindex!(::Type{Void},v::GV) = v
+setindex!(v::GLib.GV, x) = setindex!(v, x, typeof(x))
+setindex!(gv::GV, x, i::Int) = setindex!(mutable(gv,i), x)
+
+getindex{T}(gv::GV, i::Int, ::Type{T}) = getindex(mutable(gv,i), T)
+getindex(gv::GV, i::Int) = getindex(mutable(gv,i))
+getindex(v::GV,i::Int, ::Type{Void}) = nothing
+
 #let
 #global make_gvalue, getindex
 function make_gvalue(pass_x,as_ctype,to_gtype,with_id,allow_reverse::Bool=true,fundamental::Bool=false)
@@ -44,32 +58,39 @@ function make_gvalue(pass_x,as_ctype,to_gtype,with_id,allow_reverse::Bool=true,f
                 ccall((:g_value_init,GLib.libgobject),Void,(Ptr{GLib.GValue},Csize_t), v, $with_id)
                 v
             end
-            function Base.setindex!{T<:$pass_x}(v::GLib.GV, x::T)
-                $(if to_gtype == :string; :(x = GLib.bytestring(x)) end)
-                $(if to_gtype == :pointer || to_gtype == :boxed; :(x = GLib.mutable(x)) end)
+            function Base.setindex!{T<:$pass_x}(v::GLib.GV, x, ::Type{T})
+                $(  if to_gtype == :string
+                        :(x = GLib.bytestring(x))
+                    elseif to_gtype == :pointer || to_gtype == :boxed
+                        :(x = GLib.mutable(x))
+                    elseif to_gtype == :gtype
+                        :(x = GLib.g_type(x))
+                    end)
                 ccall(($(string("g_value_set_",to_gtype)),GLib.libgobject),Void,(Ptr{GLib.GValue},$as_ctype), v, x)
                 if isa(v, GLib.MutableTypes.MutableX)
                     finalizer(v, (v::GLib.MutableTypes.MutableX)->ccall((:g_value_unset,GLib.libgobject),Void,(Ptr{GLib.GValue},), v))
                 end
                 v
             end
         end)
-        if to_gtype == :static_string
-            to_gtype = :string
-        end
+    end
+    if to_gtype == :static_string
+        to_gtype = :string
+    end
+    if pass_x !== None
         eval(current_module(),quote
             function Base.getindex{T<:$pass_x}(v::GLib.GV,::Type{T})
                 x = ccall(($(string("g_value_get_",to_gtype)),GLib.libgobject),$as_ctype,(Ptr{GLib.GValue},), v)
-                $(if to_gtype == :string; :(x = GLib.bytestring(x)) end)
-                $(if pass_x == Symbol; :(x = symbol(x)) end)
+                $(  if to_gtype == :string
+                        :(x = GLib.bytestring(x))
+                    elseif pass_x == Symbol
+                        :(x = symbol(x))
+                    end)
                 return Base.convert(T,x)
             end
         end)
     end
     if fundamental || allow_reverse
-        if to_gtype == :static_string
-            to_gtype = :string
-        end
         fn = eval(current_module(),quote
             function(v::GLib.GV)
                 x = ccall(($(string("g_value_get_",to_gtype)),GLib.libgobject),$as_ctype,(Ptr{GLib.GValue},), v)
@@ -86,53 +107,42 @@ function make_gvalue(pass_x,as_ctype,to_gtype,with_id,allow_reverse::Bool=true,f
     end
 end
 const gvalue_types = {}
-const fundamental_ids = tuple(Int[g_type_from_name(name) for (name,c,j,f) in fundamental_types]...)
 const fundamental_fns = tuple(Function[make_gvalue(juliatype, ctype, g_value_fn, fundamental_ids[i], false, true) for
     (i,(name, ctype, juliatype, g_value_fn)) in enumerate(fundamental_types)]...)
-make_gvalue(Symbol, Ptr{Uint8}, :static_string, :gstring_id, false)
+make_gvalue(Symbol, Ptr{Uint8}, :static_string, :(g_type(String)), false)
+make_gvalue(Type, GType, :gtype, (:g_gtype,:libgobject))
 
 function getindex(gv::Union(Mutable{GValue}, Ptr{GValue}))
-    g_type = unsafe_load(gv).g_type
-    if g_type == 0
+    gtyp = unsafe_load(gv).g_type
+    if gtyp == 0
         error("Invalid GValue type")
     end
-    if g_type == gvoid_id
+    if gtyp == g_type(Void)
         return nothing
     end
     # first pass: fast loop for fundamental types
     for (i,id) in enumerate(fundamental_ids)
-        if id == g_type  # if g_type == id
+        if id == gtyp  # if g_type == id
             return fundamental_fns[i](gv)
         end
     end
     # second pass: user defined (sub)types
     for (typ, typefn, getfn) in gvalue_types
-        if bool(ccall((:g_type_is_a,libgobject),Cint,(Int,Int),g_type,typefn())) # if g_type <: expr()
+        if bool(ccall((:g_type_is_a,libgobject),Cint,(Int,Int),gtyp,typefn())) # if gtyp <: expr()
             return getfn(gv)
         end
     end
     # last pass: check for derived fundamental types (which have not been overridden by the user)
     for (i,id) in enumerate(fundamental_ids)
-        if bool(ccall((:g_type_is_a,libgobject),Cint,(Int,Int),g_type,id)) # if g_type <: id
+        if bool(ccall((:g_type_is_a,libgobject),Cint,(Int,Int),gtyp,id)) # if gtyp <: id
             return fundamental_fns[i](gv)
         end
     end
-    typename = g_type_name(g_type)
+    typename = g_type_name(gtyp)
     error("Could not convert GValue of type $typename to Julia type")
 end
 #end
 
-function setindex!(dest::GV, src::GV)
-    bool(ccall((:g_value_transform,libgobject),Cint,(Ptr{GValue},Ptr{GValue}),src,dest))
-    src
-end
-
-setindex!(::Type{Void},v::GV) = v
-setindex!(gv::GV, i::Int, x) = setindex!(mutable(gv,i), x)
-getindex{T}(gv::GV, i::Int, ::Type{T}) = getindex(mutable(gv,i), T)
-getindex(gv::Union(Mutable{GValue}, Ptr{GValue}), i::Int) = getindex(mutable(gv,i))
-getindex(v::GV,i::Int,::Type{Void}) = nothing
-
 function getindex{T}(w::GObject, name::Union(String,Symbol), ::Type{T})
     v = gvalue(T)
     ccall((:g_object_get_property,libgobject), Void,
@@ -167,13 +177,12 @@ function show(io::IO, w::GObject)
         const READABLE=1
         if (param.flags&1)==READABLE &&
                 bool(ccall((:g_value_type_transformable,libgobject),Cint,
-                (Int,Int),param.value_type,gstring_id))
+                (Int,Int),param.value_type,g_type(String)))
             ccall((:g_object_get_property,libgobject), Void,
                 (Ptr{GObject}, Ptr{Uint8}, Ptr{GValue}), w, param.name, v)
             str = ccall((:g_value_get_string,libgobject),Ptr{Uint8},(Ptr{GValue},), v)
             value = (str == C_NULL ? "NULL" : bytestring(str))
-            ccall((:g_value_reset,libgobject),Ptr{Void},(Ptr{GValue},), v)
-            if param.value_type == gstring_id && str != C_NULL
+            if param.value_type == g_type(String) && str != C_NULL
                 print(io,"=\"",value,'"')
             else
                 print(io,'=',value)
@@ -194,8 +203,8 @@ end
 #  instance_size::Cuint
 #  GTypeQuery() = new(0,0,0,0)
 #end
-#function gsizeof(g_type)
+#function gsizeof(gtyp)
 #    q = mutable(GTypeQuery)
-#    ccall((:g_type_query,libgobject),Void,(Int,Ptr{GTypeQuery},),g_type,q)
+#    ccall((:g_type_query,libgobject),Void,(Int,Ptr{GTypeQuery},),gtyp,q)
 #    q[].instance_size
 #end

src/GLib/signals.jl

@@ -67,13 +67,13 @@ function GClosureMarshal(closuref, return_value, n_param_values,
             length(param_types)+1 == n_param_values || error("GCallback called with the wrong number of parameters")
             for i = 1:n_param_values
                 gv = mutable(param_values,i)
-                g_type = unsafe_load(gv).g_type
+                gtyp = unsafe_load(gv).g_type
                 # avoid auto-unboxing for some builtin types in gtk_calling_convention mode
-                if bool(ccall((:g_type_is_a,libgobject),Cint,(Int,Int),g_type,gobject_id))
+                if bool(ccall((:g_type_is_a,libgobject),Cint,(Int,Int),gtyp,g_type(GObject)))
                     params[i] = ccall((:g_value_get_object,libgobject), Ptr{GObject}, (Ptr{GValue},), gv)
-                elseif bool(ccall((:g_type_is_a,libgobject),Cint,(Int,Int),g_type,gboxed_id))
+                elseif bool(ccall((:g_type_is_a,libgobject),Cint,(Int,Int),gtyp,gboxed_id))
                     params[i] = ccall((:g_value_get_boxed,libgobject), Ptr{Void}, (Ptr{GValue},), gv)
-                elseif bool(ccall((:g_type_is_a,libgobject),Cint,(Int,Int),g_type,gstring_id))
+                elseif bool(ccall((:g_type_is_a,libgobject),Cint,(Int,Int),gtyp,g_type(String)))
                     params[i] = ccall((:g_value_get_string,libgobject), Ptr{Void}, (Ptr{GValue},), gv)
                 else
                     params[i] = gv[]
@@ -90,8 +90,8 @@ function GClosureMarshal(closuref, return_value, n_param_values,
         end
         retval = cb(params...) # widget, args...
         if return_value != C_NULL && retval !== nothing
-            g_type = unsafe_load(return_value).g_type
-            if g_type != gvoid_id && g_type != 0
+            gtyp = unsafe_load(return_value).g_type
+            if gtyp != g_type(Void) && gtyp != 0
                 return_value[] = gvalue(retval)
             end
         end