Documentation

Preface

This is the reference manual of YAAA.app (Y3A pronounced Y triple A), a GUI scripting interface that leverages Lua, Python, C# and Microsoft Excel via the Fast Light Toolkit (FLTK).

This reference manual provides comprehensive documentation on utilizing the available API to:

• Setup your app’s structure.
• Exchange data between supported languages.
• Interface with FLTK widgets.
• Access system APIs.
• Handle events and callbacks.
• Integrate with external applications.

It is assumed that the reader is familiar with basic computer programming concepts.

For convenience of reference, this document contains external (deep) links to the Lua Reference Manual and the FLTK Programming Manual.

Installation

Latest version of the app can be download from the Download page.

It ships in a fully portable package and does not require elevated user privileges for installation or operation. This makes it easy to use on any compatible Windows system without administrative rights.

To install, run the downloaded installation file, select the desired location in which you want the application files to be stored and click on Install. Please note that installing the app in system directories such as C:\Program Files would require admin rights.

Once the installation is complete, you can create a desktop shortcut or pin the exe file in application directory to the taskbar for quick access.

Writing Your First App

Y3A’s programming interface provides simple controls to create application structure.

To create a new app simply click on the Add app button on the toolbar (Button 1). You will be presented with a dialogue to set the following app’s parameters.

• Name: Unique app’s name which appear on the user’s Desktop as well as on app tree browser within the programming interface. We will set this as TestApp.
• Callback: A global Lua variable which is of type app dialogue. This is the app’s entry dialogue which is shown when the app’s icon on the desktop is clicked.
• Tooltip: Contents of the dialogue shown when users hover mouse over the Desktop icon.
• Icon: SVG code of the Desktop icon. SVG Repo contains a large range of icons which can be easily copied and used as app’s icon. Simply go to the icon’s page, click on Edit Vector and then COPY SVG.

<svg ...>
</svg>

Once all above fields are set, click on Save on the toolbar (Button 6) to save the changes. Upon completion a new app icon will appear on the Desktop with given parameters.

Next we need to define the body of the app. Y3A uses Lua as its primary programming interface due to it’s simplicity and robustness. The graphical user interface (GUI) of all apps can only be defined in Lua. In addition to Lua, other available scripting languages can be used to implement the logic of the apps.

To create a new Lua, Python or C# script, simply click on the Add Lua script, Add Python script and Add C# script on the toolbar respectively (Buttons 2-4). In the name field, write in your preferred name for the script. To save the script as a child of TestApp, name of the script needs to start with TestApp/ i.e. TestApp/TestScript.

Y3A provides a simple way to integrate Python, C# and MS Excel logics in Lua scripts. Python and C# global functions and class static functions can simply be called with PY.call and CS.call functions.

-- output is the return value from the Python function
-- func is the Python function name
-- arg1, arg2, ... are the arguments passed to the Python function
output = PY.call('func', arg1, arg2, ...)
output = PY.call('className.func', arg1, arg2, ...)

-- output is the return value from the C# function
-- func is the C# function name
-- arg1, arg2, ... are the arguments passed to the C# function
output = CS.call('func', arg1, arg2, ...)
output = CS.call('className.func', arg1, arg2, ...)

Use PY.create and CS.create functions to create instances of Python and C# classes.

pyClassInstance = PY.create('className', arg1, arg2, ...)
pyClassInstance:MyMethod(arg1, arg2, ...) -- Call class method MyMethod

Excel spreadsheet can also be used to implement the calculation logic of the apps. This method is particularly useful since most engineers are comfortable with writing Excel calculations, making it easy to distribute the development workload among team members. Refer to Sample Beam Calculator blog post to check how you can incorporate Excel calculations in your apps.

TestApp will include 3 Lua scripts to implement utility functions, callback functions and GUI layout. To create the Lua scripts click on the Add Lua script icon on the toolbar (Button 2). We will call the first Lua script Utilities and save it under TestApp by specifying the name as TestApp/Utilities.

function file_chooser_cb(udata)
    input, ext = table.unpack(udata)
    chooser = gui.native_file_chooser()
    chooser:filter(ext)
    chooser:show()
    path = chooser:filenames(1)
    if path == nil then do return end end
    input:value(path)
    input:activate()
end

function FileExists(path)
    local f = io.open(path, 'r')
    if f then
        f:close()
    end
    return f ~= nil
end

-- EPDD CB

TestApp = {
    cb = {},
    data = {}
}

local outputWB = Workbook('EPDD/xls')
outputWB:open()
local lookupWS = outputWB:worksheet('Lookup')
local reportWS = outputWB:worksheet('Report')
local inputTabs = {}

local pierDefinitionCount = nil
local rawPierDefinitions = {}

----------------------------------------------

EPDD.InitParameters = function()
    for k, v in pairs(EPDD.layout.parameterTab.widgets) do
        v:do_callback()
    end
end

----------------------------------------------

local function cb_ImportData(input)
    local type = input:label()
    local path = input:value()
    if (not (FileExists(path))) then
        msg.error('Select the ' .. type .. ' input file')
        do
            return
        end
    end

    local inputWB = Workbook(path)
    inputWB:open()
    local worksheets = Decode(inputWB:worksheets())
    local inputWS = inputWB:worksheet(worksheets[1])
    local outputWS = outputWB:worksheet(type)
    outputWS:copy(inputWS)
    inputWB:close()
    input:deactivate()
end
EPDD.cb.ImportData = cb_ImportData

local function cb_Reset()
    outputWB:close()
    EPDD.layout.reset:deactivate()
end
EPDD.cb.Reset = cb_Reset

----------------------------------------------

local function cb_Input(udata)
    local w, name = table.unpack(udata)
    if (w:value() == '') then
        local v = outputWB[name]:value()
        w:value(Decode(v)[1])
    else
        outputWB[name]:cell(0, 0):value(w:value())
    end
end
EPDD.cb.Input = cb_Input

----------------------------------------------

local function cb_NumberInput(udata)
    local w, name = table.unpack(udata)
    if (w:value() == '') then
        local v = outputWB[name]:value()
        w:value(Decode(v)[1])
    else
        outputWB[name]:cell(0, 0):value(tonumber(w:value()))
    end
end
EPDD.cb.NumberInput = cb_NumberInput

----------------------------------------------

local function cb_Output(udata)
    local w, name = table.unpack(udata)
    local v = outputWB[name]:value()
    w:value(Decode(v)[1])
end
EPDD.cb.Output = cb_Output

----------------------------------------------

function cb_Close(window)
    if IsOpen(source:value()) then
        PY.call('Close', source:value())
    end
    if IsOpen(target:value()) then
        PY.call('Close', target:value())
    end
    source:activate()
    target:activate()
    source:value('')
    target:value('')
    materialList:clear()
    sourceCase:clear()
    targetCase:clear()
    swTargetCase:clear()
    if window~=nil then
        window:hide()
    end
end

-- EPDD Layout

