A controls object contains a list of options object and a GtkGrid containing each option's widget.

    mutable struct Option{W, T} <: AbstractOption{W, T}

Represents an option object.

An option is a value of type T associated with a GtkWidget.

The option's value can be accessed with the empty bracket notation: option[]

The option.set function sets a new value for the option. The option's value can also be setted with the empty bracket notation: option[] = newvalue

Each option type defines the get and set functions.

    widget → N::Int

Returns CellSpan object for widget that spans N columns.

Examples

julia> label"I span 4 columns" → 4
CellSpan(GtkSlider..., 1, 4)

    widget → r:c

Returns a GridCell object for widget that spans r rows and c columns.

Examples

julia> Box((), :h) → 3:4
CellSpan(GtkBox..., 3, 4)

    widget ↓ N::Int

Returns CellSpan object for widget that spans N rows.

Examples

julia> Slider(1:100) ↓ 2
CellSpan(GtkSlider..., 2, 1)

    s ⟶ [a₁ a₂; b₁ b₂]

Return the value s linearly mapped from the a interval to the b interval.

Examples

julia> 1 ⟶ [0 1; 0 10]
10.0

julia> 0.5 ⟶ [0 1; 0 10]
5.0

julia> -2 ⟶ [-5 5; 0 5]
1.5

    Grid(rows::Matrix)

Creates a new GtkGrid widget.

The rows parameter is a Matrix that contains the GridCells. A GridCell can be either a GtkWidget, a CellSpan object or a empty tuple ().

The position of each element in the rows matrix will determine its position on the Grid.

An CellSpan object represents a cell that spans multiple rows or/and columns. An empty tuple indicates an empty cell.

Examples

grid = Grid(@margin(10), [
    button  slider
    ()      label
])

grid = Grid(@margin(10), [
    # the button will span 2 rows 
    CellSpan(button, 2, 1)  slider
    ()                      label
])

grid = Grid(@margin(10), [
    # the button will span 2 rows 
    button ↓ 2  slider
    # the label will span 2 columns 
    label → 2
])

grid = Grid(@margin(10)) do
    [
        # the textarea will span 3 rows and 2 columns
        textarea → 3:2  switch
        ()  ()            ()
        ()  ()            ()
        toolbar → 2     button
    ]
end

    addwidget(widget::GtkWidget)

Adds the widget widget in the current window.

Examples

julia> slider = Slider(1:100)
GtkSlider...

julia> addwidget(slider)
GtkSlider...

    framerate(fps::Real)

Sets the current framerate.

The default framerate is approximaly 60 frames/second.

    getprop(widget, key)

Returns the Gtk property key from widget.

Examples

julia> getprop(window, :title)
"My window"

    getprop(widget, key, T)

Returns the Gtk property key with type T from widget.

Examples

julia> getprop(window, :title, String)
"My window"

    init(title [, width = 400, height = 400])

Initialize Alexya by creating a new AlexyaApp global object.

The title parameter is the title of the window, the width and height parameters are not necessarily the same as the window, but they determine the size of the canvas. The size of the window and canvas can be controlled by the current layout, and the behavior of the addwidget function or @create macro are also controlled by the layout.

The default layout is canvasonly, wich means that the canvas will be the only widget on the window and uses of the addwidget function or @create macro will not work.

You can set the current layout by calling the uselayout function or the @layout macro. The layout is a just a function that determines how the widgets (including the canvas) are added to the window. You can also create your own layouts.

Examples

julia> init("My beautiful animation", 800, 600)
AlexyaApp...

julia> @layout aside(:h, 200)

julia> @layout aside(:v, 300)

julia> @layout MyLayout

julia> uselayout() do canvas, widgets
            Box(:v) do
                canvas,
                widgets...
            end # Box 
        end

    keyboard(key)

Returns a number that represents a key of the keyboard.

    mag(v::Vector{<:Real})

Returns the magnitude of v.

    mag2(v::Vector{<:Real})

Returns the magnitude squared of v.

    mag²(v::Vector{<:Real})

Returns the magnitude squared of v.

    mapr(s::Real, intervals::Matrix)

Return the value s linearly mapped from the intervals in intervals.

Examples

julia> mapr(1, [0 1; 0 10])
10.0

julia> mapr(0.5, [0 1; 0 10])
5.0

julia> mapr(-2, [-5 5; 0 5])
1.5

    noLoop()

This function will prevent the drawing loop from start, wich will call the update function just one time (or zero if you call on the setup function).

    offevent(widget, eventid)

Disconnect the event of id eventid from widget.

Examples

