Collection<StateChangeEvent> pendingStateChangeEvents = updateConnectorState(json);
// Update hierarchy, do not fire events
- Collection<ConnectorHierarchyChangedEvent> pendingHierarchyChangeEvents = updateConnectorHierarchy(json);
+ Collection<ConnectorHierarchyChangeEvent> pendingHierarchyChangeEvents = updateConnectorHierarchy(json);
// Fire hierarchy change events
sendHierarchyChangeEvents(pendingHierarchyChangeEvents);
}
private void sendHierarchyChangeEvents(
- Collection<ConnectorHierarchyChangedEvent> pendingHierarchyChangeEvents) {
+ Collection<ConnectorHierarchyChangeEvent> pendingHierarchyChangeEvents) {
if (pendingHierarchyChangeEvents.isEmpty()) {
return;
}
VConsole.log(" * Sending hierarchy change events");
- for (ConnectorHierarchyChangedEvent event : pendingHierarchyChangeEvents) {
- event.getParent().connectorHierarchyChanged(event);
+ for (ConnectorHierarchyChangeEvent event : pendingHierarchyChangeEvents) {
+ event.getConnector().fireEvent(event);
}
}
ApplicationConnection.this);
connector.setState((SharedState) state);
- events.add(new StateChangeEvent(connector));
+ StateChangeEvent event = GWT
+ .create(StateChangeEvent.class);
+ event.setConnector(connector);
+ events.add(event);
}
} catch (final Throwable e) {
VConsole.error(e);
* @return A collection of events that should be fired when update
* of hierarchy and state is complete
*/
- private Collection<ConnectorHierarchyChangedEvent> updateConnectorHierarchy(
+ private Collection<ConnectorHierarchyChangeEvent> updateConnectorHierarchy(
ValueMap json) {
- List<ConnectorHierarchyChangedEvent> events = new LinkedList<ConnectorHierarchyChangedEvent>();
+ List<ConnectorHierarchyChangeEvent> events = new LinkedList<ConnectorHierarchyChangeEvent>();
VConsole.log(" * Updating connector hierarchy");
if (!json.containsKey("hierarchy")) {
}
// Fire change event if the hierarchy has changed
- ConnectorHierarchyChangedEvent event = GWT
- .create(ConnectorHierarchyChangedEvent.class);
+ ConnectorHierarchyChangeEvent event = GWT
+ .create(ConnectorHierarchyChangeEvent.class);
event.setOldChildren(oldChildren);
- event.setParent(ccc);
+ event.setConnector(ccc);
ccc.setChildren((List) newChildren);
events.add(event);
* and the server side are in sync.
* <p>
* Note that calling this method does not fire a
- * {@link ConnectorHierarchyChangedEvent}. The event is fired only when the
+ * {@link ConnectorHierarchyChangeEvent}. The event is fired only when the
* whole hierarchy has been updated.
*
* @param parent
import java.util.List;
+import com.google.gwt.event.shared.HandlerRegistration;
import com.google.gwt.user.client.ui.HasWidgets;
+import com.vaadin.terminal.gwt.client.ConnectorHierarchyChangeEvent.ConnectorHierarchyChangeHandler;
/**
* An interface used by client-side connectors whose widget is a component
* side and the server side are in sync.
* <p>
* Note that calling this method does not call
- * {@link #connectorHierarchyChanged(ConnectorHierarchyChangedEvent)}. The
+ * {@link #connectorHierarchyChanged(ConnectorHierarchyChangeEvent)}. The
* event method is called only when the hierarchy has been updated for all
* connectors.
*
public void setChildren(List<ComponentConnector> children);
/**
- * Called when the child connector hierarchy of this connector has changed.
- * When this method is called the full hierarchy has been updated so
- * {@link #getChildren()} returns the new child connectors of this
- * connector.
+ * Adds a handler that is called whenever the child hierarchy of this
+ * connector has been updated by the server.
*
- * @param event
- * An event containing additional information about how the
- * hierarchy has changed.
+ * @param handler
+ * The handler that should be added.
+ * @return A handler registration reference that can be used to unregister
+ * the handler
*/
- public void connectorHierarchyChanged(ConnectorHierarchyChangedEvent event);
+ public HandlerRegistration addConnectorHierarchyChangeHandler(
+ ConnectorHierarchyChangeHandler handler);
}
--- /dev/null
+/*\r
+@VaadinApache2LicenseForJavaFiles@\r
+ */\r
+package com.vaadin.terminal.gwt.client;\r
+\r
+import java.io.Serializable;\r
+import java.util.List;\r
+\r
+import com.google.gwt.event.shared.EventHandler;\r
+import com.google.gwt.event.shared.GwtEvent;\r
+import com.vaadin.terminal.gwt.client.ConnectorHierarchyChangeEvent.ConnectorHierarchyChangeHandler;\r
+import com.vaadin.terminal.gwt.client.communication.AbstractServerConnectorEvent;\r
+\r
+/**\r
+ * Event for containing data related to a change in the {@link ServerConnector}\r
+ * hierarchy. A {@link ConnectorHierarchyChangedEvent} is fired when an update\r
+ * from the server has been fully processed and all hierarchy updates have been\r
+ * completed.\r
+ * \r
+ * @author Vaadin Ltd\r
+ * @version @VERSION@\r
+ * @since 7.0.0\r
+ * \r
+ */\r
+public class ConnectorHierarchyChangeEvent extends\r
+ AbstractServerConnectorEvent<ConnectorHierarchyChangeHandler> {\r
+ /**\r
+ * Type of this event, used by the event bus.\r
+ */\r
+ public static final Type<ConnectorHierarchyChangeHandler> TYPE = new Type<ConnectorHierarchyChangeHandler>();\r
+\r
+ List<ComponentConnector> oldChildren;\r
+ private ComponentContainerConnector parent;\r
+\r
+ public ConnectorHierarchyChangeEvent() {\r
+ }\r
+\r
+ /**\r
+ * Returns a collection of the old children for the connector. This was the\r
+ * state before the update was received from the server.\r
+ * \r
+ * @return A collection of old child connectors. Never returns null.\r
+ */\r
+ public List<ComponentConnector> getOldChildren() {\r
+ return oldChildren;\r
+ }\r
+\r
+ /**\r
+ * Sets the collection of the old children for the connector.\r
+ * \r
+ * @param oldChildren\r
+ * The old child connectors. Must not be null.\r
+ */\r
+ public void setOldChildren(List<ComponentConnector> oldChildren) {\r
+ this.oldChildren = oldChildren;\r
+ }\r
+\r
+ /**\r
+ * Returns the {@link ComponentContainerConnector} for which this event\r
+ * occurred.\r
+ * \r
+ * @return The {@link ComponentContainerConnector} whose child collection\r
+ * has changed. Never returns null.\r
+ */\r
+ public ComponentContainerConnector getParent() {\r
+ return parent;\r
+ }\r
+\r
+ /**\r
+ * Sets the {@link ComponentContainerConnector} for which this event\r
+ * occurred.\r
+ * \r
+ * @param The\r
+ * {@link ComponentContainerConnector} whose child collection has\r
+ * changed.\r
+ */\r
+ public void setParent(ComponentContainerConnector parent) {\r
+ this.parent = parent;\r
+ }\r
+\r
+ public interface ConnectorHierarchyChangeHandler extends Serializable,\r
+ EventHandler {\r
+ public void onConnectorHierarchyChange(\r
+ ConnectorHierarchyChangeEvent connectorHierarchyChangeEvent);\r
+ }\r
+\r
+ @Override\r
+ public void dispatch(ConnectorHierarchyChangeHandler handler) {\r
+ handler.onConnectorHierarchyChange(this);\r
+ }\r
+\r
+ @Override\r
+ public GwtEvent.Type<ConnectorHierarchyChangeHandler> getAssociatedType() {\r
+ return TYPE;\r
+ }\r
+\r
+}
\ No newline at end of file
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client;
-
-import java.util.List;
-
-/**
- * Event for containing data related to a change in the {@link ServerConnector}
- * hierarchy. A {@link ConnectorHierarchyChangedEvent} is fired when an update
- * from the server has been fully processed and all hierarchy updates have been
- * completed.
- *
- * @author Vaadin Ltd
- * @version @VERSION@
- * @since 7.0.0
- *
- */
-public class ConnectorHierarchyChangedEvent {
- List<ComponentConnector> oldChildren;
- private ComponentContainerConnector parent;
-
- public ConnectorHierarchyChangedEvent() {
- }
-
- /**
- * Returns a collection of the old children for the connector. This was the
- * state before the update was received from the server.
- *
- * @return A collection of old child connectors. Never returns null.
- */
- public List<ComponentConnector> getOldChildren() {
- return oldChildren;
- }
-
- /**
- * Sets the collection of the old children for the connector.
- *
- * @param oldChildren
- * The old child connectors. Must not be null.
- */
- public void setOldChildren(List<ComponentConnector> oldChildren) {
- this.oldChildren = oldChildren;
- }
-
- /**
- * Returns the {@link ComponentContainerConnector} for which this event
- * occurred.
- *
- * @return The {@link ComponentContainerConnector} whose child collection
- * has changed. Never returns null.
- */
- public ComponentContainerConnector getParent() {
- return parent;
- }
-
- /**
- * Sets the {@link ComponentContainerConnector} for which this event
- * occurred.
- *
- * @param The
- * {@link ComponentContainerConnector} whose child collection has
- * changed.
- */
- public void setParent(ComponentContainerConnector parent) {
- this.parent = parent;
- }
-
-}
* The new state
* @deprecated This should be removed. Framework should update what is
* returned by getState() instead of setting a new state object.
+ * Note that this must be done either so that setState accepts a
+ * state object once (first time received from the server) or
+ * getState() in AbstractConnector uses a generated class to
+ * create the state object (like RpcProy.craete())
*/
@Deprecated
public void setState(SharedState state);
*
* @param handler
* The handler that should be added.
+ * @return A handler registration reference that can be used to unregister
+ * the handler
*/
public HandlerRegistration addStateChangeHandler(StateChangeHandler handler);
extends GwtEvent<H> {
private ServerConnector connector;
- protected AbstractServerConnectorEvent(ServerConnector connector) {
- this.connector = connector;
+ protected AbstractServerConnectorEvent() {
}
public ServerConnector getConnector() {
return connector;
}
+ public void setConnector(ServerConnector connector) {
+ this.connector = connector;
+ }
+
/**
* Sends this event to the given handler.
*
import java.io.Serializable;
import com.google.gwt.event.shared.EventHandler;
-import com.vaadin.terminal.gwt.client.ServerConnector;
import com.vaadin.terminal.gwt.client.communication.StateChangeEvent.StateChangeHandler;
public class StateChangeEvent extends
return TYPE;
}
- public StateChangeEvent(ServerConnector connector) {
- super(connector);
+ public StateChangeEvent() {
}
@Override
import java.util.LinkedList;
import java.util.List;
+import com.google.gwt.event.shared.HandlerRegistration;
import com.vaadin.terminal.gwt.client.ComponentConnector;
import com.vaadin.terminal.gwt.client.ComponentContainerConnector;
import com.vaadin.terminal.gwt.client.Connector;
-import com.vaadin.terminal.gwt.client.ConnectorHierarchyChangedEvent;
+import com.vaadin.terminal.gwt.client.ConnectorHierarchyChangeEvent;
+import com.vaadin.terminal.gwt.client.ConnectorHierarchyChangeEvent.ConnectorHierarchyChangeHandler;
import com.vaadin.terminal.gwt.client.MouseEventDetails;
import com.vaadin.terminal.gwt.client.Util;
import com.vaadin.terminal.gwt.client.VConsole;
import com.vaadin.terminal.gwt.client.communication.ServerRpc;
public abstract class AbstractComponentContainerConnector extends
- AbstractComponentConnector implements ComponentContainerConnector {
+ AbstractComponentConnector implements ComponentContainerConnector,
+ ConnectorHierarchyChangeHandler {
public interface LayoutClickRPC extends ServerRpc {
/**
* Default constructor
*/
public AbstractComponentContainerConnector() {
+ addConnectorHierarchyChangeHandler(this);
}
/*
* connectorHierarchyChanged
* (com.vaadin.terminal.gwt.client.ConnectorHierarchyChangedEvent)
*/
- public void connectorHierarchyChanged(ConnectorHierarchyChangedEvent event) {
+ public void onConnectorHierarchyChange(ConnectorHierarchyChangeEvent event) {
// TODO Remove debug info
VConsole.log("Hierarchy changed for " + Util.getConnectorString(this));
String oldChildren = "* Old children: ";
}
VConsole.log(newChildren);
}
+
+ public HandlerRegistration addConnectorHierarchyChangeHandler(
+ ConnectorHierarchyChangeHandler handler) {
+ return ensureHandlerManager().addHandler(
+ ConnectorHierarchyChangeEvent.TYPE, handler);
+ }
+
}
}
@Override
- public void connectorHierarchyChanged(
- com.vaadin.terminal.gwt.client.ConnectorHierarchyChangedEvent event) {
- super.connectorHierarchyChanged(event);
+ public void onConnectorHierarchyChange(
+ com.vaadin.terminal.gwt.client.ConnectorHierarchyChangeEvent event) {
+ super.onConnectorHierarchyChange(event);
List<ComponentConnector> previousChildren = event.getOldChildren();
int currentIndex = 0;
VMeasuringOrderedLayout layout = getWidget();
import com.vaadin.terminal.gwt.client.ComponentConnector;
import com.vaadin.terminal.gwt.client.ComponentState;
import com.vaadin.terminal.gwt.client.Connector;
-import com.vaadin.terminal.gwt.client.ConnectorHierarchyChangedEvent;
+import com.vaadin.terminal.gwt.client.ConnectorHierarchyChangeEvent;
import com.vaadin.terminal.gwt.client.MouseEventDetails;
import com.vaadin.terminal.gwt.client.communication.RpcProxy;
import com.vaadin.terminal.gwt.client.communication.ServerRpc;
}
@Override
- public void connectorHierarchyChanged(ConnectorHierarchyChangedEvent event) {
- super.connectorHierarchyChanged(event);
+ public void onConnectorHierarchyChange(ConnectorHierarchyChangeEvent event) {
+ super.onConnectorHierarchyChange(event);
Widget newFirstChildWidget = null;
if (getFirstChild() != null) {
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.ui.Widget;
import com.vaadin.terminal.gwt.client.ComponentConnector;
-import com.vaadin.terminal.gwt.client.ConnectorHierarchyChangedEvent;
+import com.vaadin.terminal.gwt.client.ConnectorHierarchyChangeEvent;
import com.vaadin.terminal.gwt.client.ui.Component.LoadStyle;
import com.vaadin.ui.CustomComponent;
}
@Override
- public void connectorHierarchyChanged(ConnectorHierarchyChangedEvent event) {
- super.connectorHierarchyChanged(event);
+ public void onConnectorHierarchyChange(ConnectorHierarchyChangeEvent event) {
+ super.onConnectorHierarchyChange(event);
ComponentConnector newChild = null;
if (getChildren().size() == 1) {
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.ComponentConnector;
import com.vaadin.terminal.gwt.client.ComponentState;
-import com.vaadin.terminal.gwt.client.ConnectorHierarchyChangedEvent;
+import com.vaadin.terminal.gwt.client.ConnectorHierarchyChangeEvent;
import com.vaadin.terminal.gwt.client.LayoutManager;
import com.vaadin.terminal.gwt.client.MouseEventDetails;
import com.vaadin.terminal.gwt.client.UIDL;
}
@Override
- public void connectorHierarchyChanged(ConnectorHierarchyChangedEvent event) {
- super.connectorHierarchyChanged(event);
+ public void onConnectorHierarchyChange(ConnectorHierarchyChangeEvent event) {
+ super.onConnectorHierarchyChange(event);
// We always have 1 child, unless the child is hidden
Widget newChildWidget = null;
if (getChildren().size() == 1) {
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.BrowserInfo;
import com.vaadin.terminal.gwt.client.ComponentConnector;
-import com.vaadin.terminal.gwt.client.ConnectorHierarchyChangedEvent;
+import com.vaadin.terminal.gwt.client.ConnectorHierarchyChangeEvent;
import com.vaadin.terminal.gwt.client.ConnectorMap;
import com.vaadin.terminal.gwt.client.Focusable;
import com.vaadin.terminal.gwt.client.MouseEventDetails;
}
@Override
- public void connectorHierarchyChanged(ConnectorHierarchyChangedEvent event) {
- super.connectorHierarchyChanged(event);
+ public void onConnectorHierarchyChange(ConnectorHierarchyChangeEvent event) {
+ super.onConnectorHierarchyChange(event);
for (ComponentConnector c : getChildren()) {
if (c instanceof WindowConnector) {
WindowConnector wc = (WindowConnector) c;
projects / vaadin-framework.git / commitdiff