import java.lang.annotation.Target;
import com.vaadin.terminal.gwt.client.ui.dd.VAcceptCriterion;
-import com.vaadin.ui.ClientWidget;
/**
* An annotation type used to point the client side counterpart for server side
- * a {@link AcceptCriterion} class. Usage is pretty similar to
- * {@link ClientWidget} which is used with Vaadin components that have a
- * specialized client side counterpart.
+ * a {@link AcceptCriterion} class.
* <p>
* Annotations are used at GWT compilation phase, so remember to rebuild your
* widgetset if you do changes for {@link ClientCriterion} mappings.
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
+import java.util.Map;
import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.core.client.GWT;
private boolean usePortletURLs = false;
private String portletUidlURLBase;
- private HashMap<String, String> unknownComponents;
+ private HashMap<Integer, String> unknownComponents;
private Class<? extends ComponentConnector>[] classes = new Class[1024];
- private String windowId;
-
private boolean browserDetailsSent = false;
static// TODO consider to make this hashmap per application
private static ArrayList<ApplicationConnection> runningApplications = new ArrayList<ApplicationConnection>();
+ private Map<Integer, Integer> componentInheritanceMap = new HashMap<Integer, Integer>();
+ private Map<Integer, String> tagToServerSideClassName = new HashMap<Integer, String>();
+
public boolean usePortletURLs() {
return usePortletURLs;
}
}
public Class<? extends ComponentConnector> getWidgetClassByEncodedTag(
- String tag) {
+ int tag) {
try {
- int parseInt = Integer.parseInt(tag);
- return classes[parseInt];
+ return classes[tag];
} catch (Exception e) {
// component was not present in mappings
return UnknownComponentConnector.class;
}
}
+ public void addComponentInheritanceInfo(ValueMap valueMap) {
+ JsArrayString keyArray = valueMap.getKeyArray();
+ for (int i = 0; i < keyArray.length(); i++) {
+ String key = keyArray.get(i);
+ int value = valueMap.getInt(key);
+ componentInheritanceMap.put(Integer.parseInt(key), value);
+ }
+ }
+
public void addComponentMappings(ValueMap valueMap, WidgetSet widgetSet) {
JsArrayString keyArray = valueMap.getKeyArray();
for (int i = 0; i < keyArray.length(); i++) {
String key = keyArray.get(i).intern();
int value = valueMap.getInt(key);
- classes[value] = widgetSet.getImplementationByClassName(key);
+ tagToServerSideClassName.put(value, key);
+ }
+
+ for (int i = 0; i < keyArray.length(); i++) {
+ String key = keyArray.get(i).intern();
+ int value = valueMap.getInt(key);
+ classes[value] = widgetSet.getConnectorClassByTag(value, this);
if (classes[value] == UnknownComponentConnector.class) {
if (unknownComponents == null) {
- unknownComponents = new HashMap<String, String>();
+ unknownComponents = new HashMap<Integer, String>();
}
- unknownComponents.put("" + value, key);
- } else if (key == "com.vaadin.ui.Root") {
- windowId = "" + value;
+ unknownComponents.put(value, key);
}
}
}
- /**
- * @return the integer value that is used to code top level windows
- * "com.vaadin.ui.Window"
- */
- String getEncodedWindowTag() {
- return windowId;
+ public Integer getParentTag(int tag) {
+ return componentInheritanceMap.get(tag);
+ }
+
+ public String getServerSideClassNameForTag(Integer tag) {
+ return tagToServerSideClassName.get(tag);
}
- String getUnknownServerClassNameByEncodedTagName(String tag) {
+ String getUnknownServerClassNameByTag(int tag) {
if (unknownComponents != null) {
return unknownComponents.get(tag);
}
}
}
+ if (json.containsKey("typeInheritanceMap")) {
+ configuration.addComponentInheritanceInfo(json
+ .getValueMap("typeInheritanceMap"));
+ }
+
if (json.containsKey("typeMappings")) {
configuration.addComponentMappings(
json.getValueMap("typeMappings"), widgetSet);
for (int i = 0; i < keyArray.length(); i++) {
try {
String connectorId = keyArray.get(i);
- String connectorType = types.getString(connectorId);
+ int connectorType = Integer.parseInt(types
+ .getString((connectorId)));
ServerConnector connector = connectorMap
.getConnector(connectorId);
if (connector != null) {
continue;
}
+
+ Class<? extends ComponentConnector> connectorClass = configuration
+ .getWidgetClassByEncodedTag(connectorType);
+
// Connector does not exist so we must create it
- if (!connectorType.equals(configuration
- .getEncodedWindowTag())) {
+ if (connectorClass != RootConnector.class) {
// create, initialize and register the paintable
getConnector(connectorId, connectorType);
} else {
@Deprecated
public ComponentConnector getPaintable(UIDL uidl) {
- return getConnector(uidl.getId(), uidl.getTag());
+ return getConnector(uidl.getId(), Integer.parseInt(uidl.getTag()));
}
/**
* @return Either an existing ComponentConnector or a new ComponentConnector
* of the given type
*/
- public ComponentConnector getConnector(String connectorId,
- String connectorType) {
+ public ComponentConnector getConnector(String connectorId, int connectorType) {
if (!connectorMap.hasConnector(connectorId)) {
return createAndRegisterConnector(connectorId, connectorType);
}
* @return A new ComponentConnector of the given type
*/
private ComponentConnector createAndRegisterConnector(String connectorId,
- String connectorType) {
+ int connectorType) {
// Create and register a new connector with the given type
ComponentConnector p = widgetSet.createWidget(connectorType,
configuration);
try {
String name = uidl.getTag();
try {
- Integer.parseInt(name);
- name = getNodeName(uidl, conf, name);
+ name = getNodeName(uidl, conf, Integer.parseInt(name));
} catch (Exception e) {
// NOP
}
}
private String getNodeName(UIDL uidl, ApplicationConfiguration conf,
- String name) {
+ int tag) {
Class<? extends ComponentConnector> widgetClassByDecodedTag = conf
- .getWidgetClassByEncodedTag(name);
+ .getWidgetClassByEncodedTag(tag);
if (widgetClassByDecodedTag == UnknownComponentConnector.class) {
- return conf.getUnknownServerClassNameByEncodedTagName(name)
+ return conf.getUnknownServerClassNameByTag(tag)
+ "(NO CLIENT IMPLEMENTATION FOUND)";
} else {
return widgetClassByDecodedTag.getName();
String nodeName = uidl.getTag();
try {
- Integer.parseInt(nodeName);
- nodeName = getNodeName(uidl, conf, nodeName);
+ nodeName = getNodeName(uidl, conf, Integer.parseInt(nodeName));
} catch (Exception e) {
// NOP
}
import java.util.HashMap;
+import com.vaadin.terminal.gwt.widgetsetutils.WidgetMapGenerator;
+
+/**
+ * Abstract class mapping between {@link ComponentConnector} instances and their
+ * instances.
+ *
+ * A concrete implementation of this class is generated by
+ * {@link WidgetMapGenerator} or one of its subclasses during widgetset
+ * compilation.
+ */
abstract class WidgetMap {
protected static HashMap<Class, WidgetInstantiator> instmap = new HashMap<Class, WidgetInstantiator>();
- // FIXME: Should use Paintable and not VPaintableWidget
+ /**
+ * Create a new instance of a connector based on its type.
+ *
+ * @param classType
+ * {@link ComponentConnector} class to instantiate
+ * @return new instance of the connector
+ */
public ComponentConnector instantiate(
Class<? extends ComponentConnector> classType) {
return instmap.get(classType).get();
}
- // FIXME: Should use Paintable and not VPaintableWidget
- public abstract Class<? extends ComponentConnector> getImplementationByServerSideClassName(
+ /**
+ * Return the connector class to use for a fully qualified server side
+ * component class name.
+ *
+ * @param fullyqualifiedName
+ * fully qualified name of the server side component class
+ * @return component connector class to use
+ */
+ public abstract Class<? extends ComponentConnector> getConnectorClassForServerSideClassName(
String fullyqualifiedName);
- // FIXME: Should use Paintable and not VPaintableWidget
+ /**
+ * Return the connector classes to load after the initial widgetset load and
+ * start.
+ *
+ * @return component connector class to load after the initial widgetset
+ * loading
+ */
public abstract Class<? extends ComponentConnector>[] getDeferredLoadedWidgets();
- // FIXME: Should use Paintable and not VPaintableWidget
+ /**
+ * Make sure the code for a (deferred or lazy) component connector type has
+ * been loaded, triggering the load and waiting for its completion if
+ * necessary.
+ *
+ * @param classType
+ * component connector class
+ */
public abstract void ensureInstantiator(
Class<? extends ComponentConnector> classType);
* @return New uninitialized and unregistered component that can paint given
* UIDL.
*/
- public ComponentConnector createWidget(String tag,
+ public ComponentConnector createWidget(int tag,
ApplicationConfiguration conf) {
/*
* Yes, this (including the generated code in WidgetMap) may look very
* has no "native" counterpart on client side.
*/
- Class<? extends ComponentConnector> classType = resolveWidgetType(tag,
- conf);
+ Class<? extends ComponentConnector> classType = resolveInheritedWidgetType(
+ conf, tag);
if (classType == null || classType == UnknownComponentConnector.class) {
String serverSideName = conf
- .getUnknownServerClassNameByEncodedTagName(tag);
+ .getUnknownServerClassNameByTag(tag);
UnknownComponentConnector c = GWT
.create(UnknownComponentConnector.class);
c.setServerSideClassName(serverSideName);
*/
return widgetMap.instantiate(classType);
}
+ }
+ private Class<? extends ComponentConnector> resolveInheritedWidgetType(
+ ApplicationConfiguration conf, int tag) {
+ Class<? extends ComponentConnector> classType = null;
+ Integer t = tag;
+ do {
+ classType = resolveWidgetType(t, conf);
+ t = conf.getParentTag(t);
+ } while (classType == null && t != null);
+ return classType;
}
- protected Class<? extends ComponentConnector> resolveWidgetType(String tag,
+ protected Class<? extends ComponentConnector> resolveWidgetType(int tag,
ApplicationConfiguration conf) {
Class<? extends ComponentConnector> widgetClass = conf
.getWidgetClassByEncodedTag(tag);
return widgetClass;
-
}
/**
* limitation, widgetset must have function that returns Class by its fully
* qualified name.
*
- * @param fullyQualifiedName
+ * @param tag
* @param applicationConfiguration
* @return
*/
- public Class<? extends ComponentConnector> getImplementationByClassName(
- String fullyqualifiedName) {
- if (fullyqualifiedName == null) {
- return UnknownComponentConnector.class;
- }
- Class<? extends ComponentConnector> implementationByServerSideClassName = widgetMap
- .getImplementationByServerSideClassName(fullyqualifiedName);
-
- return implementationByServerSideClassName;
-
+ public Class<? extends ComponentConnector> getConnectorClassByTag(int tag,
+ ApplicationConfiguration conf) {
+ Class<? extends ComponentConnector> connectorClass = null;
+ Integer t = tag;
+ do {
+ connectorClass = widgetMap
+ .getConnectorClassForServerSideClassName(conf
+ .getServerSideClassNameForTag(t));
+ t = conf.getParentTag(t);
+ } while (connectorClass == UnknownComponentConnector.class && t != null);
+
+ return connectorClass;
}
public Class<? extends ComponentConnector>[] getDeferredLoadedWidgets() {
import com.vaadin.terminal.gwt.client.UIDL;
import com.vaadin.terminal.gwt.client.communication.ServerRpc;
import com.vaadin.terminal.gwt.client.ui.VAbsoluteLayout.AbsoluteWrapper;
+import com.vaadin.ui.AbsoluteLayout;
+@Component(AbsoluteLayout.class)
public class AbsoluteLayoutConnector extends
AbstractComponentContainerConnector implements DirectionalManagedLayout {
import com.vaadin.terminal.gwt.client.ComponentConnector;
import com.vaadin.terminal.gwt.client.UIDL;
import com.vaadin.terminal.gwt.client.ui.VAccordion.StackItem;
+import com.vaadin.ui.Accordion;
+@Component(Accordion.class)
public class AccordionConnector extends TabsheetBaseConnector implements
SimpleManagedLayout {
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.BrowserInfo;
import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.ui.Audio;
+@Component(Audio.class)
public class AudioConnector extends MediaBaseConnector {
@Override
import com.vaadin.terminal.gwt.client.MouseEventDetails;
import com.vaadin.terminal.gwt.client.UIDL;
import com.vaadin.terminal.gwt.client.communication.ServerRpc;
+import com.vaadin.terminal.gwt.client.ui.Component.LoadStyle;
+import com.vaadin.ui.Button;
+@Component(value = Button.class, loadStyle = LoadStyle.EAGER)
public class ButtonConnector extends AbstractComponentConnector {
/**
import com.vaadin.terminal.gwt.client.EventHelper;
import com.vaadin.terminal.gwt.client.UIDL;
import com.vaadin.terminal.gwt.client.VTooltip;
+import com.vaadin.ui.CheckBox;
+@Component(CheckBox.class)
public class CheckBoxConnector extends AbstractFieldConnector {
@Override
import com.vaadin.terminal.gwt.client.UIDL;
import com.vaadin.terminal.gwt.client.Util;
import com.vaadin.terminal.gwt.client.ui.VFilterSelect.FilterSelectSuggestion;
+import com.vaadin.ui.Select;
+@Component(Select.class)
public class ComboBoxConnector extends AbstractFieldConnector implements
SimpleManagedLayout {
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import com.vaadin.terminal.gwt.client.ComponentConnector;
+import com.vaadin.terminal.gwt.server.ClientConnector;
+import com.vaadin.terminal.gwt.widgetsetutils.CustomWidgetMapGenerator;
+import com.vaadin.terminal.gwt.widgetsetutils.EagerWidgetMapGenerator;
+import com.vaadin.terminal.gwt.widgetsetutils.LazyWidgetMapGenerator;
+import com.vaadin.terminal.gwt.widgetsetutils.WidgetMapGenerator;
+
+/**
+ * Annotation defining the default server side counterpart in GWT terminal for
+ * {@link ComponentConnector}.
+ * <p>
+ * With this annotation client side Vaadin connector is marked to have a server
+ * side counterpart. The value of the annotation is the class of server side
+ * implementation.
+ *
+ * @since 7.0
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface Component {
+
+ /**
+ * @return the server side counterpart for the annotated component connector
+ */
+ Class<? extends ClientConnector> value();
+
+ /**
+ * Depending on the used WidgetMap generator, these optional hints may be
+ * used to define how the client side components are loaded by the browser.
+ * The default is to eagerly load all widgets
+ * {@link EagerWidgetMapGenerator}, but if the {@link WidgetMapGenerator} is
+ * used by the widgetset, these load style hints are respected.
+ * <p>
+ * Lazy loading of a widget implementation means the client side component
+ * is not included in the initial JavaScript application loaded when the
+ * application starts. Instead the implementation is loaded to the client
+ * when it is first needed. Lazy loaded widget can be achieved by giving
+ * {@link LoadStyle#LAZY} value in {@link Component} annotation.
+ * <p>
+ * Lazy loaded widgets don't stress the size and startup time of the client
+ * side as much as eagerly loaded widgets. On the other hand there is a
+ * slight latency when lazy loaded widgets are first used as the client side
+ * needs to visit the server to fetch the client side implementation.
+ * <p>
+ * The {@link LoadStyle#DEFERRED} will also not stress the initially loaded
+ * JavaScript file. If this load style is defined, the widget implementation
+ * is preemptively loaded to the browser after the application is started
+ * and the communication to server idles. This load style kind of combines
+ * the best of both worlds.
+ * <p>
+ * Fine tunings to widget loading can also be made by overriding
+ * {@link WidgetMapGenerator} in the GWT module. Tunings might be helpful if
+ * the end users have slow connections and especially if they have high
+ * latency in their network. The {@link CustomWidgetMapGenerator} is an
+ * abstract generator implementation for easy customization. Vaadin package
+ * also includes {@link LazyWidgetMapGenerator} that makes as many widgets
+ * lazily loaded as possible.
+ *
+ * @since 6.4
+ *
+ * @return the hint for the widget set generator how the client side
+ * implementation should be loaded to the browser
+ */
+ LoadStyle loadStyle() default LoadStyle.DEFERRED;
+
+ public enum LoadStyle {
+ /**
+ * The widget is included in the initial JS sent to the client.
+ */
+ EAGER,
+ /**
+ * Not included in the initial set of widgets, but added to queue from
+ * which it will be loaded when network is not busy or the
+ * implementation is required.
+ */
+ DEFERRED,
+ /**
+ * Loaded to the client only if needed.
+ */
+ LAZY
+ }
+}
import com.vaadin.terminal.gwt.client.ComponentConnector;
import com.vaadin.terminal.gwt.client.UIDL;
import com.vaadin.terminal.gwt.client.communication.ServerRpc;
+import com.vaadin.ui.CssLayout;
+@Component(CssLayout.class)
public class CssLayoutConnector extends AbstractComponentContainerConnector {
private LayoutClickEventHandler clickEventHandler = new LayoutClickEventHandler(
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.ui.Component.LoadStyle;
+import com.vaadin.ui.CustomComponent;
+@Component(value = CustomComponent.class, loadStyle = LoadStyle.EAGER)
public class CustomComponentConnector extends
AbstractComponentContainerConnector {
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.ui.CustomField;
+
+@Component(value = CustomField.class)
+public class CustomFieldConnector extends CustomComponentConnector {
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VCustomComponent.class);
+ }
+
+ @Override
+ public VCustomComponent getWidget() {
+ return super.getWidget();
+ }
+}
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.ComponentConnector;
import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.ui.CustomLayout;
+@Component(CustomLayout.class)
public class CustomLayoutConnector extends AbstractComponentContainerConnector
implements SimpleManagedLayout {
import com.google.gwt.user.client.ui.Widget;
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.ui.DragAndDropWrapper;
+@Component(DragAndDropWrapper.class)
public class DragAndDropWrapperConnector extends CustomComponentConnector {
@Override
import com.vaadin.terminal.gwt.client.VConsole;
import com.vaadin.terminal.gwt.client.VTooltip;
import com.vaadin.terminal.gwt.client.communication.ServerRpc;
+import com.vaadin.ui.Embedded;
+@Component(Embedded.class)
public class EmbeddedConnector extends AbstractComponentConnector {
public interface EmbeddedServerRPC extends ClickRPC, ServerRpc {
import com.vaadin.terminal.gwt.client.ConnectorMap;
import com.vaadin.terminal.gwt.client.LayoutManager;
import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.ui.Form;
+@Component(Form.class)
public class FormConnector extends AbstractComponentContainerConnector
implements SimpleManagedLayout {
import com.vaadin.terminal.gwt.client.UIDL;
import com.vaadin.terminal.gwt.client.ui.VFormLayout.Caption;
import com.vaadin.terminal.gwt.client.ui.VFormLayout.ErrorFlag;
+import com.vaadin.ui.FormLayout;
+@Component(FormLayout.class)
public class FormLayoutConnector extends AbstractComponentContainerConnector {
@Override
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
import com.vaadin.terminal.gwt.client.communication.ServerRpc;
import com.vaadin.terminal.gwt.client.ui.VGridLayout.Cell;
import com.vaadin.terminal.gwt.client.ui.layout.VLayoutSlot;
+import com.vaadin.ui.GridLayout;
+@Component(GridLayout.class)
public class GridLayoutConnector extends AbstractComponentContainerConnector
implements DirectionalManagedLayout {
package com.vaadin.terminal.gwt.client.ui;
import com.google.gwt.core.client.GWT;
+import com.vaadin.terminal.gwt.client.ui.Component.LoadStyle;
+import com.vaadin.ui.HorizontalLayout;
+@Component(value = HorizontalLayout.class, loadStyle = LoadStyle.EAGER)
public class HorizontalLayoutConnector extends AbstractOrderedLayoutConnector {
@Override
package com.vaadin.terminal.gwt.client.ui;
import com.google.gwt.core.client.GWT;
+import com.vaadin.terminal.gwt.client.ui.Component.LoadStyle;
+import com.vaadin.ui.HorizontalSplitPanel;
+@Component(value = HorizontalSplitPanel.class, loadStyle = LoadStyle.EAGER)
public class HorizontalSplitPanelConnector extends AbstractSplitPanelConnector {
@Override
import com.vaadin.terminal.gwt.client.UIDL;
import com.vaadin.terminal.gwt.client.ui.VCalendarPanel.FocusChangeListener;
import com.vaadin.terminal.gwt.client.ui.VCalendarPanel.TimeChangeListener;
+import com.vaadin.ui.InlineDateField;
+@Component(InlineDateField.class)
public class InlineDateFieldConnector extends AbstractDateFieldConnector {
@Override
import com.google.gwt.user.client.ui.Widget;
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.ui.Link;
+@Component(Link.class)
public class LinkConnector extends AbstractComponentConnector {
@Override
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.ui.ListSelect;
+@Component(ListSelect.class)
public class ListSelectConnector extends OptionGroupBaseConnector {
@Override
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.UIDL;
import com.vaadin.terminal.gwt.client.Util;
+import com.vaadin.terminal.gwt.client.ui.Component.LoadStyle;
import com.vaadin.terminal.gwt.client.ui.VMenuBar.CustomMenuItem;
+@Component(value = com.vaadin.ui.MenuBar.class, loadStyle = LoadStyle.LAZY)
public class MenuBarConnector extends AbstractComponentConnector implements
SimpleManagedLayout {
/**
import com.vaadin.terminal.gwt.client.EventHelper;
import com.vaadin.terminal.gwt.client.UIDL;
import com.vaadin.terminal.gwt.client.ui.ButtonConnector.ButtonServerRpc;
+import com.vaadin.ui.NativeButton;
+@Component(NativeButton.class)
public class NativeButtonConnector extends AbstractComponentConnector {
@Override
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.ui.NativeSelect;
+@Component(NativeSelect.class)
public class NativeSelectConnector extends OptionGroupBaseConnector {
@Override
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.EventId;
import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.ui.OptionGroup;
+@Component(OptionGroup.class)
public class OptionGroupConnector extends OptionGroupBaseConnector {
@Override
import com.vaadin.terminal.gwt.client.UIDL;
import com.vaadin.terminal.gwt.client.Util;
import com.vaadin.terminal.gwt.client.communication.ServerRpc;
+import com.vaadin.ui.Panel;
+@Component(Panel.class)
public class PanelConnector extends AbstractComponentContainerConnector
implements SimpleManagedLayout, PostLayoutListener {
import com.google.gwt.user.client.ui.Widget;
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.ui.PasswordField;
+@Component(PasswordField.class)
public class PasswordFieldConnector extends TextFieldConnector {
@Override
import com.vaadin.terminal.gwt.client.UIDL;
import com.vaadin.terminal.gwt.client.ui.VCalendarPanel.FocusChangeListener;
import com.vaadin.terminal.gwt.client.ui.VCalendarPanel.TimeChangeListener;
+import com.vaadin.ui.DateField;
+@Component(DateField.class)
public class PopupDateFieldConnector extends TextualDateConnector {
/*
import com.vaadin.terminal.gwt.client.UIDL;
import com.vaadin.terminal.gwt.client.VCaption;
import com.vaadin.terminal.gwt.client.VCaptionWrapper;
+import com.vaadin.ui.PopupView;
+@Component(PopupView.class)
public class PopupViewConnector extends AbstractComponentContainerConnector
implements PostLayoutListener {
import com.google.gwt.user.client.ui.Widget;
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.ui.ProgressIndicator;
+@Component(ProgressIndicator.class)
public class ProgressIndicatorConnector extends AbstractFieldConnector {
@Override
import com.vaadin.terminal.gwt.client.communication.ServerRpc;
import com.vaadin.terminal.gwt.client.communication.StateChangeEvent;
import com.vaadin.terminal.gwt.client.communication.StateChangeEvent.StateChangeHandler;
+import com.vaadin.terminal.gwt.client.ui.Component.LoadStyle;
+import com.vaadin.ui.Root;
+@Component(value = Root.class, loadStyle = LoadStyle.EAGER)
public class RootConnector extends AbstractComponentContainerConnector {
public interface RootServerRPC extends ClickRPC, ServerRpc {
import com.google.gwt.user.client.ui.Widget;
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.ui.Slider;
+@Component(Slider.class)
public class SliderConnector extends AbstractFieldConnector {
@Override
import com.vaadin.terminal.gwt.client.ui.VScrollTable.ContextMenuDetails;
import com.vaadin.terminal.gwt.client.ui.VScrollTable.VScrollTableBody.VScrollTableRow;
+@Component(com.vaadin.ui.Table.class)
public class TableConnector extends AbstractComponentContainerConnector
implements DirectionalManagedLayout, PostLayoutListener {
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.ComponentConnector;
import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.ui.TabSheet;
+@Component(TabSheet.class)
public class TabsheetConnector extends TabsheetBaseConnector implements
SimpleManagedLayout {
import com.google.gwt.user.client.ui.Widget;
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.ui.TextArea;
+@Component(TextArea.class)
public class TextAreaConnector extends TextFieldConnector {
@Override
import com.google.gwt.user.client.ui.Widget;
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.terminal.gwt.client.ui.Component.LoadStyle;
import com.vaadin.terminal.gwt.client.ui.ShortcutActionHandler.BeforeShortcutActionListener;
+import com.vaadin.ui.TextField;
+@Component(value = TextField.class, loadStyle = LoadStyle.EAGER)
public class TextFieldConnector extends AbstractFieldConnector implements
BeforeShortcutActionListener {
import com.vaadin.terminal.gwt.client.TooltipInfo;
import com.vaadin.terminal.gwt.client.UIDL;
import com.vaadin.terminal.gwt.client.ui.VTree.TreeNode;
+import com.vaadin.ui.Tree;
+@Component(Tree.class)
public class TreeConnector extends AbstractComponentConnector {
public static final String ATTRIBUTE_NODE_STYLE = "style";
import com.vaadin.terminal.gwt.client.UIDL;
import com.vaadin.terminal.gwt.client.ui.VScrollTable.VScrollTableBody.VScrollTableRow;
import com.vaadin.terminal.gwt.client.ui.VTreeTable.PendingNavigationEvent;
+import com.vaadin.ui.TreeTable;
+@Component(TreeTable.class)
public class TreeTableConnector extends TableConnector {
public static final String ATTRIBUTE_HIERARCHY_COLUMN_INDEX = "hci";
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.DirectionalManagedLayout;
import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.ui.TwinColSelect;
+@Component(TwinColSelect.class)
public class TwinColSelectConnector extends OptionGroupBaseConnector implements
DirectionalManagedLayout {
if (!isRealUpdate(uidl)) {
return;
}
- getWidget().setCaption(
- "Widgetset does not contain implementation for "
- + getWidget().serverClassName
- + ". Check its @ClientWidget mapping, widgetsets "
- + "GWT module description file and re-compile your"
- + " widgetset. In case you have downloaded a vaadin"
- + " add-on package, you might want to refer to "
- + "<a href='http://vaadin.com/using-addons'>add-on "
- + "instructions</a>. Unrendered UIDL:");
+ getWidget()
+ .setCaption(
+ "Widgetset does not contain implementation for "
+ + getWidget().serverClassName
+ + ". Check its component connector's @Component mapping, widgetsets "
+ + "GWT module description file and re-compile your"
+ + " widgetset. In case you have downloaded a vaadin"
+ + " add-on package, you might want to refer to "
+ + "<a href='http://vaadin.com/using-addons'>add-on "
+ + "instructions</a>. Unrendered UIDL:");
if (getWidget().uidlTree != null) {
getWidget().uidlTree.removeFromParent();
}
import com.google.gwt.user.client.ui.Widget;
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.terminal.gwt.client.ui.Component.LoadStyle;
+import com.vaadin.ui.Upload;
+@Component(value = Upload.class, loadStyle = LoadStyle.LAZY)
public class UploadConnector extends AbstractComponentConnector {
@Override
package com.vaadin.terminal.gwt.client.ui;
import com.google.gwt.core.client.GWT;
+import com.vaadin.terminal.gwt.client.ui.Component.LoadStyle;
+import com.vaadin.ui.VerticalLayout;
+@Component(value = VerticalLayout.class, loadStyle = LoadStyle.EAGER)
public class VerticalLayoutConnector extends AbstractOrderedLayoutConnector {
@Override
package com.vaadin.terminal.gwt.client.ui;
import com.google.gwt.core.client.GWT;
+import com.vaadin.terminal.gwt.client.ui.Component.LoadStyle;
+import com.vaadin.ui.VerticalSplitPanel;
+@Component(value = VerticalSplitPanel.class, loadStyle = LoadStyle.EAGER)
public class VerticalSplitPanelConnector extends AbstractSplitPanelConnector {
@Override
import com.google.gwt.user.client.ui.Widget;
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.ui.Video;
+@Component(Video.class)
public class VideoConnector extends MediaBaseConnector {
public static final String ATTR_POSTER = "poster";
import com.vaadin.terminal.gwt.client.ui.PanelConnector.PanelState;
import com.vaadin.terminal.gwt.client.ui.ShortcutActionHandler.BeforeShortcutActionListener;
+@Component(value = com.vaadin.ui.Window.class)
public class WindowConnector extends AbstractComponentContainerConnector
implements BeforeShortcutActionListener, SimpleManagedLayout,
PostLayoutListener {
import com.vaadin.terminal.gwt.client.UIDL;
import com.vaadin.terminal.gwt.client.Util;
import com.vaadin.terminal.gwt.client.ui.AbstractComponentConnector;
+import com.vaadin.terminal.gwt.client.ui.Component;
+import com.vaadin.terminal.gwt.client.ui.Component.LoadStyle;
+import com.vaadin.ui.Label;
+@Component(value = Label.class, loadStyle = LoadStyle.EAGER)
public class LabelConnector extends AbstractComponentConnector {
public LabelConnector() {
}
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.UIDL;
import com.vaadin.terminal.gwt.client.ui.AbstractFieldConnector;
+import com.vaadin.terminal.gwt.client.ui.Component;
+import com.vaadin.terminal.gwt.client.ui.Component.LoadStyle;
import com.vaadin.terminal.gwt.client.ui.ShortcutActionHandler.BeforeShortcutActionListener;
+import com.vaadin.ui.RichTextArea;
+@Component(value = RichTextArea.class, loadStyle = LoadStyle.LAZY)
public class RichTextAreaConnector extends AbstractFieldConnector implements
BeforeShortcutActionListener {
return seckey;
}
+ @SuppressWarnings("unchecked")
public void writeUidlResponse(boolean repaintAll,
final PrintWriter outWriter, Root root, boolean analyzeLayouts)
throws PaintException {
}
outWriter.print("}");
- Collection<Class<? extends Paintable>> usedPaintableTypes = paintTarget
- .getUsedPaintableTypes();
+ Collection<Class<? extends ClientConnector>> usedClientConnectors = paintTarget
+ .getUsedClientConnectors();
boolean typeMappingsOpen = false;
ClientCache clientCache = getClientCache(root);
- for (Class<? extends Paintable> class1 : usedPaintableTypes) {
+ for (Class<? extends ClientConnector> class1 : usedClientConnectors) {
if (clientCache.cache(class1)) {
// client does not know the mapping key for this type, send
// mapping to client
outWriter.print("\"");
outWriter.print(canonicalName);
outWriter.print("\" : ");
- outWriter
- .print(getTagForType((Class<? extends ClientConnector>) class1));
+ outWriter.print(getTagForType(class1));
}
}
if (typeMappingsOpen) {
outWriter.print(" }");
}
+ boolean typeInheritanceMapOpen = false;
+ if (typeMappingsOpen) {
+ // send the whole type inheritance map if any new mappings
+ for (Class<? extends ClientConnector> class1 : usedClientConnectors) {
+ if (!typeInheritanceMapOpen) {
+ typeInheritanceMapOpen = true;
+ outWriter.print(", \"typeInheritanceMap\" : { ");
+ } else {
+ outWriter.print(" , ");
+ }
+ outWriter.print("\"");
+ outWriter.print(getTagForType(class1));
+ outWriter.print("\" : ");
+ // note that if the superclass is not in typeMappings, a "dummy"
+ // tag is used
+ outWriter
+ .print(getTagForType((Class<? extends ClientConnector>) class1
+ .getSuperclass()));
+ }
+ if (typeInheritanceMapOpen) {
+ outWriter.print(" }");
+ }
+ }
+
// add any pending locale definitions requested by the client
printLocaleDeclarations(outWriter);
package com.vaadin.terminal.gwt.server;
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.Serializable;
-import java.io.StringWriter;
import java.util.Collection;
-import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
-import java.util.LinkedList;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
import java.util.Vector;
-import java.util.logging.Level;
import java.util.logging.Logger;
import com.vaadin.Application;
import com.vaadin.terminal.VariableOwner;
import com.vaadin.terminal.gwt.client.Connector;
import com.vaadin.ui.Alignment;
-import com.vaadin.ui.ClientWidget;
import com.vaadin.ui.CustomLayout;
-import com.vaadin.ui.Root;
/**
* User Interface Description Language Target.
private final Collection<Paintable> paintedComponents = new HashSet<Paintable>();
- private final Collection<Class<? extends Paintable>> usedPaintableTypes = new LinkedList<Class<? extends Paintable>>();
+ private final Set<Class<? extends ClientConnector>> usedClientConnectors = new HashSet<Class<? extends ClientConnector>>();
/**
* Creates a new JsonPaintTarget.
return usedResources;
}
- private static final Map<Class<? extends Paintable>, Class<? extends Paintable>> widgetMappingCache = new HashMap<Class<? extends Paintable>, Class<? extends Paintable>>();
-
@SuppressWarnings("unchecked")
public String getTag(Paintable paintable) {
- Class<? extends Paintable> class1;
- synchronized (widgetMappingCache) {
- class1 = widgetMappingCache.get(paintable.getClass());
+ if (!(paintable instanceof ClientConnector)) {
+ throw new IllegalArgumentException(
+ "Tags are only available for ClientConnectors");
}
- if (class1 == null) {
- /*
- * Client widget annotation is searched from component hierarchy to
- * detect the component that presumably has client side
- * implementation. The server side name is used in the
- * transportation, but encoded into integer strings to optimized
- * transferred data.
- */
- class1 = paintable.getClass();
- while (!hasClientWidgetMapping(class1)) {
- Class<?> superclass = class1.getSuperclass();
- if (superclass != null
- && Paintable.class.isAssignableFrom(superclass)) {
- class1 = (Class<? extends Paintable>) superclass;
- } else {
- logger.warning("No superclass of "
- + paintable.getClass().getName()
- + " has a @ClientWidget"
- + " annotation. Component will not be mapped correctly on client side.");
- break;
- }
- }
- synchronized (widgetMappingCache) {
- widgetMappingCache.put(paintable.getClass(), class1);
- }
- }
-
- usedPaintableTypes.add(class1);
- return manager.getTagForType((Class<? extends ClientConnector>) class1);
-
- }
-
- private boolean hasClientWidgetMapping(Class<? extends Paintable> class1) {
- if (Root.class == class1) {
- return true;
+ Class<?> clazz = paintable.getClass();
+ while (!usedClientConnectors.contains(clazz)
+ && clazz.getSuperclass() != null
+ && ClientConnector.class
+ .isAssignableFrom(clazz.getSuperclass())) {
+ usedClientConnectors.add((Class<? extends ClientConnector>) clazz);
+ clazz = clazz.getSuperclass();
}
- try {
- return class1.isAnnotationPresent(ClientWidget.class);
- } catch (NoClassDefFoundError e) {
- String stacktrace = getStacktraceString(e);
- if (stacktrace
- .contains("com.ibm.oti.reflect.AnnotationParser.parseClass")) {
- // #7479 IBM JVM apparently tries to eagerly load the classes
- // referred to by annotations. Checking the annotation from byte
- // code to be sure that we are dealing the this case and not
- // some other class loading issue.
- if (bytecodeContainsClientWidgetAnnotation(class1)) {
- return true;
- }
- } else {
- // throw exception forward
- throw e;
- }
- } catch (LinkageError e) {
- String stacktrace = getStacktraceString(e);
- if (stacktrace
- .contains("org.jboss.modules.ModuleClassLoader.defineClass")) {
- // #7822 JBoss AS 7 apparently tries to eagerly load the classes
- // referred to by annotations. Checking the annotation from byte
- // code to be sure that we are dealing the this case and not
- // some other class loading issue.
- if (bytecodeContainsClientWidgetAnnotation(class1)) {
- // Seems that JBoss still prints a stacktrace to the logs
- // even though the LinkageError has been caught
- return true;
- }
- } else {
- // throw exception forward
- throw e;
- }
- } catch (RuntimeException e) {
- if (e.getStackTrace()[0].getClassName().equals(
- "org.glassfish.web.loader.WebappClassLoader")) {
-
- // See #3920
- // Glassfish 3 is darn eager to load the value class, even
- // though we just want to check if the annotation exists.
-
- // In some situations (depending on class loading order) it
- // would be enough to return true here, but it is safer to check
- // the annotation from byte code
-
- if (bytecodeContainsClientWidgetAnnotation(class1)) {
- return true;
- }
- } else {
- // throw exception forward
- throw e;
- }
- }
- return false;
- }
-
- private static String getStacktraceString(Throwable e) {
- StringWriter writer = new StringWriter();
- e.printStackTrace(new PrintWriter(writer));
- String stacktrace = writer.toString();
- return stacktrace;
- }
-
- private boolean bytecodeContainsClientWidgetAnnotation(
- Class<? extends Paintable> class1) {
-
- try {
- String name = class1.getName().replace('.', '/') + ".class";
-
- InputStream stream = class1.getClassLoader().getResourceAsStream(
- name);
- BufferedReader bufferedReader = new BufferedReader(
- new InputStreamReader(stream));
- try {
- String line;
- boolean atSourcefile = false;
- while ((line = bufferedReader.readLine()) != null) {
- if (line.startsWith("SourceFile")) {
- atSourcefile = true;
- }
- if (atSourcefile) {
- if (line.contains("ClientWidget")) {
- return true;
- }
- }
- // TODO could optimize to quit at the end attribute
- }
- } catch (IOException e1) {
- logger.log(Level.SEVERE,
- "An error occurred while finding widget mapping.", e1);
- } finally {
- try {
- bufferedReader.close();
- } catch (IOException e1) {
- logger.log(Level.SEVERE, "Could not close reader.", e1);
-
- }
- }
- } catch (Throwable t) {
- logger.log(Level.SEVERE,
- "An error occurred while finding widget mapping.", t);
- }
-
- return false;
+ return manager
+ .getTagForType((Class<? extends ClientConnector>) paintable
+ .getClass());
}
- Collection<Class<? extends Paintable>> getUsedPaintableTypes() {
- return usedPaintableTypes;
+ Collection<Class<? extends ClientConnector>> getUsedClientConnectors() {
+ return usedClientConnectors;
}
public void addVariable(VariableOwner owner, String name,
import com.vaadin.event.dd.acceptcriteria.AcceptCriterion;
import com.vaadin.event.dd.acceptcriteria.ClientCriterion;
import com.vaadin.terminal.Paintable;
-import com.vaadin.ui.ClientWidget;
-import com.vaadin.ui.Root;
/**
* Utility class to collect widgetset related information from classpath.
}
/**
- * Finds server side widgets with {@link ClientWidget} annotation on the
- * class path (entries that can contain widgets/widgetsets - see
+ * Finds server side widgets with ClientWidget annotation on the class path
+ * (entries that can contain widgets/widgetsets - see
* getRawClasspathEntries()).
*
* As a side effect, also accept criteria are searched under the same class
/**
* Searches for all paintable classes and accept criteria under a location
- * based on {@link ClientWidget} and {@link ClientCriterion} annotations.
+ * based on {@link ClientCriterion} annotations.
*
* Note that client criteria are updated directly to the
* {@link #acceptCriterion} field, whereas paintables are added to the
private static Set<Class<? extends AcceptCriterion>> acceptCriterion = new HashSet<Class<? extends AcceptCriterion>>();
/**
- * Checks a class for the {@link ClientWidget} and {@link ClientCriterion}
- * annotations, and adds it to the appropriate collection if it has either.
+ * Checks a class for the {@link ClientCriterion} annotations, and adds it
+ * to the appropriate collection if it has either.
*
* @param fullclassName
* @param paintables
* the collection to which to add server side classes with
- * {@link ClientWidget} annotation
+ * {@link ClientCriterion} annotation
*/
@SuppressWarnings("unchecked")
private static void tryToAdd(final String fullclassName,
Class<?> c = Class.forName(fullclassName);
- if (c.getAnnotation(ClientWidget.class) != null || Root.class == c) {
- paintables.add((Class<? extends Paintable>) c);
- // System.out.println("Found paintable " + fullclassName);
- } else if (c.getAnnotation(ClientCriterion.class) != null) {
+ if (c.getAnnotation(ClientCriterion.class) != null) {
acceptCriterion.add((Class<? extends AcceptCriterion>) c);
}
} catch (UnsupportedClassVersionError e) {
import java.util.Collection;
import java.util.HashSet;
-import com.vaadin.terminal.Paintable;
-import com.vaadin.ui.ClientWidget;
-import com.vaadin.ui.ClientWidget.LoadStyle;
+import com.vaadin.terminal.gwt.client.ComponentConnector;
+import com.vaadin.terminal.gwt.client.ui.Component;
+import com.vaadin.terminal.gwt.client.ui.Component.LoadStyle;
/**
* An abstract helper class that can be used to easily build a widgetset with
* customized load styles for each components. In three abstract methods one can
- * override the default values given in {@link ClientWidget} annotations.
+ * override the default values given in {@link Component} annotations.
*
* @see WidgetMapGenerator
*
*/
public abstract class CustomWidgetMapGenerator extends WidgetMapGenerator {
- private Collection<Class<? extends Paintable>> eagerPaintables = new HashSet<Class<? extends Paintable>>();
- private Collection<Class<? extends Paintable>> lazyPaintables = new HashSet<Class<? extends Paintable>>();
- private Collection<Class<? extends Paintable>> deferredPaintables = new HashSet<Class<? extends Paintable>>();
+ private Collection<Class<? extends ComponentConnector>> eagerPaintables = new HashSet<Class<? extends ComponentConnector>>();
+ private Collection<Class<? extends ComponentConnector>> lazyPaintables = new HashSet<Class<? extends ComponentConnector>>();
+ private Collection<Class<? extends ComponentConnector>> deferredPaintables = new HashSet<Class<? extends ComponentConnector>>();
@Override
- protected LoadStyle getLoadStyle(Class<? extends Paintable> paintableType) {
+ protected LoadStyle getLoadStyle(Class<? extends ComponentConnector> connector) {
if (eagerPaintables == null) {
init();
}
- if (eagerPaintables.contains(paintableType)) {
+ if (eagerPaintables.contains(connector)) {
return LoadStyle.EAGER;
}
- if (lazyPaintables.contains(paintableType)) {
+ if (lazyPaintables.contains(connector)) {
return LoadStyle.LAZY;
}
- if (deferredPaintables.contains(paintableType)) {
+ if (deferredPaintables.contains(connector)) {
return LoadStyle.DEFERRED;
}
- return super.getLoadStyle(paintableType);
+ return super.getLoadStyle(connector);
}
private void init() {
- Class<? extends Paintable>[] eagerComponents = getEagerComponents();
+ Class<? extends ComponentConnector>[] eagerComponents = getEagerComponents();
if (eagerComponents != null) {
- for (Class<? extends Paintable> class1 : eagerComponents) {
+ for (Class<? extends ComponentConnector> class1 : eagerComponents) {
eagerPaintables.add(class1);
}
}
- Class<? extends Paintable>[] lazyComponents = getEagerComponents();
+ Class<? extends ComponentConnector>[] lazyComponents = getEagerComponents();
if (lazyComponents != null) {
- for (Class<? extends Paintable> class1 : lazyComponents) {
+ for (Class<? extends ComponentConnector> class1 : lazyComponents) {
lazyPaintables.add(class1);
}
}
- Class<? extends Paintable>[] deferredComponents = getEagerComponents();
+ Class<? extends ComponentConnector>[] deferredComponents = getEagerComponents();
if (deferredComponents != null) {
- for (Class<? extends Paintable> class1 : deferredComponents) {
+ for (Class<? extends ComponentConnector> class1 : deferredComponents) {
deferredPaintables.add(class1);
}
}
* @return an array of components whose load style should be overridden to
* {@link LoadStyle#EAGER}
*/
- protected abstract Class<? extends Paintable>[] getEagerComponents();
+ protected abstract Class<? extends ComponentConnector>[] getEagerComponents();
/**
* @return an array of components whose load style should be overridden to
* {@link LoadStyle#LAZY}
*/
- protected abstract Class<? extends Paintable>[] getLazyComponents();
+ protected abstract Class<? extends ComponentConnector>[] getLazyComponents();
/**
* @return an array of components whose load style should be overridden to
* {@link LoadStyle#DEFERRED}
*/
- protected abstract Class<? extends Paintable>[] getDeferredComponents();
+ protected abstract Class<? extends ComponentConnector>[] getDeferredComponents();
}
*/
package com.vaadin.terminal.gwt.widgetsetutils;
-import com.vaadin.terminal.Paintable;
-import com.vaadin.ui.ClientWidget.LoadStyle;
+import com.vaadin.terminal.gwt.client.ComponentConnector;
+import com.vaadin.terminal.gwt.client.ui.Component.LoadStyle;
/**
* WidgetMap generator that builds a widgetset that packs all included widgets
*
*/
public class EagerWidgetMapGenerator extends WidgetMapGenerator {
- @Override
- protected LoadStyle getLoadStyle(Class<? extends Paintable> paintableType) {
- return LoadStyle.EAGER;
+
+
+ @Override
+ protected LoadStyle getLoadStyle(Class<? extends ComponentConnector> connector) {
+ return LoadStyle.EAGER;
}
}
*/
package com.vaadin.terminal.gwt.widgetsetutils;
-import com.vaadin.terminal.Paintable;
-import com.vaadin.ui.ClientWidget.LoadStyle;
+import com.vaadin.terminal.gwt.client.ComponentConnector;
+import com.vaadin.terminal.gwt.client.ui.Component.LoadStyle;
+
/**
* WidgetMap generator that builds a widgetset that optimizes the transferred
*/
public class LazyWidgetMapGenerator extends WidgetMapGenerator {
@Override
- protected LoadStyle getLoadStyle(Class<? extends Paintable> paintableType) {
+ protected LoadStyle getLoadStyle(Class<? extends ComponentConnector> connector) {
return LoadStyle.LAZY;
}
import com.google.gwt.core.ext.typeinfo.TypeOracle;
import com.google.gwt.user.rebind.ClassSourceFileComposerFactory;
import com.google.gwt.user.rebind.SourceWriter;
-import com.vaadin.terminal.Paintable;
import com.vaadin.terminal.gwt.client.ComponentConnector;
+import com.vaadin.terminal.gwt.client.Connector;
+import com.vaadin.terminal.gwt.client.ui.Component;
+import com.vaadin.terminal.gwt.client.ui.Component.LoadStyle;
import com.vaadin.terminal.gwt.client.ui.RootConnector;
import com.vaadin.terminal.gwt.client.ui.UnknownComponentConnector;
-import com.vaadin.ui.ClientWidget;
-import com.vaadin.ui.ClientWidget.LoadStyle;
-import com.vaadin.ui.Root;
+import com.vaadin.terminal.gwt.server.ClientConnector;
/**
* WidgetMapGenerator's are GWT generator to build WidgetMapImpl dynamically
- * based on {@link ClientWidget} annotations available in workspace. By
- * modifying the generator it is possible to do some fine tuning for the
- * generated widgetset (aka client side engine). The components to be included
- * in the client side engine can modified be overriding
- * {@link #getUsedPaintables()}.
+ * based on {@link Component} annotations available in workspace. By modifying
+ * the generator it is possible to do some fine tuning for the generated
+ * widgetset (aka client side engine). The components to be included in the
+ * client side engine can modified be overriding {@link #getUsedConnectors()}.
* <p>
* The generator also decides how the client side component implementations are
* loaded to the browser. The default generator is
* that loads all widget implementation on application initialization. This has
* been the only option until Vaadin 6.4.
* <p>
- * This generator uses the loadStyle hints from the {@link ClientWidget}
+ * This generator uses the loadStyle hints from the {@link Component}
* annotations. Depending on the {@link LoadStyle} used, the widget may be
* included in the initially loaded JavaScript, loaded when the application has
* started and there is no communication to server or lazy loaded when the
*/
public class WidgetMapGenerator extends Generator {
- private static String paintableClassName = ComponentConnector.class
+ private static String componentConnectorClassName = ComponentConnector.class
.getName();
private String packageName;
SourceWriter sourceWriter = composer.createSourceWriter(context,
printWriter);
- Collection<Class<? extends Paintable>> paintablesHavingWidgetAnnotation = getUsedPaintables();
+ Collection<Class<? extends ComponentConnector>> connectors = getUsedConnectors(context
+ .getTypeOracle());
- validatePaintables(logger, context, paintablesHavingWidgetAnnotation);
+ validateConnectors(logger, connectors);
+ logConnectors(logger, context, connectors);
// generator constructor source code
- generateImplementationDetector(sourceWriter,
- paintablesHavingWidgetAnnotation);
- generateInstantiatorMethod(sourceWriter,
- paintablesHavingWidgetAnnotation);
+ generateImplementationDetector(sourceWriter, connectors);
+ generateInstantiatorMethod(sourceWriter, connectors);
// close generated class
sourceWriter.outdent();
sourceWriter.println("}");
}
- /**
- * Verifies that all client side components are available for client side
- * GWT module.
- *
- * @param logger
- * @param context
- * @param paintablesHavingWidgetAnnotation
- */
- private void validatePaintables(
- TreeLogger logger,
- GeneratorContext context,
- Collection<Class<? extends Paintable>> paintablesHavingWidgetAnnotation) {
- TypeOracle typeOracle = context.getTypeOracle();
-
- for (Iterator<Class<? extends Paintable>> iterator = paintablesHavingWidgetAnnotation
- .iterator(); iterator.hasNext();) {
- Class<? extends Paintable> class1 = iterator.next();
-
- Class<? extends com.vaadin.terminal.gwt.client.ComponentConnector> clientClass = getClientClass(class1);
- if (typeOracle.findType(clientClass.getName()) == null) {
- // GWT widget not inherited
- logger.log(Type.WARN, "Widget class " + clientClass.getName()
- + " was not found. The component " + class1.getName()
- + " will not be included in the widgetset.");
- iterator.remove();
+ private void validateConnectors(TreeLogger logger,
+ Collection<Class<? extends ComponentConnector>> connectors) {
+
+ Iterator<Class<? extends ComponentConnector>> iter = connectors
+ .iterator();
+ while (iter.hasNext()) {
+ Class<? extends ComponentConnector> connectorClass = iter.next();
+ Component annotation = connectorClass
+ .getAnnotation(Component.class);
+ if (!ClientConnector.class.isAssignableFrom(annotation.value())) {
+ logger.log(
+ Type.WARN,
+ "Connector class "
+ + annotation.value().getName()
+ + " defined in @Component annotation is not a subclass of "
+ + ClientConnector.class.getName()
+ + ". The component connector "
+ + connectorClass.getName()
+ + " will not be included in the widgetset.");
+ iter.remove();
}
-
}
+
+ }
+
+ private void logConnectors(TreeLogger logger, GeneratorContext context,
+ Collection<Class<? extends ComponentConnector>> connectors) {
logger.log(Type.INFO,
- "Widget set will contain implementations for following components: ");
+ "Widget set will contain implementations for following component connectors: ");
TreeSet<String> classNames = new TreeSet<String>();
HashMap<String, String> loadStyle = new HashMap<String, String>();
- for (Class<? extends Paintable> class1 : paintablesHavingWidgetAnnotation) {
- String className = class1.getCanonicalName();
+ for (Class<? extends ComponentConnector> connectorClass : connectors) {
+ String className = connectorClass.getCanonicalName();
classNames.add(className);
- if (getLoadStyle(class1) == LoadStyle.DEFERRED) {
+ if (getLoadStyle(connectorClass) == LoadStyle.DEFERRED) {
loadStyle.put(className, "DEFERRED");
- } else if (getLoadStyle(class1) == LoadStyle.LAZY) {
+ } else if (getLoadStyle(connectorClass) == LoadStyle.LAZY) {
loadStyle.put(className, "LAZY");
}
* @return a collections of Vaadin components that will be added to
* widgetset
*/
- protected Collection<Class<? extends Paintable>> getUsedPaintables() {
- return ClassPathExplorer.getPaintablesHavingWidgetAnnotation();
+ @SuppressWarnings("unchecked")
+ private Collection<Class<? extends ComponentConnector>> getUsedConnectors(
+ TypeOracle typeOracle) {
+ JClassType connectorType = typeOracle.findType(Connector.class
+ .getName());
+ Collection<Class<? extends ComponentConnector>> connectors = new HashSet<Class<? extends ComponentConnector>>();
+ for (JClassType jClassType : connectorType.getSubtypes()) {
+ Component annotation = jClassType.getAnnotation(Component.class);
+ if (annotation != null) {
+ try {
+ Class<? extends ComponentConnector> clazz = (Class<? extends ComponentConnector>) Class
+ .forName(jClassType.getQualifiedSourceName());
+ connectors.add(clazz);
+ } catch (ClassNotFoundException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+ return connectors;
}
/**
* Returns true if the widget for given component will be lazy loaded by the
* client. The default implementation reads the information from the
- * {@link ClientWidget} annotation.
+ * {@link Component} annotation.
* <p>
* The method can be overridden to optimize the widget loading mechanism. If
* the Widgetset is wanted to be optimized for a network with a high latency
* or for a one with a very fast throughput, it may be good to return false
* for every component.
*
- * @param paintableType
+ * @param connector
* @return true iff the widget for given component should be lazy loaded by
* the client side engine
*/
- protected LoadStyle getLoadStyle(Class<? extends Paintable> paintableType) {
- if (Root.class == paintableType) {
- return LoadStyle.EAGER;
- }
- ClientWidget annotation = paintableType
- .getAnnotation(ClientWidget.class);
+ protected LoadStyle getLoadStyle(
+ Class<? extends ComponentConnector> connector) {
+ Component annotation = connector.getAnnotation(Component.class);
return annotation.loadStyle();
}
private void generateInstantiatorMethod(
SourceWriter sourceWriter,
- Collection<Class<? extends Paintable>> paintablesHavingWidgetAnnotation) {
+ Collection<Class<? extends ComponentConnector>> connectorsHavingComponentAnnotation) {
Collection<Class<?>> deferredWidgets = new LinkedList<Class<?>>();
// lookup with index than with the hashmap
sourceWriter.println("public void ensureInstantiator(Class<? extends "
- + paintableClassName + "> classType) {");
+ + componentConnectorClassName + "> classType) {");
sourceWriter.println("if(!instmap.containsKey(classType)){");
boolean first = true;
- ArrayList<Class<? extends Paintable>> lazyLoadedWidgets = new ArrayList<Class<? extends Paintable>>();
+ ArrayList<Class<? extends ComponentConnector>> lazyLoadedWidgets = new ArrayList<Class<? extends ComponentConnector>>();
- HashSet<Class<? extends com.vaadin.terminal.gwt.client.ComponentConnector>> widgetsWithInstantiator = new HashSet<Class<? extends com.vaadin.terminal.gwt.client.ComponentConnector>>();
+ HashSet<Class<? extends com.vaadin.terminal.gwt.client.ComponentConnector>> connectorsWithInstantiator = new HashSet<Class<? extends com.vaadin.terminal.gwt.client.ComponentConnector>>();
- for (Class<? extends Paintable> class1 : paintablesHavingWidgetAnnotation) {
- Class<? extends com.vaadin.terminal.gwt.client.ComponentConnector> clientClass = getClientClass(class1);
- if (widgetsWithInstantiator.contains(clientClass)) {
+ for (Class<? extends ComponentConnector> class1 : connectorsHavingComponentAnnotation) {
+ Class<? extends ComponentConnector> clientClass = class1;
+ if (connectorsWithInstantiator.contains(clientClass)) {
continue;
}
if (clientClass == RootConnector.class) {
+ ".class) {");
String instantiator = "new WidgetInstantiator() {\n public "
- + paintableClassName + " get() {\n return GWT.create("
- + clientClass.getName() + ".class );\n}\n}\n";
+ + componentConnectorClassName
+ + " get() {\n return GWT.create(" + clientClass.getName()
+ + ".class );\n}\n}\n";
LoadStyle loadStyle = getLoadStyle(class1);
sourceWriter.print(");");
}
sourceWriter.print("}");
- widgetsWithInstantiator.add(clientClass);
+ connectorsWithInstantiator.add(clientClass);
}
sourceWriter.println("}");
sourceWriter.println("}");
- sourceWriter.println("public Class<? extends " + paintableClassName
+ sourceWriter.println("public Class<? extends "
+ + componentConnectorClassName
+ ">[] getDeferredLoadedWidgets() {");
sourceWriter.println("return new Class[] {");
sourceWriter.println(",");
}
first = false;
- ClientWidget annotation = class2.getAnnotation(ClientWidget.class);
- Class<? extends com.vaadin.terminal.gwt.client.ComponentConnector> value = annotation
- .value();
- sourceWriter.print(value.getName() + ".class");
+ sourceWriter.print(class2.getName() + ".class");
}
sourceWriter.println("};");
// TODO an index of last ensured widget in array
- sourceWriter.println("public " + paintableClassName
- + " instantiate(Class<? extends " + paintableClassName
+ sourceWriter.println("public " + componentConnectorClassName
+ + " instantiate(Class<? extends " + componentConnectorClassName
+ "> classType) {");
sourceWriter.indent();
- sourceWriter.println(paintableClassName
+ sourceWriter.println(componentConnectorClassName
+ " p = super.instantiate(classType); if(p!= null) return p;");
sourceWriter.println("return instmap.get(classType).get();");
*/
private void generateImplementationDetector(
SourceWriter sourceWriter,
- Collection<Class<? extends Paintable>> paintablesHavingWidgetAnnotation) {
+ Collection<Class<? extends ComponentConnector>> paintablesHavingWidgetAnnotation) {
sourceWriter
.println("public Class<? extends "
- + paintableClassName
+ + componentConnectorClassName
+ "> "
- + "getImplementationByServerSideClassName(String fullyQualifiedName) {");
+ + "getConnectorClassForServerSideClassName(String fullyQualifiedName) {");
sourceWriter.indent();
sourceWriter
.println("fullyQualifiedName = fullyQualifiedName.intern();");
- for (Class<? extends Paintable> class1 : paintablesHavingWidgetAnnotation) {
- Class<? extends com.vaadin.terminal.gwt.client.ComponentConnector> clientClass = getClientClass(class1);
+ for (Class<? extends ComponentConnector> connectorClass : paintablesHavingWidgetAnnotation) {
+ Class<? extends ClientConnector> clientConnectorClass = getClientConnectorClass(connectorClass);
sourceWriter.print("if ( fullyQualifiedName == \"");
- sourceWriter.print(class1.getName());
+ sourceWriter.print(clientConnectorClass.getName());
sourceWriter.print("\" ) { ensureInstantiator("
- + clientClass.getName() + ".class); return ");
- sourceWriter.print(clientClass.getName());
+ + connectorClass.getName() + ".class); return ");
+ sourceWriter.print(connectorClass.getName());
sourceWriter.println(".class;}");
sourceWriter.print("else ");
}
}
- private static Class<? extends com.vaadin.terminal.gwt.client.ComponentConnector> getClientClass(
- Class<? extends Paintable> class1) {
- Class<? extends com.vaadin.terminal.gwt.client.ComponentConnector> clientClass;
- if (Root.class == class1) {
- clientClass = RootConnector.class;
- } else {
- ClientWidget annotation = class1.getAnnotation(ClientWidget.class);
- clientClass = annotation.value();
- }
- return clientClass;
+ private static Class<? extends ClientConnector> getClientConnectorClass(
+ Class<? extends ComponentConnector> connectorClass) {
+ Component annotation = connectorClass.getAnnotation(Component.class);
+ return (Class<? extends ClientConnector>) annotation.value();
}
}
*
*/
@SuppressWarnings("serial")
-@ClientWidget(AbsoluteLayoutConnector.class)
public class AbsoluteLayout extends AbstractLayout implements
LayoutClickNotifier {
*/
package com.vaadin.ui;
-import com.vaadin.terminal.gwt.client.ui.AccordionConnector;
-
/**
* An accordion is a component similar to a {@link TabSheet}, but with a
* vertical orientation and the selected component presented between tabs.
*
* @see TabSheet
*/
-@ClientWidget(AccordionConnector.class)
public class Accordion extends TabSheet {
}
package com.vaadin.ui;
import com.vaadin.terminal.Resource;
-import com.vaadin.terminal.gwt.client.ui.AudioConnector;
/**
* The Audio component translates into an HTML5 <audio> element and as
* @author Vaadin Ltd
* @since 6.7.0
*/
-@ClientWidget(AudioConnector.class)
public class Audio extends AbstractMedia {
public Audio() {
import com.vaadin.event.ShortcutListener;
import com.vaadin.terminal.gwt.client.ComponentState;
import com.vaadin.terminal.gwt.client.MouseEventDetails;
-import com.vaadin.terminal.gwt.client.ui.ButtonConnector;
import com.vaadin.terminal.gwt.client.ui.ButtonConnector.ButtonServerRpc;
import com.vaadin.terminal.gwt.client.ui.ButtonState;
import com.vaadin.tools.ReflectTools;
-import com.vaadin.ui.ClientWidget.LoadStyle;
import com.vaadin.ui.Component.Focusable;
/**
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(value = ButtonConnector.class, loadStyle = LoadStyle.EAGER)
public class Button extends AbstractComponent implements
FieldEvents.BlurNotifier, FieldEvents.FocusNotifier, Focusable,
Action.ShortcutNotifier {
import com.vaadin.event.FieldEvents.FocusListener;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.gwt.client.ui.CheckBoxConnector;
import com.vaadin.terminal.gwt.client.ui.VCheckBox;
-@ClientWidget(CheckBoxConnector.class)
public class CheckBox extends AbstractField<Boolean> {
/**
* Creates a new checkbox.
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-/**
- *
- */
-package com.vaadin.ui;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-import com.vaadin.terminal.gwt.client.ComponentConnector;
-import com.vaadin.terminal.gwt.widgetsetutils.CustomWidgetMapGenerator;
-import com.vaadin.terminal.gwt.widgetsetutils.EagerWidgetMapGenerator;
-import com.vaadin.terminal.gwt.widgetsetutils.LazyWidgetMapGenerator;
-import com.vaadin.terminal.gwt.widgetsetutils.WidgetMapGenerator;
-
-/**
- * Annotation defining the default client side counterpart in GWT terminal for
- * {@link Component}.
- * <p>
- * With this annotation server side Vaadin component is marked to have a client
- * side counterpart. The value of the annotation is the class of client side
- * implementation.
- * <p>
- * Note, even though client side implementation is needed during development,
- * one may safely remove them from the classpath of the production server.
- *
- * @since 6.2
- */
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.TYPE)
-public @interface ClientWidget {
- /**
- * @return the client side counterpart for the annotated component
- */
- Class<? extends ComponentConnector> value();
-
- /**
- * Depending on the used WidgetMap generator, these optional hints may be
- * used to define how the client side components are loaded by the browser.
- * The default is to eagerly load all widgets
- * {@link EagerWidgetMapGenerator}, but if the {@link WidgetMapGenerator} is
- * used by the widgetset, these load style hints are respected.
- * <p>
- * Lazy loading of a widget implementation means the client side component
- * is not included in the initial JavaScript application loaded when the
- * application starts. Instead the implementation is loaded to the client
- * when it is first needed. Lazy loaded widget can be achieved by giving
- * {@link LoadStyle#LAZY} value in ClientWidget annotation.
- * <p>
- * Lazy loaded widgets don't stress the size and startup time of the client
- * side as much as eagerly loaded widgets. On the other hand there is a
- * slight latency when lazy loaded widgets are first used as the client side
- * needs to visit the server to fetch the client side implementation.
- * <p>
- * The {@link LoadStyle#DEFERRED} will also not stress the initially loaded
- * JavaScript file. If this load style is defined, the widget implementation
- * is preemptively loaded to the browser after the application is started
- * and the communication to server idles. This load style kind of combines
- * the best of both worlds.
- * <p>
- * Fine tunings to widget loading can also be made by overriding
- * {@link WidgetMapGenerator} in the GWT module. Tunings might be helpful if
- * the end users have slow connections and especially if they have high
- * latency in their network. The {@link CustomWidgetMapGenerator} is an
- * abstract generator implementation for easy customization. Vaadin package
- * also includes {@link LazyWidgetMapGenerator} that makes as many widgets
- * lazily loaded as possible.
- *
- * @since 6.4
- *
- * @return the hint for the widget set generator how the client side
- * implementation should be loaded to the browser
- */
- LoadStyle loadStyle() default LoadStyle.DEFERRED;
-
- public enum LoadStyle {
- /**
- * The widget is included in the initial JS sent to the client.
- */
- EAGER,
- /**
- * Not included in the initial set of widgets, but added to queue from
- * which it will be loaded when network is not busy or the
- * implementation is required.
- */
- DEFERRED,
- /**
- * Loaded to the client only if needed.
- */
- LAZY
- }
-
-}
import com.vaadin.data.Container;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.gwt.client.ui.ComboBoxConnector;
import com.vaadin.terminal.gwt.client.ui.VFilterSelect;
/**
*
*/
@SuppressWarnings("serial")
-@ClientWidget(ComboBoxConnector.class)
public class ComboBox extends Select {
private String inputPrompt = null;
* @since 6.1 brought in from "FastLayouts" incubator project
*
*/
-@ClientWidget(CssLayoutConnector.class)
public class CssLayout extends AbstractLayout implements LayoutClickNotifier {
private CssLayoutServerRPC rpc = new CssLayoutServerRPC() {
import java.io.Serializable;
import java.util.Iterator;
-import com.vaadin.terminal.gwt.client.ui.CustomComponentConnector;
-import com.vaadin.ui.ClientWidget.LoadStyle;
-
/**
* Custom component provides simple implementation of Component interface for
* creation of new UI components by composition of existing components.
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(value = CustomComponentConnector.class, loadStyle = LoadStyle.EAGER)
public class CustomComponent extends AbstractComponentContainer {
/**
import com.vaadin.data.Property;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.gwt.client.ui.CustomComponentConnector;
/**
* A {@link Field} whose UI content can be constructed by the user, enabling the
*
* @since 7.0
*/
-@ClientWidget(CustomComponentConnector.class)
public abstract class CustomField<T> extends AbstractField<T> implements
ComponentContainer {
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.gwt.client.ui.CustomLayoutConnector;
/**
* <p>
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(CustomLayoutConnector.class)
public class CustomLayout extends AbstractLayout {
private static final int BUFFER_SIZE = 10000;
import com.vaadin.event.FieldEvents.FocusListener;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.gwt.client.ui.PopupDateFieldConnector;
import com.vaadin.terminal.gwt.client.ui.VDateField;
/**
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(PopupDateFieldConnector.class)
public class DateField extends AbstractField<Date> implements
FieldEvents.BlurNotifier, FieldEvents.FocusNotifier {
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.StreamVariable;
import com.vaadin.terminal.gwt.client.MouseEventDetails;
-import com.vaadin.terminal.gwt.client.ui.DragAndDropWrapperConnector;
import com.vaadin.terminal.gwt.client.ui.VDragAndDropWrapper;
import com.vaadin.terminal.gwt.client.ui.dd.HorizontalDropLocation;
import com.vaadin.terminal.gwt.client.ui.dd.VerticalDropLocation;
@SuppressWarnings("serial")
-@ClientWidget(DragAndDropWrapperConnector.class)
public class DragAndDropWrapper extends CustomComponent implements DropTarget,
DragSource {
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(EmbeddedConnector.class)
public class Embedded extends AbstractComponent {
/**
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.UserError;
-import com.vaadin.terminal.gwt.client.ui.FormConnector;
/**
* Form component provides easy way of creating and managing sets fields.
* @deprecated Use {@link FieldGroup} instead of {@link Form} for more
* flexibility.
*/
-@ClientWidget(FormConnector.class)
@Deprecated
public class Form extends AbstractField<Object> implements Item.Editor,
Buffered, Item, Validatable, Action.Notifier, HasComponents {
package com.vaadin.ui;
-import com.vaadin.terminal.gwt.client.ui.FormLayoutConnector;
/**
* FormLayout is used by {@link Form} to layout fields. It may also be used
* bottom are by default on.
*
*/
-@ClientWidget(FormLayoutConnector.class)
public class FormLayout extends AbstractOrderedLayout {
public FormLayout() {
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(GridLayoutConnector.class)
public class GridLayout extends AbstractLayout implements
Layout.AlignmentHandler, Layout.SpacingHandler, LayoutClickNotifier {
*/
package com.vaadin.ui;
-import com.vaadin.terminal.gwt.client.ui.HorizontalLayoutConnector;
-import com.vaadin.ui.ClientWidget.LoadStyle;
/**
* Horizontal layout
* @since 5.3
*/
@SuppressWarnings("serial")
-@ClientWidget(value = HorizontalLayoutConnector.class, loadStyle = LoadStyle.EAGER)
public class HorizontalLayout extends AbstractOrderedLayout {
public HorizontalLayout() {
*/
package com.vaadin.ui;
-import com.vaadin.terminal.gwt.client.ui.HorizontalSplitPanelConnector;
-import com.vaadin.ui.ClientWidget.LoadStyle;
/**
* A horizontal split panel contains two components and lays them horizontally.
* @VERSION@
* @since 6.5
*/
-@ClientWidget(value = HorizontalSplitPanelConnector.class, loadStyle = LoadStyle.EAGER)
public class HorizontalSplitPanel extends AbstractSplitPanel {
public HorizontalSplitPanel() {
super();
import java.util.Date;
import com.vaadin.data.Property;
-import com.vaadin.terminal.gwt.client.ui.InlineDateFieldConnector;
/**
* <p>
* @VERSION@
* @since 5.0
*/
-@ClientWidget(InlineDateFieldConnector.class)
public class InlineDateField extends DateField {
public InlineDateField() {
import com.vaadin.data.util.ObjectProperty;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.gwt.client.ui.label.LabelConnector;
-import com.vaadin.ui.ClientWidget.LoadStyle;
/**
* Label component for showing non-editable short texts.
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(value = LabelConnector.class, loadStyle = LoadStyle.EAGER)
// TODO generics for interface Property
public class Label extends AbstractComponent implements Property,
Property.Viewer, Property.ValueChangeListener,
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.Resource;
-import com.vaadin.terminal.gwt.client.ui.LinkConnector;
/**
* Link is used to create external or internal URL links.
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(LinkConnector.class)
public class Link extends AbstractComponent {
/* Target window border type constant: No window border */
import com.vaadin.data.Container;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.gwt.client.ui.ListSelectConnector;
/**
* This is a simple list select without, for instance, support for new items,
* lazyloading, and other advanced features.
*/
@SuppressWarnings("serial")
-@ClientWidget(ListSelectConnector.class)
public class ListSelect extends AbstractSelect {
private int columns = 0;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.Resource;
-import com.vaadin.terminal.gwt.client.ui.MenuBarConnector;
import com.vaadin.terminal.gwt.client.ui.VMenuBar;
-import com.vaadin.ui.ClientWidget.LoadStyle;
/**
* <p>
* </p>
*/
@SuppressWarnings("serial")
-@ClientWidget(value = MenuBarConnector.class, loadStyle = LoadStyle.LAZY)
public class MenuBar extends AbstractComponent {
// Items of the top-level menu
*/
package com.vaadin.ui;
-import com.vaadin.terminal.gwt.client.ui.NativeButtonConnector;
@SuppressWarnings("serial")
-@ClientWidget(NativeButtonConnector.class)
public class NativeButton extends Button {
public NativeButton() {
import com.vaadin.data.Container;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.gwt.client.ui.NativeSelectConnector;
/**
* This is a simple drop-down select without, for instance, support for
* better choice.
*/
@SuppressWarnings("serial")
-@ClientWidget(NativeSelectConnector.class)
public class NativeSelect extends AbstractSelect {
// width in characters, mimics TextField
import com.vaadin.event.FieldEvents.FocusListener;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.gwt.client.ui.OptionGroupConnector;
import com.vaadin.terminal.gwt.client.ui.VOptionGroup;
/**
* Configures select to be used as an option group.
*/
@SuppressWarnings("serial")
-@ClientWidget(OptionGroupConnector.class)
public class OptionGroup extends AbstractSelect implements
FieldEvents.BlurNotifier, FieldEvents.FocusNotifier {
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(PanelConnector.class)
public class Panel extends AbstractComponentContainer implements Scrollable,
ComponentContainer.ComponentAttachListener,
ComponentContainer.ComponentDetachListener, Action.Notifier, Focusable {
package com.vaadin.ui;
import com.vaadin.data.Property;
-import com.vaadin.terminal.gwt.client.ui.PasswordFieldConnector;
/**
* A field that is used to enter secret text information like passwords. The
* entered text is not displayed on the screen.
*/
-@ClientWidget(PasswordFieldConnector.class)
public class PasswordField extends AbstractTextField {
/**
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.gwt.client.ui.PopupViewConnector;
/**
*
* @author Vaadin Ltd.
*/
@SuppressWarnings("serial")
-@ClientWidget(PopupViewConnector.class)
public class PopupView extends AbstractComponentContainer {
private Content content;
import com.vaadin.data.util.ObjectProperty;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.gwt.client.ui.ProgressIndicatorConnector;
/**
* <code>ProgressIndicator</code> is component that shows user state of a
* @since 4
*/
@SuppressWarnings("serial")
-@ClientWidget(ProgressIndicatorConnector.class)
public class ProgressIndicator extends AbstractField<Number> implements
Property.Viewer, Property.ValueChangeListener {
import com.vaadin.data.Property;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.gwt.client.ui.richtextarea.RichTextAreaConnector;
-import com.vaadin.ui.ClientWidget.LoadStyle;
/**
* A simple RichTextArea to edit HTML format text.
* {@link RichTextArea} may produce unexpected results as formatting is counted
* into length of field.
*/
-@ClientWidget(value = RichTextAreaConnector.class, loadStyle = LoadStyle.LAZY)
public class RichTextArea extends AbstractField<String> {
/**
*
* @since 7.0
*/
-// @ClientWidget(View.class) - Can't have annotation because of eager
-// classloaders in application servers and hard coded logic in client side code
public abstract class Root extends AbstractComponentContainer implements
Action.Container, Action.Notifier {
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.Resource;
-import com.vaadin.terminal.gwt.client.ui.ComboBoxConnector;
/**
* <p>
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(ComboBoxConnector.class)
public class Select extends AbstractSelect implements AbstractSelect.Filtering,
FieldEvents.BlurNotifier, FieldEvents.FocusNotifier {
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.gwt.client.ui.SliderConnector;
/**
* A component for selecting a numerical value within a range.
*
* @author Vaadin Ltd.
*/
-@ClientWidget(SliderConnector.class)
public class Slider extends AbstractField<Double> {
public static final int ORIENTATION_HORIZONTAL = 0;
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.Resource;
import com.vaadin.terminal.gwt.client.ui.TabsheetBaseConnector;
-import com.vaadin.terminal.gwt.client.ui.TabsheetConnector;
import com.vaadin.terminal.gwt.client.ui.VTabsheet;
import com.vaadin.ui.Component.Focusable;
import com.vaadin.ui.themes.Reindeer;
* @VERSION@
* @since 3.0
*/
-@ClientWidget(TabsheetConnector.class)
public class TabSheet extends AbstractComponentContainer implements Focusable,
FocusNotifier, BlurNotifier {
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.Resource;
import com.vaadin.terminal.gwt.client.MouseEventDetails;
-import com.vaadin.terminal.gwt.client.ui.TableConnector;
import com.vaadin.terminal.gwt.client.ui.VScrollTable;
import com.vaadin.terminal.gwt.client.ui.dd.VLazyInitItemIdentifiers;
* @since 3.0
*/
@SuppressWarnings({ "deprecation" })
-@ClientWidget(TableConnector.class)
public class Table extends AbstractSelect implements Action.Container,
Container.Ordered, Container.Sortable, ItemClickSource,
ItemClickNotifier, DragSource, DropTarget, HasComponents {
import com.vaadin.data.Property;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.gwt.client.ui.TextAreaConnector;
/**
* A text field that supports multi line editing.
*/
-@ClientWidget(TextAreaConnector.class)
public class TextArea extends AbstractTextField {
private static final int DEFAULT_ROWS = 5;
package com.vaadin.ui;
import com.vaadin.data.Property;
-import com.vaadin.terminal.gwt.client.ui.TextFieldConnector;
-import com.vaadin.ui.ClientWidget.LoadStyle;
/**
* <p>
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(value = TextFieldConnector.class, loadStyle = LoadStyle.EAGER)
public class TextField extends AbstractTextField {
/**
* @since 3.0
*/
@SuppressWarnings({ "serial", "deprecation" })
-@ClientWidget(TreeConnector.class)
public class Tree extends AbstractSelect implements Container.Hierarchical,
Action.Container, ItemClickSource, ItemClickNotifier, DragSource,
DropTarget {
import java.util.Map;
import java.util.logging.Logger;
-import com.google.gwt.user.client.ui.Tree;
import com.vaadin.data.Container;
import com.vaadin.data.Container.Hierarchical;
import com.vaadin.data.Container.ItemSetChangeEvent;
* share UI state in the container.
*/
@SuppressWarnings({ "serial" })
-@ClientWidget(TreeTableConnector.class)
public class TreeTable extends Table implements Hierarchical {
private static final Logger logger = Logger.getLogger(TreeTable.class
import com.vaadin.data.Container;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.gwt.client.ui.TwinColSelectConnector;
import com.vaadin.terminal.gwt.client.ui.VTwinColSelect;
/**
* side for selected items.
*/
@SuppressWarnings("serial")
-@ClientWidget(TwinColSelectConnector.class)
public class TwinColSelect extends AbstractSelect {
private int columns = 0;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.StreamVariable.StreamingProgressEvent;
-import com.vaadin.terminal.gwt.client.ui.UploadConnector;
import com.vaadin.terminal.gwt.server.NoInputStreamException;
import com.vaadin.terminal.gwt.server.NoOutputStreamException;
-import com.vaadin.ui.ClientWidget.LoadStyle;
/**
* Component for uploading files from client to server.
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(value = UploadConnector.class, loadStyle = LoadStyle.LAZY)
public class Upload extends AbstractComponent implements Component.Focusable {
/**
*/
package com.vaadin.ui;
-import com.vaadin.terminal.gwt.client.ui.VerticalLayoutConnector;
-import com.vaadin.ui.ClientWidget.LoadStyle;
-
/**
* Vertical layout
*
* @since 5.3
*/
@SuppressWarnings("serial")
-@ClientWidget(value = VerticalLayoutConnector.class, loadStyle = LoadStyle.EAGER)
public class VerticalLayout extends AbstractOrderedLayout {
public VerticalLayout() {
*/
package com.vaadin.ui;
-import com.vaadin.terminal.gwt.client.ui.VerticalSplitPanelConnector;
-import com.vaadin.ui.ClientWidget.LoadStyle;
/**
* A vertical split panel contains two components and lays them vertically. The
* </pre>
*
*/
-@ClientWidget(value = VerticalSplitPanelConnector.class, loadStyle = LoadStyle.EAGER)
public class VerticalSplitPanel extends AbstractSplitPanel {
public VerticalSplitPanel() {
* @author Vaadin Ltd
* @since 6.7.0
*/
-@ClientWidget(VideoConnector.class)
public class Video extends AbstractMedia {
private Resource poster;
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(WindowConnector.class)
public class Window extends Panel implements FocusNotifier, BlurNotifier {
/**
import com.vaadin.event.dd.acceptcriteria.AcceptAll;
import com.vaadin.event.dd.acceptcriteria.AcceptCriterion;
import com.vaadin.ui.AbstractComponent;
-import com.vaadin.ui.ClientWidget;
import com.vaadin.ui.Component;
import com.vaadin.ui.CssLayout;
import com.vaadin.ui.CustomComponent;
* Check the @ClientWidget
*
*/
- @ClientWidget(MyDropTargetConnector.class)
class MyDropTarget extends AbstractComponent implements DropTarget {
public DropHandler getDropHandler() {
return new DropHandler() {
* operations that are controlled via server side api.
*
*/
- @ClientWidget(MyDragSourceConnector.class)
public class MyDragSource extends AbstractComponent implements Component {
}
import com.vaadin.terminal.gwt.client.ApplicationConnection;
import com.vaadin.terminal.gwt.client.UIDL;
import com.vaadin.terminal.gwt.client.ui.AbstractComponentConnector;
+import com.vaadin.terminal.gwt.client.ui.Component;
+import com.vaadin.tests.dd.CustomDDImplementation.MyDragSource;
+@Component(MyDragSource.class)
public class MyDragSourceConnector extends AbstractComponentConnector {
@Override
import com.vaadin.terminal.gwt.client.UIDL;
import com.vaadin.terminal.gwt.client.ui.AbstractComponentConnector;
+import com.vaadin.terminal.gwt.client.ui.Component;
+import com.vaadin.tests.dd.CustomDDImplementation.MyDropTarget;
+
+@Component(MyDropTarget.class)
public class MyDropTargetConnector extends AbstractComponentConnector {
@Override
projects / vaadin-framework.git / commitdiff