All Classes

Connects the server side AbsoluteLayout with the client side counterpart VAbsoluteLayout

Resolver that maps beans to their (item) identifiers, removing the need to explicitly specify item identifiers when there is no need to customize this.

An abstract base class for ClientConnector implementations.

Interface for converting 2d-coordinates to a Color

An abstract class that defines default implementation for a color picker connector.

Client side connector for subclasses of AbstractComponentConnector.

An abstract implementation of Connector.

An event object specifying the container whose Item set has changed.

Abstract base for embedding components.

Base class for component error messages.

An extension is an entity that is attached to a Component or another Extension and independently communicates between client and server.

Abstract field component for implementing buffered property editors.

An Event object specifying the Property whose read-only status has changed.

Shared state for AbstractField.

Base interface of all handlers for Grid.AbstractGridKeyEvents.

Base interface of all handlers for Grid.AbstractGridMouseEvents.

Abstract Container class that handles common functionality for in-memory containers.

An Event object specifying information about the removed items.

Base class for Extensions with all client-side logic implemented using JavaScript.

Abstract base class for filters that are composed of multiple sub-filters.

Abstract base class for the HTML5 media components.

An Event object specifying the Property whose read-only status has been changed.

Callback used by AbstractRemoteDataSource.requestRows(int, int, RequestRowsCallback) to pass data to the underlying implementation when data has been fetched.

An abstract class that adds a consistent API for common methods that's needed by Vaadin's server-based selection models to work.

This criterion accepts a only a Transferable that contains given Item (practically its identifier) from a specific AbstractSelect.

An accept criterion to accept drops only on a specific vertical location of an item.

Client side connector for subclasses of AbstractSingleComponentConnector.

Event that indicates a change in SplitPanel's splitter position.

A converter that converts from the number type T to String and back.

Different modes how the TextField can trigger FieldEvents.TextChangeEvents.

Common base class for database query classes that handle connections and transactions.

Criterion that accepts all drops anywhere on the component.

An annotation type used to point the server side counterpart for client side a VAcceptCriterion class.

Interface implemented by all components where actions can be registered.

An Action that implements this interface can be added to an Action.Notifier (or NotifierProxy) via the addAction() -method, which in many cases is easier than implementing the Action.Handler interface.

Analyze layouts view panel of the debug window.

A compound criterion that accepts the drag if all of its criteria accepts the drag.

Utility methods for working with CSS transitions and animations.

This is the client side communication "engine", managing client-server communication with its server side counterpart com.vaadin.server.VaadinService.

A listener for listening to application stopped events.

The communication handler methods are called at certain points during communication with the server.

Helper class that helps to implement the WAI-ARIA functionality.

A lightweight array of booleans.

A lightweight array of numbers.

The default PushConnection implementation that uses Atmosphere for handling the communication channel.

Represents a message that can arrive as multiple fragments.

Marker annotation for automatically generated code elements.

Callback that notifies when the cursor is on top of a new row or column because of the automatic scrolling.

The Base theme is the foundation for all Vaadin themes.

Implements basic functionality needed to switch to day view when a single day is clicked.

Implements basic functionality needed to enable moving events.

Implements basic functionality needed to enable event resizing.

Implements basic functionality needed to change to week view when a week number is clicked.

An in-memory container for JavaBeans.

Vaadin Validator using the JSR-303 (javax.validation) annotation-based bean validation.

Validator for validating that an BigDecimal is inside a given range.

Handler for GridClickEvents that happen in the body of the Grid.

Handler for GridKeyDownEvents that happen when the focused cell is in the body of the Grid.

Handler for GridKeyUpEvents that happen when the focused cell is in the body of the Grid.

A representation of a bootstrap page being generated.

Constants for border styles used on HTML elements.

Class used to query information about web browser.

Client-side code for BrowserWindowOpener

Defines the interface to commit and discard changes to an object, supporting buffering.

This interface defines the combination of Validatable and Buffered interfaces.