TestApp.layout = {
    tab1 = {
        widgets = {}},
    tab2 = {
        widgets = {}},
    tab3 = {
        widgets = {}}
}

TestApp_win = gui.app(100, 100, 700, 295, 'My first app')
TestApp_win:callback(cb_Close, TestApp_win)

local t = gui.tabs(0, 0, 700, 255)

----------------------------------------------

local g = gui.group(0, 30, 700, 255, 'Tab 1')
TestApp.layout.tab1.group = g

local function AddImportWidgets(y, label)
    local i = gui.input(70, y, 500, 30, label)
    local o = gui.button(580, y, 50, 30, 'Select')
    o:callback(file_chooser_cb, {i, 'Excel Files\t*.xlsx'})
    o = gui.button(640, y, 50, 30, 'Import')
    o:callback(TestApp.cb.ImportData, i)
    table.insert(TestApp.layout.tab1.widgets, i)
    table.insert(TestApp.layout.tab1.widgets, o)
end

AddImportWidgets(40, 'Reaction')
AddImportWidgets(75, 'Force')

g:done()

----------------------------------------------

g = gui.group(0, 30, 700, 255, 'Tab 2')
TestApp.layout.tab2.group = g

local function AddParameter(x, y, w, h, label, cb_name, tooltip, isNumber)
    tooltip = tooltip or ''
    isNumber = isNumber or false
    local o = nil
    if isNumber then
        o = gui.float_input(x, y, w, h, label)
        o:callback(EPDD.cb.NumberInput, {o, cb_name})
    else
        o = gui.input(x, y, w, h, label)
        o:callback(EPDD.cb.Input, {o, cb_name})
    end
    o:tooltip(tooltip)
    table.insert(EPDD.layout.parameterTab.widgets, o)
    return o
end

AddParameter(70, 40, 60, 30, 'µ/Sp', 'Setting.muOnSp', '', true)
AddParameter(70, 75, 60, 30, 'Top µ', 'Setting.frictionMu.Top',
    [[Coefficient of friction to reduce shear force in dowels (max. 0.6)
Note that the plastic membrane is placed over the wall prior slab pour]], true)

g:done()

----------------------------------------------

g = gui.group(0, 30, 700, 255, 'Tab 3')
TestApp.layout.tab3.group = g

local o = gui.text_editor(10, 55, 240, 190, 'Tab 3')
local buffer = gui.text_buffer()
o:buffer(buffer)
o:tooltip('INPUT FORMAT\nTag Thickness Grade VerticalReo HorizontalReo')
o:callback(EPDD.cb.AddPierDefinitions, o)
o:when('never')
buffer:text([[
P180A 180 40 N12-300 N12-300
P180B 180 40 N12-200 N12-150
P200A 200 40 N12-350 N12-350
P200B 200 40 N12-250 N12-350
P200C 200 50 N12-150 N12-150
P200D 200 40 N16-225 N12-150
P250A 250 50 N12-250 N12-350]])
table.insert(EPDD.layout.definitionTab.widgets, o)

o = gui.box(260, 55, 60, 120, 'Dowel\nsize/s')

o = gui.browser(310, 55, 60, 120, 'Bottom')
o:type('multi')
o:align(ALIGN_TOP)
o:tooltip('Select the bottom dowels to be used in the design')
o:callback(EPDD.cb.DowelSize, o)
o:when('never')
table.insert(EPDD.layout.definitionTab.widgets, o)
o:add('20')
o:add('24')
o:add('28')
o:add('32')
o:add('36')
o:add('40')
o:select(3)
o:select(4)

AddParameter(310, 180, 60, 30, 'Min.\nEdge', 'Dowel.minEdgeDistance.Bottom',
    'Min bottom dowel edge distance to panel ends', true)
AddParameter(310, 215, 60, 30, 'Min.\nSpacing', 'Dowel.minSpacing.Bottom', 'Min bottom dowel spacing', true)

o = gui.browser(380, 55, 60, 120, 'Top')
o:type('multi')
o:align(ALIGN_TOP)
o:tooltip('Select the top dowels to be used in the design')
o:callback(EPDD.cb.DowelSize, o)
o:when('never')
table.insert(EPDD.layout.definitionTab.widgets, o)
o:add('12')
o:add('16')
o:add('20')
o:add('24')
o:add('28')
o:add('32')
o:select(2)
o:select(3)

AddParameter(380, 180, 60, 30, '', 'Dowel.minEdgeDistance.Top', 'Min top dowel edge distance to panel ends', true)
AddParameter(380, 215, 60, 30, '', 'Dowel.minSpacing.Top', 'Min top dowel spacing', true)

g:done()

----------------------------------------------

g = gui.group(0, 30, 700, 255, 'Lookup')
EPDD.layout.lookupTab.group = g

local story = gui.choice(70, 40, 60, 30, 'Story:')
story:callback(EPDD.cb.StoryLookup)
EPDD.layout.lookupTab.story = story
local pier = gui.choice(70, 75, 60, 30, 'Pier:')
pier:callback(EPDD.cb.PierLookup)
EPDD.layout.lookupTab.pier = pier

local function AddOutput(x, y, w, h, label, cb_name)
    o = gui.output(x, y, w, h, label)
    o:callback(EPDD.cb.Output, {o, cb_name})
    o:when('never')
    o:clear_visible_focus()
    table.insert(EPDD.layout.lookupTab.widgets, o)
end

AddOutput(180, 40, 60, 30, 'G:', 'G')
AddOutput(180, 75, 60, 30, 'Q:', 'Q')

local location = gui.choice(480, 40, 60, 30, 'Location:')
location:callback(EPDD.cb.LocationLookup)
location:add('Bottom')
location:add('Top')
EPDD.layout.lookupTab.location = location

g:done()
g:deactivate()

----------------------------------------------

t:done()

o = gui.button(380, 260, 70, 30, 'Compute')
o:callback(EPDD.cb.Calculate)
EPDD.layout.calculate = o

o = gui.button(460, 260, 70, 30, 'Export')
o:callback(EPDD.cb.Export)
o:deactivate()
EPDD.layout.export = o

o = gui.button(540, 260, 70, 30, 'Save')
o:callback(EPDD.cb.Save)
o:deactivate()
EPDD.layout.save = o

o = gui.button(620, 260, 70, 30, 'Reset')
o:callback(EPDD.cb.Reset)
o:deactivate()
EPDD.layout.reset = o

EPDD_window:done()
EPDD.InitParameters()

It is highly recommended to define variables as local in your scripts to maintain the global states as clean as possible and avoid conflicting variable names in global scope from different apps (Similar to how they are defined above).

We will include a Python and C# script to implement part of our app’s logic in these languages. In a real scenario, these languages are used to make external API calls to external applications such as Etabs and RAM Concept.

import pandas as pd

def PyFunc():
    data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 22], 'City': ['New York', 'San Francisco', 'Los Angeles']}
    return pd.DataFrame(data)

