The Juno.jl Front-End
Juno provides some functionality using Atom's UI, which will usually have a fallback for use in other environments.
isactive() function will provide an interface for figuring out whether the current session is running within Juno:
true when the current Julia process is connected to a running Juno frontend.
Juno.jl includes features which allow package developers to created enhanced displays in Juno.
For example, we can print
info to the console in a nicer way:
Show the given message in Juno's console using blue styling, or fall back to
In a package, you can use
import Juno: info to replace the default version with this one.
or provide structured display for arbitrary objects (similar to
x's underlying representation, rather than using its normal display method. For example,
structure(:(2x+1)) displays the
Expr object with its
args fields instead of printing the expression.
For a types that have no custom rendering defined (see below), Juno's display system will fall back to
show, if there's a
showmethod more specific than the catch-all fallback method
lazy structured display similar to
To change how Juno displays a type
type CustomType field_a field_b end
it's necessary to add a new
Juno.render method for that type:
function Juno.render(i::Juno.Inline, x::CustomType) Juno.render(i, Juno.Tree(Text(x.field_a), [Text(field_b)])) end
or, using the more convenient
Juno.@render macro, which calls
Juno.render on it's first argument (
Juno.Inline in this case) and whatever it's body evaluates into:
Juno.@render Juno.Inline x::CustomType begin Juno.Tree(Text(x.field_a), [Text(x.field_b)]) end
Juno.Inline is one of the predefined rendering contexts defined in Juno:
Juno.Inline Juno.Clipboard Juno.PlotPane
render methods for all the HTML primitives defined in Hiccup.jl as well as for certain higher-level elements from Juno.jl or even Base
Juno.Tree Juno.LazyTree Juno.SubTree Juno.Link Juno.Table Juno.Row Base.Text
Should you wish to render something in the
PlotPane, you can get it's dimensions via
Get the size of Juno's plot pane in
px. Does not yet have a fallback for other environments.
Juno.jl allows package developers to use the progressbar which is provided in the Atom window. For example, you can easily show a progress meter for a
for loop via the command:
@progress for ...
The following functions provide this interface:
@progress [name] for i = ...
Show a progress metre for the given loop if possible.
p's progress to
p to an indeterminate progress bar.
progress(f::Function; name = "", msg = "")
p = ProgressBar(name = name, msg = msg) as the argument and calls
done(p) afterwards. This is guaranteed to clean up the progress bar, even if
ProgressBar(;name = "", msg = "")
Create a new progress bar and register it with Juno, if possible.
Take care to unregister the progress bar by calling
done on it, or use the
progress(f::Function) syntax, which will handle that automatically.
Update the message that will be displayed in the frontend when hovering over the corrseponding progress bar.
Update the string that will be displayed to the right of the progress bar.
Defaults to the linearly extrpolated remaining time based upon the time difference between registering a progress bar and the latest update.
p from the frontend.
It is recommended to either use the
@progress macro or the
progress(name = "Foo") do p end
notation to ensure that the progress bars are properly unregistered in the frontend.
Juno.jl lets package developers interact with users via the Atom frontend. For example, you can allow the user to select from a list of options:
selector([xs...]) -> x
Allow the user to select one of the
xs should be an iterator of strings. Currently there is no fallback in other environments.
or get input in the console:
input() -> "..."
Prompt the user to input some text, and return it.