com.vaadin.ui
Class AbstractJavaScriptComponent
java.lang.Object
com.vaadin.terminal.AbstractClientConnector
com.vaadin.ui.AbstractComponent
com.vaadin.ui.AbstractJavaScriptComponent
- All Implemented Interfaces:
- MethodEventSource, Connector, ClientConnector, RpcTarget, Sizeable, Component, Serializable
public abstract class AbstractJavaScriptComponent
- extends AbstractComponent
Base class for Components with all client-side logic implemented using
JavaScript.
When a new JavaScript component is initialized in the browser, the framework
will look for a globally defined JavaScript function that will initialize the
component. The name of the initialization function is formed by replacing .
with _ in the name of the server-side class. If no such function is defined,
each super class is used in turn until a match is found. The framework will
thus first attempt with com_example_MyComponent
for the
server-side
com.example.MyComponent extends AbstractJavaScriptComponent
class. If MyComponent instead extends com.example.SuperComponent
, then com_example_SuperComponent
will also be attempted if
com_example_MyComponent
has not been defined.
JavaScript components have a very simple GWT widget (JavaScriptWidget
) just consisting of a div
element to which the JavaScript code
should initialize its own user interface.
The initialization function will be called with this
pointing to
a connector wrapper object providing integration to Vaadin with the following
functions:
getConnectorId()
- returns a string with the id of the
connector.
getParentId([connectorId])
- returns a string with the id of
the connector's parent. If connectorId
is provided, the id of
the parent of the corresponding connector with the passed id is returned
instead.
getElement([connectorId])
- returns the DOM Element that is
the root of a connector's widget. null
is returned if the
connector can not be found or if the connector doesn't have a widget. If
connectorId
is not provided, the connector id of the current
connector will be used.
getState()
- returns an object corresponding to the shared
state defined on the server. The scheme for conversion between Java and
JavaScript types is described bellow.
registerRpc([name, ] rpcObject)
- registers the
rpcObject
as a RPC handler. rpcObject
should be an
object with field containing functions for all eligible RPC functions. If
name
is provided, the RPC handler will only used for RPC calls
for the RPC interface with the same fully qualified Java name. If no
name
is provided, the RPC handler will be used for all incoming
RPC invocations where the RPC method name is defined as a function field in
the handler. The scheme for conversion between Java types in the RPC
interface definition and the JavaScript values passed as arguments to the
handler functions is described bellow.
getRpcProxy([name])
- returns an RPC proxy object. If
name
is provided, the proxy object will contain functions for
all methods in the RPC interface with the same fully qualified name, provided
a RPC handler has been registered by the server-side code. If no
name
is provided, the returned RPC proxy object will contain
functions for all methods in all RPC interfaces registered for the connector
on the server. If the same method name is present in multiple registered RPC
interfaces, the corresponding function in the RPC proxy object will throw an
exception when called. The scheme for conversion between Java types in the
RPC interface and the JavaScript values that should be passed to the
functions is described bellow.
The connector wrapper also supports these special functions:
onStateChange
- If the JavaScript code assigns a function to
the field, that function is called whenever the contents of the shared state
is changed.
- Any field name corresponding to a call to
registerCallback(String, JavaScriptCallback)
on the server will
automatically be present as a function that triggers the registered callback
on the server.
- Any field name referred to using
invokeCallback(String, Object...)
on the server will be called if a
function has been assigned to the field.
Values in the Shared State and in RPC calls are converted between Java and
JavaScript using the following conventions:
- Primitive Java numbers (byte, char, int, long, float, double) and their
boxed types (Byte, Character, Integer, Long, Float, Double) are represented
by JavaScript numbers.
- The primitive Java boolean and the boxed Boolean are represented by
JavaScript booleans.
- Java Strings are represented by JavaScript strings.
- List, Set and all arrays in Java are represented by JavaScript arrays.
- Map in Java is represented by JavaScript object with fields
corresponding to the map keys.
- Any other Java Map is represented by a JavaScript array containing two
arrays, the first contains the keys and the second contains the values in the
same order.
- A Java Bean is represented by a JavaScript object with fields
corresponding to the bean's properties.
- A Java Connector is represented by a JavaScript string containing the
connector's id.
- A pluggable serialization mechanism is provided for types not described
here. Please refer to the documentation for specific types for serialization
information.
- Since:
- 7.0.0
- Version:
- 7.0.0.alpha3
- Author:
- Vaadin Ltd
- See Also:
- Serialized Form
Methods inherited from class com.vaadin.ui.AbstractComponent |
addListener, addListener, addListener, addListener, addShortcutListener, addStyleName, attach, detach, findAncestor, fireComponentErrorEvent, fireComponentEvent, fireEvent, focus, getActionManager, getApplication, getCaption, getComponentError, getData, getDebugId, getDescription, getErrorHandler, getErrorMessage, getHeight, getHeightUnits, getIcon, getListeners, getLocale, getParent, getRoot, getStyle, getStyleName, getWidth, getWidthUnits, handleError, hasListeners, isConnectorEnabled, isEnabled, isImmediate, isReadOnly, isVisible, removeListener, removeListener, removeListener, removeListener, removeListener, removeShortcutListener, removeStyleName, requestRepaint, setCaption, setComponentError, setData, setDebugId, setDescription, setEnabled, setErrorHandler, setHeight, setHeight, setIcon, setImmediate, setLocale, setParent, setReadOnly, setSizeFull, setSizeUndefined, setStyle, setStyleName, setVisible, setWidth, setWidth, updateState |
Methods inherited from class com.vaadin.terminal.AbstractClientConnector |
addExtension, addMethodInvocationToQueue, createState, getAllChildrenIterable, getConnectorId, getExtensions, getRpcManager, getRpcProxy, getStateType, registerRpc, removeExtension, requestRepaintAll, retrievePendingRpcCalls |
Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
AbstractJavaScriptComponent
public AbstractJavaScriptComponent()
registerRpc
protected <T> void registerRpc(T implementation,
Class<T> rpcInterfaceType)
- Description copied from class:
AbstractClientConnector
- Registers an RPC interface implementation for this component.
A component can listen to multiple RPC interfaces, and subclasses can
register additional implementations.
- Overrides:
registerRpc
in class AbstractClientConnector
- Parameters:
implementation
- RPC interface implementationrpcInterfaceType
- RPC interface class for which the implementation should be
registered
registerCallback
protected void registerCallback(String functionName,
JavaScriptCallback javaScriptCallback)
- Register a
JavaScriptCallback
that can be called from the
JavaScript using the provided name. A JavaScript function with the
provided name will be added to the connector wrapper object (initially
available as this
). Calling that JavaScript function will
cause the call method in the registered JavaScriptCallback
to be
invoked with the same arguments.
- Parameters:
functionName
- the name that should be used for client-side callbackjavaScriptCallback
- the callback object that will be invoked when the JavaScript
function is called
invokeCallback
protected void invokeCallback(String name,
Object... arguments)
- Invoke a named function that the connector JavaScript has added to the
JavaScript connector wrapper object. The arguments should only contain
data types that can be represented in JavaScript including primitives,
their boxed types, arrays, String, List, Set, Map, Connector and
JavaBeans.
- Parameters:
name
- the name of the functionarguments
- function arguments
getState
public JavaScriptComponentState getState()
- Description copied from class:
AbstractComponent
- Returns the shared state bean with information to be sent from the server
to the client.
Subclasses should override this method and set any relevant fields of the
state returned by super.getState().
- Specified by:
getState
in interface Connector
- Specified by:
getState
in interface Component
- Overrides:
getState
in class AbstractComponent
- Returns:
- updated component shared state
Copyright © 2000-2011 Vaadin Ltd. All Rights Reserved.