public class ScriptTest
{
    public string Message { get; set; } = "Hello wonderful World!!!";
    public string Name { get; set; }
    public int Id { get; set; }
}

Examples

Examples can be found in the programming interface of the app.

API Introduction

Y3A exposes FLTK functions and static methods as Lua functions contained in the gui table. For example, gui.draw( ) exposes fl_draw( ), gui.run( ) exposes Fl::run( ), and so on.

FLTK classes are exposed as Lua objects, that is, table with methods. For each (concrete) class there is a constructor function in the gui table that instantiates an object of that class, bounds it to a Lua table and returns the latter.

win = gui.double_window(0, 0, 600, 400) -- creates a Fl_Double_Window
win:label('My Window')                  -- a method

Y3A’s GUI objects preserve the FLTK class hierarchy: the win object in the above example is not only a double_window, but also a window, a group, and a widget. This means that it inherits their methods and it can be used wherever a window, a group, or a widget is expected.

Exposed functions, classes, and their methods are listed in the following sections. For most of them, their functionalities and usages are not described in this manual (please refer to the FLTK Programming Manual instead).

widget

Rfr: Fl_Widget
No Constructor (abstract class)

• :activate( )
• boolean = :active( )
• boolean = :active_r( )
• :align(alignment)
  alignment = :align( )
• :argument(arg)
  arg = :argument( )
  arg : any Lua value.
• :box(boxtype)
  boxtype = :box( )
• :callback(func [, arg])
  func = :callback( )
  The func callback (a Lua function) is executed as func(arg).
  The optional argument arg may be any Lua value.
• boolean = :changed( )
• :clear_active( )
  :clear_changed( )
  :clear_damage(damagebits)
  :clear_output( )
  :clear_visible( )
  :clear_visible_focus( )
• :color(bgcolor [, selcolor])
  bgcolor = :color( )
• boolean = :contains(widget)
• :damage(damagebits) :damage(x, y, w, h, damagebits)
  damagebits = :damage( )
• :deactivate( )
• :deimage(image)
  image = :deimage( )
• :do_callback([arg])
  The optional argument arg may be any Lua value.
  If arg is not passed, the current user_data is used.
  If arg = nil, the callback receives nil as argument.
• :draw( )
• :draw_label( )
  :draw_label(x, y, w, h [, alignment])
• boolean = :handle(event)
• :hide( )
• :image(image)
  image = :image( )
• boolean = :inside(widget)
• :label(label)
  label = :label( )
• :labelcolor(color)
  color = :labelcolor( )
• :labelfont(font)
  font = :labelfont( )
• :labelsize(fontsize)
  fontsize = :labelsize( )
• :labeltype(labeltype)
  labeltype = :labeltype( )
• width, height = :measure_label( )
• boolean = :output( )
• group = :parent( )
• :position(x, y)
• :redraw( )
  :redraw_label( )
• :resize(x, y, w, h)
• :selection_color(color)
  color = :selection_color( )
• :set_active( )
• set_changed( )
• :set_output( )
• :set_visible( )
• :set_visible_focus( )
• :show( )
• :size(w, h)
• boolean = :take_focus( )
• boolean = :takesevents( )
• :tooltip(text)
  text = :tooltip( )
• window = :top_window( )
• xoffset, yoffset = :top_window_offset( )
• :type(rtti)
  rtti = :type( )
• :userdata: alias for :argument
• boolean = :visible( )
• :visible_focus(boolean)
  boolean = :visible_focus( )
• boolean = :visible_r( )
• :when(whenflags)
  whenflags = :when()
• window = :window( )
• x, y, w, h = :xywh( )
  x = :x()
  y = :y( )
  w = :w( )
  h = :h( )

Protected methods, exposed for subclassing:

• :draw_backdrop( )
• :draw_box( )
  :draw_box(boxtype, color)
  :draw_box(boxtype, x, y, w, h, color)
• :draw_focus( )
  :draw_focus(boxtype, x, y, w, h, color)

box

Rfr: Fl_Box
Inherits from: widget

• box = gui.box(x, y, w, h [, label])
  box = gui.box(boxtype, x, y, w, h [, label])

button

Rfr: Fl_Button
Inherits from: widget
RTTI: normal, toggle, radio, hidden

• button = gui.button(x, y, w, h [, label])
• boolean = :clear( )
• :down_box(boxtype)
  boxtype = :down_box( )
• boolean = :set( )
• :setonly( )
• :shortcut(shortcut)
  shortcut = :shortcut( )
• :value(boolean)
  boolean = :value( )

light_button

Rfr: Fl_Light_Button
Inherits from: button

• light_button = gui.light_button(x, y, w, h [, label])

check_button

Rfr: Fl_Check_Button
Inherits from: light_button

• check_button = gui.check_button(x, y, w, h [, label])

radio_light_button

Rfr: Fl_Radio_Light_Button
Inherits from: light_button

• radio_light_button = gui.radio_light_button(x, y, w, h [, label])

round_button

Rfr: Fl_Round_Button
Inherits from: light_button

• round_button = gui.round_button(x, y, w, h [, label])

radio_round_button

Rfr: Fl_Radio_Round_Button
Inherits from: round_button

• radio_round_button = gui.radio_round_button(x, y, w, h [, label])

radio_button

Rfr: Fl_Radio_Button
Inherits from: button

• radio_button = gui.radio_button(x, y, w, h [, label])

repeat_button

Rfr: Fl_Repeat_Button
Inherits from: button

• repeat_button = gui.repeat_button(x, y, w, h [, label])
• :deactivate( )

return_button

Rfr: Fl_Return_Button
Inherits from: button

• return_button = gui.return_button(x, y, w, h [, label])

toggle_button

Rfr: Fl_Toggle_Button
Inherits from: button

• toggle_button = gui.toggle_button(x, y, w, h [, label])

chart

Rfr: Fl_Chart
Inherits from: widget
RTTI: bar, horbar, line, fill, spike, pie, specialpie

• chart = gui.chart(x, y, w, h [, label])
• :add(value [, label] [, color])
• :autosize(boolean)
  boolean = :autosize( )
• :bounds(lower, upper)
  lower, upper = :bounds( )
• :clear( )
• :insert(pos, value [, label] [, color])
• :maxsize(n)
  n = :maxsize( )
• :replace(pos, value [, label] [, color])
• :size(w, h)
  n = :size( )
• :textcolor(color)
  color = :textcolor( )
• :textfont(font)
  font = :textfont( )
• :textsize(fontsize)
  fontsize = :textsize( )

clock_output

Rfr: Fl_Clock_Output
Inherits from: widget

• clock_output = gui.clock_output(x, y, w, h [, label])
• hour = :hour( )
• minute = :minute( )
• second = :second( )
• :value(H, m, s)
  sec_since_UNIX_epoch (1 Jan 1970) = :value( )

clock

Rfr: Fl_Clock
Inherits from: clock_output

