LTerm_widget

# Module LTerm_widget

    module LTerm_widget: sig .. end

Widgets for creating applications

###### Base class

    class t : string -> object .. end

The base class.

###### Labels

    class label : string -> object .. end

A widget displaying a text.

###### Containers

    exception Out_of_range

    class type box = object .. end

Type of widgets displaying a list of widget.

    class hbox : box

A widget displaying a list of widgets, listed horizontally.

    class vbox : box

A widget displaying a list of widgets, listed vertically.

    class frame : object .. end

A widget displayiing another widget in a box.

    class modal_frame : object .. end

A widget displaying a frame around child widget.

###### Lines

    class hline : t

A horizontal line.

    class vline : t

A vertical line.

###### Buttons

    class button : string -> object .. end

Normal button.

    class checkbutton : string -> bool -> object .. end

Checkbutton.

    class type ['a] radio = object .. end

    class ['a] radiogroup : object .. end

Radio group.

    class ['a] radiobutton : 'a radiogroup -> string -> 'a -> object .. end

Radiobutton.

###### Running in a terminal

    val run : LTerm.t ->
           ?save_state:bool ->
           ?load_resources:bool ->
           ?resources_file:string -> #t -> 'a Lwt.t -> 'a Lwt.t

`run term ?save_state widget w` runs on the given terminal using `widget` as main widget. It returns when `w` terminates. If `save_state` is `true` (the default) then the state of the terminal is saved and restored when `w` terminates.

If `load_resources` is `true` (the default) then `resources_file` (which default to ".lambda-termrc" in the home directory) is loaded and the result is set to `w`.

    val run_modal : LTerm.t ->
           ?save_state:bool ->
           ?load_resources:bool ->
           ?resources_file:string ->
           t Lwt_react.event ->
           unit Lwt_react.event -> #t -> 'a Lwt.t -> 'a Lwt.t

This function works in the same way as `LTerm_widget.run` but also takes two `Lwt_react.event` parameters. The first one should contain `LTerm_widget.t` widget and makes it new topmost layer in UI. The second message removes the topmost level from UI. All layers are redrawn, from bottom to up, but only the topmost layer gets keyboard events delivered to it. This allows to implement things like modal dialogs.

    val prepare_simple_run : unit ->
           (#t -> 'a Lwt.t) * (#t -> unit -> unit) *
           (?step:React.step -> unit -> unit) * ('a -> unit)

`prepare_simple_run ()` returns a tuple `(do_run, push_layer, pop_layer, exit)` -- functions useful for creating simple UI.

`do_run w` where w is a widget runs the given widget in a terminal over stdout, loading resources from `.lambda-termrc`, saving state and restoring it on exit from ui. Example: `do_run my_frame`

`push_layer w` where w is a widget is a callback to add w as a new modal layer to UI. Example: `button#on_click (push_layer my_modal_dialog)`.

`pop_layer` is a callback to destroy the topmost modal layer. Example: `cancel_button#on_click pop_layer`.

`exit` is a callback to exit the UI. Example: `exit_button#on_click exit`