juliagizmos / gtkreactive.jl Goto Github PK
View Code? Open in Web Editor NEWCombining Reactive.jl with the Gtk toolkit
Home Page: https://juliagizmos.github.io/GtkReactive.jl/stable/
License: Other
Combining Reactive.jl with the Gtk toolkit
Home Page: https://juliagizmos.github.io/GtkReactive.jl/stable/
License: Other
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!
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!
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>
I wish there is a "play loop" button.
Maybe a "back and forth" looping button, and a "forward" looping button?..
Best,
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?
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
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
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.
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.
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)
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?
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.
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
Is it possible to draw three different lines with three different colors using line_to command?
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})
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?
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 push
ing 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 spinbutton
s 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).
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
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'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).
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 const
s 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
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 Reactive
ish 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 Reactive
ish application.
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
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.
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:
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.
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?
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?)
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.
In Reactive
you can conveniently have multiple Signal
s 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.
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.
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?
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.
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google ❤️ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.