• clock = gui.clock(x, y, w, h [, label])

round_clock

Rfr: Fl_Round_Clock
Inherits from: clock

• round_clock = gui.round_clock(x, y, w, h [, label])

group

Rfr: Fl_Group
Inherits from: widget

• group = gui.group(x, y, w, h [, label])
• :add(widget)
• :add_resizable(widget)
• :begin( )
• widget = :child(n)
• nchildren = :children( )
  NOTE: Children are indexed from 1 to :children() inclusive.
• :clear( )
• :clip_children(boolean)
  boolean = :clip_children( )
• :done( )
  :end is replaced by :done (end is a reserved keyword in Lua).
• n = :find(widget)
  Returns :children()+1 if widget is nil or not found.
• :init_sizes( )
• :insert(widget, n)
  :insert(widget, beforewidget)
• :remove(widget)
• :resizable(widget)
  widget = :resizable( )
  If widget is nil, then all widget remain a fixed size and distance from the top-left corner.
  NOTE: :resizable() differs from :resizable(nil): the former is a getter, while the latter is a setter function.

The following are (un)protected methods to be used only when subclassing.

• :draw_child(widget)
  :draw_children( )
  :draw_outside_label(widget)
  :update_child(widget)

browser_

Rfr: Fl_Browser_
Inherits from: group
RTTI: normal, select, hold, multi
No constructor (abstract class).

• boolean = :deselect( )
• :has_scrollbars(scrollbarsmode)
  scrollbarsmode = :has_scrollbars( )
• :hposition(pos)
  pos = :hposition( )
• :position(pos)
  pos = :position( )
• :scrollbar_left( )
  :scrollbar_right( )
• :scrollbar_size(size)
  size = :scrollbar_size( )
• :sort(order)
  order : “ascending” or “descending”
• :textcolor(color)
  color = :textcolor( )
• :textfont(font)
  font = :textfont( )
• :textsize(fontsize)
  fontsize = :textsize( )

browser

Rfr: Fl_Browser
Inherits from: browser_

• browser = gui.browser(x, y, w, h [, label])
• :add([text] [, data])
• :bottomline(line)
• :clear( )
• :column_char(c)
  c = :column_char( )
  c : ASCII character.
• :column_widths(w₁, w₂, …​, w_N)
  w₁, w₂, …​, w_N = :column_widths( )
• :data(line, data)
  data = :data(line)
  data : an integer value to associate with the item (defaults to 0).
  This value may be used as index in a Lua table containing more complex data associated with the item.
• boolean = :displayed(line)
• :format_char(c)
  c = :format_char( )
  c : ASCII character.
• :hide(line)
  :hide( )
• :icon(line, image)
  image = :icon(line)
• :insert(line [, text] [, data])
• :lineposition(line, linepos)
• ok, err = :load(filename)
  Returns true or false and an error string.
• :make_visible(line)
• :middleline(line)
• :move(to, from)
• :remove(line)
• :remove_icon(line)
• boolean = :select(line [, boolean])
• boolean = :selected(line)
• :show(line)
  :show( )
• :size(w, h)
  nlines = :size( )
• :swap(line₁, line₂)
• :text(line [, text])
  text = :text(line)
• :topline(line)
  line = :topline( )
• :value(line)
  line = :value( )
• boolean = :visible(line)

file_browser

Rfr: Fl_File_Browser
Inherits from: browser

• file_browser = gui.file_browser(x, y, w, h [, label])
• :filetype(filetype)
  filetype = :filetype( )
• :filter(pattern)
  pattern = :filter( )
• :iconsize(size)
  size = :iconsize( )
• boolean = :load(filename [, sortfunc])
• :textsize(fontsize)
  fontsize = :textsize( )

hold_browser

Rfr: Fl_Hold_Browser
Inherits from: browser

• hold_browser = gui.hold_browser(x, y, w, h [, label])

multi_browser

Rfr: Fl_Multi_Browser
Inherits from: browser

• multi_browser = gui.multi_browser(x, y, w, h [, label])

select_browser

Rfr: Fl_Select_Browser
Inherits from: browser

• select_browser = gui.select_browser(x, y, w, h [, label])

check_browser

Rfr: Fl_Check_Browser
Inherits from: browser_

• check_browser = gui.check_browser(x, y, w, h [, label])
• index = :add([text] [, boolean])
  NOTE: index is an integer in the range 1 to :nitems() inclusive.
• :check_all( )
• :check_none( )
• :checked(index, boolean)
  boolean = :checked(index)
• :clear( )
• n = :nchecked( )
• n = :nitems( )
• n = :remove(index)
• :set_checked(index)
• text = :text(index)
• index = :value( )

color_chooser

Rfr: Fl_Color_Chooser
Inherits from: group

• color_chooser = gui.color_chooser(x, y, w, h [, label])
• boolean = :hsv(rh, sg, vb)
  boolean = :rgb(r, g, b)
• hue = :hue( )
• :mode(colorchoosermode)
  colorchoosermode = :mode( )
• r = :r( )
  g = :g( )
  b = :b( )
• saturation = :saturation( )
• brightness = :value( )

help_view

Rfr: Fl_Help_View
Inherits from: group

• help_view = gui.help_view(x, y, w, h [, label])
• :clear_selection( )
• dirname = :directory( )
• filename = :filename( )
• line = :find(string [, pos])
  Returns nil if string is not found.
• :leftline(p)
  p = :leftline( )
• :link(func)
  The func callback (a function) is executed as func(uri) where uri is an URI or a pathname. It must return a pahname that can be opened as a local file, or nil (see Fl_Help_View::link() in the FLTK manual for more details).
• :load(filename)
• :resize(x, y, w, h)
• :scrollbar_size(pixels)
  pixels = :scrollbar_size( )
  NOTE: Do not use this function, use gui.scrollbar_size( ) instead.
• :select_all( )
• :size(w, h)
  size = :size( )
• :textcolor(color)
  color = :textcolor( )
• :textfont(font)
  font = :textfont( )
• :textsize(fontsize)
  fontsize = :textsize( )
• title = :title( )
• :topline(line)
  :topline(name)
  line = :topline( )
• :value(text)
  text = :value( )

input_choice

Rfr: Fl_Input_Choice
Inherits from: group

• input_choice = gui.input_choice(x, y, w, h [, label])
• :add(item)
  item : a string.
• boolean = :changed( )
• :clear( )
• :clear_changed( )
• :down_box(boxtype)
  boxtype = :down_box( )
• input = :input( )
• menu_button = :menubutton( )
• :set_changed( )
• :textcolor(color)
  color = :textcolor( )
• :textfont(font)
  font = :textfont( )
• :textsize(fontsize)
  fontsize = :textsize( )
• :value(index)
  :value(item)
  item = :value( )

pack

Rfr: Fl_Pack
Inherits from: group
RTTI: horizontal, vertical

• pack = gui.pack(x, y, w, h [, label])
• :spacing(pixels)
  pixels = :spacing( )

