juliagizmos / gtkreactive.jl Goto Github PK

I'm running drawing.jl from the REPL.

Ubuntu 20.04
JULIA VERSION 1.4.2

Any suggestions for the error below?

julia> ┌ Warning: Error in @guarded callback └ @ GtkReactive ~/.julia/packages/Gtk/X7HfN/src/base.jl:90 ERROR: MethodError: no method matching drawline(::Cairo.CairoContext, ::Array{Any,1}, ::RGB{FixedPointNumbers.Normed{UInt8,8}}) The applicable method may be too new: running in world age 27230, while current world is 27231. Closest candidates are: drawline(::Any, ::Any, ::Any) at none:2 (method too new to be called from this world context.) Stacktrace: [1] (::var"#9#10")(::Gtk.GtkCanvas, ::Array{Any,1}, ::Array{Any,1}) at ./none:6 [2] (::GtkReactive.var"#159#161"{var"#9#10",Tuple{Signal{Array{Any,1}},Signal{Array{Any,1}}}})(::Gtk.GtkCanvas) at /home/peter/.julia/packages/Gtk/X7HfN/src/base.jl:88 [3] draw(::Gtk.GtkCanvas, ::Bool) at /home/peter/.julia/packages/Gtk/X7HfN/src/cairo.jl:86 [4] draw at /home/peter/.julia/packages/Gtk/X7HfN/src/cairo.jl:84 [inlined] [5] #160 at /home/peter/.julia/packages/GtkReactive/lAPT0/src/graphics_interaction.jl:296 [inlined] [6] #33 at /home/peter/.julia/packages/Reactive/g1LZ6/src/operators.jl:41 [inlined] [7] runaction(::Reactive.var"#33#34"{GtkReactive.var"#160#162"{GtkReactive.Canvas{UserUnit}},Signal{Nothing},Tuple{Signal{Array{Any,1}},Signal{Array{Any,1}}}}) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:313 [8] foreach(::typeof(Reactive.runaction), ::Array{Function,1}) at ./abstractarray.jl:1919 [9] run_node(::Signal{Nothing}) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:340 [10] run_push(::Signal{Array{Any,1}}, ::Array{Any,1}, ::typeof(Reactive.print_error), ::Bool) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:358 [11] run_push(::Signal{Array{Any,1}}, ::Array{Any,1}, ::Function) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:345 [12] run(::Int64) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:306 [13] run at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:300 [inlined] [14] (::Reactive.var"#27#29")() at ./task.jl:358 ┌ Warning: Error in @guarded callback └ @ GtkReactive ~/.julia/packages/Gtk/X7HfN/src/base.jl:90 ERROR: MethodError: no method matching drawline(::Cairo.CairoContext, ::Array{Any,1}, ::RGB{FixedPointNumbers.Normed{UInt8,8}}) The applicable method may be too new: running in world age 27230, while current world is 27231. Closest candidates are: drawline(::Any, ::Any, ::Any) at none:2 (method too new to be called from this world context.) Stacktrace: [1] (::var"#9#10")(::Gtk.GtkCanvas, ::Array{Any,1}, ::Array{Any,1}) at ./none:6 [2] (::GtkReactive.var"#159#161"{var"#9#10",Tuple{Signal{Array{Any,1}},Signal{Array{Any,1}}}})(::Gtk.GtkCanvas) at /home/peter/.julia/packages/Gtk/X7HfN/src/base.jl:88 [3] draw(::Gtk.GtkCanvas, ::Bool) at /home/peter/.julia/packages/Gtk/X7HfN/src/cairo.jl:86 [4] draw at /home/peter/.julia/packages/Gtk/X7HfN/src/cairo.jl:84 [inlined] [5] #160 at /home/peter/.julia/packages/GtkReactive/lAPT0/src/graphics_interaction.jl:296 [inlined] [6] #33 at /home/peter/.julia/packages/Reactive/g1LZ6/src/operators.jl:41 [inlined] [7] runaction(::Reactive.var"#33#34"{GtkReactive.var"#160#162"{GtkReactive.Canvas{UserUnit}},Signal{Nothing},Tuple{Signal{Array{Any,1}},Signal{Array{Any,1}}}}) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:313 [8] foreach(::typeof(Reactive.runaction), ::Array{Function,1}) at ./abstractarray.jl:1919 [9] run_node(::Signal{Nothing}) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:340 [10] run_push(::Signal{Array{Any,1}}, ::Array{Any,1}, ::typeof(Reactive.print_error), ::Bool) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:358 [11] run_push(::Signal{Array{Any,1}}, ::Array{Any,1}, ::Function) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:345 [12] run(::Int64) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:306 [13] run at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:300 [inlined] [14] (::Reactive.var"#27#29")() at ./task.jl:358 ┌ Warning: Error in @guarded callback └ @ GtkReactive ~/.julia/packages/Gtk/X7HfN/src/base.jl:90 ERROR: MethodError: no method matching drawline(::Cairo.CairoContext, ::Array{Any,1}, ::RGB{FixedPointNumbers.Normed{UInt8,8}}) The applicable method may be too new: running in world age 27230, while current world is 27231. Closest candidates are: drawline(::Any, ::Any, ::Any) at none:2 (method too new to be called from this world context.) Stacktrace: [1] (::var"#9#10")(::Gtk.GtkCanvas, ::Array{Any,1}, ::Array{Any,1}) at ./none:6 [2] (::GtkReactive.var"#159#161"{var"#9#10",Tuple{Signal{Array{Any,1}},Signal{Array{Any,1}}}})(::Gtk.GtkCanvas) at /home/peter/.julia/packages/Gtk/X7HfN/src/base.jl:88 [3] draw(::Gtk.GtkCanvas, ::Bool) at /home/peter/.julia/packages/Gtk/X7HfN/src/cairo.jl:86 [4] draw at /home/peter/.julia/packages/Gtk/X7HfN/src/cairo.jl:84 [inlined] [5] #160 at /home/peter/.julia/packages/GtkReactive/lAPT0/src/graphics_interaction.jl:296 [inlined] [6] #33 at /home/peter/.julia/packages/Reactive/g1LZ6/src/operators.jl:41 [inlined] [7] runaction(::Reactive.var"#33#34"{GtkReactive.var"#160#162"{GtkReactive.Canvas{UserUnit}},Signal{Nothing},Tuple{Signal{Array{Any,1}},Signal{Array{Any,1}}}}) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:313 [8] foreach(::typeof(Reactive.runaction), ::Array{Function,1}) at ./abstractarray.jl:1919 [9] run_node(::Signal{Nothing}) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:340 [10] run_push(::Signal{Array{Any,1}}, ::Array{Any,1}, ::typeof(Reactive.print_error), ::Bool) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:358 [11] run_push(::Signal{Array{Any,1}}, ::Array{Any,1}, ::Function) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:345 [12] run(::Int64) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:306 [13] run at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:300 [inlined] [14] (::Reactive.var"#27#29")() at ./task.jl:358 ┌ Warning: Error in @guarded callback └ @ GtkReactive ~/.julia/packages/Gtk/X7HfN/src/base.jl:90 ERROR: MethodError: no method matching drawline(::Cairo.CairoContext, ::Array{Any,1}, ::RGB{FixedPointNumbers.Normed{UInt8,8}}) The applicable method may be too new: running in world age 27230, while current world is 27231. Closest candidates are: drawline(::Any, ::Any, ::Any) at none:2 (method too new to be called from this world context.) Stacktrace: [1] (::var"#9#10")(::Gtk.GtkCanvas, ::Array{Any,1}, ::Array{Any,1}) at ./none:6 [2] (::GtkReactive.var"#159#161"{var"#9#10",Tuple{Signal{Array{Any,1}},Signal{Array{Any,1}}}})(::Gtk.GtkCanvas) at /home/peter/.julia/packages/Gtk/X7HfN/src/base.jl:88 [3] draw(::Gtk.GtkCanvas, ::Bool) at /home/peter/.julia/packages/Gtk/X7HfN/src/cairo.jl:86 [4] draw at /home/peter/.julia/packages/Gtk/X7HfN/src/cairo.jl:84 [inlined] [5] #160 at /home/peter/.julia/packages/GtkReactive/lAPT0/src/graphics_interaction.jl:296 [inlined] [6] #33 at /home/peter/.julia/packages/Reactive/g1LZ6/src/operators.jl:41 [inlined] [7] runaction(::Reactive.var"#33#34"{GtkReactive.var"#160#162"{GtkReactive.Canvas{UserUnit}},Signal{Nothing},Tuple{Signal{Array{Any,1}},Signal{Array{Any,1}}}}) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:313 [8] foreach(::typeof(Reactive.runaction), ::Array{Function,1}) at ./abstractarray.jl:1919 [9] run_node(::Signal{Nothing}) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:340 [10] run_push(::Signal{Array{Any,1}}, ::Array{Any,1}, ::typeof(Reactive.print_error), ::Bool) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:358 [11] run_push(::Signal{Array{Any,1}}, ::Array{Any,1}, ::Function) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:345 [12] run(::Int64) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:306 [13] run at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:300 [inlined] [14] (::Reactive.var"#27#29")() at ./task.jl:358 ┌ Warning: Error in @guarded callback └ @ GtkReactive ~/.julia/packages/Gtk/X7HfN/src/base.jl:90 ERROR: MethodError: no method matching drawline(::Cairo.CairoContext, ::Array{Any,1}, ::RGB{FixedPointNumbers.Normed{UInt8,8}}) The applicable method may be too new: running in world age 27230, while current world is 27231. Closest candidates are: drawline(::Any, ::Any, ::Any) at none:2 (method too new to be called from this world context.) Stacktrace: [1] (::var"#9#10")(::Gtk.GtkCanvas, ::Array{Any,1}, ::Array{Any,1}) at ./none:6 [2] (::GtkReactive.var"#159#161"{var"#9#10",Tuple{Signal{Array{Any,1}},Signal{Array{Any,1}}}})(::Gtk.GtkCanvas) at /home/peter/.julia/packages/Gtk/X7HfN/src/base.jl:88 [3] draw(::Gtk.GtkCanvas, ::Bool) at /home/peter/.julia/packages/Gtk/X7HfN/src/cairo.jl:86 [4] draw at /home/peter/.julia/packages/Gtk/X7HfN/src/cairo.jl:84 [inlined] [5] #160 at /home/peter/.julia/packages/GtkReactive/lAPT0/src/graphics_interaction.jl:296 [inlined] [6] #33 at /home/peter/.julia/packages/Reactive/g1LZ6/src/operators.jl:41 [inlined] [7] runaction(::Reactive.var"#33#34"{GtkReactive.var"#160#162"{GtkReactive.Canvas{UserUnit}},Signal{Nothing},Tuple{Signal{Array{Any,1}},Signal{Array{Any,1}}}}) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:313 [8] foreach(::typeof(Reactive.runaction), ::Array{Function,1}) at ./abstractarray.jl:1919 [9] run_node(::Signal{Nothing}) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:340 [10] run_push(::Signal{Array{Any,1}}, ::Array{Any,1}, ::typeof(Reactive.print_error), ::Bool) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:358 [11] run_push(::Signal{Array{Any,1}}, ::Array{Any,1}, ::Function) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:345 [12] run(::Int64) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:306 [13] run at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:300 [inlined] [14] (::Reactive.var"#27#29")() at ./task.jl:358 ┌ Warning: Error in @guarded callback └ @ GtkReactive ~/.julia/packages/Gtk/X7HfN/src/base.jl:90 ERROR: MethodError: no method matching drawline(::Cairo.CairoContext, ::Array{Any,1}, ::RGB{FixedPointNumbers.Normed{UInt8,8}}) The applicable method may be too new: running in world age 27230, while current world is 27231. Closest candidates are: drawline(::Any, ::Any, ::Any) at none:2 (method too new to be called from this world context.) Stacktrace: [1] (::var"#9#10")(::Gtk.GtkCanvas, ::Array{Any,1}, ::Array{Any,1}) at ./none:6 [2] (::GtkReactive.var"#159#161"{var"#9#10",Tuple{Signal{Array{Any,1}},Signal{Array{Any,1}}}})(::Gtk.GtkCanvas) at /home/peter/.julia/packages/Gtk/X7HfN/src/base.jl:88 [3] draw(::Gtk.GtkCanvas, ::Bool) at /home/peter/.julia/packages/Gtk/X7HfN/src/cairo.jl:86 [4] draw at /home/peter/.julia/packages/Gtk/X7HfN/src/cairo.jl:84 [inlined] [5] #160 at /home/peter/.julia/packages/GtkReactive/lAPT0/src/graphics_interaction.jl:296 [inlined] [6] #33 at /home/peter/.julia/packages/Reactive/g1LZ6/src/operators.jl:41 [inlined] [7] runaction(::Reactive.var"#33#34"{GtkReactive.var"#160#162"{GtkReactive.Canvas{UserUnit}},Signal{Nothing},Tuple{Signal{Array{Any,1}},Signal{Array{Any,1}}}}) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:313 [8] foreach(::typeof(Reactive.runaction), ::Array{Function,1}) at ./abstractarray.jl:1919 [9] run_node(::Signal{Nothing}) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:340 [10] run_push(::Signal{Array{Any,1}}, ::Array{Any,1}, ::typeof(Reactive.print_error), ::Bool) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:358 [11] run_push(::Signal{Array{Any,1}}, ::Array{Any,1}, ::Function) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:345 [12] run(::Int64) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:306 [13] run at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:300 [inlined] [14] (::Reactive.var"#27#29")() at ./task.jl:358 ┌ Warning: Error in @guarded callback └ @ GtkReactive ~/.julia/packages/Gtk/X7HfN/src/base.jl:90 ERROR: MethodError: no method matching drawline(::Cairo.CairoContext, ::Array{Any,1}, ::RGB{FixedPointNumbers.Normed{UInt8,8}}) The applicable method may be too new: running in world age 27230, while current world is 27231. Closest candidates are: drawline(::Any, ::Any, ::Any) at none:2 (method too new to be called from this world context.) Stacktrace: [1] (::var"#9#10")(::Gtk.GtkCanvas, ::Array{Any,1}, ::Array{Any,1}) at ./none:6 [2] (::GtkReactive.var"#159#161"{var"#9#10",Tuple{Signal{Array{Any,1}},Signal{Array{Any,1}}}})(::Gtk.GtkCanvas) at /home/peter/.julia/packages/Gtk/X7HfN/src/base.jl:88 [3] draw(::Gtk.GtkCanvas, ::Bool) at /home/peter/.julia/packages/Gtk/X7HfN/src/cairo.jl:86 [4] draw at /home/peter/.julia/packages/Gtk/X7HfN/src/cairo.jl:84 [inlined] [5] #160 at /home/peter/.julia/packages/GtkReactive/lAPT0/src/graphics_interaction.jl:296 [inlined] [6] #33 at /home/peter/.julia/packages/Reactive/g1LZ6/src/operators.jl:41 [inlined] [7] runaction(::Reactive.var"#33#34"{GtkReactive.var"#160#162"{GtkReactive.Canvas{UserUnit}},Signal{Nothing},Tuple{Signal{Array{Any,1}},Signal{Array{Any,1}}}}) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:313 [8] foreach(::typeof(Reactive.runaction), ::Array{Function,1}) at ./abstractarray.jl:1919 [9] run_node(::Signal{Nothing}) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:340 [10] run_push(::Signal{Array{Any,1}}, ::Array{Any,1}, ::typeof(Reactive.print_error), ::Bool) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:358 [11] run_push(::Signal{Array{Any,1}}, ::Array{Any,1}, ::Function) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:345 [12] run(::Int64) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:306 [13] run at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:300 [inlined] [14] (::Reactive.var"#27#29")() at ./task.jl:358 ┌ Warning: Error in @guarded callback └ @ GtkReactive ~/.julia/packages/Gtk/X7HfN/src/base.jl:90 ERROR: MethodError: no method matching drawline(::Cairo.CairoContext, ::Array{Any,1}, ::RGB{FixedPointNumbers.Normed{UInt8,8}}) The applicable method may be too new: running in world age 27230, while current world is 27231. Closest candidates are: drawline(::Any, ::Any, ::Any) at none:2 (method too new to be called from this world context.) Stacktrace: [1] (::var"#9#10")(::Gtk.GtkCanvas, ::Array{Any,1}, ::Array{Any,1}) at ./none:6 [2] (::GtkReactive.var"#159#161"{var"#9#10",Tuple{Signal{Array{Any,1}},Signal{Array{Any,1}}}})(::Gtk.GtkCanvas) at /home/peter/.julia/packages/Gtk/X7HfN/src/base.jl:88 [3] draw(::Gtk.GtkCanvas, ::Bool) at /home/peter/.julia/packages/Gtk/X7HfN/src/cairo.jl:86 [4] draw at /home/peter/.julia/packages/Gtk/X7HfN/src/cairo.jl:84 [inlined] [5] #160 at /home/peter/.julia/packages/GtkReactive/lAPT0/src/graphics_interaction.jl:296 [inlined] [6] #33 at /home/peter/.julia/packages/Reactive/g1LZ6/src/operators.jl:41 [inlined] [7] runaction(::Reactive.var"#33#34"{GtkReactive.var"#160#162"{GtkReactive.Canvas{UserUnit}},Signal{Nothing},Tuple{Signal{Array{Any,1}},Signal{Array{Any,1}}}}) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:313 [8] foreach(::typeof(Reactive.runaction), ::Array{Function,1}) at ./abstractarray.jl:1919 [9] run_node(::Signal{Nothing}) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:340 [10] run_push(::Signal{Array{Any,1}}, ::Array{Any,1}, ::typeof(Reactive.print_error), ::Bool) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:358 [11] run_push(::Signal{Array{Any,1}}, ::Array{Any,1}, ::Function) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:345 [12] run(::Int64) at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:306 [13] run at /home/peter/.julia/packages/Reactive/g1LZ6/src/core.jl:300 [inlined] [14] (::Reactive.var"#27#29")() at ./task.jl:358