julia> id = onevent(:destroy, window) do
            println("The window has been closed")
       end

julia> destroy(window)
The window has been closed

julia> offevent(window, id)

julia> show(window)
GtkWindow...

julia> destroy(window)

    onevent(callback, event, widget)

Adds a event listener for widget. The callback is called when the event is fired.

Examples

julia> onevent(:destroy, window) do
            println("The window has been closed")
       end

    point(v::Vector)

Converts a Vector to a Point object.

random(len [, T = Float64])

Returns a random number between 0 and len. The result is converted to the type T.

random(a, b [, T = Float64])

Returns a random number between a and b. The result is converted to the type T.

    randv()

Returns a vector of magnitude 1 pointing in a random direction.

    rot(v::Vector{<:Real}, φ)

Returns a new vector where its magnitude is the same as v, but its angle is the sum of φ and the angle of v.

    set!(widget, props::Dict)

Sets a Gtk property of widget for each key-value pair in props.

    set!(widget, props::NamedTuple)

Sets a Gtk property of widget for each key-value pair in props.

Examples

julia> set!(button, (label = "Click-me"))

julia> set!(color_btn, (color = colorant"#f1a"))

    set!(widget, prop, values::NamedTuple)

Sets a Gtk property of widget for each key-value pair in values.

The name of the final property will be prop-key where key is a key of values.

For example, instead of setting the margins of a widget each time, like this:

set!(mywidget, :margin_top, 10)
set!(mywidget, :margin_bottom, 20)
set!(mywidget, :margin_left, 15)
set!(mywidget, :margin_right, 10)

We can simple do:

set!(mywidget, :margin, (
    top = 10,
    bottom = 20,
    left = 15,
    right = 10
))

    set!(widget; props...)

Sets a Gtk property of widget for each key-value pair in props.

    set!(widget, prop, value)

Sets the value of the Gtk property prop of widget.

Examples

julia> set!(window, :title, "My window")

julia> set!(entry, :text, "Foo bar")

    span(widget, r, c)

Creates a GridCell containing widget that spans r rows and c columns.

Examples

julia> span(mybutton, 2, 2)
CellSpan(GtkButton..., 2, 2)

    start(; [ async = false])

Starts the current AlexyaApp.

This function will setup all the events, apply the current layout and start the canvas drawing loop. The async parameter determines if the loop should be asynchronous.

    use(type::Symbol, func::Function)

Alexya works with events, and event listeners can be attached to the current application with the use function or the @use macro.

Each event has a unique type (a symbol) that determines how it is fired.

Examples

@use function setup()
    println("My application has started!")
end

@use function update()
    background("black")
    # Luxor drawing here
end

@use function keypress(event)
    @info "Key press event" key=event.keyval
end

@use function mousepress(event)
    @info "Mouse clicked" pos=event.pos
end

@use function mouserelease(event)
    @info "Mouse button release" pos=event.pos
end

@use function mousemotion(event)
    @info "Cursor moving" pos=event.pos
end

@use function appclosed()
    @info "Window closed"
end

    withangle(angle [, abs = 1])

Returns a vector of magnitude abs and angle angle.

    withmag(v, m)

Returns a vector with the same direction as v, but with magnitude m.

    angle(v::Vector{<:Real})

Returns the angle (in radians) that a 2D vector v makes with the positive x-axis.

    @align v h

Sets the vertical and horizontal alignment of Gtk widget.

Examples

julia> Button("Foo", @align(:center)) # Sets both alignments to center
GtkButton...

julia> Button("Foo", @align(:center, :end))
GtkButton...

    @canvas

Returns the current canvas.

    @create widget

Adds a widget in the current application.

    @framecount

Returns the current frame count.

    @framerate

Returns the current framerate.

    @height

Returns the current canvas height.

    @init title width height

Shorthand macro for the init function.

    @init title [width = 400, height = 400]

Shorthand macro for the init function.

    @margin values...

Useful macro for setting the margins of a widget.

Examples

julia> Button(:Foo, @margin(10)) # Sets all margins to 10
GtkButton...

julia> Button(:Foo, @margin(10, 20)) # Sets top-bottom margins to 10 and left-right margins to 20
GtkButton...

    @spacing r c

Sets the row and column spacing of a GtkGrid widget.

Examples

julia> Grid(@spacing(10)) # sets both row and column spacing.
GtkGrid...

julia> Grid(@spacing(10, 20))
GtkGrid...

    @use event

Adds a event listener on the current application.

The @use macro should be use in a function declaration expression.

The event type is automatically determined by the name of the function.

    @width

Returns the current canvas width.

    @window

Returns the current window.