scroll

Rfr: Fl_Scroll
Inherits from: group
RTTI: no scrollbar, horizontal, vertical, both, always on, horizontal always, vertical always, both always

• scroll = gui.scroll(x, y, w, h [, label])
• :clear( )
• scrollbar = :hscrollbar( )
  Returns a reference to the horizontal scrollbar widget.
• scrollbar = :scrollbar( )
  Returns a reference to the vertical scrollbar widget.
• :scrollbar_size(pixels)
  pixels = :scrollbar_size( )
• :scroll_to(x, y)
• x :xposition( )
  y :yposition( )

spinner

Rfr: Fl_Spinner
Inherits from: group
RTTI: float, int

• spinner = gui.spinner(x, y, w, h [, label])
• :color(color)
  color = :color( )
• :format(fmt)
  fmt = :format( )
• :maximum(number)
  number = :maximum( )
• :minimum(number)
  number = :minimum( )
• :range(min, max)
• :selection_color(color)
  color = :selection_color( )
• :step(number)
  number = :step( )
• :textcolor(color)
  color = :textcolor( )
• :textfont(font)
  font = :textfont( )
• :textsize(fontsize)
  fontsize = :textsize( )
• :value(number)
  number = :value( )

table

Rfr: Fl_Table
Inherits from: group

• table = gui.table(x, y, w, h [, label])
  NOTE: Row and column numbers, as well as children indices, are 1-based (Lua-style).
• tablecontext = :callback_context( )
• col = :callback_col( )
• row = :callback_row( )
• :col_header(boolean)
  boolean = :col_header( )
• :col_header_color(color)
  color = :col_header_color( )
• :col_header_height(h)
  h = :col_header_height( )
• :col_position(col)
  col = :col_position( )
• :col_resize(boolean)
  boolean = :col_resize( )
• :col_resize_min(val)
  val = :col_resize_min( )
• :col_width(col, w)
  w = :col_width(col)
• :col_width_all(w)
• ncols = :cols( )
• :draw_cell(tablecontext, r, c, x, y, w, h)
• x, y, w, h = :find_cell(tablecontext, row, col)
• row_top, col_left, row_bottom, col_right = :get_selection( )
• boolean = :is_interactive_resize( )
• boolean = :is_selected(row, col)
• boolean = :move_cursor(deltarow, deltacol [, shiftselect])
• row = :current_row( )
  col = :current_col( )
  Return nil if none is selected.
• :row_header(boolean)
  boolean = :row_header( )
• :row_header_color(color)
  color = :row_header_color( )
• :row_header_width(w)
  w = :row_header_width( )
• :row_height(row, h)
  h = :row_height(row)
• :row_height_all(h)
• :row_position(row)
  row = :row_position( )
• :row_resize(boolean)
  boolean = :row_resize( )
• :row_resize_min(val)
  val = :row_resize_min( )
• nrows = :rows( )
• :scrollbar_size(val)
  val = :scrollbar_size( )
• :set_selection(row_top, col_left, row_bottom, col_right)
• :table_box(boxtype)
  boxtype = :table_box( )
• :tab_cell_nav(boolean)
  boolean = :tab_cell_nav( )
• row₁, row₂, col₁, col₂ = :visible_cells( )

table_row

Rfr: Fl_Table_Row
Inherits from: table
RTTI: none, single, multi

• table_row = gui.table_row(x, y, w, h [, label])
  NOTE: Row and column numbers, as well as children indices, are 1-based (Lua-style).

• boolean = :row_selected(row)
  Returns nil, errmsg if row is out of range.
• :rows(nrows)
  nrows = :rows( )
• :select_all_rows([option])
  option : deselect, select (default), toggle
• boolean = :select_row(row [, option])
  option : deselect, select (default), toggle
  Returns nil, errmsg if row is out of range.

tabs

Rfr: Fl_Tabs
Inherits from: group

• tabs = gui.tabs(x, y, w, h [, label])
• x, y, w, h = :client_area([tabh])
• widget = :push( )
• widget = :value( )
  boolean = :value(widget)
• widget = :which(event_x, event_y)

text_display

Rfr: Fl_Text_Display
Inherits from: group
IMPORTANT: See text_buffer indexing.

• text_display = gui.text_display(x, y, w, h [, label])
• :buffer(text_buffer)
  text_buffer = :buffer( )
• nlines = :count_lines(start [, end] [, islinestart])
• :cursor_color(color)
  color = :cursor_color( )
• :cursor_style(cursorstyle)
• :hide_cursor( )
• :highlight_data(stylebuffer, styletable [, unfinishedstyle, func])
  stylebuffer : a text_buffer.
  styletable : an array (integer-indexed table) of style-describing arrays, each of which in the form: { color, font, fontsize, fontattr }
  fontattr is optional and defaults to 0.
  Characters in the stylebuffer indicate styles in the styletable : ‘A’, denotes the first style, ‘B’ the second, and so on (up to ‘~’).
  unfinishedstyle : (optional) character denoting the unfinished style that triggers the callback below.
  func : (optional) callback triggered by unfinishedstyle. The callback is executed as func(pos).
• boolean = :in_selection(x, y)
• :insert(text)
• :insert_position(pos)
  pos = :insert_position( )
• pos = :line_end(pos [, islinestart])
• pos = :line_start(pos)
• :linenumber_align(alignment)
  alignment = :linenumber_align( )
• :linenumber_bgcolor(color)
  color = :linenumber_bgcolor( )
• :linenumber_fgcolor(color)
  color = :linenumber_fgcolor( )
• :linenumber_font(font)
  font = :linenumber_font( )
• :linenumber_format(fmt)
  fmt = :linenumber_format( )
• :linenumber_size(fontsize)
  fontsize = :linenumber_size( )
• :linenumber_width(w)
  w = :linenumber_width( )
• boolean = :move_down( )
  boolean = :move_left( )
  boolean = :move_right( )
  boolean = :move_up( )
• :next_word( )
• :overstrike( )
• x, y = :position_to_xy(pos)
  Returns nil if character is vertically out of view.
• :previous_word( )
• :redisplay_range(start, end)
• pos = :rewind_lines(start, nlines)
• :scrollbar_align(alignment)
  alignment = :scrollbar_align( )
• :scrollbar_width(w)
  w = :scrollbar_width( )
• :shortcut(shortcut)
  shortcut = :shortcut( )
• :show_cursor(boolean)
• :show_insert_position( )
• pos = :skip_lines(start, nlines [, islinestart])
• :textcolor(color)
  color = :textcolor( )
• :textfont(font)
  font = :textfont( )
• :textsize(fontsize)
  fontsize = :textsize( )
• start = :word_start(pos)
• end + 1 = :word_end(pos)
• :wrap_mode(wrapmode, margin)

text_editor

Rfr: Fl_Text_Editor
Inherits from: text_display

