Project

Topics

Namespaces

Public Vars

functional-vaadin.core

The primary namespace for the project, contains all publically accesible buidlers and vars.

All builder functions take a variable number of orguments, all of a similar form:

(<builder> ctor-arguments? config? & children)

where:

ctor-arguments: are any set of constructor arguments for the corresponding component, as defined in the Vaadin javadoc.
                if this is not supplied, the null constructor will be used.

config:         is a Map of attribute-vaue pairs corresponding to setters on the Component. The names are the same as the
                setter name, minus the 'set' prefix, and all lower case e.g. the config '{:id "this-como"} will set
                the 'id' attribute using setId(val)

                Certain config items can take more convenient specification of value:

                :margin - can be either "true", indicating full margins, or an array of any combination of :top, :bottom,
                          :left, :right, :vertical or :horizontal, indicating that margins should be added to the
                          respective location(s)

                :validateWith - adds a validator to a Field. The argument is any Vaadin Validator instance. There is also
                          a Clojure type FunctionalValidator which can be used to create a Validator from an arbitrary function.

                :id - will set the component id, and also allow lookup via (component-named). This removes the need to
                      use temporary variables when referencing already-built components.

                :addStyleNamed - will add a style to a component. The name is a String

                Positioning and expansion options that Vaadin requires specified on the parent can now be placed on the child -
                these include :expansionRatio, :componentAlignment, :position and :span

children:       are the Components child Components, which will be added as appropriate

->FunctionalConverter

(->FunctionalConverter to-model-fn to-presn-fn model-type presn-type)
Positional factory function for class functional_vaadin.core.FunctionalConverter.

accordion

(accordion & args)
Usage: (accordion ctor_args? config_map? children?)

Create an Accordion component from constructor arguments or a configuration Map. Remaining arguments are children..

action-manager

