A connection has a source widget and a target widget. When the source widget receives a specified event, the connection is activated, executing a specified function, which is called
An action is always executed in a new Thread (and hence will not block the GUI), unless the priority
Main is specified.
What to do when the same action (= same connection id) is already running?
val connect : t -> t -> action -> ?priority:action_priority -> ?update_target:bool -> ?join:connection -> Trigger.t list -> connection
connect source target action triggers creates a connection from the
source widget to the
target widget, but does not register it (this may change in the future...). Once it is registered (either by
add_connection), and assuming that the layout containing the source widget has focus, then when an event
ev matches one of the
triggers list, the
action is executed with arguments
source target ev.
val connect_main : t -> t -> action -> ?update_target:bool -> ?join:connection -> Trigger.t list -> connection
connect ~priority:Main. Should be used for very fast actions that can be run in the main thread.
Registers the connection with the widget. This should systematically be done after each connection creation, when the connection is created after
Connections that are created before
Main.make should rather be passed as argument to
Main.make, and not via
add_connection. Although this is not striclty necessary, this indicates that these connections are more 'pure' or at least more static, in the sense that they will not be modified by Bogue. These are usually much easier to debug.
add_connection is separated from
connect because it is not pure: it mutates the widget. This might change in future versions.
val update : t -> unit
update w asks the widget
w to refresh at next frame. The most probable use of
update is within the code of an
action. It can happen that the action modifies the visual state of a widget that is neither the source or the target, and then one needs to explicitly tell this widget to re-draw itself.
on_release ~release:f w registers on the widget
w the action
f, which will be executed when the mouse button is released on this widget. Uses
Create a Box widget, which simply displays a rectangle, optionally with rounded corners and drop shadow. It is often used for the background of a group of widgets (i.e. a
The standard on/off check boxes.
val set_check_state : t -> bool -> unit
Use this for multi-line text.
val text_display : ?w:int -> ?h:int -> string -> t
val verbatim : string -> t
val html : string -> t
Display basic html text by interpreting the following tags:
<em>,</em>, <b>,</b>, <strong>,</strong>, <p>,</p>, <br>
Create a Label widget with a one-line text.
Create a Label widget with a FontAwesome icon.
icon ~size:24 "star" creates a widget that displays the "fa-star" fontawesome icon.
val empty : w:int -> h:int -> unit -> t
Create a widget that does not display anything but still gets focus and reacts to events.
val slider_with_action : ?priority:action_priority -> ?step:int -> ?kind:Slider.kind -> value:int -> ?length:int -> ?thickness:int -> ?tick_size:int -> action:( int -> unit ) -> int -> t
Create a slider that executes an action each time the local value of the slider is modified by the user.
You can use an Sdl_area widget to draw whatever you want using all the power of the SDL Renderer API.
Sdl_area.create regarding the size
let b,l = check_box_with_label text creates a check box
b, a label
l, and connect them so that clicking on the text will also act on the check box.
These generic functions work on all types of widgets, and emit an error in the log (without raising any exception) whenever the type of the argument makes no sense for the function.
These functions are very handy, but sometimes can hide a bug. For instance if you want to use
get_state t, while you know that
t should always be of type
Button, then it will help debugging to use instead the slightly longer form
(get_button t). Indeed the latter will fail if
t happens not to be a Button.
val get_state : t -> bool
Query a boolean state. Works for Button and Check.
val get_text : t -> string
Return the text of the widget. Works for Button, TextDisplay, Label, and TextInput.
val size : t -> int * int
If the widget is not rendered yet, a default size may be returned instead of the true size.
val set_state : t -> bool -> unit
Set a boolean state. Works for Button and Check.
val set_text : t -> string -> unit
Change the text of a widget. Works for Button, TextDisplay, Label, and TextInput.
Set the cursor that should be displayed for this widget. Note that the Sdl functions for creating cursor are only available after SDL initialization. One can use a
Lazy type or
Sync.push for delaying their execution.
These functions raise
Invalid_argument whenever their argument is not of the correct type.