• text_editor = gui.text_editor(x, y, w, h [, label])
• :insert_mode(boolean)
  boolean = :insert_mode( )
• :key_callback(func)
  Registers func as the callback for key bindings. A text_editor may have only one key callback, and this will handle all the (key, modifiers) combinations bound with the key_bind( ) method. The callback is executed as func(editor, key, modifiers) and must return a boolean (the modifiers argument is passed as integer code).
• :key_bind(key, modifiers)
  Binds (key, modifiers) to the key callback.
• :key_unbind(key, modifiers)
  Unbinds (key, modifiers). This method can be used also to unbind default key bindings, not only for keys bound to the key callback.
• :remove_all_key_bindings( )

Built-in key handling functions are available as members of the gui table and may be used in the key callback:

• boolean = gui.kf_default(key, text_editor)
  boolean = gui.kf_ignore(key, text_editor)
  boolean = gui.kf_backspace(key, text_editor)
  boolean = gui.kf_enter(key, text_editor)
  boolean = gui.kf_move(key, text_editor)
  boolean = gui.kf_shift_move(key, text_editor)
  boolean = gui.kf_ctrl_move(key, text_editor)
  boolean = gui.kf_c_s_move(key, text_editor)
  boolean = gui.kf_meta_move(key, text_editor)
  boolean = gui.kf_m_s_move(key, text_editor)
  boolean = gui.kf_home(key, text_editor)
  boolean = gui.kf_end(key, text_editor)
  boolean = gui.kf_left(key, text_editor)
  boolean = gui.kf_up(key, text_editor)
  boolean = gui.kf_right(key, text_editor)
  boolean = gui.kf_down(key, text_editor)
  boolean = gui.kf_page_up(key, text_editor)
  boolean = gui.kf_page_down(key, text_editor)
  boolean = gui.kf_insert(key, text_editor)
  boolean = gui.kf_delete(key, text_editor)
  boolean = gui.kf_copy(key, text_editor)
  boolean = gui.kf_cut(key, text_editor)
  boolean = gui.kf_paste(key, text_editor)
  boolean = gui.kf_select_all(key, text_editor)
  boolean = gui.kf_undo(key, text_editor)

tile

Rfr: Fl_Tile
Inherits from: group

• tile = gui.tile(x, y, w, h [, label])
• :move_intersection(oldx, oldy, newx, newy)

tree

Rfr: Fl_Tree
Inherits from: group
RTTI: see treeselect
NOTE: In Y3A, tree items are identified by their pathname and the tree they belong to (orphaned items are not supported). The Fl_Tree_Item class in not directly exposed, while its methods are exposed as methods of the gui.tree object (renamed with a leading item_ prefix, and accepting the item’s pathname as first argument). Children items’ indices are 1-based.

• tree = gui.tree(x, y, w, h [, label])
• :add(pathname)
• :argument(arg)
  arg + = :argument( )
  arg : any Lua value.
• :callback(func [, arg])
  func + = :callback( )
  The func callback (a Lua function) is executed as func(tree, pathname, reason, arg), where pathname is the affected item and reason is the reason for calling back (see treereason). The optional argument arg may be any Lua value.
• :clear([pathname])
  If pathname is passed, clears the item’s subtree, otherwise clears the whole tree.
• :closeicon(image)
  image = :closeicon( )
• :connectorcolor(color)
  color = :connectorcolor( )
• :connectorstyle(treeconnector)
  treeconnector = :connectorstyle( )
• :connectorwidth(pixels)
  pixels = :connectorwidth( )
• :extend_selection_up(from, to [, op] [, visible])
  n = :extend_selection_down(from, to [, op] [, visible])
  from, to : items pathnames.
  op : select (default), deselect, toggle
  visible : boolean (default=false).
• pathname = :first( )
  pathname = :first_selected_item( )
  pathname = :first_visible_item( )
• pathname = :get_item_focus( )
• :hposition(h)
  h = :hposition( )
• pathname = :insert_above(above, name)
  above : pathname of the item above which the new item has to be inserted.
  name : name of the new item.
  Returns the pathname of the newly inserted item.
• pathname = :insert(parent, name, index)
  parent : pathname of the parent item.
  name : name of the new item.
  Returns the pathname of the newly inserted item.
• boolean = :is_hscroll_visible( )
  boolean = :is_vscroll_visible( )
• :labelmarginleft(pixels)
• pixels = :labelmarginleft( )
• pathname = :last( )
  pathname = :last_selected_item( )
  pathname = :last_visible_item( )
• :linespacing(pixels)
  pixels = :linespacing( )
• :marginleft(pixels)
  pixels = :marginleft( )
• :margintop(pixels)
  pixels = :margintop( )
• pathname = :next(pathname)
  pathname = :next_selected_item(pathname)
  pathname = :next_visible_item(pathname)
• :openicon(image)
  image = :openicon( )
• :openchild_marginbottom(pixels)
  pixels = :openchild_marginbottom( )
• pathname = :prev(pathname)
  pathname = :prev_selected_item(pathname)
  pathname = :prev_visible_item(pathname)
• :remove(pathname)
• :root_label(name)
• name = :root( )
• :scrollbar_size(pixels)
  pixels = :scrollbar_size( )
• :show_item([pathname] [, yoffset])
• :show_item_bottom([pathname])
  :show_item_middle([pathname])
  :show_item_top([pathname])
• :selectbox(boxtype)
  boxtype = :selectbox( )
• :selectmode(treeselect)
  treeselect = :selectmode( )
• :set_item_focus([pathname])
• :showcollapse(boolean)
  boolean = :showcollapse( )
• :showroot(boolean)
  boolean = :showroot( )
• :show_self( )
• :sortorder(treesort)
  treesort = :sortorder( )
• :usericon(image)
  image = :usericon( )
• :usericon_marginleft(pixels)
  pixels = :usericon_marginleft( )
• :vposition(v)
  v = :vposition( )
• :item_activate(pathname)
• pathname = :item_child(pathname, index)
• n = :item_children(pathname)
• boolean = :item_close(pathname [, docallback])
• :item_deactivate(pathname)
• n = :item_depth(pathname)
• boolean = :item_deselect([pathname] [, docallback])
  boolean = :item_deselect_all([pathname] [, docallback])
• :item_display([pathname])
• boolean = :item_displayed([pathname])
• index = :item_find_child(pathname, name)
  Returns nil if the item pathname has no child named name, otherwise returns its index (1-based).
• h = :item_h(pathname)
• boolean = :item_has_children(pathname)
  boolean = :item_is_active(pathname)
  boolean = :item_is_activated(pathname)
  boolean = :item_is_close(pathname)
  boolean = :item_is_open(pathname)
  boolean = :item_is_root(pathname)
  boolean = :item_is_selected(pathname)
  boolean = :item_is_visible(pathname)
• :item_label(pathname, label)
  label = :item_label(pathname)
• x = :item_label_x(pathname)
  y = :item_label_y(pathname)
  w = :item_label_w(pathname)
  h = :item_label_h(pathname)