A generic button component.

Interface for listening for a Button.ClickEvent fired by a Component.

A Renderer that displays a button with a textual caption.

RPC interface for calls from client to server.

Validator for validating that an Byte is inside a given range.

A helper class for creating a simple symmetric cache strategy that uses the same logic for both rows before and after the currently cached range.

Vaadin Calendar is for visualizing events in a calendar.

Interface for all Vaadin Calendar events.

BackwardHandler handles BackwardEvent.

DateClickEvent is sent when a date is clicked.

EventClick is sent when an event is clicked.

Handler interface for when events are being dragged on the calendar

EventResize is sent when an event is resized

Notifier interface for event resizing.

ForwardHandler handles ForwardEvent.

Notifier interface for navigation listening.

RangeSelectHandler handles RangeSelectEvent.

WeekClick is sent when week is clicked.

Handles communication between Calendar on the server side and VCalendar on the client side.

Utility class used to represent a day when updating views.

An event provider which allows adding and removing events

A client side implementation of a calendar event

Event to signal that an event has changed.

Notifier interface for EventChange events.

Interface for querying events.

Listener for EventSetChange events.

Handles DD when the monthly view is showing in the Calendar.

Drop details for Calendar.

A comparison function which imposes total ordering on a set of objects.

A comparison function which imposes total ordering on a set of numbers.

Describes a cell

Callback interface for generating custom style names for cells

Utility class to collect widgetset related information from classpath.

ClassResource is a named resource accessed with the class loader.

An abstract superclass for Renderers that render clickable items.

An event fired when a button rendered by a ButtonRenderer is clicked.

An interface for listening to renderer click events.

Generic class to perform selections when clicking on cells in body of Grid.

Event fired after a connector is attached to the application.

An error event for connector related errors.

Interface for listening connector detach events.

Interface to be extended by all server to client RPC interfaces.

Parent class for criteria that can be completely validated on client side.

Container needed by large lazy loading hierarchies displayed e.g.

The color changed event which is passed to the listeners when a color change occurs.

A class that defines default (button-like) implementation for a color picker component.

A class that defines an implementation for a color picker connector.

A component that represents a color gradient within a color picker.

RPC interface for ColorPickerGradient.

A component that represents a color selection grid within a color picker.

RPC interface for ColorPickerGrid.

A component that represents color selection history within a color picker.

A component that represents color selection preview within a color picker.

RPC interface for AbstractColorPicker.

An interface for a color selector.

The column group data shared between the server and the client

An event for notifying that the columns in the Grid have been reordered.

An event for notifying that the columns in the Grid have been resized.

Collection of modes used for resizing columns in the Grid.

Handler for a Grid column visibility change event, called when the Grid's columns have changed visibility to hidden or visible.

ItemStyleGenerator can be used to add custom styles to combo box items shown in the popup.

Simple container filter comparing an item property value against a given constant value.

A Compare filter that accepts items for which the identified property value is greater than value.

A Compare filter that accepts items for which the identified property value is less than value.