using Gtk.ShortNames, GtkReactive
sl = slider(1:11)
win = Window("Testing") |> (bx = Box(:v))
push!(bx, sl)
showall(win)

produces UndefVarError: showall not defined. This example works fine with using Gtk added.

Is it possible to draw three different lines with three different colors using line_to command?

Hello,
is possible to include a plot (for example a function) in a window? How?
Can you use any plot package? like inspectDR?
can you show an example?
I'm very interested.

Thanks

Why does this (albeit contrived) example not work?

using GtkReactive, Gtk.ShortNames
w = Window("a")
a = button("a")
b = Box(:h)
push!(b, a)
foreach(a) do _
    cb = checkbox(rand(Bool))
    foreach(println, cb)
    push!(b, cb)
end
push!(w, b)
showall(w)

Running this builds the checkbox and prints the boolean, but then it dies (pressing on the button doesn't produce any additional checkboxes nor prints the booleans). Rerunning this within the same session halts the Julia session and I need to pkill julia or Ctrl-Z.
I'm on Version 0.6.0-dev.1393 (2016-12-09 01:03 UTC)

This is an error I have so far only encountered with checkboxes when they are somehow associated with draw methods.
Upon pressing the checkbox for the first time, I receive this error message and all of the signals stop updating. i.e. sliders no longer update, other buttons no longer update their values, etc.

Failed to push!
    false
to node
    input-2: Signal{Bool}(false, nactions=3)

error at node: map(input-2)-2: Signal{Void}(nothing, nactions=0)
MethodError: Cannot `convert` an object of type Gtk.GtkCanvas to an object of type Void
This may have arisen from a call to the constructor Void(...),
since type constructors fall back to convert methods.
 in send_value!(::Reactive.Signal{Void}, ::Gtk.GtkCanvas, ::Int64) at C:\Users\Tomer\.julia\v0.5\Reactive\src\core.jl:154
 in (::Reactive.##25#26{##5#6{GtkReactive.Checkbox,GtkReactive.Canvas{GtkReactive.UserUnit},Reactive.Signal{Array{ColorTypes.RGB{FixedPointNumbers.Normed{UInt8,8}},2}},Reactive.Signal{GtkReactive.ZoomRegion{RoundingIntegers.RInt64}}},Tuple{Reactive.Signal{Bool}}})(::Reactive.Signal{Void}, ::Int64) at C:\Users\Tomer\.julia\v0.5\Reactive\src\operators.jl:41
 in do_action(::Reactive.Action, ::Int64) at C:\Users\Tomer\.julia\v0.5\Reactive\src\core.jl:162
 in run(::Int64) at C:\Users\Tomer\.julia\v0.5\Reactive\src\core.jl:244
 in (::Reactive.##17#19)() at .\task.jl:360

This code I am trying to run is basically:

imagesignal = map(slider, button) do s, b
     get_image(s, b)
end

show_image = map(button) do b
    if b
          display_image(canvas, imagesignal, zoom_region)
          setproperty... #visible
     else 
          setproperty... # not visible
    end
end

(i.e. only draw to the canvas if the button is pressed, but always check the slider value to update which image should be drawn.)

Where display_image creates a map(zoom_region, imagesignal) block that returns a signal of the zoomed image and a draw(canvas, imgsig) block that copy!()s the image into the canvas.

I can't say for sure whether I first ran into this before or after updating GtkReactive (it was yesterday), but I've since tried downgrading to older versions of GtkReactive/Reactive with no luck. Is the issue with the checkbox, with Reactive, or with neither?

Combining Reactive with Gtk is awesome. Thank you!!!

Not sure if this is an issue, but:
If I make a textbox from a Signal:

t = textbox("abc")
w = Window("example")
push!(w, t)
showall(w)

and in the created textbox, I edit the "abc" text, say erase the 'c', then this happens:

julia> getproperty(t.widget,:text, String)
"ab"
julia> t.signal.value
"abc"

The change does not propagate to the signal before the user presses Enter, or a push!command is issued.
One way around this is if the nature of the coupling between the Signal and the widget could be specified by the user. In this specific example, changing the Gtk signal from activate to changed might propagate the change all the way to the Signal.

There is an unexpected effect seen when trying to dock a canvas onto a Box, and then include a Button widget as well, or even when trying to duplicate the image into 2 segments:

img = load("hg1.png")
img2 = load("hg1.png")
c = canvas(UserUnit)
c2 = canvas(UserUnit)
bx = Box(:v)

win = Window("ok")
push!(win,bx)
push!(bx,c)
push!(bx,c2)

with the remaining code from the zoom/pan example remaining the same

zr = Signal(ZoomRegion(img))
# Interactivity: hold down Ctrl and then click-drag to select a
# region via rubberband. It updates `zr`.
zoomsigs = init_zoom_rubberband(c, zr)
# See also: init_pan_drag, init_zoom_scroll, init_pan_scroll
# You can turn on all of these for the same canvas
# Create a Signal containing a `view` of the image over the
# region of interest. This view will update anytime `zr` updates.
imgsig = map(zr) do r
    cv = r.currentview
    view(img, UnitRange{Int}(cv.y), UnitRange{Int}(cv.x))
end
## Turn on drawing for the canvas
# `draw`, when passed Signal(s), will cause the canvas to be updated
# whenever any of the input Signals updates. It will also redraw
# whenever the Canvas is resized.
redraw = draw(c, imgsig) do cnvs, image
    copy!(cnvs, image)
    # canvas adopts the indices of the zoom region. That way if we
    # zoom in further, we select the correct region.
    set_coordinates(cnvs, value(zr))
end

## Don't forget this!
Gtk.showall(win)

This effect where the displays for both Box components are disrupted is also visible when

bt = Button("ok")
push!(bx,bt)

how can the images on the canvas become stacked onto the layout object without a disruption?

Hi @jverzani and @shashi,

I've started working on this package. It began as GtkInteract, but I ended up feeling that it wasn't ideally suited for more sophisticated GUIs (largely because, after creating the minimal signals, it throws away the GtkWidget). I also didn't want to lock myself to a particular plotting toolkit, so I was going to have to ditch @manipulate. Since AFAICT that's the main point of GtkInteract, I decided that rather than try to force my vision on @jverzani this should just be a new package forked from GtkInteract (to give credit where credit is due).

I then copied Interact's src/widgets.jl here and gave @shashi credit. Then I started making changes; the current state is visible on the dev branch.

Before I go further, are these commits in your names acceptable to the two of you? If so, I'd eventually like to register this package, and likely host it with an organization. @shashi, would you prefer JuliaGizmos or JuliaGraphics? Either seems appropriate to me.

I've been using this package successfully on a 2015 macbook running macOS Sierra, but have also recently been working on a 2012 macbook pro.

I just tried running the imageviewer.jl example and init_zoom_rubberband(c, zr) doesn't work. There is no error message, and the image appears in the window as expected and can still be zoomed using init_zoom_scoll(c,zr).

This may not be a worthwhile issue to deal with, but I thought it would be worth mentioning.

I was trying to make a simple implementation and I came across a doubt. Consider the following two codes.

Code 1.

using Gtk.ShortNames, GtkReactive
win=Window("My first project using GtkReactive")
bx=Box(:v);
push!(win,bx);
btn=button("Click Here");
push!(bx,btn);
text_out=textarea("1");
push!(bx,text_out);
i=Signal(1)
map(signal(btn)) do _
push!(text_out,string(value(i)))
push!(i,value(i)+1)
end
showall(win);

Code 2
using Gtk.ShortNames, GtkReactive
win=Window("My first project using GtkReactive")
bx=Box(:v);
push!(win,bx);
btn=button("Click Here");
push!(bx,btn);
text_out=textarea("1");
push!(bx,text_out);
i=1
map(signal(btn)) do _
push!(text_out,string(i))
i=i+1
end
showall(win);

The code 1 works fine. The code 2 has an error about definition of i. So, my question is: Any variable in map block must be a signal?

PS. Sorry about my english.

So, I can imagine that any/all of the existing Gtk widgets will want to get wrapped up by a Reactive Signal. I for one would welcome a SpinButton. I could try to take a stab at doing exactly that... Or would you rather?

OK, I found the culprit (in reference to and completely independent of the specific problem resolved by #32). Consider the following example. I'm sure that pushing into the slider, which is triggered by updates to the slider, is causing this to crash:

using GtkReactive, Gtk.ShortNames
w = Window("a")
s = slider(0:10)
b = Box(:v)
push!(b, s)
foreach(s) do t
    if t > 5
        push!(s, 5) # problematic
    end
end
foreach(s) do t
    push!(b, label(string(t + rand())))
    showall(w)
end
push!(w, b)
showall(w)

In the actual code I'm writing, I allow the user to adjust some inputs (textarea, dropdown, spinbutton), then press an "OK" button, and then some things happen accordingly. But, I also need to update the same inputs according to what the user pressed OK to (thus automatically advancing the spinbuttons etc). I guess what would be cool, is if those updates wouldn't propagate further (cause they were caused by the machine, not the user, and where intended only as a guess to what the user might want next round).

I've prepared a branch with REQUIRE entries pinned to the latest versions that still work with Julia 0.6:

https://github.com/Cody-G/GtkReactive.jl/tree/julia0.6

This has been very useful to ease the transition to 0.7. If you'd like to add my branch here let me know (and create a julia0.6 branch for me to submit the PR against).

See JuliaImages/ImageView.jl#141 for context. All Gtk.jl tests pass, but several of the canvas-related tests of GtkReactive.jl are failing on one of our machines. Curiously, julia package versions, OS (Ubuntu 17.10), and GTK libraries appear to match another of our machines that passes tests. Here is the test output:

julia> Pkg.test("GtkReactive")
INFO: Computing test dependencies for GtkReactive...
INFO: No packages to install, update or remove
INFO: Testing GtkReactive
Test Summary: | Pass  Total
Widgets       |   63     63
Test Summary:    | Pass  Total
Compound widgets |    3      3
Test Summary: | Pass  Total
CairoUnits    |    9      9
Canvas: Test Failed
  Expression: GtkReactive.convertunits(UserUnit, c, corner_dev...) == corner_usr
   Evaluated: (UserUnit(208.0), UserUnit(207.0)) == (UserUnit(1.0), UserUnit(1.0))
Stacktrace:
 [1] macro expansion at /home/cody/.julia/reg_and_seg/v0.6/GtkReactive/test/runtests.jl:351 [inlined]
 [2] macro expansion at ./test.jl:860 [inlined]
 [3] anonymous at ./<missing>:?
Canvas: Test Failed
  Expression: GtkReactive.convertunits(DeviceUnit, c, corner_usr...) == corner_dev
   Evaluated: (DeviceUnit(1.0), DeviceUnit(1.0)) == (DeviceUnit(208.0), DeviceUnit(207.0))
Stacktrace:
 [1] macro expansion at /home/cody/.julia/reg_and_seg/v0.6/GtkReactive/test/runtests.jl:354 [inlined]
 [2] macro expansion at ./test.jl:860 [inlined]
 [3] anonymous at ./<missing>:?
Canvas: Test Failed
  Expression: GtkReactive.convertunits(UserUnit, c, corner_dev...) == corner_usr
   Evaluated: (UserUnit(208.0), UserUnit(207.0)) == (UserUnit(5.0), UserUnit(10.0))
Stacktrace:
 [1] macro expansion at /home/cody/.julia/reg_and_seg/v0.6/GtkReactive/test/runtests.jl:351 [inlined]
 [2] macro expansion at ./test.jl:860 [inlined]
 [3] anonymous at ./<missing>:?
Canvas: Test Failed
  Expression: GtkReactive.convertunits(DeviceUnit, c, corner_usr...) == corner_dev
   Evaluated: (DeviceUnit(5.0), DeviceUnit(10.0)) == (DeviceUnit(208.0), DeviceUnit(207.0))
Stacktrace:
 [1] macro expansion at /home/cody/.julia/reg_and_seg/v0.6/GtkReactive/test/runtests.jl:354 [inlined]
 [2] macro expansion at ./test.jl:860 [inlined]
 [3] anonymous at ./<missing>:?
Canvas: Test Failed
  Expression: GtkReactive.convertunits(UserUnit, c, corner_dev...) == corner_usr
   Evaluated: (UserUnit(208.0), UserUnit(207.0)) == (UserUnit(110.0), UserUnit(1.0))
Stacktrace:
 [1] macro expansion at /home/cody/.julia/reg_and_seg/v0.6/GtkReactive/test/runtests.jl:351 [inlined]
 [2] macro expansion at ./test.jl:860 [inlined]
 [3] anonymous at ./<missing>:?
Canvas: Test Failed
  Expression: GtkReactive.convertunits(DeviceUnit, c, corner_usr...) == corner_dev
   Evaluated: (DeviceUnit(110.0), DeviceUnit(1.0)) == (DeviceUnit(208.0), DeviceUnit(207.0))
Stacktrace:
 [1] macro expansion at /home/cody/.julia/reg_and_seg/v0.6/GtkReactive/test/runtests.jl:354 [inlined]
 [2] macro expansion at ./test.jl:860 [inlined]
 [3] anonymous at ./<missing>:?
Test Summary: | Pass  Fail  Total
Canvas        |   23     6     29
ERROR: LoadError: Some tests did not pass: 23 passed, 6 failed, 0 errored, 0 broken.
while loading /home/cody/.julia/reg_and_seg/v0.6/GtkReactive/test/runtests.jl, in expression starting on line 318
================================================================[ ERROR: GtkReactive ]=================================================================

failed process: Process(`/home/cody/src/julia_06/usr/bin/julia -Cnative -J/home/cody/src/julia_06/usr/lib/julia/sys.so --compile=yes --depwarn=yes --check-bounds=yes --code-coverage=none --color=yes --compilecache=yes /home/cody/.julia/reg_and_seg/v0.6/GtkReactive/test/runtests.jl`, ProcessExited(1)) [1]

=======================================================================================================================================================
INFO: Removing ImageMagick v0.5.0
INFO: Removing TestImages v0.2.0
INFO: Removing ZipFile v0.5.0
ERROR: GtkReactive had test errors

I went to add and build in Julia 1.0.0 and got the following error:

julia> using GtkReactive
[ Info: Precompiling GtkReactive [27996c0f-39cd-5cc1-a27a-05f136f946b6]
WARNING: could not import Base.showall into GLib
WARNING: could not import Base.showcompact into GLib
WARNING: could not import Base.start into GLib
WARNING: could not import Base.next into GLib
WARNING: could not import Base.done into GLib
WARNING: could not import Base.endof into GLib
WARNING: could not import Base.shift! into GLib

signal (11): Segmentation fault
in expression starting at /home/krudd/.julia/packages/Gtk/oHM1K/src/GLib/gvalues.jl:121
unknown function (ip: 0xffffffffffffffff)
unknown function (ip: 0x7f04d0755d50)
unknown function (ip: 0x1b63cef)
unknown function (ip: 0x16)
unknown function (ip: 0x7fffebe8c9e7)
unknown function (ip: 0x7fffebe8ca7f)
Allocations: 1000121 (Pool: 999862; Big: 259); GC: 1
ERROR: LoadError: Failed to precompile Gtk [4c0ca9eb-093a-5379-98c5-f87ac0bbbf44] to /home/krudd/.julia/compiled/v1.0/Gtk/Vjnq0.ji.
Stacktrace:
[1] error(::String) at ./error.jl:33
[2] macro expansion at ./logging.jl:313 [inlined]
[3] compilecache(::Base.PkgId, ::String) at ./loading.jl:1184
[4] _require(::Base.PkgId) at ./logging.jl:311
[5] require(::Base.PkgId) at ./loading.jl:852
[6] macro expansion at ./logging.jl:311 [inlined]
[7] require(::Module, ::Symbol) at ./loading.jl:834
[8] include at ./boot.jl:317 [inlined]
[9] include_relative(::Module, ::String) at ./loading.jl:1038
[10] include(::Module, ::String) at ./sysimg.jl:29
[11] top-level scope at none:2
[12] eval at ./boot.jl:319 [inlined]
[13] eval(::Expr) at ./client.jl:389
[14] top-level scope at ./none:3
in expression starting at /home/krudd/.julia/packages/GtkReactive/Vqohy/src/GtkReactive.jl:7
ERROR: Failed to precompile GtkReactive [27996c0f-39cd-5cc1-a27a-05f136f946b6] to /home/krudd/.julia/compiled/v1.0/GtkReactive/2WqeG.ji.
Stacktrace:
[1] error(::String) at ./error.jl:33
[2] macro expansion at ./logging.jl:313 [inlined]
[3] compilecache(::Base.PkgId, ::String) at ./loading.jl:1184
[4] _require(::Base.PkgId) at ./logging.jl:311
[5] require(::Base.PkgId) at ./loading.jl:852
[6] macro expansion at ./logging.jl:311 [inlined]
[7] require(::Module, ::Symbol) at ./loading.jl:834

Are there plans to update? (Or is there something I'm doing wrong?)

Hello, ive been trying to run this library from inside a function, this causes it to not react to mouse clicks from within code.
Is this meant to be occuring or have i done something wrong?

sigclick = map(d["gui"]["canvas"].mouse.buttonpress) do btn
    if(btn.button == 1)
        #println(btn.position)
        push!(e.last_points, (btn.position.x.val, btn.position.y.val))
        if(length(e.last_points) > max_points)
            splice!(e.last_points,1)
        end
        println(size(e.last_points)," ",e.last_points)
    end
end

While we can now have multiple GtkReactives in one map (#22), it'd be cool if mixing both GtkReactives and Reactive Signals would work...

This is obviously a feature/enhancement request.

Is there some way to arrange objects (boxes, canvases, buttons, etc.) using Grid() or something like it?
Attempting to place a canvas into a grid yields:

LoadError: MethodError: no method matching unsafe_convert(::Type{Ptr{Gtk.GLib.GObject}}, ::GtkReactive.Canvas{GtkReactive.UserUnit})

I wish there is a "play loop" button.
Maybe a "back and forth" looping button, and a "forward" looping button?..

Best,

The example at: https://juliagizmos.github.io/GtkReactive.jl/latest/controls.html
no longer works in Julia 1.9.0

First, the web page says to "showall(win)". This no longer exists.
If I change "showall" to "show" I get an empty window.
This is what I get:

Hi Tim!
How could I help you add a SpinButton widget for representing hours:minutes:seconds (as in e.g. 01:06:22 for one hour, six minutes, and 22 seconds)?
It should respond to scrolling, be limited by 0-59 for the seconds and minutes, and play nicely with either Dates.Second or Julia v0.6's Time type.
I think many (read me) are currently using one spinbutton per time unit: silly.

Last week I used GtkReactive and I can only give you my high praises. I did my Phd on a GUI related topic, and I really appreciate the conciseness and the high quality of the code and comments. It was very easy to use. Wow!

One feature I still think about is handling key events with GtkReactive for a canvas. I’d like to use it similar to "c.mouse.motion" but for key events. Is this difficult to add? I looked into adding this feature but did not get far.

I'd like to have a button's label always be equal to the text in a textbox. Is it possible to assign a signal to the button's label?

The title. I'm not sure if I'm choosing the wrong settings in glade or if it's genuinely something completely different:

julia> using Gtk.ShortNames, GtkReactive

julia> builder = Builder(filename="tmp.glade")
Gtk.GtkBuilderLeaf(translation-domain=NULL)

julia> x = dropdown(; widget=builder["combobox"])
ERROR: MethodError: no method matching start(::Void)
Closest candidates are:
  start(::SimpleVector) at essentials.jl:258
  start(::Base.MethodList) at reflection.jl:560
  start(::ExponentialBackOff) at error.jl:107
  ...
Stacktrace:
 [1] first(::Void) at ./abstractarray.jl:152
 [2] (::GtkReactive.#kw##dropdown)(::Array{Any,1}, ::GtkReactive.#dropdown) at ./<missing>:0

Here's what I have in tmp.glade:

<?xml version="1.0" encoding="UTF-8"?>
<!-- Generated with glade 3.20.0 -->
<interface>
  <requires lib="gtk+" version="3.20"/>
  <object class="GtkWindow" id="window">
    <property name="can_focus">False</property>
    <property name="title" translatable="yes">BeetleWay</property>
    <child>
      <object class="GtkComboBox" id="combobox">
        <property name="visible">True</property>
        <property name="can_focus">False</property>
      </object>
    </child>
  </object>
</interface>

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

This isn't an issue with the package in any way, only with my understanding of it. I have a limited knowledge of Julia in general, and Gtk in particular, so delving into the source code hasn't done much to help me.
That said, I am migrating some of my code from GtkUtilties to GtkReactive at the moment, and I'd like to be able to accomplish all of the same things while taking advantage of GtkReactive's more "streamlined" approach to signal handling.

Here is a very simple program that adds the value of two sliders together and prints the result to the console. It uses the map() do syntax that I have noticed the examples make use of. I am not happy with it at the moment, for several reasons.

using GtkReactive, Gtk.ShortNames
slider1 = slider(1:10)
slider2 = slider(1:10)
cb = checkbox(false, label ="sum")
box = Box(:v)

push!(box, slider1)
push!(box, slider2)
push!(box, cb)

win = Window()
push!(win, box)

add = map(cb) do clicked
    if clicked
        s = slider1.signal.value + slider2.signal.value
        println(s)
    end
end

change_value = map(slider1) do val1
    if  cb.signal.value
        s = val1 + slider2.signal.value
        println(s)
    end
end
change_value = map(slider2) do val2
    if  cb.signal.value
        s = slider1.signal.value + val2
        println(s)
    end
end
showall(win)

The first reason, is that this code works at all, despite overwriting the variable change_value. I have no idea why this should be working at all, and yet it is.
The second reason is that it is quite verbose. I would prefer to connect both slider1 and slider2 as signals to the same operation, preferably combining that together with cb into a single function that responds to all 3 signals. I am sure that this is possible I just don't know how to do it with these new objects and notations, and was hoping for some guidance.
The third reason is that I would actually like to write the result to a textbox for any of the signals, but initiating a textbox with any one of those signals yields an error.

Anyway, clarity with signals in this example will be very helpful for me moving forward with the GUI I am working on.

Thanks in advance!

I have a button and I want it to trigger the NativeFileDialog picker:

win = Window("Test")
inputfiles = Signal([""])
inputfilebtn = button("Input files")
inputfilebtn_handler = map(inputfilebtn) do btn
    push!(inputfiles, pick_multi_file())
end
push!(win, inputfilebtn)
showall(win)

So, this does work to trigger the dialog when the button is pressed. But it also runs when it is first defined, and no button is pressed. Is there a better way to handle this than having a global is_initializing variable that all button signal handlers check?

julia> spinbutton(1.1:1.1:2.2)
ERROR: type StepRangeLen has no field start

and would be cool if more exotic ranges could also be supported, linspace(colorant"black", colorant"white", 10) from Colors, and Second(2):Second(1):Second(5) from Base.Dates, for example.

Being new to the ecosystem, I picked up the drawing.jl example and started toying with it. I refactored a lot of the inline GtkReactive behaviours out into functions, and, instead of using global Signals, I parametrized those functions with them and created a "run" function that instantiates the Gtk window, signals and behaviours.

Problem is the program halts after some drawing. It does it in different ways each time, which you notice when you log traces when signals change. Some signals stop changing, for example the drawing Bool signal, or the lines signal starts getting populated with empty lines.

Also, I can't reproduce it now, but early in the debugging I would get messages that are something like "Reactive.jl message queue full, use this ENV variable to change the queue size". What's interesting is that I would get these "queue full" errors (which would halt the program) immediately on subsequent launches of the program (I reuse REPL sessions).

I isolated the problem with signals stopping to work by wrapping the original drawing.jl example into a run function, replacing all consts with local variables. If I run this with include("wrapped_drawing.jl"); run(), and manically draw for 30-60 seconds, I can reliably cause the program to hang (without error messages). The line being drawn during the hang stays red even after releasing the left mouse button. For comparison, if I run the original example, I can't make it halt.

I only wrapped everything in one module and one function, and added a wait at the end so that the routines would wait for the window to close before continuing, but for the sake of completeness, here's the code:

module SmallRefacDrawing

using Gtk.ShortNames, GtkReactive, Graphics, Colors

function run()

  win = Window("Drawing")
  c = canvas(UserUnit)       # create a canvas with user-specified coordinates
  push!(win, c)

  lines = Signal([])   # the list of lines that we'll draw
  newline = Signal([]) # the in-progress line (will be added to list above)

  # Add mouse interactions
  drawing = Signal(false)  # this will be true if we're dragging a new line
  sigstart = map(c.mouse.buttonpress) do btn
    if btn.button == 1 && btn.modifiers == 0
      push!(drawing, true)   # start extending the line
      push!(newline, [btn.position])
    end
  end

  dummybutton = MouseButton{UserUnit}()
  sigextend = map(filterwhen(drawing, dummybutton, c.mouse.motion)) do btn
    push!(newline, push!(value(newline), btn.position))
  end

  sigend = map(c.mouse.buttonrelease) do btn
    if btn.button == 1
      push!(drawing, false)  # stop extending the line
      push!(lines, push!(value(lines), value(newline)))
      push!(newline, [])
    end
  end

  # Draw on the canvas
  redraw = draw(c, lines, newline) do cnvs, lns, newl
    fill!(cnvs, colorant"white")   # background is white
    set_coordinates(cnvs, BoundingBox(0, 1, 0, 1))  # set coords to 0..1 along each axis
    ctx = getgc(cnvs)
    for l in lns
      drawline(ctx, l, colorant"blue")
    end
    drawline(ctx, newl, colorant"red")
  end

  function drawline(ctx, l, color)
    isempty(l) && return
    p = first(l)
    move_to(ctx, p.x, p.y)
    set_source(ctx, color)
    for i = 2:length(l)
      p = l[i]
      line_to(ctx, p.x, p.y)
    end
    stroke(ctx)
  end

  Gtk.showall(win)

  window_closed = Condition()
  signal_connect(win, :destroy) do widget
    notify(window_closes)
  end
  wait(window_closed)
  @info "program stop"

end
end

As seen in the travis osx failures in #86 and JuliaImages/ImageView.jl#175

using GtkReactive, Gtk.ShortNames, Graphics, Test

c = canvas(208, 207)
win = Window(c)
Gtk.showall(win)
sleep(0.1)
@test Graphics.width(c) == 208
@test Graphics.height(c) == 207

Expression: Graphics.width(c) == 208
Evaluated: 1 == 208

Expression: Graphics.height(c) == 207
Evaluated: 1 == 207

It would be nice to have a progress bar. Something like this maybe:

pb = progressbar(4, widget=builder["a_GtkProgressBar_I_made_in_Glade"])
push!(pb, 2) # half way through!

In Reactive you can conveniently have multiple Signals in one map. In GtkReactive, you need to wrap each GtkReactive with a signal function if you want more than one GtkReactive in one map.

Evaluating GtkWindowLeaf outputs:
GtkWindowLeaf(name="", parent, width-request=600, height-request=-1, visible=TRUE, ....
Can it be modified to:
GtkWindowLeaf(name="", parent, width_request=600, height_request=-1, visible=true, ...
so it's syntactically correct in Julia?

While most of the other widgets have some Reactiveish meaning (e.g. slider updates a Signal with the value of the widget), button doesn't. It would be very useful if button had a meaning.
Maybe something like a release gate:

a = button("a")
x = Signal(1)
y_temp = map(sin, x)
y = release(a, y_temp)
<all sorts of push!es to x>
h = map(println, y)

while y_temp updates with each push! to x, y doesn't. Only when button a gets pushed, y updates with y_temp's last value (and triggers the println).
This is just an idea, but it seems like button could benefit from some Reactiveish application.