• :item_labelbgcolor([pathname], color)
  color = :item_labelbgcolor([pathname])
  pathname=nil to set/get the default color.
• :item_labelfgcolor([pathname], color)
  color = :item_labelfgcolor([pathname])
  pathname=nil to set/get the default color.
• :item_labelcolor: alias for :item_labelfgcolor.
• :item_labelfont([pathname], font)
  font = :item_labelfont([pathname])
  pathname=nil to set/get the default font.
• :item_labelsize([pathname], fontsize)
  fontsize = :item_labelsize([pathname])
  pathname=nil to set/get the default font size.
• boolean = :item_open(pathname [, docallback])
• boolean = :item_open_toggle(pathname [, docallback])
• pathname = :item_parent(pathname)
• :item_show_self(pathname [, indent])
• boolean = :item_select([pathname] [, docallback])
  boolean = :item_select_all([pathname] [, docallback])
  boolean = :item_select_only([pathname] [, docallback])
  boolean = :item_select_toggle([pathname] [, docallback])
• :item_swap_children(pathname, name₁, name₂)
• :item_user_data(pathname, val)
  val = :item_user_data(pathname)
  val: integer value to associate with the item (may be used to index a Lua table containing more complex data).
• :item_usericon(pathname, image)
  image = :item_usericon(pathname)
• :item_visible(pathname)
  boolean = :item_visible_r(pathname)
• w = :item_w(pathname)
• :item_widget(pathname, widget)
  widget = :item_widget(pathname)
• x = :item_x(pathname)
  y = :item_y(pathname)

window

Rfr: Fl_Window
Inherits from: group

• window = gui.window(x, y, w, h [, label])
  window = gui.window(w, h [, label])
• :border(boolean)
  boolean = :border( )
• :clear_border( )
• :clear_modal_states( )
• :cursor(cursortype)
  :cursor(image, hotx, hoty)
• height = :decorated_h( )
  width = :decorated_w( )
• :default_cursor(cursortype)
• :fullscreen( )
• boolean = :fullscreen_active( )
• :fullscreen_off( )
  :fullscreen_off(x, y, w, h)
• :fullscreen_screens(top, bottom, left, right)
• :hotspot(widget [, offscreen])
  :hotspot(x, y [, offscreen])
• :icon(image)
• :iconize( )
• :iconlabel(label)
  label = :iconlabel( )
• :label(label)
  label = :label( )
• :make_current( )
• boolean = :menu_window( )
  boolean = :modal( )
  boolean = :non_modal( )
  boolean = :override( )
• :set_menu_window( )
  :set_modal( )
  :set_non_modal( )
  :set_override( )
• :set_tooltip_window( )
• :shape(image)
• :show( )
• boolean = :shown( )
• :size_range(minw, minh [, maxw, maxh, dw, dh, aspect])
• boolean = :tooltip_window( )
• :wait_for_expose( )
• x = :x_root( )
  y = :y_root( )
• xclass = :xclass( )

double_window

Rfr: Fl_Double_Window
Inherits from: window

• double_window = gui.double_window(x, y, w, h [, label])
  double_window = gui.double_window(w, h [, label])
• :flush( )

app

Inherits from: double_window

• app = gui.app(x, y, w, h [, label])
  app = gui.app(w, h [, label])

overlay_window

Rfr: Fl_Overlay_Window
Inherits from: double_window
No constructor (abstract class).

• boolean = :can_do_overlay( )
• :draw_overlay( )
  :redraw_overlay( )

gl_window

Rfr: Fl_Gl_Window
Inherits from: window
No constructor (abstract class).

• :can_do( )
  boolean = :can_do_overlay( )
• :context_valid(boolean)
  boolean = :context_valid( )
• :hide_overlay( )
• :invalidate( )
• :flush( )
• :make_current( )
• :make_overlay_current( )
• :mode(mode)
  mode = :mode( )
• :redraw_overlay( )
• :swap_buffers( )
• :valid(boolean)
  boolean = :valid( )

single_window

Rfr: Fl_Single_Window
Inherits from: window

• single_window = gui.single_window(x, y, w, h [, label])
  single_window = gui.single_window(w, h [, label])

menu_window

Rfr: Fl_Menu_Window
Inherits from: window

• menu_window = gui.menu_window(x, y, w, h [, label])
  menu_window = gui.menu_window(w, h [, label])

wizard

Rfr: Fl_Wizard
Inherits from: group

• wizard = gui.wizard(x, y, w, h [, label])
• :next( )
  :prev( )
• :value(widget)
  widget = :value( )

input_

Rfr: Fl_Input_
Inherits from: widget
RTTI: normal, float, int, hidden, multiline, secret
No constructor (abstract class).

• boolean = :copy(clipboard)
  clipboard : 0 for current text selection, 1 for cut&paste clipboard.
• boolean = :copy_cuts( )
• :cursor_color(color)
  color = :cursor_color( )
• boolean = :cut( )
  boolean = :cut(n)
  boolean = :cut(n₁, n₂)
• ucs4 = :index(n)
• :input_type(rtti)
  rtti = :input_type( )
• boolean = :insert(text)
• boolean = :mark(m)
  m = :mark( )
• :maximum_size(nchars)
  nchars = :maximum_size( )
• :position(pos)
  boolean = :position(pos, m)
  pos = :position( )
• :readonly(boolean)
  boolean = :readonly( )
• boolean = :replace(begin, end, text)
• :shortcut(shortcut)
  shortcut = :shortcut( )
• :size(w, h)
  nbytes = :size( )
• :tab_nav(boolean)
  boolean = :tab_nav( )
• :textcolor(color)
  color = :textcolor( )
• :textfont(font)
  font = :textfont( )
• :textsize(fontsize)
  fontsize = :textsize( )
• boolean = :undo( )
• boolean = :value(text)
  text = :value( )
• :wrap(boolean)
  boolean = :wrap( )

input

Rfr: Fl_Input
Inherits from: input_

• input = gui.input(x, y, w, h [, label])

file_input

Rfr: Fl_File_Input
Inherits from: input

• file_input = gui.file_input(x, y, w, h [, label])
• :down_box(boxtype)
  boxtype = :down_box( )
• :errorcolor(color)
  color = :errorcolor( )
• boolean = :value(text)
  text = :value( )

float_input

Rfr: Fl_Float_Input
Inherits from: input

• float_input = gui.float_input(x, y, w, h [, label])

int_input

Rfr: Fl_Int_Input
Inherits from: input

• int_input = gui.int_input(x, y, w, h [, label])

multiline_input

Rfr: Fl_Multiline_Input
Inherits from: input

• multiline_input = gui.multiline_input(x, y, w, h [, label])

output

Rfr: Fl_Output
Inherits from: input

• output = gui.output(x, y, w, h [, label])

multiline_output

Rfr: Fl_Multiline_Output
Inherits from: output

