* @param variables
* the Mapping from variable names to new variable values.
*/
- public void changeVariables(Object source, Map variables);
+ public void changeVariables(Object source, Map<String, Object> variables);
/**
* <p>
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
+import java.util.Map;
import java.util.Set;
import com.google.gwt.core.client.GWT;
* <li><code>vaadin.postRequestHooks</code> is a map of functions which gets
* called after each XHR made by vaadin application. Note, that it is
* attaching js functions responsibility to create the variable like this:
- *
+ *
* <code><pre>
* if(!vaadin.postRequestHooks) {vaadin.postRequestHooks = new Object();}
* postRequestHooks.myHook = function(appId) {
* </pre></code> First parameter passed to these functions is the identifier
* of Vaadin application that made the request.
* </ul>
- *
+ *
* TODO make this multi-app aware
*/
private native void initializeClientHooks()
/**
* Runs possibly registered client side post request hooks. This is expected
* to be run after each uidl request made by Vaadin application.
- *
+ *
* @param appId
*/
private static native void runPostRequestHooks(String appId)
/**
* Checks if client side is in debug mode. Practically this is invoked by
* adding ?debug parameter to URI.
- *
+ *
* @return true if client side is currently been debugged
*/
public native static boolean isDebugMode()
}
}
if (windowName != null && windowName.length() > 0) {
- uri += (repaintAll || configuration.usePortletURLs() ? "&" : "?") + "windowName=" + windowName;
+ uri += (repaintAll || configuration.usePortletURLs() ? "&" : "?")
+ + "windowName=" + windowName;
}
if (!forceSync) {
/**
* Shows the communication error notification. The 'details' only go to the
* console for now.
- *
+ *
* @param details
* Optional details for debugging.
*/
/**
* This method is called after applying uidl change set to application.
- *
+ *
* It will clean current and queued variable change sets. And send next
* change set if it exists.
*/
/**
* Cleans given queue of variable changes of such changes that came from
* components that do not exist anymore.
- *
+ *
* @param variableBurst
*/
private void cleanVariableBurst(ArrayList<String> variableBurst) {
/**
* Returns Paintable element by its id
- *
+ *
* @param id
* Paintable ID
*/
/**
* This method sends currently queued variable changes to server. It is
* called when immediate variable update must happen.
- *
+ *
* To ensure correct order for variable changes (due servers multithreading
* or network), we always wait for active request to be handler before
* sending a new one. If there is an active request, we will put varible
* "burst" to queue that will be purged after current request is handled.
- *
+ *
*/
@SuppressWarnings("unchecked")
public void sendPendingVariableChanges() {
/**
* Build the variable burst and send it to server.
- *
+ *
* When sync is forced, we also force sending of all pending variable-bursts
* at the same time. This is ok as we can assume that DOM will never be
* updated after this.
- *
+ *
* @param pendingVariables
* Vector of variable changes to send
* @param forceSync
: "false", immediate, 'b');
}
+ public void updateVariable(String paintableId, String variableName,
+ Map<String, Object> map, boolean immediate) {
+ final StringBuffer buf = new StringBuffer();
+ Iterator<String> iterator = map.keySet().iterator();
+ while (iterator.hasNext()) {
+ String key = iterator.next();
+ Object value = map.get(key);
+ char transportType = getTransportType(value);
+ buf.append(transportType);
+ buf.append(key);
+ buf.append(VAR_ARRAYITEM_SEPARATOR);
+ if (transportType == 'p') {
+ buf.append(getPid((Paintable) value));
+ } else {
+ buf.append(value);
+ }
+
+ if (iterator.hasNext()) {
+ buf.append(VAR_ARRAYITEM_SEPARATOR);
+ }
+ }
+
+ addVariableToQueue(paintableId, variableName, buf.toString(),
+ immediate, 'm');
+ }
+
+ private char getTransportType(Object value) {
+ if (value instanceof String) {
+ return 's';
+ } else if (value instanceof Paintable) {
+ return 'p';
+ } else if (value instanceof Boolean) {
+ return 'b';
+ } else if (value instanceof Integer) {
+ return 'i';
+ } else if (value instanceof Float) {
+ return 'f';
+ } else if (value instanceof Double) {
+ return 'd';
+ } else if (value instanceof Long) {
+ return 'l';
+ }
+ return 'u';
+ }
+
+ public void updateVariable(String paintableId, String variableName,
+ String[] values, boolean immediate) {
+ final StringBuffer buf = new StringBuffer();
+ for (int i = 0; i < values.length; i++) {
+ if (i > 0) {
+ buf.append(VAR_ARRAYITEM_SEPARATOR);
+ }
+ buf.append(values[i]);
+ }
+ addVariableToQueue(paintableId, variableName, buf.toString(),
+ immediate, 'c');
+ }
+
public void updateVariable(String paintableId, String variableName,
Object[] values, boolean immediate) {
final StringBuffer buf = new StringBuffer();
if (i > 0) {
buf.append(VAR_ARRAYITEM_SEPARATOR);
}
- buf.append(values[i].toString());
+ Object value = values[i];
+ char transportType = getTransportType(value);
+ // first char tells the type in array
+ buf.append(transportType);
+ if (transportType == 'p') {
+ buf.append(getPid((Paintable) value));
+ } else {
+ buf.append(value);
+ }
}
addVariableToQueue(paintableId, variableName, buf.toString(),
immediate, 'a');
/**
* Update generic component features.
- *
+ *
* <h2>Selecting correct implementation</h2>
- *
+ *
* <p>
* The implementation of a component depends on many properties, including
* styles, component features, etc. Sometimes the user changes those
* the beginning of your updateFromUIDL -method automatically replaces your
* component with more appropriate if the requested implementation changes.
* </p>
- *
+ *
* <h2>Caption, icon, error messages and description</h2>
- *
+ *
* <p>
* Component can delegate management of caption, icon, error messages and
* description to parent layout. This is optional an should be decided by
* component author
* </p>
- *
+ *
* <h2>Component visibility and disabling</h2>
- *
+ *
* This method will manage component visibility automatically and if
* component is an instanceof FocusWidget, also handle component disabling
* when needed.
- *
+ *
* @param component
* Widget to be updated, expected to implement an instance of
* Paintable
* @param manageCaption
* True if you want to delegate caption, icon, description and
* error message management to parent.
- *
+ *
* @return Returns true iff no further painting is needed by caller
*/
public boolean updateComponent(Widget component, UIDL uidl,
/**
* Traverses recursively child widgets until ContainerResizedListener child
* widget is found. They will delegate it further if needed.
- *
+ *
* @param container
*/
private boolean runningLayout = false;
/**
* Converts relative sizes into pixel sizes.
- *
+ *
* @param child
* @return true if the child has a relative size
*/
/**
* Converts relative sizes into pixel sizes.
- *
+ *
* @param child
* @return true if the child has a relative size
*/
/**
* Get either existing or new Paintable for given UIDL.
- *
+ *
* If corresponding Paintable has been previously painted, return it.
* Otherwise create and register a new Paintable from UIDL. Caller must
* update the returned Paintable from UIDL after it has been connected to
* parent.
- *
+ *
* @param uidl
* UIDL to create Paintable from.
* @return Either existing or new Paintable corresponding to UIDL.
/**
* Returns a Paintable element by its root element
- *
+ *
* @param element
* Root element of the paintable
*/
/**
* Singleton method to get instance of app's context menu.
- *
+ *
* @return VContextMenu object
*/
public VContextMenu getContextMenu() {
* Translates custom protocols in UIDL URI's to be recognizable by browser.
* All uri's from UIDL should be routed via this method before giving them
* to browser due URI's in UIDL may contain custom protocols like theme://.
- *
+ *
* @param uidlUri
* Vaadin URI from uidl
* @return translated URI ready for browser
/**
* Listens for Notification hide event, and redirects. Used for system
* messages, such as session expired.
- *
+ *
*/
private class NotificationRedirect implements VNotification.EventListener {
String url;
/**
* Data showed in tooltips are stored centrilized as it may be needed in
* varios place: caption, layouts, and in owner components themselves.
- *
+ *
* Updating TooltipInfo is done in updateComponent method.
- *
+ *
*/
public TooltipInfo getTooltipTitleInfo(Paintable titleOwner, Object key) {
if (null == titleOwner) {
* Component may want to delegate Tooltip handling to client. Layouts add
* Tooltip (description, errors) to caption, but some components may want
* them to appear one other elements too.
- *
+ *
* Events wanted by this handler are same as in Tooltip.TOOLTIP_EVENTS
- *
+ *
* @param event
* @param owner
*/
* Component may want to delegate Tooltip handling to client. Layouts add
* Tooltip (description, errors) to caption, but some components may want
* them to appear one other elements too.
- *
+ *
* Events wanted by this handler are same as in Tooltip.TOOLTIP_EVENTS
- *
+ *
* @param event
* @param owner
* @param key
/**
* Adds PNG-fix conditionally (only for IE6) to the specified IMG -element.
- *
+ *
* @param el
* the IMG element to fix
*/
* Reset the name of the current browser-window. This should reflect the
* window-name used in the server, but might be different from the
* window-object target-name on client.
- *
+ *
* @param stringAttribute
* New name for the window.
*/
* <p>
* This method can also be used to deregister tooltips by using null as
* tooltip
- *
+ *
* @param paintable
* Paintable "owning" this tooltip
* @param key
* key assosiated with given tooltip. Can be any object. For
* example a related dom element. Same key must be given for
* {@link #handleTooltipEvent(Event, Paintable, Object)} method.
- *
+ *
* @param tooltip
* the TooltipInfo object containing details shown in tooltip,
* null if deregistering tooltip
}
@Override
- protected Object[] getSelectedItems() {
- final ArrayList selectedItemKeys = new ArrayList();
+ protected String[] getSelectedItems() {
+ final ArrayList<String> selectedItemKeys = new ArrayList<String>();
for (int i = 0; i < select.getItemCount(); i++) {
if (select.isItemSelected(i)) {
selectedItemKeys.add(select.getValue(i));
}
}
- return selectedItemKeys.toArray();
+ return selectedItemKeys.toArray(new String[selectedItemKeys.size()]);
}
@Override
}
@Override
- protected Object[] getSelectedItems() {
- final ArrayList selectedItemKeys = new ArrayList();
+ protected String[] getSelectedItems() {
+ final ArrayList<String> selectedItemKeys = new ArrayList<String>();
for (int i = 0; i < select.getItemCount(); i++) {
if (select.isItemSelected(i)) {
selectedItemKeys.add(select.getValue(i));
}
}
- return selectedItemKeys.toArray();
+ return selectedItemKeys.toArray(new String[selectedItemKeys.size()]);
}
@Override
}\r
\r
@Override\r
- protected Object[] getSelectedItems() {\r
- return selectedKeys.toArray();\r
+ protected String[] getSelectedItems() {\r
+ return selectedKeys.toArray(new String[selectedKeys.size()]);\r
}\r
\r
@Override\r
\r
protected String id;\r
\r
- protected Set selectedKeys;\r
+ protected Set<String> selectedKeys;\r
\r
private boolean immediate;\r
\r
\r
protected abstract void buildOptions(UIDL uidl);\r
\r
- protected abstract Object[] getSelectedItems();\r
+ protected abstract String[] getSelectedItems();\r
\r
- protected Object getSelectedItem() {\r
- final Object[] sel = getSelectedItems();\r
+ protected String getSelectedItem() {\r
+ final String[] sel = getSelectedItems();\r
if (sel.length > 0) {\r
return sel[0];\r
} else {\r
// update variable to server
client.updateVariable(paintableId, "collapsedcolumns",
- collapsedColumns.toArray(), false);
+ collapsedColumns.toArray(new String[collapsedColumns
+ .size()]), false);
// let rowRequestHandler determine proper rows
rowRequestHandler.refreshContent();
}
// might
// require changes to "clickEvent" immediateness
// also.
- client.updateVariable(paintableId, "selected",
- selectedRowKeys.toArray(), immediate);
+ client
+ .updateVariable(
+ paintableId,
+ "selected",
+ selectedRowKeys
+ .toArray(new String[selectedRowKeys
+ .size()]),
+ immediate);
}
break;
case Event.ONCONTEXTMENU:
private int selectMode = Table.SELECT_MODE_NONE;
- private final ArrayList selectedRowKeys = new ArrayList();
+ private final ArrayList<String> selectedRowKeys = new ArrayList<String>();
private int totalRows;
}
if (uidl.hasAttribute("selected")) {
- final Set selectedKeys = uidl
+ final Set<String> selectedKeys = uidl
.getStringArrayVariableAsSet("selected");
selectedRowKeys.clear();
- for (final Iterator it = selectedKeys.iterator(); it.hasNext();) {
+ for (final Iterator<String> it = selectedKeys.iterator(); it
+ .hasNext();) {
selectedRowKeys.add(it.next());
}
}
/**
* Updates row data from uidl. UpdateFromUIDL delegates updating tBody to
* this method.
- *
+ *
* Updates may be to different part of tBody, depending on update type. It
* can be initial row data, scroll up, scroll down...
- *
+ *
* @param uidl
* which contains row data
*/
/**
* Abstraction of table cell content. In needs to know on which row it is in
* case of context click.
- *
+ *
* @author mattitahvonen
*/
public class BodyCell extends SimplePanel {
/**
* This method is used to set row status. Does not change value on
* server.
- *
+ *
* @param selected
*/
public void setSelected(boolean sel) {
/**
* Toggles rows select state. Also updates state to server according to
* tables immediate flag.
- *
+ *
*/
public void toggleSelected() {
if (selected) {
}
setSelected(true);
}
- client.updateVariable(id, "selected", selectedRowKeys.toArray(),
- immediate);
+ client.updateVariable(id, "selected", selectedRowKeys
+ .toArray(new String[selectedRowKeys.size()]), immediate);
}
/**
* Shows context menu for this row.
- *
+ *
* @param event
* Event which triggered context menu. Correct place for
* context menu can be determined with it.
private static final String ATTR_INPUTPROMPT = "prompt";
private String inputPrompt = null;
private boolean prompting = false;
+ private boolean listenFocus;
public VTextField() {
this(DOM.createInputText());
setReadOnly(false);
}
+ listenFocus = uidl.getBooleanAttribute("listenFocus");
+
inputPrompt = uidl.getStringAttribute(ATTR_INPUTPROMPT);
setMaxLength(uidl.hasAttribute("maxLength") ? uidl
}
}
focusedTextField = this;
+ if (listenFocus) {
+ client.updateVariable(id, "focus", true, true);
+ }
}
public void onBlur(BlurEvent event) {
selectedIds.remove(treeNode.key);
treeNode.setSelected(false);
}
- client.updateVariable(paintableId, "selected", selectedIds.toArray(),
- immediate);
+
+ Object[] foo = new Object[] { new Integer(33), new Float(3.2f),
+ new Long(222), this, "bar", true, new Double(3.33332) };
+ client.updateVariable(paintableId, "foo", foo, false);
+
+ HashMap<String, Object> bar = new HashMap<String, Object>();
+ bar.put("paintable", this);
+ bar.put("String", "bar");
+ bar.put("Integer", 33);
+
+ client.updateVariable(paintableId, "bar", bar, false);
+
+ client.updateVariable(paintableId, "selected", selectedIds
+ .toArray(new String[selectedIds.size()]), immediate);
}
public boolean isSelected(TreeNode treeNode) {
}\r
\r
@Override\r
- protected Object[] getSelectedItems() {\r
- final ArrayList selectedItemKeys = new ArrayList();\r
+ protected String[] getSelectedItems() {\r
+ final ArrayList<String> selectedItemKeys = new ArrayList<String>();\r
for (int i = 0; i < selections.getItemCount(); i++) {\r
selectedItemKeys.add(selections.getValue(i));\r
}\r
- return selectedItemKeys.toArray();\r
+ return selectedItemKeys.toArray(new String[selectedItemKeys.size()]);\r
}\r
\r
private boolean[] getItemsToAdd() {\r
options.removeItem(optionIndex);\r
}\r
}\r
- client.updateVariable(id, "selected", selectedKeys.toArray(),\r
- isImmediate());\r
+ client.updateVariable(id, "selected", selectedKeys\r
+ .toArray(new String[selectedKeys.size()]), isImmediate());\r
\r
} else if (event.getSource() == remove) {\r
final boolean[] sel = getItemsToRemove();\r
selections.removeItem(selectionIndex);\r
}\r
}\r
- client.updateVariable(id, "selected", selectedKeys.toArray(),\r
- isImmediate());\r
+ client.updateVariable(id, "selected", selectedKeys\r
+ .toArray(new String[selectedKeys.size()]), isImmediate());\r
} else if (event.getSource() == options) {\r
// unselect all in other list, to avoid mistakes (i.e wrong button)\r
final int c = selections.getItemCount();\r
* communication system between the client code (compiled with GWT into
* JavaScript) and the server side components. Its client side counterpart is
* {@link ApplicationConnection}.
- *
+ *
* A server side component sends its state to the client in a paint request (see
* {@link Paintable} and {@link PaintTarget} on the server side). The client
* widget receives these paint requests as calls to
* component communicates back to the server by sending a list of variable
* changes (see {@link ApplicationConnection#updateVariable()} and
* {@link VariableOwner#changeVariables(Object, Map)}).
- *
+ *
* TODO Document better!
*/
@SuppressWarnings("serial")
/**
* Generic interface of a (HTTP or Portlet) request to the application.
- *
+ *
* This is a wrapper interface that allows
* {@link AbstractCommunicationManager} to use a unified API.
- *
+ *
* @see javax.servlet.ServletRequest
* @see javax.portlet.PortletRequest
- *
+ *
* @author peholmst
*/
protected interface Request {
/**
* Gets a {@link Session} wrapper implementation representing the
* session for which this request was sent.
- *
+ *
* Multiple Vaadin applications can be associated with a single session.
- *
+ *
* @return Session
*/
public Session getSession();
/**
* Are the applications in this session running in a portlet or directly
* as servlets.
- *
+ *
* @return true if in a portlet
*/
public boolean isRunningInPortlet();
/**
* Get the named HTTP or portlet request parameter.
- *
+ *
* @see javax.servlet.ServletRequest#getParameter(String)
* @see javax.portlet.PortletRequest#getParameter(String)
- *
+ *
* @param name
* @return
*/
/**
* Returns the length of the request content that can be read from the
* input stream returned by {@link #getInputStream()}.
- *
+ *
* @return content length in bytes
*/
public int getContentLength();
* Returns an input stream from which the request content can be read.
* The request content length can be obtained with
* {@link #getContentLength()} without reading the full stream contents.
- *
+ *
* @return
* @throws IOException
*/
/**
* Returns the request identifier that identifies the target Vaadin
* window for the request.
- *
+ *
* @return String identifier for the request target window
*/
public String getRequestID();
/**
* Gets the underlying request object. The request is typically either a
* {@link ServletRequest} or a {@link PortletRequest}.
- *
+ *
* @return wrapped request object
*/
public Object getWrappedRequest();
/**
* Generic interface of a (HTTP or Portlet) response from the application.
- *
+ *
* This is a wrapper interface that allows
* {@link AbstractCommunicationManager} to use a unified API.
- *
+ *
* @see javax.servlet.ServletResponse
* @see javax.portlet.PortletResponse
- *
+ *
* @author peholmst
*/
protected interface Response {
/**
* Gets the output stream to which the response can be written.
- *
+ *
* @return
* @throws IOException
*/
/**
* Sets the MIME content type for the response to be communicated to the
* browser.
- *
+ *
* @param type
*/
public void setContentType(String type);
/**
* Gets the wrapped response object, usually a class implementing either
* {@link ServletResponse} or {@link PortletResponse}.
- *
+ *
* @return wrapped request object
*/
public Object getWrappedResponse();
/**
* Generic wrapper interface for a (HTTP or Portlet) session.
- *
+ *
* Several applications can be associated with a single session.
- *
+ *
* TODO Document me!
- *
+ *
* @see javax.servlet.http.HttpSession
* @see javax.portlet.PortletSession
- *
+ *
* @author peholmst
*/
protected interface Session {
/**
* TODO Document me!
- *
+ *
* @author peholmst
*/
protected interface Callback {
private static final int VAR_TYPE = 3;
private static final int VAR_VALUE = 0;
+ private static final char VTYPE_PAINTABLE = 'p';
+ private static final char VTYPE_BOOLEAN = 'b';
+ private static final char VTYPE_DOUBLE = 'd';
+ private static final char VTYPE_FLOAT = 'f';
+ private static final char VTYPE_LONG = 'l';
+ private static final char VTYPE_INTEGER = 'i';
+ private static final char VTYPE_STRING = 's';
+ private static final char VTYPE_ARRAY = 'a';
+ private static final char VTYPE_STRINGARRAY = 'c';
+ private static final char VTYPE_MAP = 'm';
+
private static final String VAR_RECORD_SEPARATOR = "\u001e";
private static final String VAR_FIELD_SEPARATOR = "\u001f";
/**
* TODO New constructor - document me!
- *
+ *
* @param application
*/
public AbstractCommunicationManager(Application application) {
/**
* Create an upload handler that is appropriate to the context in which the
* application is being run (servlet or portlet).
- *
+ *
* @return new {@link FileUpload} instance
*/
protected abstract FileUpload createFileUpload();
/**
* TODO New method - document me!
- *
+ *
* @param upload
* @param request
* @return
* @throws IOException
* @throws FileUploadException
*/
- protected abstract FileItemIterator getUploadItemIterator(FileUpload upload,
- Request request) throws IOException, FileUploadException;
+ protected abstract FileItemIterator getUploadItemIterator(
+ FileUpload upload, Request request) throws IOException,
+ FileUploadException;
/**
* TODO New method - document me!
- *
+ *
* @param request
* @param response
* @throws IOException
/**
* TODO document
- *
+ *
* @param request
* @param response
* @throws IOException
*/
- protected void sendUploadResponse(Request request, Response response) throws IOException {
+ protected void sendUploadResponse(Request request, Response response)
+ throws IOException {
response.setContentType("text/html");
final OutputStream out = response.getOutputStream();
final PrintWriter outWriter = new PrintWriter(new BufferedWriter(
/**
* Internally process a UIDL request from the client.
- *
+ *
* This method calls
* {@link #handleVariables(Request, Response, Callback, Application, Window)}
* to process any changes to variables by the client and then repaints
* affected components using {@link #paintAfterVariableChanges()}.
- *
+ *
* Also, some cleanup is done when a request arrives for an application that
* has already been closed.
- *
+ *
* The method handleUidlRequest(...) in subclasses should call this method.
- *
+ *
* TODO better documentation
- *
+ *
* @param request
* @param response
* @param callback
final OutputStream out;
repaintAll = (request.getParameter(GET_PARAM_REPAINT_ALL) != null);
- //|| (request.getSession().isNew()); FIXME What the h*ll is this??
+ // || (request.getSession().isNew()); FIXME What the h*ll is this??
out = response.getOutputStream();
boolean analyzeLayouts = false;
}
}
- //out.flush(); - this line will cause errors when deployed on GateIn.
+ // out.flush(); - this line will cause errors when deployed on GateIn.
out.close();
}
/**
* TODO document
- *
+ *
* @param request
* @param response
* @param callback
/**
* TODO document
- *
+ *
* If this method returns false, something was submitted that we did not
* expect; this is probably due to the client being out-of-sync and sending
* variable changes for non-existing pids
- *
+ *
* @return true if successful, false if there was an inconsistency
*/
private boolean handleVariables(Request request, Response response,
// TODO this should be Map<String, Object>, but the
// VariableOwner API does not guarantee the key is a
// string
- Map<Object, Object> m;
+ Map<String, Object> m;
if (nextVariable != null
&& variable[VAR_PID]
.equals(nextVariable[VAR_PID])) {
// we have more than one value changes in row for
// one variable owner, collect em in HashMap
- m = new HashMap<Object, Object>();
+ m = new HashMap<String, Object>();
m.put(variable[VAR_NAME], convertVariableValue(
variable[VAR_TYPE].charAt(0),
variable[VAR_VALUE]));
} else {
// use optimized single value map
- m = Collections.singletonMap(
- (Object) variable[VAR_NAME],
+ m = Collections.singletonMap(variable[VAR_NAME],
convertVariableValue(variable[VAR_TYPE]
.charAt(0), variable[VAR_VALUE]));
}
/**
* Reads the request data from the Request and returns it converted to an
* UTF-8 string.
- *
+ *
* @param request
* @return
* @throws IOException
/**
* Handles an error (exception) that occurred when processing variable
* changes from the client or a failure of a file upload.
- *
+ *
* For {@link AbstractField} components,
* {@link AbstractField#handleError(com.vaadin.ui.AbstractComponent.ComponentErrorEvent)}
* is called. In all other cases (or if the field does not handle the
* error), {@link ErrorListener#terminalError(ErrorEvent)} for the
* application error handler is called.
- *
+ *
* @param application
* @param owner
* component that the error concerns
private Object convertVariableValue(char variableType, String strValue) {
Object val = null;
switch (variableType) {
- case 'a':
+ case VTYPE_ARRAY:
+ val = convertArray(strValue);
+ break;
+ case VTYPE_MAP:
+ val = convertMap(strValue);
+ break;
+ case VTYPE_STRINGARRAY:
val = strValue.split(VAR_ARRAYITEM_SEPARATOR);
break;
- case 's':
+ case VTYPE_STRING:
val = strValue;
break;
- case 'i':
+ case VTYPE_INTEGER:
val = Integer.valueOf(strValue);
break;
- case 'l':
+ case VTYPE_LONG:
val = Long.valueOf(strValue);
break;
- case 'f':
+ case VTYPE_FLOAT:
val = Float.valueOf(strValue);
break;
- case 'd':
+ case VTYPE_DOUBLE:
val = Double.valueOf(strValue);
break;
- case 'b':
+ case VTYPE_BOOLEAN:
val = Boolean.valueOf(strValue);
break;
- case 'p':
+ case VTYPE_PAINTABLE:
val = idPaintableMap.get(strValue);
break;
}
return val;
}
+ private Object convertMap(String strValue) {
+ String[] parts = strValue.split(VAR_ARRAYITEM_SEPARATOR);
+ HashMap<String, Object> map = new HashMap<String, Object>();
+ for (int i = 0; i < parts.length; i += 2) {
+ String key = parts[i];
+ char variabletype = key.charAt(0);
+ Object value = convertVariableValue(variabletype, parts[i + 1]);
+ map.put(key.substring(1), value);
+ }
+ return map;
+ }
+
+ private Object convertArray(String strValue) {
+ String[] val = strValue.split(VAR_ARRAYITEM_SEPARATOR);
+ Object[] values = new Object[val.length];
+ for (int i = 0; i < values.length; i++) {
+ String string = val[i];
+ // first char of string is typ
+ char variableType = string.charAt(0);
+ values[i] = convertVariableValue(variableType, string.substring(1));
+ }
+ return values;
+ }
+
/**
- * Prints the queued (pending) locale definitions to a {@link PrintWriter} in
- * a (UIDL) format that can be sent to the client and used there in formatting
- * dates, times etc.
- *
+ * Prints the queued (pending) locale definitions to a {@link PrintWriter}
+ * in a (UIDL) format that can be sent to the client and used there in
+ * formatting dates, times etc.
+ *
* @param outWriter
*/
private void printLocaleDeclarations(PrintWriter outWriter) {
final String timeformat = df.substring(timeStart, df.length());
/*
* Doesn't return second or milliseconds.
- *
+ *
* We use timeformat to determine 12/24-hour clock
*/
final boolean twelve_hour_clock = timeformat.indexOf("a") > -1;
/**
* TODO New method - document me!
- *
+ *
* @param request
* @param callback
* @param application
/**
* Ends the Application.
- *
+ *
* The browser is redirected to the Application logout URL set with
* {@link Application#setLogoutURL(String)}, or to the application URL if no
* logout URL is given.
- *
+ *
* @param request
* the request instance.
* @param response
/**
* Gets the Paintable Id. If Paintable has debug id set it will be used
* prefixed with "PID_S". Otherwise a sequenced ID is created.
- *
+ *
* @param paintable
* @return the paintable Id.
*/
/**
* Returns dirty components which are in given window. Components in an
* invisible subtrees are omitted.
- *
+ *
* @param w
* root window for which dirty components is to be fetched
* @return
&& !component.getParent().isVisible()) {
/*
* Do not return components in an invisible subtree.
- *
+ *
* Components that are invisible in visible subree, must
* be rendered (to let client know that they need to be
* hidden).
/**
* Internally mark a {@link Paintable} as painted and start collecting new
* repaint requests for it.
- *
+ *
* @param paintable
*/
private void paintablePainted(Paintable paintable) {
private final Throwable throwable;
/**
- *
+ *
* @param owner
* @param throwable
*/
* Queues a locale to be sent to the client (browser) for date and time
* entry etc. All locale specific information is derived from server-side
* {@link Locale} instances and sent to the client when needed, eliminating
- * the need to use the {@link Locale} class and all the framework behind
- * it on the client.
- *
+ * the need to use the {@link Locale} class and all the framework behind it
+ * on the client.
+ *
* @see Locale#toString()
- *
+ *
* @param value
*/
public void requireLocale(String value) {
/**
* Constructs a {@link Locale} instance to be sent to the client based on a
* short locale description string.
- *
+ *
* @see #requireLocale(String)
- *
+ *
* @param value
* @return
*/
/**
* Helper method to test if a component contains another
- *
+ *
* @param parent
* @param child
*/
/**
* Calls the Window URI handler for a request and returns the
* {@link DownloadStream} returned by the handler.
- *
+ *
* If the window is the main window of an application, the (deprecated)
* {@link Application#handleURI(java.net.URL, String)} is called first to
* handle {@link ApplicationResource}s, and the window handler is only
* called if it returns null.
- *
+ *
* @param window
* the target window of the request
* @param request
/**
* Helper class for terminal to keep track of data that client is expected
* to know.
- *
+ *
* TODO make customlayout templates (from theme) to be cached here.
*/
class OpenWindowCache implements Serializable {
private Set<Object> res = new HashSet<Object>();
/**
- *
+ *
* @param paintable
* @return true if the given class was added to cache
*/
* comment here, we use the default documentation from implemented
* interface.
*/
- public void changeVariables(Object source, Map variables) {
+ public void changeVariables(Object source, Map<String, Object> variables) {
}
/* General event framework */
* </p>
*
* <p>
- * AbstractField also provides the {@link com.vaadin.data.Buffered}
- * interface for buffering the data source value. By default the Field is in
- * write through-mode and {@link #setWriteThrough(boolean)}should be called to
- * enable buffering.
+ * AbstractField also provides the {@link com.vaadin.data.Buffered} interface
+ * for buffering the data source value. By default the Field is in write
+ * through-mode and {@link #setWriteThrough(boolean)}should be called to enable
+ * buffering.
* </p>
*
* <p>
- * The class also supports {@link com.vaadin.data.Validator validators}
- * to make sure the value contained in the field is valid.
+ * The class also supports {@link com.vaadin.data.Validator validators} to make
+ * sure the value contained in the field is valid.
* </p>
*
* @author IT Mill Ltd.
}
@Override
- public void changeVariables(Object source, Map variables) {
+ public void changeVariables(Object source, Map<String, Object> variables) {
super.changeVariables(source, variables);
}
* java.util.Map)
*/
@Override
- public void changeVariables(Object source, Map variables) {
+ public void changeVariables(Object source, Map<String, Object> variables) {
super.changeVariables(source, variables);
// New option entered (and it is allowed)
projects / vaadin-framework.git / commitdiff