Base class for renderers that needs initialization and destruction logic (override #init(FlyweightCell) and #destroy(FlyweightCell) and event handling (see #onBrowserEvent(Cell, NativeEvent), ComplexRenderer.getConsumedEvents() and #onActivate().

Class of all component originated error events.

A sub-interface implemented by components that can obtain input focus.

An interface used by client-side widgets or paintable parts to receive updates from the corresponding server-side components in the form of UIDL.

ComponentLocator provides methods for generating a String locator for a given DOM element and for locating a DOM element using a String locator.

The CompositeValidator allows you to chain (compose) many validators to validate one field.

Interface implemented by all classes that are capable of communicating with the server or the client side.

A handler for focus and blur events which uses FieldRpc.FocusAndBlurServerRpc to transmit received events to the server.

Event for containing data related to a change in the ServerConnector hierarchy.

Serializes a connector hierarchy to JSON.

Serializes connector type mappings to JSON.

A specialized set of identified Items.

Filter interface for container filtering.

Interface for Container classes whose Items can be arranged hierarchically.

An Event object specifying information about the added items.

An Event object specifying the Container whose Item set has changed (items added, removed or reordered).

The interface for adding and removing ItemSetChangeEvent listeners.

An Event object specifying the Container whose Property set has changed.

The interface for adding and removing PropertySetChangeEvent listeners.

Interface for Container classes whose Items can be sorted.

A event provider which uses a Container as a datasource.

A wrapper class for adding external hierarchy to containers not implementing the Container.Hierarchical interface.

Content modes defining how the client should interpret a Label's value.

Listener for ContextClickEvents.

Client-to-server RPC interface for context click events

An exception that signals that the value passed to Converter.convertToPresentation(Object, Class, Locale) or Converter.convertToModel(Object, Class, Locale) could not be converted.

Connects the server side widget CssLayout with the client side counterpart VCssLayout

Keeps track of various current instances for the current thread.

Custom component provides a simple implementation of the Component interface to allow creating new UI components by composition of existing server-side components.

A Field whose UI content can be constructed by the user, enabling the creation of e.g.

Contains the system messages used to notify the user about various critical situations that can occur.

Event object describing a change of row availability in DataSource of a Grid.

Parent class for Transferable implementations that have a Vaadin container as a data source.

Interface for Grid.AbstractGridExtensions that allows adding data to row objects being sent to client by the RpcDataProviderExtension.

RPC interface used for requesting container data to the client.

A handle that contains information on whether a row should be pinned or unpinned, and also always the most recent representation for that particular row.

Internally used by the calendar

A renderer for rendering dates into cells

A connector for DateRenderer.

This class provides date/time parsing services to all components on the client side.

Converter for handling conversion between Date and Date.

Client RPC methods for the Debug Window.

The default implementation of DeploymentConfiguration based on a base class for resolving system properties and a set of init parameters.

This class contains a basic implementation for FieldGroupFieldFactory .The class is singleton, use DefaultFieldGroupFieldFactory.get() method to get reference to the instance.

Provides a default comparator used for comparing Property values.

Generates generic SQL that is supported by HSQLDB, MySQL and PostgreSQL.

Invoking a method in a ServerRpc interface marked with this annotation will only add the invocation to a queue of outgoing RPC invocations, but it will not cause the queue to be purged and sent to the server.

Internal helper for handling default values in a uniform way both at runtime and during widgetset compilation.

Callback for creating instances of a given component class when reading designs.

Default implementation of Design.ComponentFactory, using Class.forName(className).newInstance() for finding the component class and creating a component instance.

Default attribute handler implementation used when parsing designs to component trees.

Interface to be implemented by component creation listeners

An converter for Enum to/from String for DesignAttributeHandler to use internally.

Class focused on flexible and consistent formatting and parsing of different values throughout reading and writing Design.

A converter for Resource implementations supported by DesignAttributeHandler.

Converter for ShortcutActions.

Utility class for DesignAttributeHandler that deals with converting various types to string.

A callback interface for generating details for a particular row in Grid.

DragAndDropEvent wraps information related to drag and drop operation.

Callback interface for drag and drop.

RPC interface for calls from client to server.

Drag handle implementation.

Interface implemented by widgets if the drag image used for drag'n'drop requires additional initialization/configuration.

DropHandlers contain the actual business logic for drag and drop operations.

Extension to the basic CalendarEvent.

An interface for binding widgets and data to the grid row editor.

An RPC interface for the grid editor client-to-server communications.

A component for embedding external objects.

Utilities related to various encoding schemes.

Interface for listening to errors in the application.

Represents the error levels displayed on components.

A low-level table-like widget that features a scrolling virtual viewport and lazily generated rows.

An interface that allows client code to define how a certain row in Escalator will be displayed.

Helper class for attaching/detaching handlers for Vaadin client side components, based on identifiers in UIDL.

EventRouter class implementing the inheritable event listening model.

An extension is an entity that is attached to a Component or another Extension and independently communicates between client and server.

This interface indicates that the component is a Field (serverside), and wants (for instance) to automatically get the v-modified classname.

An Event object specifying the Field whose value has been changed.

Exception that is thrown when an error occurs during field binding when reading a design template

BlurEvent class for holding additional event information.

The interface for adding and removing BlurEvent listeners.

FocusEvent class for holding additional event information.

The interface for adding and removing FocusEvent listeners.

A listener for FieldEvents.TextChangeEvents.

FieldGroup provides an easy way of binding fields to data and handling commits of these fields.

FIXME javadoc

CommitHandlers are used by FieldGroup.commit() as part of the commit transactions.

Extension that starts a download when the extended component is clicked.

FileResources are files or directories on local filesystem.

Utility class that can figure out mime-types and icons related to files.

Stream that extracts content from another stream until the boundary string is encountered.

A FlyweightCell represents a cell in the Grid or Escalator at a certain point in time.

GWT's HasFocus is way too overkill for just receiving focus in simple components.

Adds keyboard focus to FlexPanel.

A Grid that can be focused

A scrollhandlers similar to ScrollPanel.

A helper class used to make it easier for Widgets to implement Focusable.

A font-based icon implementation.

Handler for GridClickEvents that happen in the footer of the Grid.

Handler for GridKeyDownEvents that happen when the focused cell is in the footer of the Grid.

Handler for GridKeyUpEvents that happen when the focused cell is in the footer of the Grid.

FormLayout is used by Form to layout fields.

Shared state for the FormLayout component.

FreeformStatementDelegate is an extension to FreeformQueryDelegate that provides definitions for methods that produce StatementHelper objects instead of basic query strings.

Container wrapper that adds support for generated properties.

A generic implementation of FontIcon interface

A data grid view that supports columns and lazy loading of data rows from a data source.

An abstract base class for server-side Grid extensions.

A base class for SelectionModels that contains some of the logic that is reusable.

A data class which contains information which identifies a cell in a Grid.

Base class for grid columns internally used by the Grid.

An event that is fired when the columns are reordered.

An event that is fired when a column is resized, either programmatically or by the user.

An event that is fired when a column's visibility changes.

An event which is fired when saving the editor fails

A callback interface for generating details for a particular row in Grid.

A handler for events related to the Grid editor.

This event gets fired when an editor is dismissed or closed by other means.

Error handler for the editor

Field factory used by default in the editor.

This event gets fired when an editor is opened while another row is being edited (i.e.

Represents the footer section of a Grid.

A single cell in a grid Footer row.

A single row in a grid Footer section.

ContextClickEvent for the Grid Component.

Represents the header section of a Grid.

A single cell in a grid header row.

A single row in a grid header section.

A default implementation of a Grid.SelectionModel.Multi

A callback interface for generating optional descriptions (tooltips) for Grid rows.

A callback interface for generating custom style names for Grid rows.

Selection modes representing built-in SelectionModels that come bundled with Grid.

Interface implemented by selection models which support disabling client side selection while still allowing programmatic selection on the server.

A SelectionModel that does not allow for rows to be selected.

A default implementation of a Grid.SelectionModel.Single

Abstract base class for Grid header and footer sections.

Abstract base class for Grid header and footer rows.

Represents native mouse click event in Grid.

Column state DTO for transferring column properties from the server to the client

Container class for common constants and default values used by the Grid component.

Represents native mouse double click event in Grid.

Handler for a Grid enabled/disabled event, called when the Grid is enabled or disabled.

Represents native key down event in Grid.

Represents native key up event in Grid.

Client-to-server RPC interface for the Grid component

A description of which of the three bundled SelectionModels is currently in use.

Shared state for Grid headers and footers.

Some Widgets need to handle the required handling for WAI-ARIA themselfs, as this attribute needs to be set to the input element itself.

Component with layout measuring hint.

Connector with layout measuring hint.

Interface for HasComponents implementations that support sending attach and detach events for components.

Component attach listener interface.

Component detach listener interface.

For Calendar client-side internal use only.

Handler for GridClickEvents that happen in the header of the Grid.

Handler for GridKeyDownEvents that happen when the focused cell is in the header of the Grid.

Handler for GridKeyUpEvents that happen when the focused cell is in the header of the Grid.

Handles heartbeat requests.

The modes for height calculation that are supported by Grid ( client and server) / Escalator.

A wrapper class for adding external ordering to containers not implementing the Container.Ordered interface while retaining Container.Hierarchical features.

Provides functionality for examining the UI component hierarchy.

Highlights a widget in the UI by overlaying a semi-transparent colored div.

Horizontal layout HorizontalLayout is a component container, which shows the subcomponents in the order of their addition (horizontally).

DragAndDropWrapper can receive also files from client computer if appropriate HTML 5 features are supported on client side.

A renderer for presenting HTML content.

An abstract representation of an icon.

A renderer that renders an image into a cell.

A connector for ImageRenderer.

An event object specifying the list whose Item set has changed.

A date entry component, which displays the actual date selector inline.

Interface implemented by the Editor classes capable of editing the Item.

The listener interface for receiving PropertySetChangeEvent objects.

Interface implemented by viewer classes capable of using an Item as a data source.

An item comparator which is compatible with the Container.Sortable interface.

If this annotation is present on a ClientConnector class, the framework ensures the referenced JavaScript files are loaded before the init method for the corresponding client-side connector is invoked.

Defines a method that is called by a client-side JavaScript function.

Connector for server-side renderer implemented using JavaScript.

Interface for implementing connection pools to be used with SQLContainer.

Server-side implementation of JsonBoolean.

Server-side implementation of JsonObject.

Server-side implementation of JsonObject.

JRE (non-Client) implementation of JreJsonValue.

Special Invoker that uses JSNI to invoke methods with limited visibility.

Represents a Json array.

Decoder for converting RPC parameters and other values from JSON in transfer between the client and the server and vice versa.

Encoder for converting RPC parameters and other values to JSON for transfer between the client and the server.

Factory interface for parsing and creating JSON objects.

Represents a Json number value.

User Interface Description Language Target.

Implementors of this interface knows how to serialize an Object of a given type to JSON and how to deserialize the JSON back into an object.

Represents the type of the underlying JsonValue.

Base interface for all Json values.

"ServletConfig" which only provides information from a ServletRegistration and its ServletContext

Label component for showing non-editable short texts.

Extension to the ComponentContainer interface which adds the layouting control to the elements in the container.

This type of layout supports automatic addition of margins (space around its components).

Internal class used to keep track of layout dependencies during one layout run.

An event fired when the layout has been clicked.

The interface for adding and removing LayoutClickEvent listeners.

Alternative MeasuredSize storage for IE8.

The LegacyLocatorStrategy class handles the legacy locator syntax that was introduced in version 5.4 of the framework.

One registered event listener.

Provides sorting facility from Grid for the ListDataSource in-memory data source.

Server side service which handles locale and the transmission of locale date to the client side LocaleService.

Common String manipulator utilities used in VaadinFinderLocatorStrategy and SelectorPredicates.

This event is sent when login form is submitted.

Displays the log messages.

Validator for validating that an Long is inside a given range.

A lightweight map from int to objects.

A lightweight map from String to any object type.

A lightweight map from String to int.

A lightweight map from String to String.

Describes the margin settings for each edge of a Component.

Event which is fired for all registered MarkDirtyListeners when a connector is marked as dirty.

Server to client RPC interface for controlling playback of the media.

A class representing a horizontal menu bar.

A MessageHandler is responsible for handling all incoming messages (JSON) from the server (state changes, RPCs and other updates) and ensuring that the connectors are updated accordingly.

Serializes miscellaneous metadata to JSON.

Interface for classes supporting registration of methods as event receivers.

Proxy class for creating Properties from pairs of getter and setter methods of a Bean property.

Property descriptor that is able to create simple MethodProperty instances for a bean, using given accessors.

Constants for mouse buttons.

Interface that serves as a wrapper for mouse related events.

Interface for listening for a MouseEvents.ClickEvent fired by a Component.

Interface for listening for a MouseEvents.DoubleClickEvent fired by a Component.

Connector for server-side MultiSelectionModelConnector.MultiSelectionModel.

SharedState object for MultiSelectionModel.

Multi select modes that controls how multi select behaves.

This is a simple drop-down select without, for instance, support for multiselect, new items, lazyloading, and other advanced features.

An interface for handling interaction between Navigator and the browser location URI or other similar view identification and bookmarking system.

A ViewProvider which maps a single view name to a class to instantiate for the view.

Empty view component.

A ViewProvider which supports mapping a single view name to a single pre-initialized view instance.

Nested accessor based property for a bean.

Displays network activity; requests and responses.

Annotation used to mark server RPC methods for which it isn't necessary to show the loading indicator.

Connector for server-side Grid.NoSelectionModel.

Criterion that wraps another criterion and inverts its return value.

Available WAI-ARIA roles for a notification.

This validator is used for validating properties that do or do not allow null values.

A renderer for presenting number values.

A simple data object containing one typed value.

Encapsulates the data that the widgetset compiler generates for supporting a connector method annotated with OnStateChange

Optimized widgetset view panel of the debug window.

A compound Container.Filter that accepts an item if any of its filters accept the item.

Overlay widget extending the PopupPanel.

Listener that gets notified when the size of the browser window containing the uI has changed.

Event fired when the URI fragment of a Page changes.

This interface defines the methods for painting XML to the UIDL stream.

Panel - a simple single component container.

A field that is used to enter secret text information like passwords.

Represents a native PointerCancelEvent.

Represents a native PointerDownEvent.

Abstract class representing Pointer events.

Main pointer event support implementation class.

Pointer event support class for IE 11+ (unprefixed pointer events)

Handler interface for PointerMoveEvent events.

Handler interface for PointerUpEvent events.

A component for displaying a two different views to data.

This event is received by the PopupVisibilityListeners when the visibility of the popup changes.

A functional interface that can be used for positioning elements in the DOM.

A position function using "transform: translate3d(x,y,z)" to position elements in the DOM.

A position function using "-webkit-transform: translate3d(x,y,z)" to position elements in the DOM.

Enumeration that provides a hint to the browser how media should be preloaded.

Lightweight profiling tool that can be used to collect profiling data with zero overhead unless enabled.

A hierarchical representation of the time spent running a named block of code.

Debug window section for investigating Profiler data.

Connector for VProgressBar.

A renderer that represents a double values as a graphical progress bar.

SharedState for ProgressBar

The Property is a simple data object that contains one typed value.

Exception object that signals that a requested Property modification failed because it's in read-only mode.

The listener interface for receiving ReadOnlyStatusChangeEvent objects.

A Property that is capable of handle a transaction that can end in commit or rollback.

The listener interface for receiving ValueChangeEvent objects.

Interface implemented by the viewer classes capable of using a Property as a data source.

Defines the custom property name to be bound to a Field using FieldGroup or BeanFieldGroup.

PropertyValueGenerator for GeneratedPropertyContainer.

Serves a connector resource from the classpath if the resource has previously been registered by calling LegacyCommunicationManager.registerDependency(String, Class).

Handles Atmosphere requests and forwards them to logical methods in PushHandler

Represents the client-side endpoint of a bidirectional ("push") communication channel.

Shared constants used by push.

The mode of bidirectional ("push") communication that is in use.

An Event object specifying the old and new RowId of an added item after the addition has been successfully committed.

The interface for adding and removing RowIdChangeEvent listeners.

An base implementation for validating any objects that implement Comparable.

Interface which must be implemented by the reconnect dialog

An util class with helpers for reflection operations.

A ClientConnector for controlling client-side Grid renderers.

Contains information about render area.

Resolutions for DateFields

ResourceLoader lets you dynamically include external scripts and styles on the page and lets you know when the resource has been loaded.

Event listener that gets notified when a resource has been loaded

Serializes resources to JSON.

The client side connector for the Responsive extension.

A simple RichTextArea to edit HTML format text.

Shared state for the RichTextArea component.

A representation of the rows in each of the sections (header, body and footer) in an Escalator.

Event fired when the row height changed in the Escalator's header, body or footer.

RowId represents identifiers of a single database result set row.

A data class which contains information which identifies a row in a Grid.

Event fired when the range of visible rows changes e.g.

Provides Vaadin server-side container data source to a com.vaadin.client.ui.grid.GridConnector.

Client side RPC manager that can invoke methods based on RPC calls received from the server.

This interface is implemented by all visual objects that can be scrolled programmatically from the server-side.

The orientation of the scrollbar.

A representation of a single vertical scrollbar.

A means to listen to when the scrollbar handle in a ScrollbarBundle either appears or is removed.

Enumeration, specifying the destinations that are supported when scrolling rows or columns into view.

A handler that gets called whenever a scrollbar bundle is scrolled

Handler for a Grid select all event, called when the Grid needs all rows in data source to be selected.

Event object describing a change in Grid row selection state.

The listener interface for receiving SelectionEvents.

Handler for SelectionEvents.

Selection model that allows for several rows to be selected at once.

Interface for a selection model that does not allow anything to be selected.

Multi-row selection model.

Single-row selection model.

A single segment of a selector path pointing to an Element.

Helper class for performing serialization.

Interface to be extended by all client to server RPC interfaces.

A data transfer object representing an RPC request sent by the client side.

Wrapper exception for exceptions which occur during invocation of an RPC call

Manages the queue of server invocations (RPC) which are waiting to be sent to the server.

Event fired to ServiceDestroyListener when a VaadinService is being destroyed.

Event fired when a Vaadin service session is no longer in use.

Event gets fired when a new Vaadin service session is initialized for a Vaadin service.

Handles a request by passing it to each registered RequestHandler in the session in turn until one produces a response.

Serializes shared state changes to JSON.

Shortcuts are a special type of Actions used to create keyboard shortcuts.

Modifier key constants

A focusable ComponentConnector implementing this interface will be notified before shortcut actions are handled if it will be the target of the action (most commonly means it is the focused component during the keyboard combination is triggered by the user).

Delegate used by DesignContext to determine whether container data should be written out for a component.

Simple implementation of the JDBCConnectionPool interface.

Simple string filter for matching items that start with or contain a specified string.

Interface for component containers that have one child component and do not support adding or removing components.

ServerRpc for SingleSelectionModel.

Interface to be implemented by components wishing to display some object that may be dynamically resized during runtime.

A class for representing a value-unit pair.

Represents a slot which contains the actual widget in the layout.

Fluid Sort API.

A sort event, fired by the Grid when it needs its data source to provide data sorted in a specific manner.

Listener for sort order change events.

Handler for a Grid sort event, called when the Grid needs its data source to provide data sorted in a specific manner.

Sort order descriptor.

A criterion that ensures the drag source is the same as drop target.

An interface that handles the display of content for spacers.

Event handler for a spacer visibility changed event.

The SQLGenerator interface is meant to be implemented for each different SQL syntax that is to be supported.

StatementHelper is a simple helper class that assists TableQuery and the query generators in filling a PreparedStatement.

Interface implemented by the source of a StreamResource.

Event passed to #uploadFinished(StreamingEndEvent) method the contents have been streamed to StreamVariable successfully.

Event passed to #uploadStarted(StreamingStartEvent) method before the streaming of the content to StreamVariable starts.

This StringLengthValidator is used to validate the length of strings.

A converter that converts from String to BigInteger and back.

A converter that converts from String to Byte and back.

Collection factory.

A converter that converts from Date to String and back.

A converter that converts from String to an Enum and back.

A converter that converts from String to Integer and back.

A converter that converts from String to Short and back.

If this annotation is present on a ClientConnector class, the framework ensures the referenced style sheets are loaded before the init method for the corresponding client-side connector is invoked.

Class that enables SuperDevMode using a ?superdevmode parameter in the url.

RequestHandler which takes care of locking and unlocking of the VaadinSession automatically.

Interface implemented by state classes that support tab indexes.

Allow to define specific style on cells (and rows) contents.

Interface for listening to column collapse events.

Interface for listening to column reorder events.

Interface for listening to column resize events.

Interface for the listener for column footer mouse click events.

Click event fired when clicking on the Table headers.

Row generators can be used to replace certain items in a table with a generated string.

ContextClickEvent for the Table Component.

Lazy loading accept criterion for Table.

Factory interface for creating new Field-instances based on Container (datasource), item id, property id and uiContext (the component responsible for displaying fields).

Simple RowIdChangeEvent implementation.

Shared state for the Table component.

CloseHandler is used to process tab closing events.

Selected tab change event listener.

Server to client RPC methods for the TabSheet.

Criterion for checking if drop target details contains the specific property with the specific value.

A HashMap backed implementation of TargetDetails for terminal implementation and for extension.

Provides functionality for picking selectors for Vaadin TestBench.

A text editor component that can be bound to any bindable Property.

Renderer that renders text into a cell.

A connector for TextRenderer.

ThemeResource is a named theme dependant resource provided and managed by a theme.

Provides method for configuring the tooltip.

Provides one finger touch scrolling for elements with once scrollable elements inside.

Wrapper class that helps implement two-phase commit for a non-transactional property.

TODO Javadoc!

Transport modes for Push

Collapse event

Event to fired when a node is expanded.

ItemStyleGenerator can be used to add custom styles to tree items.

ContextClickEvent for the Tree Component.

Lazy loading accept criterion for Tree.

Client-to-server RPC interface for the Tree component

TreeTable extends the Table component so that it can also visualize a hierarchy of its Items in a similar manner that Tree does.

Multiselect component with two lists: left side for available items and right side for selected items.

The topmost component in any component hierarchy.

Server to Client RPC methods for UI

Exception thrown if the UI has been detached when it should not be.

A class that contains events, listeners and handlers specific to the UI class.

A UIEvents.PollListener receives and handles PollEvents fired by PollNotifiers.

Handles an initial request from the client to initialize a UI.

Base class for the events that are sent to various methods in UIProvider.

A base class for generating an unique object that is serializable.

Connector used as a placeholder for extensions that are not present in the widgetset.

Exception for cases where a container does not support a specific type of filters.

Upload.ChangeEvent event is sent when the value (filename) of the upload changes.

Upload.FailedEvent event is sent when the upload is received, but the reception is interrupted for some reason.

Upload.FinishedEvent is sent when the upload receives a file, regardless of whether the reception was successful or failed.

FailedEvent that indicates that an input stream could not be obtained.

ProgressListener receives events to track progress of upload.

Upload.StartedEvent event is sent when the upload is started to received.

Upload.SucceededEvent event is sent when the upload is received successfully.

Server-to-client RPC interface for Upload.

IE does not have onload, detect onload via readystatechange

Shared state for the Upload component.

Property descriptor that can create a property instance for a bean.

A generic response from the server, wrapping a more specific response type, e.g.

Annotation for configuring subclasses of VaadinServlet.

Wrapper for HttpServletRequest.

Encapsulates a Runnable submitted using VaadinSession.access(Runnable).

Utility for translating special Vaadin URIs like theme:// and app:// into URLs usable by the browser.