• multiline_output = gui.multiline_output(x, y, w, h [, label])

secret_input

Rfr: Fl_Secret_Input
Inherits from: input

• secret_input = gui.secret_input(x, y, w, h [, label])

menu_item

Rfr: Fl_Menu_Item

• :activate()
• boolean = :active( )
• boolean = :activevisible( )
• :argument(argument)
  argument = :argument( )
• :callback(func)
  func = :callback( )
• boolean = :checkbox( )
• :clear( )
• :deactivate( )
• menuitemflags = :flags( )
• :hide( )
• :image(image)
• :label(label)
  :label(labeltype, label)
  label = :label( )
• :labelcolor(color)
  color = :labelcolor( )
• :labelfont(font)
  font = :labelfont( )
• :labelsize(fontsize)
  fontsize = :labelsize( )
• :labeltype(labeltype)
  labeltype = :labeltype( )
• boolean = :radio( )
• :set( )
• :setonly( )
• :shortcut(shortcut)
  shortcut = :shortcut( )
• :show( )
• nitems = :size( )
  Returns the no. of items from this one to the end.
• boolean = :submenu( )
• boolean = :value( )
• boolean = :visible( )

menu_

Rfr: Fl_Menu_
Inherits from: widget.
No constructor (abstract class).

• index = :add(pathname [, shortcut] [, func] [, argument] [, menuitemflags])
  The func callback, if any, is executed as func(menu, pathname, argument).
  The argument may be any valid Lua value.
• :clear( )
• :clear_submenu(pathname)
• :down_box(boxtype)
  boxtype = :down_box( )
• :global( )
• :mode(pathname, menuitemflags)
  menuitemflags = :mode(pathname)
• pathname = :mvalue( )
• :remove(pathname)
• :replace(pathname, newlabel)
• :shortcut(pathname, shortcut)
  shortcut = :shortcut(pathname)
• :size(w, h)
  nitems = :size( )
• pathname = :test_shortcut( )
• label = :text([pathname])
  If pathname is not passed, the label of the last picked item is returned (i.e. pathname defaults to :mvalue()).
• :textcolor(color)
  color = :textcolor( )
• :textfont(font)
  font = :textfont( )
• :textsize(fontsize)
  fontsize = :textsize( )
• changed = :value(pathname)
• pathname = :value( )

choice

Rfr: Fl_Choice
Inherits from: menu_

• choice = gui.choice(x, y, w, h [, label])
• changed = :value(pathname)
  pathname = :value( )

menu_bar

Rfr: Fl_Menu_Bar
Inherits from: menu_

• menu_bar = gui.menu_bar(x, y, w, h [, label])

menu_button

Rfr: Fl_Menu_Button
Inherits from: menu_
RTTI: popup1, popup2, popup12, popup3, popup13, popup23, popup123.

• menu_button = gui.menu_button(x, y, w, h [, label])
• pathname = :popup( )

progress

Rfr: Fl_Progress
Inherits from: widget

• progress = gui.progress(x, y, w, h [, label])
• :maximum(number)
  number = :maximum( )
• :minimum(number)
  number = :minimum( )
• :value(number)
  number = :value( )

valuator

Rfr: Fl_Valuator
Inherits from: widget
No constructor (abstract class).

• :bounds(min, max)
• number = :clamp(number)
• string = :format( )
• number = :increment(step, n)
• :maximum(number)
  number = :maximum( )
• :minimum(number)
  number = :minimum( )
• :precision(ndigits)
• :range(min, max)
• number = :round(number)
• :step(number)
  :step(a, n)
• number = :step( )
• changed = :value(number)
  number = :value( )

adjuster

Rfr: Fl_Adjuster
Inherits from: valuator

• adjuster = gui.adjuster(x, y, w, h [, label])
• :soft(boolean)
  boolean = :soft( )

counter

Rfr: Fl_Counter
Inherits from: valuator
RTTI: normal, simple

• counter = gui.counter(x, y, w, h [, label])
• :lstep(number)
  :step(number)
  :step(step, lstep)
• :textcolor(color)
  color = :textcolor( )
• :textfont(font)
  font = :textfont( )
• :textsize(fontsize)
  fontsize = :textsize( )

simple_counter

Rfr: Fl_Simple_Counter
Inherits from: counter

• simple_counter = gui.simple_counter(x, y, w, h [, label])

dial

Rfr: Fl_Dial
Inherits from: valuator
RTTI: normal, line, fill

• dial = gui.dial(x, y, w, h [, label])
• :angle1(deg)
  deg = :angle1( )
• :angle2(deg)
  deg = :angle2( )
• :angles(deg₁, deg₂)

fill_dial

Rfr: Fl_Fill_Dial
Inherits from: dial

• fill_dial = gui.fill_dial(x, y, w, h [, label])

line_dial

Rfr: Fl_Line_Dial
Inherits from: dial

• line_dial = gui.line_dial(x, y, w, h [, label])

roller

Rfr: Fl_Roller
Inherits from: valuator
RTTI: vertical, horizontal

• roller = gui.roller(x, y, w, h [, label])

slider

Rfr: Fl_Slider
Inherits from: valuator
RTTI: vertical, horizontal, vertical fill, horizontal fill, vertical nice, horizontal nice

• slider = gui.slider(x, y, w, h [, label])
• :bounds(min, max)
• number = :scrollvalue(pos, size, first, total)
• :slider(boxtype)
  boxtype = :slider( )
• :slider_size(fraction)
  fraction = :slider_size( )

fill_slider

Rfr: Fl_Fill_Slider
Inherits from: slider

• fill_slider = gui.fill_slider(x, y, w, h [, label])

hor_fill_slider

Rfr: Fl_Hor_Fill_Slider
Inherits from: slider

• hor_fill_slider = gui.hor_fill_slider(x, y, w, h [, label])

hor_nice_slider

Rfr: Fl_Hor_Nice_Slider
Inherits from: slider

• hor_nice_slider = gui.hor_nice_slider(x, y, w, h [, label])

hor_slider

Rfr: Fl_Hor_Slider
Inherits from: slider

• hor_slider = gui.hor_slider(x, y, w, h [, label])

nice_slider

Rfr: Fl_Nice_Slider
Inherits from: slider

• nice_slider = gui.nice_slider(x, y, w, h [, label])

scrollbar

Rfr: Fl_Scrollbar
Inherits from: slider
RTTI: vertical, horizontal

• scrollbar = gui.scrollbar(x, y, w, h [, label])
• :linesize(step)
  step = :linesize( )
• boolean = :value(pos)
  boolean = :value(pos, winsize, first, total)
  pos = :value( )

value_slider

Rfr: Fl_Value_Slider
Inherits from: slider

• value_slider = gui.value_slider(x, y, w, h [, label])
• :textcolor(color)
  color = :textcolor( )
• :textfont(font)
  font = :textfont( )
• :textsize(fontsize)
  fontsize = :textsize( )