(action-manager & args)
Usage: (action-manager ctor_args? config_map?

Creates an ActionManager for general use

button

(button & args)
Usage: (button ctor_args? config_map?)

Create a Button component from constructor arguments or a configuration Map

check-box

(check-box & args)
Usage: (check-box ctor_args? config_map?)

Create a CheckBox component from constructor arguments or a configuration Map.

combo-box

(combo-box & args)
Usage: (combo-box ctor_args? config_map?)

Create a ComboBox component from constructor arguments or a configuration Map.

componentNamed

(componentNamed key ui)
Return a component named with an : configuration attriute in the given UI

defui

macro

(defui ui top-form)
Defines a Vaadin UI using the builder syntax. Given a com.vaadin.ui.UI object and a series of builder forms, creates
and installs the generated components on the UI object.

embedded

(embedded & args)
Usage: (embedded ctor_args? config_map?)

Create an Embedded component from constructor arguments or a configuration Map.

form

macro

(form & args)
Usage: (form [^ComponentContainer content] [^Map config] children*)

Create a Form. This is a pseudo component that returns a ComponentConainer with an added Field Group. The FieldGroup
is made available for binding form (children) fields, and in all event handlers attached to form components

The content may be specified directly as the first argument, which must be a ComponentContainer, or as a :content
configuration option. Any remaining configuration optiond are applied to the container. If neither are present the
contnet defaults to a FormLayout

form-layout

(form-layout & args)
Usage: (form-layout ctor_args? config_map? children?)

Create a FormLayout component from constructor arguments or a configuration Map. Remaining arguments are children..

grid-layout

(grid-layout & args)
Usage: (grid-layout ctor_args? config_map? children?)

Create a GridLayout component from constructor arguments or a configuration Map. Remaining arguments are children.
Childen may have :position and :span configuration options to specify their position and size

horizontal-layout

(horizontal-layout & args)
Usage: (horizontal-layout ctor_args? config_map? children?)

Create a HorizontalLayout component from constructor arguments or a configuration Map. Remaining arguments are children.
Expansion ration a alignment parameters  areplaced on the children, not the layout itself

horizontal-split-panel

(horizontal-split-panel & args)
Usage: (horizontal-split-panel ctor_args? config_map? children?)

Create a HorizontalSplitPanel component from constructor arguments or a configuration Map. Only zero or two children may
be specified

image

(image & args)
Usage: (image ctor_args? config_map?)

Create an Image component from constructor arguments or a configuration Map.

inline-date-field

(inline-date-field & args)
Usage: (inline-date-field ctor_args? config_map?)

Create a InineDateField component from constructor arguments or a configuration Map.

label

(label & args)
Usage: (label ctor_args? config_map?)

Create a Label component from constructor arguments or a configuration Map

list-select

(list-select & args)
Usage: (list-select ctor_args? config_map?)

Create a ListSelect component from constructor arguments or a configuration Map.

login-form

(login-form & args)
Usage: (login-form config_map? login-fn)

Create an LoginForm component from a login function and an optional configuration Map. The login function will be called
with arguments "[source event username password]" when the loginform is submitted.

The optional config can set the usual setters on LoginForm, and also accepts options
to alter the creation of the login button, user name and password fields:

option :loginButtonFunc takes a function that should return the login button component. It must be a Button
option :usernameFieldFunc takes a function that should return the user name field. It must be a TextField
option :passwordFieldFunc takes a function that should return the password field. It must be a TextField

Defaults for these are as for com.vaadin.ui.LoginForm

menu-bar

(menu-bar & args)
Usage: (menu-bar ctor_args? config_map? menu-items?)

Create a MenuBar. Children must be MenuItem builders.

menu-item

(menu-item & args)
Usage: (menu-item name icon_resource? [menu-fn | menu-items])

Create a menu item for the contaning menu. "name" is the menu item name, "icon" is and optional Resource that
defines the menu item icon. Further arguments are either a single fn defining the menu action, or further menu-items
defining a sub-menu

When triggered, the menu-fn is called with the selected MenuItem

menu-separator

(menu-separator)
Usage: (menu-separator)

Create a menu separator in a menu.

native-select

(native-select & args)
Usage: (native-select ctor_args? config_map?)

Create a NativeSelect component from constructor arguments or a configuration Map.

option-group

(option-group & args)
Usage: (option-group ctor_args? config_map?)

Create an OptionGroup component from constructor arguments or a configuration Map.

panel

(panel & args)
Usage: (panel ctor_args? config_map? children?)

Create a Panel component from constructor arguments or a configuration Map. Content can be set as either a constructor argument,
configuration option, or a single child. If the content is set via constructor or configuration, multiple children may be given,
and will be added as children of the panel content (if applicable)

password-field

(password-field & args)
Usage: (password-field ctor_args? config_map?)

Create a PassowrdField component from constructor arguments or a configuration Map

popup-date-field

(popup-date-field & args)
Usage: (popup-date-field ctor_args? config_map?)

Create a PopupDateField component from constructor arguments and/or a configuration Map.

progress-bar

(progress-bar & args)
Usage: (progress-bar ctor_args? config_map?)

Create a ProgressBar component from constructor arguments or a configuration Map.

rich-text-area

(rich-text-area & args)
Usage: (rich-text-area ctor_args? config_map?)

Create a RichTextArea component from constructor arguments or a configuration Map.

shortcutAction

deprecated in 0.3.0

(shortcutAction name keycode a-fn modifiers)(shortcutAction name keycode a-fn)
Deprecated. Use (->ShortcutAction) instead

slider

(slider & args)
Usage: (slider ctor_args? config_map?)

Create a Slider component from constructor arguments or a configuration Map.

tab-sheet

(tab-sheet & args)
Usage: (tab-sheet ctor_args? config_map? children?)

Create a TabSheet componentfrom constructor arguments or a configuration Map. Remaining arguments are children..

table

(table & args)
Usage: (table ctor_args? config_map? table-columns?)

Create a Table component from constructor arguments or a configuration Map. Children must be table-column specifications

table-column

(table-column propertyId config)(table-column propertyId)
Usage: (table-column property_id config_map)

Create a table column. Only valid as a child of a Table component. The first argument must be the name of the
data binding property that the column will bind to. Other config options can be the type (:type) and default value
(:default) of the property, plus any of the table setColumnXXX setters. These will be configured on the table as
for other config options

text-area

(text-area & args)
Usage: (text-area ctor_args? config_map?)

Create a TextArea component from constructor arguments or a configuration Map.

text-field

(text-field & args)
Usage: (text-field ctor_args? config_map?)

Create a TextField component from constructor arguments or a configuration Map.

tree

(tree & args)
Usage: (tree ctor_args? config_map?)

Create a Tree component from constructor arguments or a configuration Map.

tree-table

(tree-table & args)
Usage: (tree-table ctor_args? config_map? table-columns?)

Create a TreeTable component from constructor arguments or a configuration Map. Children must be table-column specifications

twin-col-select

(twin-col-select & args)
Usage: (twin-col-select ctor_args? config_map?)

Create a TwinColSelect component from constructor arguments or a configuration Map.

upload

(upload & args)
Usage: (upload ctor_args? config_map?)

Create an Upload component from constructor arguments or a configuration Map.

vertical-layout

(vertical-layout & args)
Usage: (vertical-layout ctor_args? config_map? children?)

Create a VerticalLayout component from constructor arguments or a configuration Map. Remaining arguments are children.
Expansion ration and alignment parameters are placed on the children, not the layout itself

vertical-split-panel

(vertical-split-panel & args)
Usage: (vertical-split-panel ctor_args? config_map? children?)

Create a VerticalSplitPanel component from constructor arguments or a configuration Map. Only zero or two children may
be specified

window

(window & args)
Usage: (window ctor_args? config_map? children?)

Create a Window component from constructor arguments or a configuration Map. Content may be specified as for a Panel