import com.google.gwt.core.client.Scheduler.ScheduledCommand;
import com.google.gwt.user.client.Command;
import com.google.gwt.user.client.Timer;
-import com.vaadin.terminal.gwt.client.ui.VUnknownComponentPaintable;
+import com.vaadin.terminal.gwt.client.ui.UnknownComponentConnector;
public class ApplicationConfiguration implements EntryPoint {
return classes[parseInt];
} catch (Exception e) {
// component was not present in mappings
- return VUnknownComponentPaintable.class;
+ return UnknownComponentConnector.class;
}
}
String key = keyArray.get(i).intern();
int value = valueMap.getInt(key);
classes[value] = widgetSet.getImplementationByClassName(key);
- if (classes[value] == VUnknownComponentPaintable.class) {
+ if (classes[value] == UnknownComponentConnector.class) {
if (unknownComponents == null) {
unknownComponents = new HashMap<String, String>();
}
import com.google.gwt.user.client.ui.HasWidgets;
import com.google.gwt.user.client.ui.Widget;
import com.vaadin.terminal.gwt.client.ApplicationConfiguration.ErrorMessage;
-import com.vaadin.terminal.gwt.client.RenderInformation.FloatSize;
-import com.vaadin.terminal.gwt.client.RenderInformation.Size;
import com.vaadin.terminal.gwt.client.communication.JsonDecoder;
import com.vaadin.terminal.gwt.client.communication.JsonEncoder;
import com.vaadin.terminal.gwt.client.communication.MethodInvocation;
import com.vaadin.terminal.gwt.client.communication.SharedState;
+import com.vaadin.terminal.gwt.client.ui.RootConnector;
import com.vaadin.terminal.gwt.client.ui.VContextMenu;
import com.vaadin.terminal.gwt.client.ui.VNotification;
import com.vaadin.terminal.gwt.client.ui.VNotification.HideEvent;
-import com.vaadin.terminal.gwt.client.ui.VViewPaintable;
import com.vaadin.terminal.gwt.client.ui.dd.VDragAndDropManager;
import com.vaadin.terminal.gwt.server.AbstractCommunicationManager;
*
* Client-side widgets receive updates from the corresponding server-side
* components as calls to
- * {@link ComponentConnector#updateFromUIDL(UIDL, ApplicationConnection)} (not to
- * be confused with the server side interface
+ * {@link ComponentConnector#updateFromUIDL(UIDL, ApplicationConnection)} (not
+ * to be confused with the server side interface
* {@link com.vaadin.terminal.Paintable} ). Any client-side changes (typically
* resulting from user actions) are sent back to the server as variable changes
* (see {@link #updateVariable()}).
private Timer loadTimer3;
private Element loadElement;
- private final VViewPaintable view;
+ private final RootConnector view;
protected boolean applicationRunning = false;
private final LayoutManager layoutManager = new LayoutManager(this);
public ApplicationConnection() {
- view = GWT.create(VViewPaintable.class);
+ view = GWT.create(RootConnector.class);
view.setConnection(this);
}
if (loadElement == null) {
loadElement = DOM.createDiv();
DOM.setStyleAttribute(loadElement, "position", "absolute");
- DOM.appendChild(view.getWidget().getElement(),
- loadElement);
+ DOM.appendChild(view.getWidget().getElement(), loadElement);
VConsole.log("inserting load indicator");
}
DOM.setElementProperty(loadElement, "className", "v-loading-indicator");
protected void handleUIDLMessage(final Date start, final String jsonText,
final ValueMap json) {
+ VConsole.log("Handling message from server");
// Handle redirect
if (json.containsKey("redirect")) {
String url = json.getValueMap("redirect").getString("url");
VConsole.dirUIDL(json, configuration);
if (json.containsKey("locales")) {
+ VConsole.log(" * Handling locales");
// Store locale data
JsArray<ValueMap> valueMapArray = json
.getJSValueMapArray("locales");
boolean repaintAll = false;
ValueMap meta = null;
if (json.containsKey("meta")) {
+ VConsole.log(" * Handling meta information");
meta = json.getValueMap("meta");
if (meta.containsKey("repaintAll")) {
repaintAll = true;
int length = changes.length();
+ VConsole.log(" * Creating connectors (if needed)");
// create paintables if necessary
for (int i = 0; i < length; i++) {
try {
}
}
+ VConsole.log(" * Updating connector states");
// set states for all paintables mentioned in "state"
ValueMap states = json.getValueMap("state");
JsArrayString keyArray = states.getKeyArray();
}
}
+ VConsole.log(" * Passing UIDL to Vaadin 6 style connectors");
// update paintables
for (int i = 0; i < length; i++) {
try {
}
/**
- * Gets the main view, a.k.a top-level window.
+ * Gets the main view
*
* @return the main view
*/
- public VViewPaintable getView() {
+ public RootConnector getView() {
return view;
}
return element.vMeasuredSize || defaultSize;
}-*/;
- private static final MeasuredSize getMeasuredSize(ComponentConnector paintable) {
+ private static final MeasuredSize getMeasuredSize(
+ ComponentConnector paintable) {
Element element = paintable.getWidget().getElement();
MeasuredSize measuredSize = getMeasuredSize(element, null);
if (measuredSize == null) {
}
public void doLayout() {
+ VConsole.log("Starting layout phase");
+
ConnectorMap paintableMap = connection.getConnectorMap();
ComponentConnector[] paintableWidgets = paintableMap
.getRegisteredComponentConnectors();
}
}
+ VConsole.log("Layout phase done");
+ VConsole.log("Calling post layout listeners");
+
for (ComponentConnector vPaintableWidget : paintableWidgets) {
if (vPaintableWidget instanceof PostLayoutListener) {
((PostLayoutListener) vPaintableWidget).postLayout();
}
}
- VConsole.log("Total layout time: " + totalDuration.elapsedMillis()
- + "ms");
+ VConsole.log("Total layout phase time: "
+ + totalDuration.elapsedMillis() + "ms");
}
private void measureElements(ComponentConnector[] paintableWidgets) {
for (ComponentConnector paintableWidget : paintableWidgets) {
- Element element = paintableWidget.getWidget()
- .getElement();
+ Element element = paintableWidget.getWidget().getElement();
MeasuredSize measuredSize = getMeasuredSize(paintableWidget);
measuredAndUpdate(element, measuredSize);
}
boolean wasWidthChanged = widthChanged;
ComputedStyle computedStyle = new ComputedStyle(element);
-
int[] paddings = computedStyle.getPadding();
if (!heightChanged && hasHeightChanged(this.paddings, paddings)) {
heightChanged = true;
setOuterHeight(requiredHeight + marginHeight);
int requiredWidth = Util.getRequiredWidth(element);
+ VConsole.log("Width of " + element.toString() + " is " + requiredWidth);
int marginWidth = sumWidths(margins);
setOuterWidth(requiredWidth + marginWidth);
import com.google.gwt.user.client.ui.HTML;
import com.vaadin.terminal.gwt.client.ui.Icon;
import com.vaadin.terminal.gwt.client.ui.AbstractComponentConnector;
-import com.vaadin.terminal.gwt.client.ui.VTabsheetBasePaintable;
+import com.vaadin.terminal.gwt.client.ui.TabsheetBaseConnector;
public class VCaption extends HTML {
} else {
// TODO fallback for cases where the caption has no owner (Tabsheet,
// Accordion)
- if (uidl.getStringAttribute(VTabsheetBasePaintable.ATTRIBUTE_TAB_CAPTION) != null) {
+ if (uidl.getStringAttribute(TabsheetBaseConnector.ATTRIBUTE_TAB_CAPTION) != null) {
return true;
}
}
import com.google.gwt.event.dom.client.MouseOutHandler;
import com.google.gwt.user.client.ui.RootPanel;
import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ui.VUnknownComponentPaintable;
+import com.vaadin.terminal.gwt.client.ui.UnknownComponentConnector;
import com.vaadin.terminal.gwt.client.ui.VWindow;
public class VUIDLBrowser extends SimpleTree {
String name) {
Class<? extends ComponentConnector> widgetClassByDecodedTag = conf
.getWidgetClassByEncodedTag(name);
- if (widgetClassByDecodedTag == VUnknownComponentPaintable.class) {
+ if (widgetClassByDecodedTag == UnknownComponentConnector.class) {
return conf.getUnknownServerClassNameByEncodedTagName(name)
+ "(NO CLIENT IMPLEMENTATION FOUND)";
} else {
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ui.VUnknownComponentPaintable;
+import com.vaadin.terminal.gwt.client.ui.UnknownComponentConnector;
public class WidgetSet {
Class<? extends ComponentConnector> classType = resolveWidgetType(tag,
conf);
- if (classType == null || classType == VUnknownComponentPaintable.class) {
+ if (classType == null || classType == UnknownComponentConnector.class) {
String serverSideName = conf
.getUnknownServerClassNameByEncodedTagName(tag);
- VUnknownComponentPaintable c = GWT
- .create(VUnknownComponentPaintable.class);
+ UnknownComponentConnector c = GWT
+ .create(UnknownComponentConnector.class);
c.setServerSideClassName(serverSideName);
return c;
} else {
public Class<? extends ComponentConnector> getImplementationByClassName(
String fullyqualifiedName) {
if (fullyqualifiedName == null) {
- return VUnknownComponentPaintable.class;
+ return UnknownComponentConnector.class;
}
Class<? extends ComponentConnector> implementationByServerSideClassName = widgetMap
.getImplementationByServerSideClassName(fullyqualifiedName);
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import java.util.HashSet;
+import java.util.Iterator;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.dom.client.Style;
+import com.google.gwt.dom.client.Style.Unit;
+import com.google.gwt.event.dom.client.DomEvent.Type;
+import com.google.gwt.event.shared.EventHandler;
+import com.google.gwt.event.shared.HandlerRegistration;
+import com.google.gwt.user.client.Element;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.DirectionalManagedLayout;
+import com.vaadin.terminal.gwt.client.EventId;
+import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.terminal.gwt.client.ComponentConnector;
+import com.vaadin.terminal.gwt.client.ui.VAbsoluteLayout.AbsoluteWrapper;
+
+public class AbsoluteLayoutConnector extends AbstractComponentContainerConnector
+ implements DirectionalManagedLayout {
+
+ private LayoutClickEventHandler clickEventHandler = new LayoutClickEventHandler(
+ this, EventId.LAYOUT_CLICK) {
+
+ @Override
+ protected ComponentConnector getChildComponent(Element element) {
+ return getWidget().getComponent(element);
+ }
+
+ @Override
+ protected <H extends EventHandler> HandlerRegistration registerHandler(
+ H handler, Type<H> type) {
+ return getWidget().addDomHandler(handler, type);
+ }
+ };
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ getWidget().client = client;
+ // TODO margin handling
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ clickEventHandler.handleEventHandlerRegistration(client);
+
+ HashSet<String> unrenderedPids = new HashSet<String>(
+ getWidget().pidToComponentWrappper.keySet());
+
+ for (Iterator<Object> childIterator = uidl.getChildIterator(); childIterator
+ .hasNext();) {
+ UIDL cc = (UIDL) childIterator.next();
+ if (cc.getTag().equals("cc")) {
+ UIDL componentUIDL = cc.getChildUIDL(0);
+ unrenderedPids.remove(componentUIDL.getId());
+ getWidget().getWrapper(client, componentUIDL)
+ .updateFromUIDL(cc);
+ }
+ }
+
+ for (String pid : unrenderedPids) {
+ AbsoluteWrapper absoluteWrapper = getWidget().pidToComponentWrappper
+ .get(pid);
+ getWidget().pidToComponentWrappper.remove(pid);
+ absoluteWrapper.destroy();
+ }
+ }
+
+ public void updateCaption(ComponentConnector component, UIDL uidl) {
+ AbsoluteWrapper parent2 = (AbsoluteWrapper) (component
+ .getWidget()).getParent();
+ parent2.updateCaption(uidl);
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VAbsoluteLayout.class);
+ }
+
+ @Override
+ public VAbsoluteLayout getWidget() {
+ return (VAbsoluteLayout) super.getWidget();
+ }
+
+ public void layoutVertically() {
+ VAbsoluteLayout layout = getWidget();
+ for (ComponentConnector paintable : getChildren()) {
+ Widget widget = paintable.getWidget();
+ AbsoluteWrapper wrapper = (AbsoluteWrapper) widget.getParent();
+ Style wrapperStyle = wrapper.getElement().getStyle();
+
+ if (paintable.isRelativeHeight()) {
+ int h;
+ if (wrapper.top != null && wrapper.bottom != null) {
+ h = wrapper.getOffsetHeight();
+ } else if (wrapper.bottom != null) {
+ // top not defined, available space 0... bottom of
+ // wrapper
+ h = wrapper.getElement().getOffsetTop()
+ + wrapper.getOffsetHeight();
+ } else {
+ // top defined or both undefined, available space ==
+ // canvas - top
+ h = layout.canvas.getOffsetHeight()
+ - wrapper.getElement().getOffsetTop();
+ }
+ wrapperStyle.setHeight(h, Unit.PX);
+ } else {
+ wrapperStyle.clearHeight();
+ }
+
+ wrapper.updateCaptionPosition();
+ }
+ }
+
+ public void layoutHorizontally() {
+ VAbsoluteLayout layout = getWidget();
+ for (ComponentConnector paintable : getChildren()) {
+ Widget widget = paintable.getWidget();
+ AbsoluteWrapper wrapper = (AbsoluteWrapper) widget.getParent();
+ Style wrapperStyle = wrapper.getElement().getStyle();
+
+ if (paintable.isRelativeWidth()) {
+ int w;
+ if (wrapper.left != null && wrapper.right != null) {
+ w = wrapper.getOffsetWidth();
+ } else if (wrapper.right != null) {
+ // left == null
+ // available width == right edge == offsetleft + width
+ w = wrapper.getOffsetWidth()
+ + wrapper.getElement().getOffsetLeft();
+ } else {
+ // left != null && right == null || left == null &&
+ // right == null
+ // available width == canvas width - offset left
+ w = layout.canvas.getOffsetWidth()
+ - wrapper.getElement().getOffsetLeft();
+ }
+ wrapperStyle.setWidth(w, Unit.PX);
+ } else {
+ wrapperStyle.clearWidth();
+ }
+
+ wrapper.updateCaptionPosition();
+ }
+ }
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import java.util.Date;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.LocaleNotLoadedException;
+import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.terminal.gwt.client.VConsole;
+
+public class AbstractDateFieldConnector extends AbstractComponentConnector {
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ // Ensure correct implementation and let layout manage caption
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ // Save details
+ getWidget().client = client;
+ getWidget().paintableId = uidl.getId();
+ getWidget().immediate = getState().isImmediate();
+
+ getWidget().readonly = getState().isReadOnly();
+ getWidget().enabled = !getState().isDisabled();
+
+ if (uidl.hasAttribute("locale")) {
+ final String locale = uidl.getStringAttribute("locale");
+ try {
+ getWidget().dts.setLocale(locale);
+ getWidget().currentLocale = locale;
+ } catch (final LocaleNotLoadedException e) {
+ getWidget().currentLocale = getWidget().dts
+ .getLocale();
+ VConsole.error("Tried to use an unloaded locale \"" + locale
+ + "\". Using default locale ("
+ + getWidget().currentLocale + ").");
+ VConsole.error(e);
+ }
+ }
+
+ // We show week numbers only if the week starts with Monday, as ISO 8601
+ // specifies
+ getWidget().showISOWeekNumbers = uidl
+ .getBooleanAttribute(VDateField.WEEK_NUMBERS)
+ && getWidget().dts.getFirstDayOfWeek() == 1;
+
+ int newResolution;
+ if (uidl.hasVariable("sec")) {
+ newResolution = VDateField.RESOLUTION_SEC;
+ } else if (uidl.hasVariable("min")) {
+ newResolution = VDateField.RESOLUTION_MIN;
+ } else if (uidl.hasVariable("hour")) {
+ newResolution = VDateField.RESOLUTION_HOUR;
+ } else if (uidl.hasVariable("day")) {
+ newResolution = VDateField.RESOLUTION_DAY;
+ } else if (uidl.hasVariable("month")) {
+ newResolution = VDateField.RESOLUTION_MONTH;
+ } else {
+ newResolution = VDateField.RESOLUTION_YEAR;
+ }
+
+ getWidget().currentResolution = newResolution;
+
+ // Add stylename that indicates current resolution
+ getWidget()
+ .addStyleName(
+ VDateField.CLASSNAME
+ + "-"
+ + VDateField
+ .resolutionToString(getWidget().currentResolution));
+
+ final int year = uidl.getIntVariable("year");
+ final int month = (getWidget().currentResolution >= VDateField.RESOLUTION_MONTH) ? uidl
+ .getIntVariable("month") : -1;
+ final int day = (getWidget().currentResolution >= VDateField.RESOLUTION_DAY) ? uidl
+ .getIntVariable("day") : -1;
+ final int hour = (getWidget().currentResolution >= VDateField.RESOLUTION_HOUR) ? uidl
+ .getIntVariable("hour") : 0;
+ final int min = (getWidget().currentResolution >= VDateField.RESOLUTION_MIN) ? uidl
+ .getIntVariable("min") : 0;
+ final int sec = (getWidget().currentResolution >= VDateField.RESOLUTION_SEC) ? uidl
+ .getIntVariable("sec") : 0;
+
+ // Construct new date for this datefield (only if not null)
+ if (year > -1) {
+ getWidget().setCurrentDate(
+ new Date((long) getWidget().getTime(year,
+ month, day, hour, min, sec, 0)));
+ } else {
+ getWidget().setCurrentDate(null);
+ }
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VDateField.class);
+ }
+
+ @Override
+ public VDateField getWidget() {
+ return (VDateField) super.getWidget();
+ }
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import java.util.HashSet;
+import java.util.Iterator;
+
+import com.google.gwt.dom.client.Node;
+import com.google.gwt.dom.client.Style;
+import com.google.gwt.user.client.Element;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.ComponentConnector;
+import com.vaadin.terminal.gwt.client.ConnectorMap;
+import com.vaadin.terminal.gwt.client.DirectionalManagedLayout;
+import com.vaadin.terminal.gwt.client.LayoutManager;
+import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.terminal.gwt.client.VCaption;
+import com.vaadin.terminal.gwt.client.ValueMap;
+import com.vaadin.terminal.gwt.client.ui.layout.VLayoutSlot;
+import com.vaadin.terminal.gwt.client.ui.layout.ComponentConnectorLayoutSlot;
+
+public abstract class AbstractOrderedLayoutConnector extends
+ AbstractComponentContainerConnector implements DirectionalManagedLayout {
+
+ @Override
+ public void init() {
+ getLayoutManager().registerDependency(this,
+ getWidget().spacingMeasureElement);
+ }
+
+ public void updateCaption(ComponentConnector component, UIDL uidl) {
+ VMeasuringOrderedLayout layout = getWidget();
+ if (VCaption.isNeeded(uidl, component.getState())) {
+ VLayoutSlot layoutSlot = layout.getSlotForChild(component
+ .getWidget());
+ VCaption caption = layoutSlot.getCaption();
+ if (caption == null) {
+ caption = new VCaption(component, getConnection());
+
+ Widget widget = component.getWidget();
+
+ layout.setCaption(widget, caption);
+ }
+ caption.updateCaption(uidl);
+ } else {
+ layout.setCaption(component.getWidget(), null);
+ }
+ }
+
+ @Override
+ public VMeasuringOrderedLayout getWidget() {
+ return (VMeasuringOrderedLayout) super.getWidget();
+ }
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ HashSet<ComponentConnector> previousChildren = new HashSet<ComponentConnector>(
+ getChildren());
+
+ VMeasuringOrderedLayout layout = getWidget();
+
+ ValueMap expandRatios = uidl.getMapAttribute("expandRatios");
+ ValueMap alignments = uidl.getMapAttribute("alignments");
+
+ int currentIndex = 0;
+ // TODO Support reordering elements!
+ for (final Iterator<Object> it = uidl.getChildIterator(); it.hasNext();) {
+ final UIDL childUIDL = (UIDL) it.next();
+ final ComponentConnector child = client.getPaintable(childUIDL);
+ Widget widget = child.getWidget();
+
+ VLayoutSlot slot = layout.getSlotForChild(widget);
+
+ if (widget.getParent() != layout) {
+ slot = new ComponentConnectorLayoutSlot(getWidget()
+ .getStylePrimaryName(), child);
+ }
+ layout.addOrMove(slot, currentIndex++);
+
+ String pid = child.getId();
+
+ AlignmentInfo alignment;
+ if (alignments.containsKey(pid)) {
+ alignment = new AlignmentInfo(alignments.getInt(pid));
+ } else {
+ alignment = AlignmentInfo.TOP_LEFT;
+ }
+ slot.setAlignment(alignment);
+
+ double expandRatio;
+ if (expandRatios.containsKey(pid)) {
+ expandRatio = expandRatios.getRawNumber(pid);
+ } else {
+ expandRatio = 0;
+ }
+ slot.setExpandRatio(expandRatio);
+
+ if (!childUIDL.getBooleanAttribute("cached")) {
+ child.updateFromUIDL(childUIDL, client);
+ }
+
+ previousChildren.remove(child);
+ }
+
+ for (ComponentConnector child : previousChildren) {
+ Widget widget = child.getWidget();
+
+ // Don't remove and unregister if it has been moved to a different
+ // parent. Slot element will be left behind, but that is taken care
+ // of later
+ if (widget.getParent() == getWidget()) {
+ layout.removeSlot(layout.getSlotForChild(widget));
+
+ ConnectorMap vPaintableMap = ConnectorMap.get(client);
+ vPaintableMap.unregisterConnector(child);
+ }
+ }
+
+ // Remove empty layout slots left behind after children have moved to
+ // other paintables
+ while (true) {
+ int childCount = layout.getElement().getChildCount();
+ if (childCount <= 1) {
+ // Stop if no more slots (spacing element is always present)
+ break;
+ }
+
+ Node lastSlot = layout.getElement().getChild(childCount - 2);
+ if (lastSlot.getChildCount() == 0) {
+ // Remove if empty
+ lastSlot.removeFromParent();
+ } else {
+ // Stop searching when last slot is not empty
+ break;
+ }
+ }
+
+ int bitMask = uidl.getIntAttribute("margins");
+ layout.updateMarginStyleNames(new VMarginInfo(bitMask));
+
+ layout.updateSpacingStyleName(uidl.getBooleanAttribute("spacing"));
+
+ getLayoutManager().setNeedsUpdate(this);
+ }
+
+ private int getSizeForInnerSize(int size, boolean isVertical) {
+ LayoutManager layoutManager = getLayoutManager();
+ Element element = getWidget().getElement();
+ if (isVertical) {
+ return size + layoutManager.getBorderHeight(element)
+ + layoutManager.getPaddingHeight(element);
+ } else {
+ return size + layoutManager.getBorderWidth(element)
+ + layoutManager.getPaddingWidth(element);
+ }
+ }
+
+ private static String getSizeProperty(boolean isVertical) {
+ return isVertical ? "height" : "width";
+ }
+
+ private boolean isUndefinedInDirection(boolean isVertical) {
+ if (isVertical) {
+ return isUndefinedHeight();
+ } else {
+ return isUndefinedWidth();
+ }
+ }
+
+ private int getInnerSizeInDirection(boolean isVertical) {
+ if (isVertical) {
+ return getLayoutManager().getInnerHeight(getWidget().getElement());
+ } else {
+ return getLayoutManager().getInnerWidth(getWidget().getElement());
+ }
+ }
+
+ private void layoutPrimaryDirection() {
+ VMeasuringOrderedLayout layout = getWidget();
+ boolean isVertical = layout.isVertical;
+ boolean isUndefined = isUndefinedInDirection(isVertical);
+
+ int startPadding = getStartPadding(isVertical);
+ int spacingSize = getSpacingInDirection(isVertical);
+ int allocatedSize;
+
+ if (isUndefined) {
+ allocatedSize = -1;
+ } else {
+ allocatedSize = getInnerSizeInDirection(isVertical);
+ }
+
+ allocatedSize = layout.layoutPrimaryDirection(spacingSize,
+ allocatedSize, startPadding);
+
+ Style ownStyle = getWidget().getElement().getStyle();
+ if (isUndefined) {
+ ownStyle.setPropertyPx(getSizeProperty(isVertical),
+ getSizeForInnerSize(allocatedSize, isVertical));
+ } else {
+ ownStyle.setProperty(getSizeProperty(isVertical),
+ getDefinedSize(isVertical));
+ }
+ }
+
+ private int getSpacingInDirection(boolean isVertical) {
+ if (isVertical) {
+ return getLayoutManager().getOuterHeight(
+ getWidget().spacingMeasureElement);
+ } else {
+ return getLayoutManager().getOuterWidth(
+ getWidget().spacingMeasureElement);
+ }
+ }
+
+ private void layoutSecondaryDirection() {
+ VMeasuringOrderedLayout layout = getWidget();
+ boolean isVertical = layout.isVertical;
+ boolean isUndefined = isUndefinedInDirection(!isVertical);
+
+ int startPadding = getStartPadding(!isVertical);
+
+ int allocatedSize;
+ if (isUndefined) {
+ allocatedSize = -1;
+ } else {
+ allocatedSize = getInnerSizeInDirection(!isVertical);
+ }
+
+ allocatedSize = layout.layoutSecondaryDirection(allocatedSize,
+ startPadding);
+
+ Style ownStyle = getWidget().getElement().getStyle();
+
+ if (isUndefined) {
+ ownStyle.setPropertyPx(getSizeProperty(!getWidget().isVertical),
+ getSizeForInnerSize(allocatedSize, !getWidget().isVertical));
+ } else {
+ ownStyle.setProperty(getSizeProperty(!getWidget().isVertical),
+ getDefinedSize(!getWidget().isVertical));
+ }
+ }
+
+ private String getDefinedSize(boolean isVertical) {
+ if (isVertical) {
+ return getDeclaredHeight();
+ } else {
+ return getDeclaredWidth();
+ }
+ }
+
+ private int getStartPadding(boolean isVertical) {
+ if (isVertical) {
+ return getLayoutManager().getPaddingTop(getWidget().getElement());
+ } else {
+ return getLayoutManager().getPaddingLeft(getWidget().getElement());
+ }
+ }
+
+ public void layoutHorizontally() {
+ if (getWidget().isVertical) {
+ layoutSecondaryDirection();
+ } else {
+ layoutPrimaryDirection();
+ }
+ }
+
+ public void layoutVertically() {
+ if (getWidget().isVertical) {
+ layoutPrimaryDirection();
+ } else {
+ layoutSecondaryDirection();
+ }
+ }
+
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.dom.client.NativeEvent;
+import com.google.gwt.event.dom.client.DomEvent.Type;
+import com.google.gwt.event.shared.EventHandler;
+import com.google.gwt.event.shared.HandlerRegistration;
+import com.google.gwt.user.client.Element;
+import com.google.gwt.user.client.Event;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.ComponentConnector;
+import com.vaadin.terminal.gwt.client.ConnectorMap;
+import com.vaadin.terminal.gwt.client.UIDL;
+
+public abstract class AbstractSplitPanelConnector extends
+ AbstractComponentContainerConnector implements SimpleManagedLayout {
+
+ public static final String SPLITTER_CLICK_EVENT_IDENTIFIER = "sp_click";
+
+ public void updateCaption(ComponentConnector component, UIDL uidl) {
+ // TODO Implement caption handling
+ }
+
+ ClickEventHandler clickEventHandler = new ClickEventHandler(this,
+ SPLITTER_CLICK_EVENT_IDENTIFIER) {
+
+ @Override
+ protected <H extends EventHandler> HandlerRegistration registerHandler(
+ H handler, Type<H> type) {
+ if ((Event.getEventsSunk(getWidget().splitter) & Event
+ .getTypeInt(type.getName())) != 0) {
+ // If we are already sinking the event for the splitter we do
+ // not want to additionally sink it for the root element
+ return getWidget().addHandler(handler, type);
+ } else {
+ return getWidget().addDomHandler(handler, type);
+ }
+ }
+
+ @Override
+ public void onContextMenu(
+ com.google.gwt.event.dom.client.ContextMenuEvent event) {
+ Element target = event.getNativeEvent().getEventTarget().cast();
+ if (getWidget().splitter.isOrHasChild(target)) {
+ super.onContextMenu(event);
+ }
+ };
+
+ @Override
+ protected void fireClick(NativeEvent event) {
+ Element target = event.getEventTarget().cast();
+ if (getWidget().splitter.isOrHasChild(target)) {
+ super.fireClick(event);
+ }
+ }
+
+ @Override
+ protected Element getRelativeToElement() {
+ return null;
+ }
+
+ };
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ getWidget().client = client;
+ getWidget().id = uidl.getId();
+
+ getWidget().immediate = getState().isImmediate();
+
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+ getWidget().setEnabled(!getState().isDisabled());
+
+ clickEventHandler.handleEventHandlerRegistration(client);
+ if (getState().hasStyles()) {
+ getWidget().componentStyleNames = getState().getStyle().split(" ");
+ } else {
+ getWidget().componentStyleNames = new String[0];
+ }
+
+ getWidget().setLocked(uidl.getBooleanAttribute("locked"));
+
+ getWidget().setPositionReversed(uidl.getBooleanAttribute("reversed"));
+
+ getWidget().setStylenames();
+
+ getWidget().position = uidl.getStringAttribute("position");
+
+ final ComponentConnector newFirstChildPaintable = client
+ .getPaintable(uidl.getChildUIDL(0));
+ final ComponentConnector newSecondChildPaintable = client
+ .getPaintable(uidl.getChildUIDL(1));
+ Widget newFirstChild = newFirstChildPaintable.getWidget();
+ Widget newSecondChild = newSecondChildPaintable.getWidget();
+
+ if (getWidget().firstChild != newFirstChild) {
+ if (getWidget().firstChild != null) {
+ client.unregisterPaintable(ConnectorMap.get(client)
+ .getConnector(getWidget().firstChild));
+ }
+ getWidget().setFirstWidget(newFirstChild);
+ }
+ if (getWidget().secondChild != newSecondChild) {
+ if (getWidget().secondChild != null) {
+ client.unregisterPaintable(ConnectorMap.get(client)
+ .getConnector(getWidget().secondChild));
+ }
+ getWidget().setSecondWidget(newSecondChild);
+ }
+ newFirstChildPaintable.updateFromUIDL(uidl.getChildUIDL(0), client);
+ newSecondChildPaintable.updateFromUIDL(uidl.getChildUIDL(1), client);
+
+ // This is needed at least for cases like #3458 to take
+ // appearing/disappearing scrollbars into account.
+ client.runDescendentsLayout(getWidget());
+
+ getLayoutManager().setNeedsUpdate(this);
+ }
+
+ public void layout() {
+ VAbstractSplitPanel splitPanel = getWidget();
+ splitPanel.setSplitPosition(splitPanel.position);
+ splitPanel.updateSizes();
+ }
+
+ @Override
+ public VAbstractSplitPanel getWidget() {
+ return (VAbstractSplitPanel) super.getWidget();
+ }
+
+ @Override
+ protected abstract VAbstractSplitPanel createWidget();
+
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import java.util.Iterator;
+
+import com.google.gwt.core.client.GWT;
+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.ComponentConnector;
+import com.vaadin.terminal.gwt.client.ui.VAccordion.StackItem;
+
+public class AccordionConnector extends TabsheetBaseConnector implements
+ SimpleManagedLayout {
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ getWidget().selectedUIDLItemIndex = -1;
+ super.updateFromUIDL(uidl, client);
+ /*
+ * Render content after all tabs have been created and we know how large
+ * the content area is
+ */
+ if (getWidget().selectedUIDLItemIndex >= 0) {
+ StackItem selectedItem = getWidget().getStackItem(
+ getWidget().selectedUIDLItemIndex);
+ UIDL selectedTabUIDL = getWidget().lazyUpdateMap
+ .remove(selectedItem);
+ getWidget().open(
+ getWidget().selectedUIDLItemIndex);
+
+ selectedItem.setContent(selectedTabUIDL);
+ } else if (isRealUpdate(uidl)
+ && getWidget().openTab != null) {
+ getWidget().close(getWidget().openTab);
+ }
+
+ getWidget().iLayout();
+ // finally render possible hidden tabs
+ if (getWidget().lazyUpdateMap.size() > 0) {
+ for (Iterator iterator = getWidget().lazyUpdateMap
+ .keySet().iterator(); iterator.hasNext();) {
+ StackItem item = (StackItem) iterator.next();
+ item.setContent(getWidget().lazyUpdateMap.get(item));
+ }
+ getWidget().lazyUpdateMap.clear();
+ }
+
+ getWidget().renderInformation
+ .updateSize(getWidget().getElement());
+ }
+
+ @Override
+ public VAccordion getWidget() {
+ return (VAccordion) super.getWidget();
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VAccordion.class);
+ }
+
+ public void updateCaption(ComponentConnector component, UIDL uidl) {
+ /* Accordion does not render its children's captions */
+ }
+
+ public void layout() {
+ VAccordion accordion = getWidget();
+
+ accordion.updateOpenTabSize();
+
+ if (isUndefinedHeight()) {
+ accordion.openTab.setHeightFromWidget();
+ }
+ accordion.iLayout();
+
+ }
+
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.dom.client.Style;
+import com.google.gwt.dom.client.Style.Unit;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.BrowserInfo;
+import com.vaadin.terminal.gwt.client.UIDL;
+
+public class AudioConnector extends MediaBaseConnector {
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+ Style style = getWidget().getElement().getStyle();
+
+ // Make sure that the controls are not clipped if visible.
+ if (shouldShowControls(uidl)
+ && (style.getHeight() == null || "".equals(style.getHeight()))) {
+ if (BrowserInfo.get().isChrome()) {
+ style.setHeight(32, Unit.PX);
+ } else {
+ style.setHeight(25, Unit.PX);
+ }
+ }
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VAudio.class);
+ }
+
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.user.client.DOM;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.ComponentState;
+import com.vaadin.terminal.gwt.client.EventHelper;
+import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.terminal.gwt.client.communication.ClientToServerRpc;
+
+public class ButtonConnector extends AbstractComponentConnector {
+
+ /**
+ * RPC interface for calls from client to server.
+ *
+ * @since 7.0
+ */
+ public interface ButtonClientToServerRpc extends ClientToServerRpc {
+ /**
+ * Button click event.
+ *
+ * @param mouseEventDetails
+ * serialized mouse event details
+ */
+ public void click(String mouseEventDetails);
+
+ /**
+ * Indicate to the server that the client has disabled the button as a
+ * result of a click.
+ */
+ public void disableOnClick();
+ }
+
+ @Override
+ protected boolean delegateCaptionHandling() {
+ return false;
+ }
+
+ @Override
+ public void init() {
+ super.init();
+ ButtonClientToServerRpc rpcProxy = GWT
+ .create(ButtonClientToServerRpc.class);
+ getWidget().buttonRpcProxy = initRPC(rpcProxy);
+ }
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+
+ // Ensure correct implementation,
+ // but don't let container manage caption etc.
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ getWidget().focusHandlerRegistration = EventHelper
+ .updateFocusHandler(this, client,
+ getWidget().focusHandlerRegistration);
+ getWidget().blurHandlerRegistration = EventHelper
+ .updateBlurHandler(this, client,
+ getWidget().blurHandlerRegistration);
+
+ // Save details
+ getWidget().client = client;
+ getWidget().paintableId = uidl.getId();
+
+ // Set text
+ getWidget().setText(getState().getCaption());
+
+ getWidget().disableOnClick = getState().isDisableOnClick();
+
+ // handle error
+ if (uidl.hasAttribute("error")) {
+ if (getWidget().errorIndicatorElement == null) {
+ getWidget().errorIndicatorElement = DOM
+ .createSpan();
+ getWidget().errorIndicatorElement
+ .setClassName("v-errorindicator");
+ }
+ getWidget().wrapper.insertBefore(
+ getWidget().errorIndicatorElement,
+ getWidget().captionElement);
+
+ } else if (getWidget().errorIndicatorElement != null) {
+ getWidget().wrapper
+ .removeChild(getWidget().errorIndicatorElement);
+ getWidget().errorIndicatorElement = null;
+ }
+
+ if (uidl.hasAttribute(ATTRIBUTE_ICON)) {
+ if (getWidget().icon == null) {
+ getWidget().icon = new Icon(client);
+ getWidget().wrapper.insertBefore(
+ getWidget().icon.getElement(),
+ getWidget().captionElement);
+ }
+ getWidget().icon.setUri(uidl
+ .getStringAttribute(ATTRIBUTE_ICON));
+ } else {
+ if (getWidget().icon != null) {
+ getWidget().wrapper
+ .removeChild(getWidget().icon.getElement());
+ getWidget().icon = null;
+ }
+ }
+
+ getWidget().clickShortcut = getState()
+ .getClickShortcutKeyCode();
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VButton.class);
+ }
+
+ @Override
+ public VButton getWidget() {
+ return (VButton) super.getWidget();
+ }
+
+ @Override
+ public ButtonState getState() {
+ return (ButtonState) super.getState();
+ }
+
+ @Override
+ protected ComponentState createState() {
+ return GWT.create(ButtonState.class);
+ }
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.user.client.DOM;
+import com.google.gwt.user.client.Event;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.EventHelper;
+import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.terminal.gwt.client.VTooltip;
+
+public class CheckBoxConnector extends AbstractComponentConnector {
+
+ @Override
+ protected boolean delegateCaptionHandling() {
+ return false;
+ }
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ // Save details
+ getWidget().client = client;
+ getWidget().id = uidl.getId();
+
+ // Ensure correct implementation
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ getWidget().focusHandlerRegistration = EventHelper
+ .updateFocusHandler(this, client,
+ getWidget().focusHandlerRegistration);
+ getWidget().blurHandlerRegistration = EventHelper
+ .updateBlurHandler(this, client,
+ getWidget().blurHandlerRegistration);
+
+ if (uidl.hasAttribute("error")) {
+ if (getWidget().errorIndicatorElement == null) {
+ getWidget().errorIndicatorElement = DOM
+ .createSpan();
+ getWidget().errorIndicatorElement
+ .setInnerHTML(" ");
+ DOM.setElementProperty(
+ getWidget().errorIndicatorElement,
+ "className", "v-errorindicator");
+ DOM.appendChild(getWidget().getElement(),
+ getWidget().errorIndicatorElement);
+ DOM.sinkEvents(getWidget().errorIndicatorElement,
+ VTooltip.TOOLTIP_EVENTS | Event.ONCLICK);
+ } else {
+ DOM.setStyleAttribute(
+ getWidget().errorIndicatorElement,
+ "display", "");
+ }
+ } else if (getWidget().errorIndicatorElement != null) {
+ DOM.setStyleAttribute(
+ getWidget().errorIndicatorElement, "display",
+ "none");
+ }
+
+ if (getState().isReadOnly()) {
+ getWidget().setEnabled(false);
+ }
+
+ if (uidl.hasAttribute(ATTRIBUTE_ICON)) {
+ if (getWidget().icon == null) {
+ getWidget().icon = new Icon(client);
+ DOM.insertChild(getWidget().getElement(),
+ getWidget().icon.getElement(), 1);
+ getWidget().icon
+ .sinkEvents(VTooltip.TOOLTIP_EVENTS);
+ getWidget().icon.sinkEvents(Event.ONCLICK);
+ }
+ getWidget().icon.setUri(uidl
+ .getStringAttribute(ATTRIBUTE_ICON));
+ } else if (getWidget().icon != null) {
+ // detach icon
+ DOM.removeChild(getWidget().getElement(),
+ getWidget().icon.getElement());
+ getWidget().icon = null;
+ }
+
+ // Set text
+ getWidget().setText(getState().getCaption());
+ getWidget()
+ .setValue(
+ uidl.getBooleanVariable(getWidget().VARIABLE_STATE));
+ getWidget().immediate = getState().isImmediate();
+ }
+
+ @Override
+ public VCheckBox getWidget() {
+ return (VCheckBox) super.getWidget();
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VCheckBox.class);
+ }
+
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import java.util.Iterator;
+
+import com.google.gwt.core.client.GWT;
+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.Util;
+import com.vaadin.terminal.gwt.client.ui.VFilterSelect.FilterSelectSuggestion;
+
+public class ComboBoxConnector extends AbstractComponentConnector implements
+ SimpleManagedLayout {
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * com.vaadin.terminal.gwt.client.Paintable#updateFromUIDL(com.vaadin.terminal
+ * .gwt.client.UIDL, com.vaadin.terminal.gwt.client.ApplicationConnection)
+ */
+ @Override
+ @SuppressWarnings("deprecation")
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ // Save details
+ getWidget().client = client;
+ getWidget().paintableId = uidl.getId();
+
+ getWidget().readonly = getState().isReadOnly();
+ getWidget().enabled = !getState().isDisabled();
+
+ getWidget().tb.setEnabled(getWidget().enabled);
+ getWidget().updateReadOnly();
+
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ // Inverse logic here to make the default case (text input enabled)
+ // work without additional UIDL messages
+ boolean noTextInput = uidl
+ .hasAttribute(VFilterSelect.ATTR_NO_TEXT_INPUT)
+ && uidl.getBooleanAttribute(VFilterSelect.ATTR_NO_TEXT_INPUT);
+ getWidget().setTextInputEnabled(!noTextInput);
+
+ // not a FocusWidget -> needs own tabindex handling
+ if (uidl.hasAttribute("tabindex")) {
+ getWidget().tb.setTabIndex(uidl
+ .getIntAttribute("tabindex"));
+ }
+
+ if (uidl.hasAttribute("filteringmode")) {
+ getWidget().filteringmode = uidl
+ .getIntAttribute("filteringmode");
+ }
+
+ getWidget().immediate = getState().isImmediate();
+
+ getWidget().nullSelectionAllowed = uidl
+ .hasAttribute("nullselect");
+
+ getWidget().nullSelectItem = uidl
+ .hasAttribute("nullselectitem")
+ && uidl.getBooleanAttribute("nullselectitem");
+
+ getWidget().currentPage = uidl.getIntVariable("page");
+
+ if (uidl.hasAttribute("pagelength")) {
+ getWidget().pageLength = uidl
+ .getIntAttribute("pagelength");
+ }
+
+ if (uidl.hasAttribute(VFilterSelect.ATTR_INPUTPROMPT)) {
+ // input prompt changed from server
+ getWidget().inputPrompt = uidl
+ .getStringAttribute(VFilterSelect.ATTR_INPUTPROMPT);
+ } else {
+ getWidget().inputPrompt = "";
+ }
+
+ getWidget().suggestionPopup.updateStyleNames(uidl,
+ getState());
+
+ getWidget().allowNewItem = uidl
+ .hasAttribute("allownewitem");
+ getWidget().lastNewItemString = null;
+
+ getWidget().currentSuggestions.clear();
+ if (!getWidget().waitingForFilteringResponse) {
+ /*
+ * Clear the current suggestions as the server response always
+ * includes the new ones. Exception is when filtering, then we need
+ * to retain the value if the user does not select any of the
+ * options matching the filter.
+ */
+ getWidget().currentSuggestion = null;
+ /*
+ * Also ensure no old items in menu. Unless cleared the old values
+ * may cause odd effects on blur events. Suggestions in menu might
+ * not necessary exist in select at all anymore.
+ */
+ getWidget().suggestionPopup.menu.clearItems();
+
+ }
+
+ final UIDL options = uidl.getChildUIDL(0);
+ if (uidl.hasAttribute("totalMatches")) {
+ getWidget().totalMatches = uidl
+ .getIntAttribute("totalMatches");
+ } else {
+ getWidget().totalMatches = 0;
+ }
+
+ // used only to calculate minimum popup width
+ String captions = Util.escapeHTML(getWidget().inputPrompt);
+
+ for (final Iterator<?> i = options.getChildIterator(); i.hasNext();) {
+ final UIDL optionUidl = (UIDL) i.next();
+ final FilterSelectSuggestion suggestion = getWidget().new FilterSelectSuggestion(
+ optionUidl);
+ getWidget().currentSuggestions.add(suggestion);
+ if (optionUidl.hasAttribute("selected")) {
+ if (!getWidget().waitingForFilteringResponse
+ || getWidget().popupOpenerClicked) {
+ String newSelectedOptionKey = Integer.toString(suggestion
+ .getOptionKey());
+ if (!newSelectedOptionKey
+ .equals(getWidget().selectedOptionKey)
+ || suggestion.getReplacementString().equals(
+ getWidget().tb.getText())) {
+ // Update text field if we've got a new selection
+ // Also update if we've got the same text to retain old
+ // text selection behavior
+ getWidget().setPromptingOff(
+ suggestion.getReplacementString());
+ getWidget().selectedOptionKey = newSelectedOptionKey;
+ }
+ }
+ getWidget().currentSuggestion = suggestion;
+ getWidget().setSelectedItemIcon(
+ suggestion.getIconUri());
+ }
+
+ // Collect captions so we can calculate minimum width for textarea
+ if (captions.length() > 0) {
+ captions += "|";
+ }
+ captions += Util.escapeHTML(suggestion.getReplacementString());
+ }
+
+ if ((!getWidget().waitingForFilteringResponse || getWidget().popupOpenerClicked)
+ && uidl.hasVariable("selected")
+ && uidl.getStringArrayVariable("selected").length == 0) {
+ // select nulled
+ if (!getWidget().waitingForFilteringResponse
+ || !getWidget().popupOpenerClicked) {
+ if (!getWidget().focused) {
+ /*
+ * client.updateComponent overwrites all styles so we must
+ * ALWAYS set the prompting style at this point, even though
+ * we think it has been set already...
+ */
+ getWidget().prompting = false;
+ getWidget().setPromptingOn();
+ } else {
+ // we have focus in field, prompting can't be set on,
+ // instead just clear the input
+ getWidget().tb.setValue("");
+ }
+ }
+ getWidget().setSelectedItemIcon(null);
+ getWidget().selectedOptionKey = null;
+ }
+
+ if (getWidget().waitingForFilteringResponse
+ && getWidget().lastFilter.toLowerCase().equals(
+ uidl.getStringVariable("filter"))) {
+ getWidget().suggestionPopup.showSuggestions(
+ getWidget().currentSuggestions,
+ getWidget().currentPage,
+ getWidget().totalMatches);
+ getWidget().waitingForFilteringResponse = false;
+ if (!getWidget().popupOpenerClicked
+ && getWidget().selectPopupItemWhenResponseIsReceived != VFilterSelect.Select.NONE) {
+ // we're paging w/ arrows
+ if (getWidget().selectPopupItemWhenResponseIsReceived == VFilterSelect.Select.LAST) {
+ getWidget().suggestionPopup.menu
+ .selectLastItem();
+ } else {
+ getWidget().suggestionPopup.menu
+ .selectFirstItem();
+ }
+
+ // This is used for paging so we update the keyboard selection
+ // variable as well.
+ MenuItem activeMenuItem = getWidget().suggestionPopup.menu
+ .getSelectedItem();
+ getWidget().suggestionPopup.menu
+ .setKeyboardSelectedItem(activeMenuItem);
+
+ // Update text field to contain the correct text
+ getWidget()
+ .setTextboxText(activeMenuItem.getText());
+ getWidget().tb.setSelectionRange(
+ getWidget().lastFilter.length(),
+ activeMenuItem.getText().length()
+ - getWidget().lastFilter.length());
+
+ getWidget().selectPopupItemWhenResponseIsReceived = VFilterSelect.Select.NONE; // reset
+ }
+ if (getWidget().updateSelectionWhenReponseIsReceived) {
+ getWidget().suggestionPopup.menu
+ .doPostFilterSelectedItemAction();
+ }
+ }
+
+ // Calculate minumum textarea width
+ getWidget().suggestionPopupMinWidth = getWidget()
+ .minWidth(captions);
+
+ getWidget().popupOpenerClicked = false;
+
+ if (!getWidget().initDone) {
+ getWidget().updateRootWidth();
+ }
+
+ // Focus dependent style names are lost during the update, so we add
+ // them here back again
+ if (getWidget().focused) {
+ getWidget().addStyleDependentName("focus");
+ }
+
+ getWidget().initDone = true;
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VFilterSelect.class);
+ }
+
+ @Override
+ public VFilterSelect getWidget() {
+ return (VFilterSelect) super.getWidget();
+ }
+
+ public void layout() {
+ VFilterSelect widget = getWidget();
+ if (widget.initDone) {
+ widget.updateRootWidth();
+ }
+ }
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.event.dom.client.DomEvent.Type;
+import com.google.gwt.event.shared.EventHandler;
+import com.google.gwt.event.shared.HandlerRegistration;
+import com.google.gwt.user.client.Element;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.EventId;
+import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.terminal.gwt.client.ComponentConnector;
+
+public class CssLayoutConnector extends AbstractComponentContainerConnector {
+
+ private LayoutClickEventHandler clickEventHandler = new LayoutClickEventHandler(
+ this, EventId.LAYOUT_CLICK) {
+
+ @Override
+ protected ComponentConnector getChildComponent(Element element) {
+ return getWidget().panel.getComponent(element);
+ }
+
+ @Override
+ protected <H extends EventHandler> HandlerRegistration registerHandler(
+ H handler, Type<H> type) {
+ return getWidget().addDomHandler(handler, type);
+ }
+ };
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+ clickEventHandler.handleEventHandlerRegistration(client);
+
+ getWidget().setMarginAndSpacingStyles(
+ new VMarginInfo(uidl.getIntAttribute("margins")),
+ uidl.hasAttribute("spacing"));
+ getWidget().panel.updateFromUIDL(uidl, client);
+ }
+
+ @Override
+ public VCssLayout getWidget() {
+ return (VCssLayout) super.getWidget();
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VCssLayout.class);
+ }
+
+ public void updateCaption(ComponentConnector component, UIDL uidl) {
+ getWidget().panel.updateCaption(component, uidl);
+ }
+
+}
--- /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.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.terminal.gwt.client.ConnectorMap;
+import com.vaadin.terminal.gwt.client.ComponentConnector;
+
+public class CustomComponentConnector extends
+ AbstractComponentContainerConnector {
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, final ApplicationConnection client) {
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+ final UIDL child = uidl.getChildUIDL(0);
+ if (child != null) {
+ final ComponentConnector paintable = client.getPaintable(child);
+ Widget widget = paintable.getWidget();
+ if (widget != getWidget().getWidget()) {
+ if (getWidget().getWidget() != null) {
+ client.unregisterPaintable(ConnectorMap.get(client)
+ .getConnector(getWidget().getWidget()));
+ getWidget().clear();
+ }
+ getWidget().setWidget(widget);
+ }
+ paintable.updateFromUIDL(child, client);
+ }
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VCustomComponent.class);
+ }
+
+ @Override
+ public VCustomComponent getWidget() {
+ return (VCustomComponent) super.getWidget();
+ }
+
+ public void updateCaption(ComponentConnector component, UIDL uidl) {
+ // NOP, custom component dont render composition roots caption
+ }
+
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.user.client.DOM;
+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.ComponentConnector;
+
+public class CustomLayoutConnector extends AbstractComponentContainerConnector
+ implements SimpleManagedLayout {
+
+ /** Update the layout from UIDL */
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ getWidget().client = client;
+ // ApplicationConnection manages generic component features
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ getWidget().pid = uidl.getId();
+ if (!getWidget().hasTemplate()) {
+ // Update HTML template only once
+ getWidget().initializeHTML(uidl, client);
+ }
+
+ // Evaluate scripts
+ VCustomLayout.eval(getWidget().scripts);
+ getWidget().scripts = null;
+
+ // TODO Check if this is needed
+ client.runDescendentsLayout(getWidget());
+
+ Set<Widget> oldWidgets = new HashSet<Widget>();
+ oldWidgets.addAll(getWidget().locationToWidget.values());
+
+ // For all contained widgets
+ for (final Iterator<?> i = uidl.getChildIterator(); i.hasNext();) {
+ final UIDL uidlForChild = (UIDL) i.next();
+ if (uidlForChild.getTag().equals("location")) {
+ final String location = uidlForChild.getStringAttribute("name");
+ UIDL childUIDL = uidlForChild.getChildUIDL(0);
+ final ComponentConnector childPaintable = client
+ .getPaintable(childUIDL);
+ Widget childWidget = childPaintable.getWidget();
+ try {
+ getWidget().setWidget(childWidget, location);
+ childPaintable.updateFromUIDL(childUIDL, client);
+ } catch (final IllegalArgumentException e) {
+ // If no location is found, this component is not visible
+ }
+ oldWidgets.remove(childWidget);
+ }
+ }
+ for (Iterator<Widget> iterator = oldWidgets.iterator(); iterator
+ .hasNext();) {
+ Widget oldWidget = iterator.next();
+ if (oldWidget.isAttached()) {
+ // slot of this widget is emptied, remove it
+ getWidget().remove(oldWidget);
+ }
+ }
+
+ // TODO Check if this is needed
+ client.runDescendentsLayout(getWidget());
+
+ }
+
+ @Override
+ public VCustomLayout getWidget() {
+ return (VCustomLayout) super.getWidget();
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VCustomLayout.class);
+ }
+
+ public void updateCaption(ComponentConnector paintable, UIDL uidl) {
+ getWidget().updateCaption(paintable, uidl);
+
+ }
+
+ public void layout() {
+ getWidget().iLayoutJS(
+ DOM.getFirstChild(getWidget().getElement()));
+ }
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import java.util.HashMap;
+import java.util.Set;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.UIDL;
+
+public class DragAndDropWrapperConnector extends CustomComponentConnector {
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ getWidget().client = client;
+ super.updateFromUIDL(uidl, client);
+ if (isRealUpdate(uidl) && !uidl.hasAttribute("hidden")) {
+ UIDL acceptCrit = uidl.getChildByTagName("-ac");
+ if (acceptCrit == null) {
+ getWidget().dropHandler = null;
+ } else {
+ if (getWidget().dropHandler == null) {
+ getWidget().dropHandler = getWidget().new CustomDropHandler();
+ }
+ getWidget().dropHandler.updateAcceptRules(acceptCrit);
+ }
+
+ Set<String> variableNames = uidl.getVariableNames();
+ for (String fileId : variableNames) {
+ if (fileId.startsWith("rec-")) {
+ String receiverUrl = uidl.getStringVariable(fileId);
+ fileId = fileId.substring(4);
+ if (getWidget().fileIdToReceiver == null) {
+ getWidget().fileIdToReceiver = new HashMap<String, String>();
+ }
+ if ("".equals(receiverUrl)) {
+ Integer id = Integer.parseInt(fileId);
+ int indexOf = getWidget().fileIds.indexOf(id);
+ if (indexOf != -1) {
+ getWidget().files.remove(indexOf);
+ getWidget().fileIds.remove(indexOf);
+ }
+ } else {
+ getWidget().fileIdToReceiver.put(fileId, receiverUrl);
+ }
+ }
+ }
+ getWidget().startNextUpload();
+
+ getWidget().dragStartMode = uidl
+ .getIntAttribute(VDragAndDropWrapper.DRAG_START_MODE);
+ getWidget().initDragStartMode();
+ getWidget().html5DataFlavors = uidl
+ .getMapAttribute(VDragAndDropWrapper.HTML5_DATA_FLAVORS);
+ }
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VDragAndDropWrapper.class);
+ }
+
+ @Override
+ public VDragAndDropWrapper getWidget() {
+ return (VDragAndDropWrapper) super.getWidget();
+ }
+
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+
+package com.vaadin.terminal.gwt.client.ui;
+
+import java.util.Map;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.dom.client.Document;
+import com.google.gwt.dom.client.Node;
+import com.google.gwt.dom.client.NodeList;
+import com.google.gwt.dom.client.ObjectElement;
+import com.google.gwt.dom.client.Style;
+import com.google.gwt.event.dom.client.DomEvent.Type;
+import com.google.gwt.event.shared.EventHandler;
+import com.google.gwt.event.shared.HandlerRegistration;
+import com.google.gwt.user.client.DOM;
+import com.google.gwt.user.client.Element;
+import com.google.gwt.user.client.Event;
+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.VConsole;
+import com.vaadin.terminal.gwt.client.VTooltip;
+
+public class EmbeddedConnector extends AbstractComponentConnector {
+
+ public static final String CLICK_EVENT_IDENTIFIER = "click";
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ // Save details
+ getWidget().client = client;
+
+ boolean clearBrowserElement = true;
+
+ clickEventHandler.handleEventHandlerRegistration(client);
+
+ if (uidl.hasAttribute("type")) {
+ getWidget().type = uidl.getStringAttribute("type");
+ if (getWidget().type.equals("image")) {
+ getWidget().addStyleName(
+ VEmbedded.CLASSNAME + "-image");
+ Element el = null;
+ boolean created = false;
+ NodeList<Node> nodes = getWidget().getElement()
+ .getChildNodes();
+ if (nodes != null && nodes.getLength() == 1) {
+ Node n = nodes.getItem(0);
+ if (n.getNodeType() == Node.ELEMENT_NODE) {
+ Element e = (Element) n;
+ if (e.getTagName().equals("IMG")) {
+ el = e;
+ }
+ }
+ }
+ if (el == null) {
+ getWidget().setHTML("");
+ el = DOM.createImg();
+ created = true;
+ DOM.sinkEvents(el, Event.ONLOAD);
+ }
+
+ // Set attributes
+ Style style = el.getStyle();
+ style.setProperty("width", getState().getWidth());
+ style.setProperty("height", getState().getHeight());
+
+ DOM.setElementProperty(el, "src", getWidget()
+ .getSrc(uidl, client));
+
+ if (created) {
+ // insert in dom late
+ getWidget().getElement().appendChild(el);
+ }
+
+ /*
+ * Sink tooltip events so tooltip is displayed when hovering the
+ * image.
+ */
+ getWidget().sinkEvents(VTooltip.TOOLTIP_EVENTS);
+
+ } else if (getWidget().type.equals("browser")) {
+ getWidget().addStyleName(
+ VEmbedded.CLASSNAME + "-browser");
+ if (getWidget().browserElement == null) {
+ getWidget().setHTML(
+ "<iframe width=\"100%\" height=\"100%\" frameborder=\"0\""
+ + " allowTransparency=\"true\" src=\"\""
+ + " name=\"" + uidl.getId()
+ + "\"></iframe>");
+ getWidget().browserElement = DOM
+ .getFirstChild(getWidget().getElement());
+ }
+ DOM.setElementAttribute(getWidget().browserElement,
+ "src", getWidget().getSrc(uidl, client));
+ clearBrowserElement = false;
+ } else {
+ VConsole.log("Unknown Embedded type '"
+ + getWidget().type + "'");
+ }
+ } else if (uidl.hasAttribute("mimetype")) {
+ final String mime = uidl.getStringAttribute("mimetype");
+ if (mime.equals("application/x-shockwave-flash")) {
+ // Handle embedding of Flash
+ getWidget().addStyleName(
+ VEmbedded.CLASSNAME + "-flash");
+ getWidget().setHTML(
+ getWidget().createFlashEmbed(uidl));
+
+ } else if (mime.equals("image/svg+xml")) {
+ getWidget().addStyleName(
+ VEmbedded.CLASSNAME + "-svg");
+ String data;
+ Map<String, String> parameters = VEmbedded.getParameters(uidl);
+ if (parameters.get("data") == null) {
+ data = getWidget().getSrc(uidl, client);
+ } else {
+ data = "data:image/svg+xml," + parameters.get("data");
+ }
+ getWidget().setHTML("");
+ ObjectElement obj = Document.get().createObjectElement();
+ obj.setType(mime);
+ obj.setData(data);
+ if (!isUndefinedWidth()) {
+ obj.getStyle().setProperty("width", "100%");
+ }
+ if (!isUndefinedHeight()) {
+ obj.getStyle().setProperty("height", "100%");
+ }
+ if (uidl.hasAttribute("classid")) {
+ obj.setAttribute("classid",
+ uidl.getStringAttribute("classid"));
+ }
+ if (uidl.hasAttribute("codebase")) {
+ obj.setAttribute("codebase",
+ uidl.getStringAttribute("codebase"));
+ }
+ if (uidl.hasAttribute("codetype")) {
+ obj.setAttribute("codetype",
+ uidl.getStringAttribute("codetype"));
+ }
+ if (uidl.hasAttribute("archive")) {
+ obj.setAttribute("archive",
+ uidl.getStringAttribute("archive"));
+ }
+ if (uidl.hasAttribute("standby")) {
+ obj.setAttribute("standby",
+ uidl.getStringAttribute("standby"));
+ }
+ getWidget().getElement().appendChild(obj);
+
+ } else {
+ VConsole.log("Unknown Embedded mimetype '" + mime + "'");
+ }
+ } else {
+ VConsole.log("Unknown Embedded; no type or mimetype attribute");
+ }
+
+ if (clearBrowserElement) {
+ getWidget().browserElement = null;
+ }
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VEmbedded.class);
+ }
+
+ @Override
+ public VEmbedded getWidget() {
+ return (VEmbedded) super.getWidget();
+ }
+
+ protected final ClickEventHandler clickEventHandler = new ClickEventHandler(
+ this, CLICK_EVENT_IDENTIFIER) {
+
+ @Override
+ protected <H extends EventHandler> HandlerRegistration registerHandler(
+ H handler, Type<H> type) {
+ return getWidget().addDomHandler(handler, type);
+ }
+
+ };
+
+}
\ No newline at end of file
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.dom.client.Style.Unit;
+import com.google.gwt.event.dom.client.KeyDownEvent;
+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.ConnectorMap;
+import com.vaadin.terminal.gwt.client.ComponentConnector;
+
+public class FormConnector extends AbstractComponentContainerConnector implements
+ SimpleManagedLayout {
+
+ @Override
+ public void init() {
+ VForm form = getWidget();
+ getLayoutManager().registerDependency(this, form.footerContainer);
+ }
+
+ @Override
+ protected boolean delegateCaptionHandling() {
+ return false;
+ }
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ getWidget().client = client;
+ getWidget().id = uidl.getId();
+
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ boolean legendEmpty = true;
+ if (getState().getCaption() != null) {
+ getWidget().caption.setInnerText(getState()
+ .getCaption());
+ legendEmpty = false;
+ } else {
+ getWidget().caption.setInnerText("");
+ }
+ if (uidl.hasAttribute(ATTRIBUTE_ICON)) {
+ if (getWidget().icon == null) {
+ getWidget().icon = new Icon(client);
+ getWidget().legend
+ .insertFirst(getWidget().icon.getElement());
+ }
+ getWidget().icon.setUri(uidl
+ .getStringAttribute(ATTRIBUTE_ICON));
+ legendEmpty = false;
+ } else {
+ if (getWidget().icon != null) {
+ getWidget().legend
+ .removeChild(getWidget().icon.getElement());
+ }
+ }
+ if (legendEmpty) {
+ getWidget().addStyleDependentName("nocaption");
+ } else {
+ getWidget().removeStyleDependentName("nocaption");
+ }
+
+ if (uidl.hasAttribute("error")) {
+ final UIDL errorUidl = uidl.getErrors();
+ getWidget().errorMessage.updateFromUIDL(errorUidl);
+ getWidget().errorMessage.setVisible(true);
+ } else {
+ getWidget().errorMessage.setVisible(false);
+ }
+
+ if (getState().hasDescription()) {
+ getWidget().desc.setInnerHTML(getState()
+ .getDescription());
+ if (getWidget().desc.getParentElement() == null) {
+ getWidget().fieldSet.insertAfter(
+ getWidget().desc,
+ getWidget().legend);
+ }
+ } else {
+ getWidget().desc.setInnerHTML("");
+ if (getWidget().desc.getParentElement() != null) {
+ getWidget().fieldSet
+ .removeChild(getWidget().desc);
+ }
+ }
+
+ // first render footer so it will be easier to handle relative height of
+ // main layout
+ if (uidl.getChildCount() > 1
+ && !uidl.getChildUIDL(1).getTag().equals("actions")) {
+ // render footer
+ ComponentConnector newFooter = client.getPaintable(uidl
+ .getChildUIDL(1));
+ Widget newFooterWidget = newFooter.getWidget();
+ if (getWidget().footer == null) {
+ getWidget().add(newFooter.getWidget(),
+ getWidget().footerContainer);
+ getWidget().footer = newFooterWidget;
+ } else if (newFooter != getWidget().footer) {
+ getWidget().remove(getWidget().footer);
+ client.unregisterPaintable(ConnectorMap.get(getConnection())
+ .getConnector(getWidget().footer));
+ getWidget().add(newFooter.getWidget(),
+ getWidget().footerContainer);
+ }
+ getWidget().footer = newFooterWidget;
+ newFooter.updateFromUIDL(uidl.getChildUIDL(1), client);
+ } else {
+ if (getWidget().footer != null) {
+ getWidget().remove(getWidget().footer);
+ client.unregisterPaintable(ConnectorMap.get(getConnection())
+ .getConnector(getWidget().footer));
+ }
+ }
+
+ final UIDL layoutUidl = uidl.getChildUIDL(0);
+ ComponentConnector newLayout = client.getPaintable(layoutUidl);
+ Widget newLayoutWidget = newLayout.getWidget();
+ if (getWidget().lo == null) {
+ // Layout not rendered before
+ getWidget().lo = newLayoutWidget;
+ getWidget().add(newLayoutWidget,
+ getWidget().fieldContainer);
+ } else if (getWidget().lo != newLayoutWidget) {
+ // Layout has changed
+ client.unregisterPaintable(ConnectorMap.get(getConnection())
+ .getConnector(getWidget().lo));
+ getWidget().remove(getWidget().lo);
+ getWidget().lo = newLayoutWidget;
+ getWidget().add(newLayoutWidget,
+ getWidget().fieldContainer);
+ }
+ newLayout.updateFromUIDL(layoutUidl, client);
+
+ // also recalculates size of the footer if undefined size form - see
+ // #3710
+ client.runDescendentsLayout(getWidget());
+
+ // We may have actions attached
+ if (uidl.getChildCount() > 1) {
+ UIDL childUidl = uidl.getChildByTagName("actions");
+ if (childUidl != null) {
+ if (getWidget().shortcutHandler == null) {
+ getWidget().shortcutHandler = new ShortcutActionHandler(
+ getId(), client);
+ getWidget().keyDownRegistration = getWidget()
+ .addDomHandler(getWidget(),
+ KeyDownEvent.getType());
+ }
+ getWidget().shortcutHandler
+ .updateActionMap(childUidl);
+ }
+ } else if (getWidget().shortcutHandler != null) {
+ getWidget().keyDownRegistration.removeHandler();
+ getWidget().shortcutHandler = null;
+ getWidget().keyDownRegistration = null;
+ }
+ }
+
+ public void updateCaption(ComponentConnector component, UIDL uidl) {
+ // NOP form don't render caption for neither field layout nor footer
+ // layout
+ }
+
+ @Override
+ public VForm getWidget() {
+ return (VForm) super.getWidget();
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VForm.class);
+ }
+
+ public void layout() {
+ VForm form = getWidget();
+
+ int footerHeight = getLayoutManager().getOuterHeight(
+ form.footerContainer);
+
+ form.fieldContainer.getStyle().setPaddingBottom(footerHeight, Unit.PX);
+ form.footerContainer.getStyle().setMarginTop(-footerHeight, Unit.PX);
+ }
+
+}
--- /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.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.terminal.gwt.client.ComponentConnector;
+
+public class FormLayoutConnector extends AbstractComponentContainerConnector {
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ getWidget().client = client;
+
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ getWidget().table.updateFromUIDL(uidl, client);
+ }
+
+ public void updateCaption(ComponentConnector component, UIDL uidl) {
+ getWidget().table.updateCaption(component, uidl);
+ }
+
+ @Override
+ public VFormLayout getWidget() {
+ return (VFormLayout) super.getWidget();
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VFormLayout.class);
+ }
+
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import java.util.HashSet;
+import java.util.Iterator;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.event.dom.client.DomEvent.Type;
+import com.google.gwt.event.shared.EventHandler;
+import com.google.gwt.event.shared.HandlerRegistration;
+import com.google.gwt.user.client.Element;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.DirectionalManagedLayout;
+import com.vaadin.terminal.gwt.client.EventId;
+import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.terminal.gwt.client.VCaption;
+import com.vaadin.terminal.gwt.client.ConnectorMap;
+import com.vaadin.terminal.gwt.client.ComponentConnector;
+import com.vaadin.terminal.gwt.client.ui.VGridLayout.Cell;
+import com.vaadin.terminal.gwt.client.ui.layout.VLayoutSlot;
+
+public class GridLayoutConnector extends AbstractComponentContainerConnector
+ implements DirectionalManagedLayout {
+ private LayoutClickEventHandler clickEventHandler = new LayoutClickEventHandler(
+ this, EventId.LAYOUT_CLICK) {
+
+ @Override
+ protected ComponentConnector getChildComponent(Element element) {
+ return getWidget().getComponent(element);
+ }
+
+ @Override
+ protected <H extends EventHandler> HandlerRegistration registerHandler(
+ H handler, Type<H> type) {
+ return getWidget().addDomHandler(handler, type);
+ }
+ };
+
+ @Override
+ public void init() {
+ getLayoutManager().registerDependency(this,
+ getWidget().spacingMeasureElement);
+ }
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ VGridLayout layout = getWidget();
+ layout.client = client;
+
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+ clickEventHandler.handleEventHandlerRegistration(client);
+
+ int cols = uidl.getIntAttribute("w");
+ int rows = uidl.getIntAttribute("h");
+
+ layout.columnWidths = new int[cols];
+ layout.rowHeights = new int[rows];
+
+ if (layout.cells == null) {
+ layout.cells = new Cell[cols][rows];
+ } else if (layout.cells.length != cols
+ || layout.cells[0].length != rows) {
+ Cell[][] newCells = new Cell[cols][rows];
+ for (int i = 0; i < layout.cells.length; i++) {
+ for (int j = 0; j < layout.cells[i].length; j++) {
+ if (i < cols && j < rows) {
+ newCells[i][j] = layout.cells[i][j];
+ }
+ }
+ }
+ layout.cells = newCells;
+ }
+
+ final int[] alignments = uidl.getIntArrayAttribute("alignments");
+ int alignmentIndex = 0;
+
+ HashSet<Widget> nonRenderedWidgets = new HashSet<Widget>(
+ layout.widgetToCell.keySet());
+
+ for (final Iterator<?> i = uidl.getChildIterator(); i.hasNext();) {
+ final UIDL r = (UIDL) i.next();
+ if ("gr".equals(r.getTag())) {
+ for (final Iterator<?> j = r.getChildIterator(); j.hasNext();) {
+ final UIDL c = (UIDL) j.next();
+ if ("gc".equals(c.getTag())) {
+ Cell cell = layout.getCell(c);
+ if (cell.hasContent()) {
+ cell.setAlignment(new AlignmentInfo(
+ alignments[alignmentIndex++]));
+ nonRenderedWidgets.remove(cell.slot.getWidget());
+ }
+ }
+ }
+ }
+ }
+
+ layout.colExpandRatioArray = uidl.getIntArrayAttribute("colExpand");
+ layout.rowExpandRatioArray = uidl.getIntArrayAttribute("rowExpand");
+
+ // clean non rendered components
+ for (Widget w : nonRenderedWidgets) {
+ Cell cell = layout.widgetToCell.remove(w);
+ cell.slot.setCaption(null);
+
+ if (w.getParent() == layout) {
+ w.removeFromParent();
+ ConnectorMap paintableMap = ConnectorMap.get(client);
+ paintableMap.unregisterConnector(paintableMap.getConnector(w));
+ }
+ cell.slot.getWrapperElement().removeFromParent();
+ }
+
+ int bitMask = uidl.getIntAttribute("margins");
+ layout.updateMarginStyleNames(new VMarginInfo(bitMask));
+
+ layout.updateSpacingStyleName(uidl.getBooleanAttribute("spacing"));
+
+ getLayoutManager().setNeedsUpdate(this);
+ }
+
+ public void updateCaption(ComponentConnector paintable, UIDL uidl) {
+ VGridLayout layout = getWidget();
+ if (VCaption.isNeeded(uidl, paintable.getState())) {
+ Cell cell = layout.widgetToCell.get(paintable
+ .getWidget());
+ VLayoutSlot layoutSlot = cell.slot;
+ VCaption caption = layoutSlot.getCaption();
+ if (caption == null) {
+ caption = new VCaption(paintable, getConnection());
+
+ Widget widget = paintable.getWidget();
+
+ layout.setCaption(widget, caption);
+ }
+ caption.updateCaption(uidl);
+ } else {
+ layout.setCaption(paintable.getWidget(), null);
+ }
+ }
+
+ @Override
+ public VGridLayout getWidget() {
+ return (VGridLayout) super.getWidget();
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VGridLayout.class);
+ }
+
+ public void layoutVertically() {
+ getWidget().updateHeight();
+ }
+
+ public void layoutHorizontally() {
+ getWidget().updateWidth();
+ }
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.core.client.GWT;
+
+public class HorizontalLayoutConnector extends AbstractOrderedLayoutConnector {
+
+ @Override
+ public VHorizontalLayout getWidget() {
+ return (VHorizontalLayout) super.getWidget();
+ }
+
+ @Override
+ protected VHorizontalLayout createWidget() {
+ return GWT.create(VHorizontalLayout.class);
+ }
+
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.core.client.GWT;
+
+public class HorizontalSplitPanelConnector extends AbstractSplitPanelConnector {
+
+ @Override
+ protected VAbstractSplitPanel createWidget() {
+ return GWT.create(VSplitPanelHorizontal.class);
+ }
+
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import java.util.Date;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.DateTimeService;
+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;
+
+public class InlineDateFieldConnector extends AbstractDateFieldConnector {
+
+ @Override
+ @SuppressWarnings("deprecation")
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ super.updateFromUIDL(uidl, client);
+ getWidget().calendarPanel
+ .setShowISOWeekNumbers(getWidget()
+ .isShowISOWeekNumbers());
+ getWidget().calendarPanel
+ .setDateTimeService(getWidget()
+ .getDateTimeService());
+ getWidget().calendarPanel
+ .setResolution(getWidget().getCurrentResolution());
+ Date currentDate = getWidget().getCurrentDate();
+ if (currentDate != null) {
+ getWidget().calendarPanel.setDate(new Date(currentDate
+ .getTime()));
+ } else {
+ getWidget().calendarPanel.setDate(null);
+ }
+
+ if (getWidget().currentResolution > VDateField.RESOLUTION_DAY) {
+ getWidget().calendarPanel
+ .setTimeChangeListener(new TimeChangeListener() {
+ public void changed(int hour, int min, int sec, int msec) {
+ Date d = getWidget().getDate();
+ if (d == null) {
+ // date currently null, use the value from
+ // calendarPanel
+ // (~ client time at the init of the widget)
+ d = (Date) getWidget().calendarPanel
+ .getDate().clone();
+ }
+ d.setHours(hour);
+ d.setMinutes(min);
+ d.setSeconds(sec);
+ DateTimeService.setMilliseconds(d, msec);
+
+ // Always update time changes to the server
+ getWidget().calendarPanel.setDate(d);
+ getWidget().updateValueFromPanel();
+ }
+ });
+ }
+
+ if (getWidget().currentResolution <= VDateField.RESOLUTION_MONTH) {
+ getWidget().calendarPanel
+ .setFocusChangeListener(new FocusChangeListener() {
+ public void focusChanged(Date date) {
+ Date date2 = new Date();
+ if (getWidget().calendarPanel.getDate() != null) {
+ date2.setTime(getWidget().calendarPanel
+ .getDate().getTime());
+ }
+ /*
+ * Update the value of calendarPanel
+ */
+ date2.setYear(date.getYear());
+ date2.setMonth(date.getMonth());
+ getWidget().calendarPanel
+ .setDate(date2);
+ /*
+ * Then update the value from panel to server
+ */
+ getWidget().updateValueFromPanel();
+ }
+ });
+ } else {
+ getWidget().calendarPanel.setFocusChangeListener(null);
+ }
+
+ // Update possible changes
+ getWidget().calendarPanel.renderCalendar();
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VDateFieldCalendar.class);
+ }
+
+ @Override
+ public VDateFieldCalendar getWidget() {
+ return (VDateFieldCalendar) super.getWidget();
+ }
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.user.client.DOM;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.UIDL;
+
+public class LinkConnector extends AbstractComponentConnector {
+
+ @Override
+ protected boolean delegateCaptionHandling() {
+ return false;
+ }
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+
+ // Ensure correct implementation,
+ // but don't let container manage caption etc.
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ getWidget().client = client;
+
+ getWidget().enabled = !getState().isDisabled();
+ getWidget().readonly = getState().isReadOnly();
+
+ if (uidl.hasAttribute("name")) {
+ getWidget().target = uidl.getStringAttribute("name");
+ getWidget().anchor.setAttribute("target",
+ getWidget().target);
+ }
+ if (uidl.hasAttribute("src")) {
+ getWidget().src = client.translateVaadinUri(uidl
+ .getStringAttribute("src"));
+ getWidget().anchor.setAttribute("href",
+ getWidget().src);
+ }
+
+ if (uidl.hasAttribute("border")) {
+ if ("none".equals(uidl.getStringAttribute("border"))) {
+ getWidget().borderStyle = VLink.BORDER_STYLE_NONE;
+ } else {
+ getWidget().borderStyle = VLink.BORDER_STYLE_MINIMAL;
+ }
+ } else {
+ getWidget().borderStyle = VLink.BORDER_STYLE_DEFAULT;
+ }
+
+ getWidget().targetHeight = uidl
+ .hasAttribute("targetHeight") ? uidl
+ .getIntAttribute("targetHeight") : -1;
+ getWidget().targetWidth = uidl.hasAttribute("targetWidth") ? uidl
+ .getIntAttribute("targetWidth") : -1;
+
+ // Set link caption
+ getWidget().captionElement.setInnerText(getState()
+ .getCaption());
+
+ // handle error
+ if (uidl.hasAttribute("error")) {
+ if (getWidget().errorIndicatorElement == null) {
+ getWidget().errorIndicatorElement = DOM.createDiv();
+ DOM.setElementProperty(
+ getWidget().errorIndicatorElement,
+ "className", "v-errorindicator");
+ }
+ DOM.insertChild(getWidget().getElement(),
+ getWidget().errorIndicatorElement, 0);
+ } else if (getWidget().errorIndicatorElement != null) {
+ DOM.setStyleAttribute(
+ getWidget().errorIndicatorElement, "display",
+ "none");
+ }
+
+ if (uidl.hasAttribute(ATTRIBUTE_ICON)) {
+ if (getWidget().icon == null) {
+ getWidget().icon = new Icon(client);
+ getWidget().anchor.insertBefore(
+ getWidget().icon.getElement(),
+ getWidget().captionElement);
+ }
+ getWidget().icon.setUri(uidl
+ .getStringAttribute(ATTRIBUTE_ICON));
+ }
+
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VLink.class);
+ }
+
+ @Override
+ public VLink getWidget() {
+ return (VLink) super.getWidget();
+ }
+}
--- /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;
+
+public class ListSelectConnector extends OptionGroupBaseConnector {
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VListSelect.class);
+ }
+
+ @Override
+ public VListSelect getWidget() {
+ return (VListSelect) super.getWidget();
+ }
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.terminal.gwt.client.Util;
+
+public abstract class MediaBaseConnector extends AbstractComponentConnector {
+
+ public static final String TAG_SOURCE = "src";
+
+ public static final String ATTR_PAUSE = "pause";
+ public static final String ATTR_PLAY = "play";
+ public static final String ATTR_MUTED = "muted";
+ public static final String ATTR_CONTROLS = "ctrl";
+ public static final String ATTR_AUTOPLAY = "auto";
+ public static final String ATTR_RESOURCE = "res";
+ public static final String ATTR_RESOURCE_TYPE = "type";
+ public static final String ATTR_HTML = "html";
+ public static final String ATTR_ALT_TEXT = "alt";
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ getWidget().setControls(shouldShowControls(uidl));
+ getWidget().setAutoplay(shouldAutoplay(uidl));
+ getWidget().setMuted(isMediaMuted(uidl));
+
+ // Add all sources
+ for (int ix = 0; ix < uidl.getChildCount(); ix++) {
+ UIDL child = uidl.getChildUIDL(ix);
+ if (TAG_SOURCE.equals(child.getTag())) {
+ getWidget()
+ .addSource(getSourceUrl(child), getSourceType(child));
+ }
+ }
+ setAltText(uidl);
+
+ evalPauseCommand(uidl);
+ evalPlayCommand(uidl);
+ }
+
+ protected boolean shouldShowControls(UIDL uidl) {
+ return uidl.getBooleanAttribute(ATTR_CONTROLS);
+ }
+
+ private boolean shouldAutoplay(UIDL uidl) {
+ return uidl.getBooleanAttribute(ATTR_AUTOPLAY);
+ }
+
+ private boolean isMediaMuted(UIDL uidl) {
+ return uidl.getBooleanAttribute(ATTR_MUTED);
+ }
+
+ private boolean allowHtmlContent(UIDL uidl) {
+ return uidl.getBooleanAttribute(ATTR_HTML);
+ }
+
+ private void evalPlayCommand(UIDL uidl) {
+ if (uidl.hasAttribute(ATTR_PLAY)) {
+ getWidget().play();
+ }
+ }
+
+ private void evalPauseCommand(UIDL uidl) {
+ if (uidl.hasAttribute(ATTR_PAUSE)) {
+ getWidget().pause();
+ }
+ }
+
+ @Override
+ public VMediaBase getWidget() {
+ return (VMediaBase) super.getWidget();
+ }
+
+ /**
+ * @param uidl
+ * @return the URL of a resource to be used as a source for the media
+ */
+ private String getSourceUrl(UIDL uidl) {
+ String url = getConnection().translateVaadinUri(
+ uidl.getStringAttribute(MediaBaseConnector.ATTR_RESOURCE));
+ if (url == null) {
+ return "";
+ }
+ return url;
+ }
+
+ /**
+ * @param uidl
+ * @return the mime type of the media
+ */
+ private String getSourceType(UIDL uidl) {
+ return uidl.getStringAttribute(MediaBaseConnector.ATTR_RESOURCE_TYPE);
+ }
+
+ private void setAltText(UIDL uidl) {
+ String alt = uidl.getStringAttribute(MediaBaseConnector.ATTR_ALT_TEXT);
+
+ if (alt == null || "".equals(alt)) {
+ alt = getWidget().getDefaultAltHtml();
+ } else if (!allowHtmlContent(uidl)) {
+ alt = Util.escapeHTML(alt);
+ }
+ getWidget().setAltText(alt);
+ }
+
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import java.util.Iterator;
+import java.util.Stack;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.user.client.Command;
+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.Util;
+import com.vaadin.terminal.gwt.client.ui.VMenuBar.CustomMenuItem;
+
+public class MenuBarConnector extends AbstractComponentConnector implements
+ SimpleManagedLayout {
+ /**
+ * This method must be implemented to update the client-side component from
+ * UIDL data received from server.
+ *
+ * This method is called when the page is loaded for the first time, and
+ * every time UI changes in the component are received from the server.
+ */
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ // This call should be made first. Ensure correct implementation,
+ // and let the containing layout manage caption, etc.
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ getWidget().htmlContentAllowed = uidl
+ .hasAttribute(VMenuBar.HTML_CONTENT_ALLOWED);
+
+ getWidget().openRootOnHover = uidl
+ .getBooleanAttribute(VMenuBar.OPEN_ROOT_MENU_ON_HOWER);
+
+ getWidget().enabled = !getState().isDisabled();
+
+ // For future connections
+ getWidget().client = client;
+ getWidget().uidlId = uidl.getId();
+
+ // Empty the menu every time it receives new information
+ if (!getWidget().getItems().isEmpty()) {
+ getWidget().clearItems();
+ }
+
+ UIDL options = uidl.getChildUIDL(0);
+
+ if (null != getState() && !getState().isUndefinedWidth()) {
+ UIDL moreItemUIDL = options.getChildUIDL(0);
+ StringBuffer itemHTML = new StringBuffer();
+
+ if (moreItemUIDL.hasAttribute("icon")) {
+ itemHTML.append("<img src=\""
+ + Util.escapeAttribute(client
+ .translateVaadinUri(moreItemUIDL
+ .getStringAttribute("icon")))
+ + "\" class=\"" + Icon.CLASSNAME + "\" alt=\"\" />");
+ }
+
+ String moreItemText = moreItemUIDL.getStringAttribute("text");
+ if ("".equals(moreItemText)) {
+ moreItemText = "►";
+ }
+ itemHTML.append(moreItemText);
+
+ getWidget().moreItem = GWT.create(CustomMenuItem.class);
+ getWidget().moreItem.setHTML(itemHTML.toString());
+ getWidget().moreItem.setCommand(VMenuBar.emptyCommand);
+
+ getWidget().collapsedRootItems = new VMenuBar(true,
+ getWidget());
+ getWidget().moreItem
+ .setSubMenu(getWidget().collapsedRootItems);
+ getWidget().moreItem.addStyleName(VMenuBar.CLASSNAME
+ + "-more-menuitem");
+ }
+
+ UIDL uidlItems = uidl.getChildUIDL(1);
+ Iterator<Object> itr = uidlItems.getChildIterator();
+ Stack<Iterator<Object>> iteratorStack = new Stack<Iterator<Object>>();
+ Stack<VMenuBar> menuStack = new Stack<VMenuBar>();
+ VMenuBar currentMenu = getWidget();
+
+ while (itr.hasNext()) {
+ UIDL item = (UIDL) itr.next();
+ CustomMenuItem currentItem = null;
+
+ final int itemId = item.getIntAttribute("id");
+
+ boolean itemHasCommand = item.hasAttribute("command");
+ boolean itemIsCheckable = item
+ .hasAttribute(VMenuBar.ATTRIBUTE_CHECKED);
+
+ String itemHTML = getWidget().buildItemHTML(item);
+
+ Command cmd = null;
+ if (!item.hasAttribute("separator")) {
+ if (itemHasCommand || itemIsCheckable) {
+ // Construct a command that fires onMenuClick(int) with the
+ // item's id-number
+ cmd = new Command() {
+ public void execute() {
+ getWidget().hostReference
+ .onMenuClick(itemId);
+ }
+ };
+ }
+ }
+
+ currentItem = currentMenu.addItem(itemHTML.toString(), cmd);
+ currentItem.updateFromUIDL(item, client);
+
+ if (item.getChildCount() > 0) {
+ menuStack.push(currentMenu);
+ iteratorStack.push(itr);
+ itr = item.getChildIterator();
+ currentMenu = new VMenuBar(true, currentMenu);
+ // this is the top-level style that also propagates to items -
+ // any item specific styles are set above in
+ // currentItem.updateFromUIDL(item, client)
+ if (getState().hasStyles()) {
+ for (String style : getState().getStyle().split(" ")) {
+ currentMenu.addStyleDependentName(style);
+ }
+ }
+ currentItem.setSubMenu(currentMenu);
+ }
+
+ while (!itr.hasNext() && !iteratorStack.empty()) {
+ boolean hasCheckableItem = false;
+ for (CustomMenuItem menuItem : currentMenu.getItems()) {
+ hasCheckableItem = hasCheckableItem
+ || menuItem.isCheckable();
+ }
+ if (hasCheckableItem) {
+ currentMenu.addStyleDependentName("check-column");
+ } else {
+ currentMenu.removeStyleDependentName("check-column");
+ }
+
+ itr = iteratorStack.pop();
+ currentMenu = menuStack.pop();
+ }
+ }// while
+
+ getWidget().iLayout(false);
+
+ }// updateFromUIDL
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VMenuBar.class);
+ }
+
+ @Override
+ public VMenuBar getWidget() {
+ return (VMenuBar) super.getWidget();
+ }
+
+ public void layout() {
+ getWidget().iLayout();
+ }
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.user.client.DOM;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.ComponentState;
+import com.vaadin.terminal.gwt.client.EventHelper;
+import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.terminal.gwt.client.ui.ButtonConnector.ButtonClientToServerRpc;
+
+public class NativeButtonConnector extends AbstractComponentConnector {
+
+ @Override
+ public void init() {
+ super.init();
+
+ ButtonClientToServerRpc rpcProxy = GWT
+ .create(ButtonClientToServerRpc.class);
+ getWidget().buttonRpcProxy = initRPC(rpcProxy);
+ }
+
+ @Override
+ protected boolean delegateCaptionHandling() {
+ return false;
+ }
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+
+ // Ensure correct implementation,
+ // but don't let container manage caption etc.
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ getWidget().disableOnClick = getState().isDisableOnClick();
+ getWidget().focusHandlerRegistration = EventHelper.updateFocusHandler(
+ this, client, getWidget().focusHandlerRegistration);
+ getWidget().blurHandlerRegistration = EventHelper.updateBlurHandler(
+ this, client, getWidget().blurHandlerRegistration);
+
+ // Save details
+ getWidget().client = client;
+ getWidget().paintableId = uidl.getId();
+
+ // Set text
+ getWidget().setText(getState().getCaption());
+
+ // handle error
+ if (uidl.hasAttribute("error")) {
+ if (getWidget().errorIndicatorElement == null) {
+ getWidget().errorIndicatorElement = DOM.createSpan();
+ getWidget().errorIndicatorElement
+ .setClassName("v-errorindicator");
+ }
+ getWidget().getElement().insertBefore(
+ getWidget().errorIndicatorElement,
+ getWidget().captionElement);
+
+ } else if (getWidget().errorIndicatorElement != null) {
+ getWidget().getElement().removeChild(
+ getWidget().errorIndicatorElement);
+ getWidget().errorIndicatorElement = null;
+ }
+
+ if (uidl.hasAttribute(ATTRIBUTE_ICON)) {
+ if (getWidget().icon == null) {
+ getWidget().icon = new Icon(client);
+ getWidget().getElement().insertBefore(
+ getWidget().icon.getElement(),
+ getWidget().captionElement);
+ }
+ getWidget().icon.setUri(uidl.getStringAttribute(ATTRIBUTE_ICON));
+ } else {
+ if (getWidget().icon != null) {
+ getWidget().getElement().removeChild(
+ getWidget().icon.getElement());
+ getWidget().icon = null;
+ }
+ }
+
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VNativeButton.class);
+ }
+
+ @Override
+ public VNativeButton getWidget() {
+ return (VNativeButton) super.getWidget();
+ }
+
+ @Override
+ public ButtonState getState() {
+ return (ButtonState) super.getState();
+ }
+
+ @Override
+ protected ComponentState createState() {
+ return GWT.create(ButtonState.class);
+ }
+}
--- /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;
+
+public class NativeSelectConnector extends OptionGroupBaseConnector {
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VNativeSelect.class);
+ }
+
+ @Override
+ public VNativeSelect getWidget() {
+ return (VNativeSelect) super.getWidget();
+ }
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.UIDL;
+
+public abstract class OptionGroupBaseConnector extends
+ AbstractComponentConnector {
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+
+ // Save details
+ getWidget().client = client;
+ getWidget().paintableId = uidl.getId();
+
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ getWidget().selectedKeys = uidl.getStringArrayVariableAsSet("selected");
+
+ getWidget().readonly = getState().isReadOnly();
+ getWidget().disabled = getState().isDisabled();
+ getWidget().multiselect = "multi".equals(uidl
+ .getStringAttribute("selectmode"));
+ getWidget().immediate = getState().isImmediate();
+ getWidget().nullSelectionAllowed = uidl
+ .getBooleanAttribute("nullselect");
+ getWidget().nullSelectionItemAvailable = uidl
+ .getBooleanAttribute("nullselectitem");
+
+ if (uidl.hasAttribute("cols")) {
+ getWidget().cols = uidl.getIntAttribute("cols");
+ }
+ if (uidl.hasAttribute("rows")) {
+ getWidget().rows = uidl.getIntAttribute("rows");
+ }
+
+ final UIDL ops = uidl.getChildUIDL(0);
+
+ if (getWidget().getColumns() > 0) {
+ getWidget().container.setWidth(getWidget().getColumns() + "em");
+ if (getWidget().container != getWidget().optionsContainer) {
+ getWidget().optionsContainer.setWidth("100%");
+ }
+ }
+
+ getWidget().buildOptions(ops);
+
+ if (uidl.getBooleanAttribute("allownewitem")) {
+ if (getWidget().newItemField == null) {
+ getWidget().newItemButton = new VNativeButton();
+ getWidget().newItemButton.setText("+");
+ getWidget().newItemButton.addClickHandler(getWidget());
+ getWidget().newItemField = new VTextField();
+ getWidget().newItemField.addKeyPressHandler(getWidget());
+ }
+ getWidget().newItemField.setEnabled(!getWidget().disabled
+ && !getWidget().readonly);
+ getWidget().newItemButton.setEnabled(!getWidget().disabled
+ && !getWidget().readonly);
+
+ if (getWidget().newItemField == null
+ || getWidget().newItemField.getParent() != getWidget().container) {
+ getWidget().container.add(getWidget().newItemField);
+ getWidget().container.add(getWidget().newItemButton);
+ final int w = getWidget().container.getOffsetWidth()
+ - getWidget().newItemButton.getOffsetWidth();
+ getWidget().newItemField.setWidth(Math.max(w, 0) + "px");
+ }
+ } else if (getWidget().newItemField != null) {
+ getWidget().container.remove(getWidget().newItemField);
+ getWidget().container.remove(getWidget().newItemButton);
+ }
+
+ getWidget().setTabIndex(
+ uidl.hasAttribute("tabindex") ? uidl
+ .getIntAttribute("tabindex") : 0);
+
+ }
+
+ @Override
+ public VOptionGroupBase getWidget() {
+ return (VOptionGroupBase) super.getWidget();
+ }
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+
+package com.vaadin.terminal.gwt.client.ui;
+
+import java.util.ArrayList;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.event.shared.HandlerRegistration;
+import com.google.gwt.user.client.ui.CheckBox;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.EventId;
+import com.vaadin.terminal.gwt.client.UIDL;
+
+public class OptionGroupConnector extends OptionGroupBaseConnector {
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ getWidget().htmlContentAllowed = uidl
+ .hasAttribute(VOptionGroup.HTML_CONTENT_ALLOWED);
+
+ super.updateFromUIDL(uidl, client);
+
+ getWidget().sendFocusEvents = client.hasEventListeners(this,
+ EventId.FOCUS);
+ getWidget().sendBlurEvents = client.hasEventListeners(this,
+ EventId.BLUR);
+
+ if (getWidget().focusHandlers != null) {
+ for (HandlerRegistration reg : getWidget().focusHandlers) {
+ reg.removeHandler();
+ }
+ getWidget().focusHandlers.clear();
+ getWidget().focusHandlers = null;
+
+ for (HandlerRegistration reg : getWidget().blurHandlers) {
+ reg.removeHandler();
+ }
+ getWidget().blurHandlers.clear();
+ getWidget().blurHandlers = null;
+ }
+
+ if (getWidget().sendFocusEvents || getWidget().sendBlurEvents) {
+ getWidget().focusHandlers = new ArrayList<HandlerRegistration>();
+ getWidget().blurHandlers = new ArrayList<HandlerRegistration>();
+
+ // add focus and blur handlers to checkboxes / radio buttons
+ for (Widget wid : getWidget().panel) {
+ if (wid instanceof CheckBox) {
+ getWidget().focusHandlers.add(((CheckBox) wid)
+ .addFocusHandler(getWidget()));
+ getWidget().blurHandlers.add(((CheckBox) wid)
+ .addBlurHandler(getWidget()));
+ }
+ }
+ }
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VOptionGroup.class);
+ }
+
+ @Override
+ public VOptionGroup getWidget() {
+ return (VOptionGroup) super.getWidget();
+ }
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.dom.client.Style;
+import com.google.gwt.dom.client.Style.Unit;
+import com.google.gwt.event.dom.client.DomEvent.Type;
+import com.google.gwt.event.shared.EventHandler;
+import com.google.gwt.event.shared.HandlerRegistration;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.LayoutManager;
+import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.terminal.gwt.client.ComponentConnector;
+
+public class PanelConnector extends AbstractComponentContainerConnector
+ implements SimpleManagedLayout, PostLayoutListener {
+
+ public static final String CLICK_EVENT_IDENTIFIER = "click";
+
+ private Integer uidlScrollTop;
+
+ private ClickEventHandler clickEventHandler = new ClickEventHandler(this,
+ CLICK_EVENT_IDENTIFIER) {
+
+ @Override
+ protected <H extends EventHandler> HandlerRegistration registerHandler(
+ H handler, Type<H> type) {
+ return getWidget().addDomHandler(handler, type);
+ }
+ };
+
+ private Integer uidlScrollLeft;
+
+ @Override
+ public void init() {
+ VPanel panel = getWidget();
+ LayoutManager layoutManager = getLayoutManager();
+
+ layoutManager.registerDependency(this, panel.captionNode);
+ layoutManager.registerDependency(this, panel.bottomDecoration);
+ layoutManager.registerDependency(this, panel.contentNode);
+ }
+
+ @Override
+ protected boolean delegateCaptionHandling() {
+ return false;
+ }
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ if (isRealUpdate(uidl)) {
+
+ // Handle caption displaying and style names, prior generics.
+ // Affects size calculations
+
+ // Restore default stylenames
+ getWidget().contentNode.setClassName(VPanel.CLASSNAME
+ + "-content");
+ getWidget().bottomDecoration
+ .setClassName(VPanel.CLASSNAME + "-deco");
+ getWidget().captionNode.setClassName(VPanel.CLASSNAME
+ + "-caption");
+ boolean hasCaption = false;
+ if (getState().getCaption() != null
+ && !"".equals(getState().getCaption())) {
+ getWidget().setCaption(getState().getCaption());
+ hasCaption = true;
+ } else {
+ getWidget().setCaption("");
+ getWidget().captionNode
+ .setClassName(VPanel.CLASSNAME + "-nocaption");
+ }
+
+ // Add proper stylenames for all elements. This way we can prevent
+ // unwanted CSS selector inheritance.
+ final String captionBaseClass = VPanel.CLASSNAME
+ + (hasCaption ? "-caption" : "-nocaption");
+ final String contentBaseClass = VPanel.CLASSNAME + "-content";
+ final String decoBaseClass = VPanel.CLASSNAME + "-deco";
+ String captionClass = captionBaseClass;
+ String contentClass = contentBaseClass;
+ String decoClass = decoBaseClass;
+ if (getState().hasStyles()) {
+ final String[] styles = getState().getStyle().split(" ");
+ for (int i = 0; i < styles.length; i++) {
+ captionClass += " " + captionBaseClass + "-" + styles[i];
+ contentClass += " " + contentBaseClass + "-" + styles[i];
+ decoClass += " " + decoBaseClass + "-" + styles[i];
+ }
+ }
+ getWidget().captionNode.setClassName(captionClass);
+ getWidget().contentNode.setClassName(contentClass);
+ getWidget().bottomDecoration.setClassName(decoClass);
+ }
+ // Ensure correct implementation
+ super.updateFromUIDL(uidl, client);
+
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ clickEventHandler.handleEventHandlerRegistration(client);
+
+ getWidget().client = client;
+ getWidget().id = uidl.getId();
+
+ getWidget().setIconUri(uidl, client);
+
+ getWidget().handleError(uidl);
+
+ // Render content
+ final UIDL layoutUidl = uidl.getChildUIDL(0);
+ final ComponentConnector newLayout = client.getPaintable(layoutUidl);
+ if (newLayout != getWidget().layout) {
+ if (getWidget().layout != null) {
+ client.unregisterPaintable(getWidget().layout);
+ }
+ getWidget()
+ .setWidget(newLayout.getWidget());
+ getWidget().layout = newLayout;
+ }
+ getWidget().layout.updateFromUIDL(layoutUidl, client);
+
+ // We may have actions attached to this panel
+ if (uidl.getChildCount() > 1) {
+ final int cnt = uidl.getChildCount();
+ for (int i = 1; i < cnt; i++) {
+ UIDL childUidl = uidl.getChildUIDL(i);
+ if (childUidl.getTag().equals("actions")) {
+ if (getWidget().shortcutHandler == null) {
+ getWidget().shortcutHandler = new ShortcutActionHandler(
+ getId(), client);
+ }
+ getWidget().shortcutHandler
+ .updateActionMap(childUidl);
+ }
+ }
+ }
+
+ if (uidl.hasVariable("scrollTop")
+ && uidl.getIntVariable("scrollTop") != getWidget().scrollTop) {
+ // Sizes are not yet up to date, so changing the scroll position
+ // is deferred to after the layout phase
+ uidlScrollTop = new Integer(uidl.getIntVariable("scrollTop"));
+ }
+
+ if (uidl.hasVariable("scrollLeft")
+ && uidl.getIntVariable("scrollLeft") != getWidget().scrollLeft) {
+ // Sizes are not yet up to date, so changing the scroll position
+ // is deferred to after the layout phase
+ uidlScrollLeft = new Integer(uidl.getIntVariable("scrollLeft"));
+ }
+
+ // And apply tab index
+ if (uidl.hasVariable("tabindex")) {
+ getWidget().contentNode.setTabIndex(uidl
+ .getIntVariable("tabindex"));
+ }
+ }
+
+ public void updateCaption(ComponentConnector component, UIDL uidl) {
+ // NOP: layouts caption, errors etc not rendered in Panel
+ }
+
+ @Override
+ public VPanel getWidget() {
+ return (VPanel) super.getWidget();
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VPanel.class);
+ }
+
+ public void layout() {
+ updateSizes();
+ }
+
+ void updateSizes() {
+ VPanel panel = getWidget();
+
+ Style contentStyle = panel.contentNode.getStyle();
+ if (isUndefinedHeight()) {
+ contentStyle.clearHeight();
+ } else {
+ contentStyle.setHeight(100, Unit.PCT);
+ }
+
+ if (isUndefinedWidth()) {
+ contentStyle.clearWidth();
+ } else {
+ contentStyle.setWidth(100, Unit.PCT);
+ }
+
+ LayoutManager layoutManager = getLayoutManager();
+ int top = layoutManager.getOuterHeight(panel.captionNode);
+ int bottom = layoutManager.getOuterHeight(panel.bottomDecoration);
+
+ Style style = panel.getElement().getStyle();
+ panel.captionNode.getStyle().setMarginTop(-top, Unit.PX);
+ panel.bottomDecoration.getStyle().setMarginBottom(-bottom, Unit.PX);
+ style.setPaddingTop(top, Unit.PX);
+ style.setPaddingBottom(bottom, Unit.PX);
+
+ // Update scroll positions
+ panel.contentNode.setScrollTop(panel.scrollTop);
+ panel.contentNode.setScrollLeft(panel.scrollLeft);
+ // Read actual value back to ensure update logic is correct
+ panel.scrollTop = panel.contentNode.getScrollTop();
+ panel.scrollLeft = panel.contentNode.getScrollLeft();
+ }
+
+ public void postLayout() {
+ VPanel panel = getWidget();
+ if (uidlScrollTop != null) {
+ panel.contentNode.setScrollTop(uidlScrollTop.intValue());
+ // Read actual value back to ensure update logic is correct
+ // TODO Does this trigger reflows?
+ panel.scrollTop = panel.contentNode.getScrollTop();
+ uidlScrollTop = null;
+ }
+
+ if (uidlScrollLeft != null) {
+ panel.contentNode.setScrollLeft(uidlScrollLeft.intValue());
+ // Read actual value back to ensure update logic is correct
+ // TODO Does this trigger reflows?
+ panel.scrollLeft = panel.contentNode.getScrollLeft();
+ uidlScrollLeft = null;
+ }
+ }
+
+}
--- /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.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.UIDL;
+
+public class PasswordFieldConnector extends TextFieldConnector {
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ super.updateFromUIDL(uidl, client);
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VPasswordField.class);
+ }
+
+ @Override
+ public VPasswordField getWidget() {
+ return (VPasswordField) super.getWidget();
+ }
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+
+package com.vaadin.terminal.gwt.client.ui;
+
+import java.util.Date;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.DateTimeService;
+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;
+
+public class PopupDateFieldConnector extends TextualDateConnector {
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * com.vaadin.terminal.gwt.client.ui.VTextualDate#updateFromUIDL(com.vaadin
+ * .terminal.gwt.client.UIDL,
+ * com.vaadin.terminal.gwt.client.ApplicationConnection)
+ */
+ @Override
+ @SuppressWarnings("deprecation")
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ boolean lastReadOnlyState = getWidget().readonly;
+ boolean lastEnabledState = getWidget().isEnabled();
+
+ getWidget().parsable = uidl.getBooleanAttribute("parsable");
+
+ super.updateFromUIDL(uidl, client);
+
+ String popupStyleNames = getStyleNameFromUIDL(
+ VPopupCalendar.POPUP_PRIMARY_STYLE_NAME, uidl, getState(),
+ false);
+ popupStyleNames += " "
+ + VDateField.CLASSNAME
+ + "-"
+ + VPopupCalendar
+ .resolutionToString(getWidget().currentResolution);
+ getWidget().popup.setStyleName(popupStyleNames);
+
+ getWidget().calendar.setDateTimeService(getWidget()
+ .getDateTimeService());
+ getWidget().calendar.setShowISOWeekNumbers(getWidget()
+ .isShowISOWeekNumbers());
+ if (getWidget().calendar.getResolution() != getWidget().currentResolution) {
+ getWidget().calendar.setResolution(getWidget().currentResolution);
+ if (getWidget().calendar.getDate() != null) {
+ getWidget().calendar.setDate((Date) getWidget()
+ .getCurrentDate().clone());
+ // force re-render when changing resolution only
+ getWidget().calendar.renderCalendar();
+ }
+ }
+ getWidget().calendarToggle.setEnabled(getWidget().enabled);
+
+ if (getWidget().currentResolution <= VPopupCalendar.RESOLUTION_MONTH) {
+ getWidget().calendar
+ .setFocusChangeListener(new FocusChangeListener() {
+ public void focusChanged(Date date) {
+ getWidget().updateValue(date);
+ getWidget().buildDate();
+ Date date2 = getWidget().calendar.getDate();
+ date2.setYear(date.getYear());
+ date2.setMonth(date.getMonth());
+ }
+ });
+ } else {
+ getWidget().calendar.setFocusChangeListener(null);
+ }
+
+ if (getWidget().currentResolution > VPopupCalendar.RESOLUTION_DAY) {
+ getWidget().calendar
+ .setTimeChangeListener(new TimeChangeListener() {
+ public void changed(int hour, int min, int sec, int msec) {
+ Date d = getWidget().getDate();
+ if (d == null) {
+ // date currently null, use the value from
+ // calendarPanel
+ // (~ client time at the init of the widget)
+ d = (Date) getWidget().calendar.getDate()
+ .clone();
+ }
+ d.setHours(hour);
+ d.setMinutes(min);
+ d.setSeconds(sec);
+ DateTimeService.setMilliseconds(d, msec);
+
+ // Always update time changes to the server
+ getWidget().updateValue(d);
+
+ // Update text field
+ getWidget().buildDate();
+ }
+ });
+ }
+
+ if (getWidget().readonly) {
+ getWidget().calendarToggle.addStyleName(VPopupCalendar.CLASSNAME
+ + "-button-readonly");
+ } else {
+ getWidget().calendarToggle.removeStyleName(VPopupCalendar.CLASSNAME
+ + "-button-readonly");
+ }
+
+ getWidget().calendarToggle.setEnabled(true);
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VPopupCalendar.class);
+ }
+
+ @Override
+ public VPopupCalendar getWidget() {
+ return (VPopupCalendar) super.getWidget();
+ }
+}
--- /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.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.terminal.gwt.client.VCaption;
+import com.vaadin.terminal.gwt.client.VCaptionWrapper;
+import com.vaadin.terminal.gwt.client.ComponentConnector;
+
+public class PopupViewConnector extends AbstractComponentContainerConnector {
+
+ @Override
+ protected boolean delegateCaptionHandling() {
+ return false;
+ }
+
+ /**
+ *
+ *
+ * @see com.vaadin.terminal.gwt.client.ComponentConnector#updateFromUIDL(com.vaadin.terminal.gwt.client.UIDL,
+ * com.vaadin.terminal.gwt.client.ApplicationConnection)
+ */
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ // This call should be made first. Ensure correct implementation,
+ // and don't let the containing layout manage caption.
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+ // These are for future server connections
+ getWidget().client = client;
+ getWidget().uidlId = uidl.getId();
+
+ getWidget().hostPopupVisible = uidl
+ .getBooleanVariable("popupVisibility");
+
+ getWidget().setHTML(uidl.getStringAttribute("html"));
+
+ if (uidl.hasAttribute("hideOnMouseOut")) {
+ getWidget().popup.setHideOnMouseOut(uidl
+ .getBooleanAttribute("hideOnMouseOut"));
+ }
+
+ // Render the popup if visible and show it.
+ if (getWidget().hostPopupVisible) {
+ UIDL popupUIDL = uidl.getChildUIDL(0);
+
+ // showPopupOnTop(popup, hostReference);
+ getWidget().preparePopup(getWidget().popup);
+ getWidget().popup.updateFromUIDL(popupUIDL, client);
+ if (getState().hasStyles()) {
+ final String[] styles = getState().getStyle().split(" ");
+ final StringBuffer styleBuf = new StringBuffer();
+ final String primaryName = getWidget().popup
+ .getStylePrimaryName();
+ styleBuf.append(primaryName);
+ for (int i = 0; i < styles.length; i++) {
+ styleBuf.append(" ");
+ styleBuf.append(primaryName);
+ styleBuf.append("-");
+ styleBuf.append(styles[i]);
+ }
+ getWidget().popup.setStyleName(styleBuf.toString());
+ } else {
+ getWidget().popup
+ .setStyleName(getWidget().popup
+ .getStylePrimaryName());
+ }
+ getWidget().showPopup(getWidget().popup);
+
+ // The popup shouldn't be visible, try to hide it.
+ } else {
+ getWidget().popup.hide();
+ }
+ }// updateFromUIDL
+
+ public void updateCaption(ComponentConnector component, UIDL uidl) {
+ if (VCaption.isNeeded(uidl, component.getState())) {
+ if (getWidget().popup.captionWrapper != null) {
+ getWidget().popup.captionWrapper
+ .updateCaption(uidl);
+ } else {
+ getWidget().popup.captionWrapper = new VCaptionWrapper(
+ component, getConnection());
+ getWidget().popup
+ .setWidget(getWidget().popup.captionWrapper);
+ getWidget().popup.captionWrapper
+ .updateCaption(uidl);
+ }
+ } else {
+ if (getWidget().popup.captionWrapper != null) {
+ getWidget().popup
+ .setWidget(getWidget().popup.popupComponentWidget);
+ }
+ }
+ }
+
+ @Override
+ public VPopupView getWidget() {
+ return (VPopupView) super.getWidget();
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VPopupView.class);
+ }
+
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.user.client.DOM;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.UIDL;
+
+public class ProgressIndicatorConnector extends AbstractComponentConnector {
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+
+ // Ensure correct implementation,
+ // but don't let container manage caption etc.
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ // Save details
+ getWidget().client = client;
+
+ getWidget().indeterminate = uidl
+ .getBooleanAttribute("indeterminate");
+
+ if (getWidget().indeterminate) {
+ String basename = VProgressIndicator.CLASSNAME + "-indeterminate";
+ getWidget().addStyleName(basename);
+ if (getState().isDisabled()) {
+ getWidget().addStyleName(basename + "-disabled");
+ } else {
+ getWidget().removeStyleName(basename + "-disabled");
+ }
+ } else {
+ try {
+ final float f = Float.parseFloat(uidl
+ .getStringAttribute("state"));
+ final int size = Math.round(100 * f);
+ DOM.setStyleAttribute(getWidget().indicator,
+ "width", size + "%");
+ } catch (final Exception e) {
+ }
+ }
+
+ if (!getState().isDisabled()) {
+ getWidget().interval = uidl
+ .getIntAttribute("pollinginterval");
+ getWidget().poller
+ .scheduleRepeating(getWidget().interval);
+ }
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VProgressIndicator.class);
+ }
+
+ @Override
+ public VProgressIndicator getWidget() {
+ return (VProgressIndicator) super.getWidget();
+ }
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import java.util.HashSet;
+import java.util.Iterator;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.core.client.Scheduler;
+import com.google.gwt.event.dom.client.DomEvent.Type;
+import com.google.gwt.event.shared.EventHandler;
+import com.google.gwt.event.shared.HandlerRegistration;
+import com.google.gwt.user.client.Command;
+import com.google.gwt.user.client.DOM;
+import com.google.gwt.user.client.Event;
+import com.google.gwt.user.client.History;
+import com.google.gwt.user.client.Window;
+import com.google.gwt.user.client.ui.RootPanel;
+import com.google.gwt.user.client.ui.Widget;
+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.ConnectorMap;
+import com.vaadin.terminal.gwt.client.Focusable;
+import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.terminal.gwt.client.Util;
+import com.vaadin.terminal.gwt.client.VConsole;
+
+public class RootConnector extends AbstractComponentContainerConnector {
+
+ private static final String CLICK_EVENT_IDENTIFIER = PanelConnector.CLICK_EVENT_IDENTIFIER;
+
+ @Override
+ public void updateFromUIDL(final UIDL uidl, ApplicationConnection client) {
+ getWidget().rendering = true;
+ // As VView is not created in the same way as all other paintables we
+ // have to set the id here
+ setId(uidl.getId());
+ getWidget().id = uidl.getId();
+ boolean firstPaint = getWidget().connection == null;
+ getWidget().connection = client;
+
+ getWidget().immediate = getState().isImmediate();
+ getWidget().resizeLazy = uidl.hasAttribute(VView.RESIZE_LAZY);
+ String newTheme = uidl.getStringAttribute("theme");
+ if (getWidget().theme != null && !newTheme.equals(getWidget().theme)) {
+ // Complete page refresh is needed due css can affect layout
+ // calculations etc
+ getWidget().reloadHostPage();
+ } else {
+ getWidget().theme = newTheme;
+ }
+ // this also implicitly removes old styles
+ getWidget()
+ .setStyleName(
+ getWidget().getStylePrimaryName() + " "
+ + getState().getStyle());
+
+ clickEventHandler.handleEventHandlerRegistration(client);
+
+ if (!getWidget().isEmbedded() && getState().getCaption() != null) {
+ // only change window title if we're in charge of the whole page
+ com.google.gwt.user.client.Window.setTitle(getState().getCaption());
+ }
+
+ // Process children
+ int childIndex = 0;
+
+ // Open URL:s
+ boolean isClosed = false; // was this window closed?
+ while (childIndex < uidl.getChildCount()
+ && "open".equals(uidl.getChildUIDL(childIndex).getTag())) {
+ final UIDL open = uidl.getChildUIDL(childIndex);
+ final String url = client.translateVaadinUri(open
+ .getStringAttribute("src"));
+ final String target = open.getStringAttribute("name");
+ if (target == null) {
+ // source will be opened to this browser window, but we may have
+ // to finish rendering this window in case this is a download
+ // (and window stays open).
+ Scheduler.get().scheduleDeferred(new Command() {
+ public void execute() {
+ VView.goTo(url);
+ }
+ });
+ } else if ("_self".equals(target)) {
+ // This window is closing (for sure). Only other opens are
+ // relevant in this change. See #3558, #2144
+ isClosed = true;
+ VView.goTo(url);
+ } else {
+ String options;
+ if (open.hasAttribute("border")) {
+ if (open.getStringAttribute("border").equals("minimal")) {
+ options = "menubar=yes,location=no,status=no";
+ } else {
+ options = "menubar=no,location=no,status=no";
+ }
+
+ } else {
+ options = "resizable=yes,menubar=yes,toolbar=yes,directories=yes,location=yes,scrollbars=yes,status=yes";
+ }
+
+ if (open.hasAttribute("width")) {
+ int w = open.getIntAttribute("width");
+ options += ",width=" + w;
+ }
+ if (open.hasAttribute("height")) {
+ int h = open.getIntAttribute("height");
+ options += ",height=" + h;
+ }
+
+ Window.open(url, target, options);
+ }
+ childIndex++;
+ }
+ if (isClosed) {
+ // don't render the content, something else will be opened to this
+ // browser view
+ getWidget().rendering = false;
+ return;
+ }
+
+ // Draw this application level window
+ UIDL childUidl = uidl.getChildUIDL(childIndex);
+ final ComponentConnector lo = client.getPaintable(childUidl);
+
+ if (getWidget().layout != null) {
+ if (getWidget().layout != lo) {
+ // remove old
+ client.unregisterPaintable(getWidget().layout);
+ // add new
+ getWidget().setWidget(lo.getWidget());
+ getWidget().layout = lo;
+ }
+ } else {
+ getWidget().setWidget(lo.getWidget());
+ getWidget().layout = lo;
+ }
+
+ getWidget().layout.updateFromUIDL(childUidl, client);
+
+ // Save currently open subwindows to track which will need to be closed
+ final HashSet<VWindow> removedSubWindows = new HashSet<VWindow>(
+ getWidget().subWindows);
+
+ // Handle other UIDL children
+ while ((childUidl = uidl.getChildUIDL(++childIndex)) != null) {
+ String tag = childUidl.getTag().intern();
+ if (tag == "actions") {
+ if (getWidget().actionHandler == null) {
+ getWidget().actionHandler = new ShortcutActionHandler(
+ getWidget().id, client);
+ }
+ getWidget().actionHandler.updateActionMap(childUidl);
+ } else if (tag == "execJS") {
+ String script = childUidl.getStringAttribute("script");
+ VView.eval(script);
+ } else if (tag == "notifications") {
+ for (final Iterator<?> it = childUidl.getChildIterator(); it
+ .hasNext();) {
+ final UIDL notification = (UIDL) it.next();
+ VNotification.showNotification(client, notification);
+ }
+ } else {
+ // subwindows
+ final WindowConnector w = (WindowConnector) client
+ .getPaintable(childUidl);
+ VWindow windowWidget = w.getWidget();
+ if (getWidget().subWindows.contains(windowWidget)) {
+ removedSubWindows.remove(windowWidget);
+ } else {
+ getWidget().subWindows.add(windowWidget);
+ }
+ w.updateFromUIDL(childUidl, client);
+ }
+ }
+
+ // Close old windows which where not in UIDL anymore
+ for (final Iterator<VWindow> rem = removedSubWindows.iterator(); rem
+ .hasNext();) {
+ final VWindow w = rem.next();
+ client.unregisterPaintable(ConnectorMap.get(getConnection())
+ .getConnector(w));
+ getWidget().subWindows.remove(w);
+ w.hide();
+ }
+
+ if (uidl.hasAttribute("focused")) {
+ // set focused component when render phase is finished
+ Scheduler.get().scheduleDeferred(new Command() {
+ public void execute() {
+ ComponentConnector paintable = (ComponentConnector) uidl
+ .getPaintableAttribute("focused", getConnection());
+
+ final Widget toBeFocused = paintable.getWidget();
+ /*
+ * Two types of Widgets can be focused, either implementing
+ * GWT HasFocus of a thinner Vaadin specific Focusable
+ * interface.
+ */
+ if (toBeFocused instanceof com.google.gwt.user.client.ui.Focusable) {
+ final com.google.gwt.user.client.ui.Focusable toBeFocusedWidget = (com.google.gwt.user.client.ui.Focusable) toBeFocused;
+ toBeFocusedWidget.setFocus(true);
+ } else if (toBeFocused instanceof Focusable) {
+ ((Focusable) toBeFocused).focus();
+ } else {
+ VConsole.log("Could not focus component");
+ }
+ }
+ });
+ }
+
+ // Add window listeners on first paint, to prevent premature
+ // variablechanges
+ if (firstPaint) {
+ Window.addWindowClosingHandler(getWidget());
+ Window.addResizeHandler(getWidget());
+ }
+
+ getWidget().onResize();
+
+ // finally set scroll position from UIDL
+ if (uidl.hasVariable("scrollTop")) {
+ getWidget().scrollable = true;
+ getWidget().scrollTop = uidl.getIntVariable("scrollTop");
+ DOM.setElementPropertyInt(getWidget().getElement(), "scrollTop",
+ getWidget().scrollTop);
+ getWidget().scrollLeft = uidl.getIntVariable("scrollLeft");
+ DOM.setElementPropertyInt(getWidget().getElement(), "scrollLeft",
+ getWidget().scrollLeft);
+ } else {
+ getWidget().scrollable = false;
+ }
+
+ // Safari workaround must be run after scrollTop is updated as it sets
+ // scrollTop using a deferred command.
+ if (BrowserInfo.get().isSafari()) {
+ Util.runWebkitOverflowAutoFix(getWidget().getElement());
+ }
+
+ getWidget().scrollIntoView(uidl);
+
+ if (uidl.hasAttribute(VView.FRAGMENT_VARIABLE)) {
+ getWidget().currentFragment = uidl
+ .getStringAttribute(VView.FRAGMENT_VARIABLE);
+ if (!getWidget().currentFragment.equals(History.getToken())) {
+ History.newItem(getWidget().currentFragment, true);
+ }
+ } else {
+ // Initial request for which the server doesn't yet have a fragment
+ // (and haven't shown any interest in getting one)
+ getWidget().currentFragment = History.getToken();
+
+ // Include current fragment in the next request
+ client.updateVariable(getWidget().id, VView.FRAGMENT_VARIABLE,
+ getWidget().currentFragment, false);
+ }
+
+ getWidget().rendering = false;
+ }
+
+ public void init(String rootPanelId,
+ ApplicationConnection applicationConnection) {
+ DOM.sinkEvents(getWidget().getElement(), Event.ONKEYDOWN
+ | Event.ONSCROLL);
+
+ // iview is focused when created so element needs tabIndex
+ // 1 due 0 is at the end of natural tabbing order
+ DOM.setElementProperty(getWidget().getElement(), "tabIndex", "1");
+
+ RootPanel root = RootPanel.get(rootPanelId);
+
+ // Remove the v-app-loading or any splash screen added inside the div by
+ // the user
+ root.getElement().setInnerHTML("");
+ // For backwards compatibility with static index pages only.
+ // No longer added by AbstractApplicationServlet/Portlet
+ root.removeStyleName("v-app-loading");
+
+ String themeUri = applicationConnection.getConfiguration()
+ .getThemeUri();
+ String themeName = themeUri.substring(themeUri.lastIndexOf('/'));
+ themeName = themeName.replaceAll("[^a-zA-Z0-9]", "");
+ root.addStyleName("v-theme-" + themeName);
+
+ root.add(getWidget());
+
+ if (applicationConnection.getConfiguration().isStandalone()) {
+ // set focus to iview element by default to listen possible keyboard
+ // shortcuts. For embedded applications this is unacceptable as we
+ // don't want to steal focus from the main page nor we don't want
+ // side-effects from focusing (scrollIntoView).
+ getWidget().getElement().focus();
+ }
+ }
+
+ private ClickEventHandler clickEventHandler = new ClickEventHandler(this,
+ CLICK_EVENT_IDENTIFIER) {
+
+ @Override
+ protected <H extends EventHandler> HandlerRegistration registerHandler(
+ H handler, Type<H> type) {
+ return getWidget().addDomHandler(handler, type);
+ }
+ };
+
+ public void updateCaption(ComponentConnector component, UIDL uidl) {
+ // NOP The main view never draws caption for its layout
+ }
+
+ @Override
+ public VView getWidget() {
+ return (VView) super.getWidget();
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VView.class);
+ }
+
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.core.client.Scheduler;
+import com.google.gwt.user.client.Command;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.UIDL;
+
+public class SliderConnector extends AbstractComponentConnector {
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+
+ getWidget().client = client;
+ getWidget().id = uidl.getId();
+
+ // Ensure correct implementation
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ getWidget().immediate = getState().isImmediate();
+ getWidget().disabled = getState().isDisabled();
+ getWidget().readonly = getState().isReadOnly();
+
+ getWidget().vertical = uidl.hasAttribute("vertical");
+
+ // TODO should these style names be used?
+ String style = getState().getStyle();
+
+ if (getWidget().vertical) {
+ getWidget().addStyleName(
+ VSlider.CLASSNAME + "-vertical");
+ } else {
+ getWidget().removeStyleName(
+ VSlider.CLASSNAME + "-vertical");
+ }
+
+ getWidget().min = uidl.getDoubleAttribute("min");
+ getWidget().max = uidl.getDoubleAttribute("max");
+ getWidget().resolution = uidl.getIntAttribute("resolution");
+ getWidget().value = new Double(
+ uidl.getDoubleVariable("value"));
+
+ getWidget().setFeedbackValue(getWidget().value);
+
+ getWidget().buildBase();
+
+ if (!getWidget().vertical) {
+ // Draw handle with a delay to allow base to gain maximum width
+ Scheduler.get().scheduleDeferred(new Command() {
+ public void execute() {
+ getWidget().buildHandle();
+ getWidget().setValue(
+ getWidget().value, false);
+ }
+ });
+ } else {
+ getWidget().buildHandle();
+ getWidget().setValue(getWidget().value,
+ false);
+ }
+ }
+
+ @Override
+ public VSlider getWidget() {
+ return (VSlider) super.getWidget();
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VSlider.class);
+ }
+
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.core.client.Scheduler;
+import com.google.gwt.dom.client.Style.Position;
+import com.google.gwt.user.client.Command;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.BrowserInfo;
+import com.vaadin.terminal.gwt.client.DirectionalManagedLayout;
+import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.terminal.gwt.client.Util;
+import com.vaadin.terminal.gwt.client.ComponentConnector;
+
+public class TableConnector extends AbstractComponentContainerConnector
+ implements DirectionalManagedLayout {
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see
+ * com.vaadin.terminal.gwt.client.Paintable#updateFromUIDL(com.vaadin.terminal
+ * .gwt.client.UIDL, com.vaadin.terminal.gwt.client.ApplicationConnection)
+ */
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ getWidget().rendering = true;
+
+ if (uidl.hasAttribute(VScrollTable.ATTRIBUTE_PAGEBUFFER_FIRST)) {
+ getWidget().serverCacheFirst = uidl
+ .getIntAttribute(VScrollTable.ATTRIBUTE_PAGEBUFFER_FIRST);
+ getWidget().serverCacheLast = uidl
+ .getIntAttribute(VScrollTable.ATTRIBUTE_PAGEBUFFER_LAST);
+ } else {
+ getWidget().serverCacheFirst = -1;
+ getWidget().serverCacheLast = -1;
+ }
+ /*
+ * We need to do this before updateComponent since updateComponent calls
+ * this.setHeight() which will calculate a new body height depending on
+ * the space available.
+ */
+ if (uidl.hasAttribute("colfooters")) {
+ getWidget().showColFooters = uidl
+ .getBooleanAttribute("colfooters");
+ }
+
+ getWidget().tFoot
+ .setVisible(getWidget().showColFooters);
+
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ getWidget().rendering = false;
+ return;
+ }
+
+ getWidget().enabled = !getState().isDisabled();
+
+ if (BrowserInfo.get().isIE8() && !getWidget().enabled) {
+ /*
+ * The disabled shim will not cover the table body if it is relative
+ * in IE8. See #7324
+ */
+ getWidget().scrollBodyPanel.getElement().getStyle()
+ .setPosition(Position.STATIC);
+ } else if (BrowserInfo.get().isIE8()) {
+ getWidget().scrollBodyPanel.getElement().getStyle()
+ .setPosition(Position.RELATIVE);
+ }
+
+ getWidget().client = client;
+ getWidget().paintableId = uidl.getStringAttribute("id");
+ getWidget().immediate = getState().isImmediate();
+
+ int previousTotalRows = getWidget().totalRows;
+ getWidget().updateTotalRows(uidl);
+ boolean totalRowsChanged = (getWidget().totalRows != previousTotalRows);
+
+ getWidget().updateDragMode(uidl);
+
+ getWidget().updateSelectionProperties(uidl, getState());
+
+ if (uidl.hasAttribute("alb")) {
+ getWidget().bodyActionKeys = uidl
+ .getStringArrayAttribute("alb");
+ } else {
+ // Need to clear the actions if the action handlers have been
+ // removed
+ getWidget().bodyActionKeys = null;
+ }
+
+ getWidget().setCacheRateFromUIDL(uidl);
+
+ getWidget().recalcWidths = uidl
+ .hasAttribute("recalcWidths");
+ if (getWidget().recalcWidths) {
+ getWidget().tHead.clear();
+ getWidget().tFoot.clear();
+ }
+
+ getWidget().updatePageLength(uidl);
+
+ getWidget().updateFirstVisibleAndScrollIfNeeded(uidl);
+
+ getWidget().showRowHeaders = uidl
+ .getBooleanAttribute("rowheaders");
+ getWidget().showColHeaders = uidl
+ .getBooleanAttribute("colheaders");
+
+ getWidget().updateSortingProperties(uidl);
+
+ boolean keyboardSelectionOverRowFetchInProgress = getWidget()
+ .selectSelectedRows(uidl);
+
+ getWidget().updateActionMap(uidl);
+
+ getWidget().updateColumnProperties(uidl);
+
+ UIDL ac = uidl.getChildByTagName("-ac");
+ if (ac == null) {
+ if (getWidget().dropHandler != null) {
+ // remove dropHandler if not present anymore
+ getWidget().dropHandler = null;
+ }
+ } else {
+ if (getWidget().dropHandler == null) {
+ getWidget().dropHandler = getWidget().new VScrollTableDropHandler();
+ }
+ getWidget().dropHandler.updateAcceptRules(ac);
+ }
+
+ UIDL partialRowAdditions = uidl.getChildByTagName("prows");
+ UIDL partialRowUpdates = uidl.getChildByTagName("urows");
+ if (partialRowUpdates != null || partialRowAdditions != null) {
+ // we may have pending cache row fetch, cancel it. See #2136
+ getWidget().rowRequestHandler.cancel();
+
+ getWidget().updateRowsInBody(partialRowUpdates);
+ getWidget().addAndRemoveRows(partialRowAdditions);
+ } else {
+ UIDL rowData = uidl.getChildByTagName("rows");
+ if (rowData != null) {
+ // we may have pending cache row fetch, cancel it. See #2136
+ getWidget().rowRequestHandler.cancel();
+
+ if (!getWidget().recalcWidths
+ && getWidget().initializedAndAttached) {
+ getWidget().updateBody(rowData,
+ uidl.getIntAttribute("firstrow"),
+ uidl.getIntAttribute("rows"));
+ if (getWidget().headerChangedDuringUpdate) {
+ getWidget().triggerLazyColumnAdjustment(
+ true);
+ } else if (!getWidget()
+ .isScrollPositionVisible()
+ || totalRowsChanged
+ || getWidget().lastRenderedHeight != getWidget().scrollBody
+ .getOffsetHeight()) {
+ // webkits may still bug with their disturbing scrollbar
+ // bug, see #3457
+ // Run overflow fix for the scrollable area
+ // #6698 - If there's a scroll going on, don't abort it
+ // by changing overflows as the length of the contents
+ // *shouldn't* have changed (unless the number of rows
+ // or the height of the widget has also changed)
+ Scheduler.get().scheduleDeferred(new Command() {
+ public void execute() {
+ Util.runWebkitOverflowAutoFix(getWidget().scrollBodyPanel
+ .getElement());
+ }
+ });
+ }
+ } else {
+ getWidget().initializeRows(uidl, rowData);
+ }
+ }
+ }
+
+ if (!getWidget().isSelectable()) {
+ getWidget().scrollBody
+ .addStyleName(VScrollTable.CLASSNAME + "-body-noselection");
+ } else {
+ getWidget().scrollBody
+ .removeStyleName(VScrollTable.CLASSNAME
+ + "-body-noselection");
+ }
+
+ getWidget().hideScrollPositionAnnotation();
+ getWidget().purgeUnregistryBag();
+
+ // selection is no in sync with server, avoid excessive server visits by
+ // clearing to flag used during the normal operation
+ if (!keyboardSelectionOverRowFetchInProgress) {
+ getWidget().selectionChanged = false;
+ }
+
+ /*
+ * This is called when the Home or page up button has been pressed in
+ * selectable mode and the next selected row was not yet rendered in the
+ * client
+ */
+ if (getWidget().selectFirstItemInNextRender
+ || getWidget().focusFirstItemInNextRender) {
+ getWidget().selectFirstRenderedRowInViewPort(
+ getWidget().focusFirstItemInNextRender);
+ getWidget().selectFirstItemInNextRender = getWidget().focusFirstItemInNextRender = false;
+ }
+
+ /*
+ * This is called when the page down or end button has been pressed in
+ * selectable mode and the next selected row was not yet rendered in the
+ * client
+ */
+ if (getWidget().selectLastItemInNextRender
+ || getWidget().focusLastItemInNextRender) {
+ getWidget().selectLastRenderedRowInViewPort(
+ getWidget().focusLastItemInNextRender);
+ getWidget().selectLastItemInNextRender = getWidget().focusLastItemInNextRender = false;
+ }
+ getWidget().multiselectPending = false;
+
+ if (getWidget().focusedRow != null) {
+ if (!getWidget().focusedRow.isAttached()
+ && !getWidget().rowRequestHandler.isRunning()) {
+ // focused row has been orphaned, can't focus
+ getWidget().focusRowFromBody();
+ }
+ }
+
+ getWidget().tabIndex = uidl.hasAttribute("tabindex") ? uidl
+ .getIntAttribute("tabindex") : 0;
+ getWidget().setProperTabIndex();
+
+ getWidget().resizeSortedColumnForSortIndicator();
+
+ // Remember this to detect situations where overflow hack might be
+ // needed during scrolling
+ getWidget().lastRenderedHeight = getWidget().scrollBody
+ .getOffsetHeight();
+
+ getWidget().rendering = false;
+ getWidget().headerChangedDuringUpdate = false;
+
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VScrollTable.class);
+ }
+
+ @Override
+ public VScrollTable getWidget() {
+ return (VScrollTable) super.getWidget();
+ }
+
+ public void updateCaption(ComponentConnector component, UIDL uidl) {
+ // NOP, not rendered
+ }
+
+ public void layoutVertically() {
+ getWidget().updateHeight();
+ }
+
+ public void layoutHorizontally() {
+ getWidget().updateWidth();
+ }
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.ComponentConnector;
+import com.vaadin.terminal.gwt.client.ConnectorMap;
+import com.vaadin.terminal.gwt.client.UIDL;
+
+public abstract class TabsheetBaseConnector extends
+ AbstractComponentContainerConnector {
+
+ public static final String ATTRIBUTE_TAB_DISABLED = "disabled";
+ public static final String ATTRIBUTE_TAB_DESCRIPTION = "description";
+ public static final String ATTRIBUTE_TAB_CAPTION = "caption";
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ getWidget().client = client;
+
+ // Ensure correct implementation
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ // Update member references
+ getWidget().id = uidl.getId();
+ getWidget().disabled = getState().isDisabled();
+
+ // Render content
+ final UIDL tabs = uidl.getChildUIDL(0);
+
+ // Paintables in the TabSheet before update
+ ArrayList<Widget> oldWidgets = new ArrayList<Widget>();
+ for (Iterator<Widget> iterator = getWidget().getWidgetIterator(); iterator
+ .hasNext();) {
+ oldWidgets.add(iterator.next());
+ }
+
+ // Clear previous values
+ getWidget().tabKeys.clear();
+ getWidget().disabledTabKeys.clear();
+
+ int index = 0;
+ for (final Iterator<Object> it = tabs.getChildIterator(); it.hasNext();) {
+ final UIDL tab = (UIDL) it.next();
+ final String key = tab.getStringAttribute("key");
+ final boolean selected = tab.getBooleanAttribute("selected");
+ final boolean hidden = tab.getBooleanAttribute("hidden");
+
+ if (tab.getBooleanAttribute(ATTRIBUTE_TAB_DISABLED)) {
+ getWidget().disabledTabKeys.add(key);
+ }
+
+ getWidget().tabKeys.add(key);
+
+ if (selected) {
+ getWidget().activeTabIndex = index;
+ }
+ getWidget().renderTab(tab, index, selected, hidden);
+ index++;
+ }
+
+ int tabCount = getWidget().getTabCount();
+ while (tabCount-- > index) {
+ getWidget().removeTab(index);
+ }
+
+ for (int i = 0; i < getWidget().getTabCount(); i++) {
+ ComponentConnector p = getWidget().getTab(i);
+ // During the initial rendering the paintable might be null (this is
+ // weird...)
+ if (p != null) {
+ oldWidgets.remove(p.getWidget());
+ }
+ }
+
+ // Perform unregister for any paintables removed during update
+ for (Iterator<Widget> iterator = oldWidgets.iterator(); iterator
+ .hasNext();) {
+ Widget oldWidget = iterator.next();
+ ComponentConnector oldPaintable = ConnectorMap.get(client)
+ .getConnector(oldWidget);
+ if (oldWidget.isAttached()) {
+ oldWidget.removeFromParent();
+ }
+ ConnectorMap.get(client).unregisterConnector(oldPaintable);
+ }
+
+ }
+
+ @Override
+ public VTabsheetBase getWidget() {
+ return (VTabsheetBase) super.getWidget();
+ }
+
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.user.client.DOM;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.ComponentConnector;
+import com.vaadin.terminal.gwt.client.UIDL;
+
+public class TabsheetConnector extends TabsheetBaseConnector implements
+ SimpleManagedLayout {
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+
+ if (isRealUpdate(uidl)) {
+ // Handle stylename changes before generics (might affect size
+ // calculations)
+ getWidget().handleStyleNames(uidl, getState());
+ }
+
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ // tabs; push or not
+ if (!isUndefinedWidth()) {
+ // FIXME: This makes tab sheet tabs go to 1px width on every update
+ // and then back to original width
+ // update width later, in updateTabScroller();
+ DOM.setStyleAttribute(getWidget().tabs, "width", "1px");
+ DOM.setStyleAttribute(getWidget().tabs, "overflow", "hidden");
+ } else {
+ getWidget().showAllTabs();
+ DOM.setStyleAttribute(getWidget().tabs, "width", "");
+ DOM.setStyleAttribute(getWidget().tabs, "overflow", "visible");
+ getWidget().updateDynamicWidth();
+ }
+
+ if (!isUndefinedHeight()) {
+ // Must update height after the styles have been set
+ getWidget().updateContentNodeHeight();
+ getWidget().updateOpenTabSize();
+ }
+
+ getWidget().iLayout();
+
+ // Re run relative size update to ensure optimal scrollbars
+ // TODO isolate to situation that visible tab has undefined height
+ try {
+ client.handleComponentRelativeSize(getWidget().tp
+ .getWidget(getWidget().tp.getVisibleWidget()));
+ } catch (Exception e) {
+ // Ignore, most likely empty tabsheet
+ }
+
+ getWidget().waitingForResponse = false;
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VTabsheet.class);
+ }
+
+ @Override
+ public VTabsheet getWidget() {
+ return (VTabsheet) super.getWidget();
+ }
+
+ public void updateCaption(ComponentConnector component, UIDL uidl) {
+ /* Tabsheet does not render its children's captions */
+ }
+
+ public void layout() {
+ VTabsheet tabsheet = getWidget();
+
+ tabsheet.updateContentNodeHeight();
+
+ if (isUndefinedWidth()) {
+ tabsheet.contentNode.getStyle().setProperty("width", "");
+ } else {
+ int contentWidth = tabsheet.getOffsetWidth()
+ - tabsheet.getContentAreaBorderWidth();
+ if (contentWidth < 0) {
+ contentWidth = 0;
+ }
+ tabsheet.contentNode.getStyle().setProperty("width",
+ contentWidth + "px");
+ }
+
+ tabsheet.updateOpenTabSize();
+ tabsheet.iLayout();
+
+ }
+
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.user.client.Event;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.UIDL;
+
+public class TextAreaConnector extends TextFieldConnector {
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ // Call parent renderer explicitly
+ super.updateFromUIDL(uidl, client);
+
+ if (uidl.hasAttribute("rows")) {
+ getWidget().setRows(uidl.getIntAttribute("rows"));
+ }
+
+ if (getWidget().getMaxLength() >= 0) {
+ getWidget().sinkEvents(Event.ONKEYUP);
+ }
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VTextArea.class);
+ }
+
+ @Override
+ public VTextArea getWidget() {
+ return (VTextArea) super.getWidget();
+ }
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.core.client.Scheduler;
+import com.google.gwt.user.client.Command;
+import com.google.gwt.user.client.Event;
+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.ShortcutActionHandler.BeforeShortcutActionListener;
+
+public class TextFieldConnector extends AbstractComponentConnector implements
+ BeforeShortcutActionListener {
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ // Save details
+ getWidget().client = client;
+ getWidget().paintableId = uidl.getId();
+
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ getWidget().setReadOnly(getState().isReadOnly());
+
+ getWidget().inputPrompt = uidl
+ .getStringAttribute(VTextField.ATTR_INPUTPROMPT);
+
+ getWidget().setMaxLength(
+ uidl.hasAttribute("maxLength") ? uidl
+ .getIntAttribute("maxLength") : -1);
+
+ getWidget().immediate = getState().isImmediate();
+
+ getWidget().listenTextChangeEvents = client
+ .hasEventListeners(this, "ie");
+ if (getWidget().listenTextChangeEvents) {
+ getWidget().textChangeEventMode = uidl
+ .getStringAttribute(VTextField.ATTR_TEXTCHANGE_EVENTMODE);
+ if (getWidget().textChangeEventMode
+ .equals(VTextField.TEXTCHANGE_MODE_EAGER)) {
+ getWidget().textChangeEventTimeout = 1;
+ } else {
+ getWidget().textChangeEventTimeout = uidl
+ .getIntAttribute(VTextField.ATTR_TEXTCHANGE_TIMEOUT);
+ if (getWidget().textChangeEventTimeout < 1) {
+ // Sanitize and allow lazy/timeout with timeout set to 0 to
+ // work as eager
+ getWidget().textChangeEventTimeout = 1;
+ }
+ }
+ getWidget().sinkEvents(VTextField.TEXTCHANGE_EVENTS);
+ getWidget().attachCutEventListener(
+ getWidget().getElement());
+ }
+
+ if (uidl.hasAttribute("cols")) {
+ getWidget().setColumns(
+ new Integer(uidl.getStringAttribute("cols")).intValue());
+ }
+
+ final String text = uidl.getStringVariable("text");
+
+ /*
+ * We skip the text content update if field has been repainted, but text
+ * has not been changed. Additional sanity check verifies there is no
+ * change in the que (in which case we count more on the server side
+ * value).
+ */
+ if (!(uidl
+ .getBooleanAttribute(VTextField.ATTR_NO_VALUE_CHANGE_BETWEEN_PAINTS)
+ && getWidget().valueBeforeEdit != null && text
+ .equals(getWidget().valueBeforeEdit))) {
+ getWidget().updateFieldContent(text);
+ }
+
+ if (uidl.hasAttribute("selpos")) {
+ final int pos = uidl.getIntAttribute("selpos");
+ final int length = uidl.getIntAttribute("sellen");
+ /*
+ * Gecko defers setting the text so we need to defer the selection.
+ */
+ Scheduler.get().scheduleDeferred(new Command() {
+ public void execute() {
+ getWidget().setSelectionRange(pos, length);
+ }
+ });
+ }
+
+ // Here for backward compatibility; to be moved to TextArea.
+ // Optimization: server does not send attribute for the default 'true'
+ // state.
+ if (uidl.hasAttribute("wordwrap")
+ && uidl.getBooleanAttribute("wordwrap") == false) {
+ getWidget().setWordwrap(false);
+ } else {
+ getWidget().setWordwrap(true);
+ }
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VTextField.class);
+ }
+
+ @Override
+ public VTextField getWidget() {
+ return (VTextField) super.getWidget();
+ }
+
+ public void onBeforeShortcutAction(Event e) {
+ getWidget().valueChange(false);
+ }
+
+}
--- /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.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.UIDL;
+
+public class TextualDateConnector extends AbstractDateFieldConnector {
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ int origRes = getWidget().currentResolution;
+ String oldLocale = getWidget().currentLocale;
+ super.updateFromUIDL(uidl, client);
+ if (origRes != getWidget().currentResolution
+ || oldLocale != getWidget().currentLocale) {
+ // force recreating format string
+ getWidget().formatStr = null;
+ }
+ if (uidl.hasAttribute("format")) {
+ getWidget().formatStr = uidl
+ .getStringAttribute("format");
+ }
+
+ getWidget().inputPrompt = uidl
+ .getStringAttribute(VTextualDate.ATTR_INPUTPROMPT);
+
+ getWidget().lenient = !uidl.getBooleanAttribute("strict");
+
+ getWidget().buildDate();
+ // not a FocusWidget -> needs own tabindex handling
+ if (uidl.hasAttribute("tabindex")) {
+ getWidget().text.setTabIndex(uidl
+ .getIntAttribute("tabindex"));
+ }
+
+ if (getWidget().readonly) {
+ getWidget().text.addStyleDependentName("readonly");
+ } else {
+ getWidget().text.removeStyleDependentName("readonly");
+ }
+
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VTextualDate.class);
+ }
+
+ @Override
+ public VTextualDate getWidget() {
+ return (VTextualDate) super.getWidget();
+ }
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import java.util.Iterator;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.user.client.ui.Widget;
+import com.vaadin.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.TooltipInfo;
+import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.terminal.gwt.client.ui.VTree.TreeNode;
+
+public class TreeConnector extends AbstractComponentConnector {
+
+ public static final String ATTRIBUTE_NODE_STYLE = "style";
+ public static final String ATTRIBUTE_NODE_CAPTION = "caption";
+ public static final String ATTRIBUTE_NODE_ICON = AbstractComponentConnector.ATTRIBUTE_ICON;
+
+ public static final String ATTRIBUTE_ACTION_CAPTION = "caption";
+ public static final String ATTRIBUTE_ACTION_ICON = AbstractComponentConnector.ATTRIBUTE_ICON;
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ // Ensure correct implementation and let container manage caption
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ getWidget().rendering = true;
+
+ getWidget().client = client;
+
+ if (uidl.hasAttribute("partialUpdate")) {
+ handleUpdate(uidl);
+ getWidget().rendering = false;
+ return;
+ }
+
+ getWidget().paintableId = uidl.getId();
+
+ getWidget().immediate = getState().isImmediate();
+
+ getWidget().disabled = getState().isDisabled();
+ getWidget().readonly = getState().isReadOnly();
+
+ getWidget().dragMode = uidl.hasAttribute("dragMode") ? uidl
+ .getIntAttribute("dragMode") : 0;
+
+ getWidget().isNullSelectionAllowed = uidl
+ .getBooleanAttribute("nullselect");
+
+ if (uidl.hasAttribute("alb")) {
+ getWidget().bodyActionKeys = uidl
+ .getStringArrayAttribute("alb");
+ }
+
+ getWidget().body.clear();
+ // clear out any references to nodes that no longer are attached
+ getWidget().clearNodeToKeyMap();
+ TreeNode childTree = null;
+ UIDL childUidl = null;
+ for (final Iterator<?> i = uidl.getChildIterator(); i.hasNext();) {
+ childUidl = (UIDL) i.next();
+ if ("actions".equals(childUidl.getTag())) {
+ updateActionMap(childUidl);
+ continue;
+ } else if ("-ac".equals(childUidl.getTag())) {
+ getWidget().updateDropHandler(childUidl);
+ continue;
+ }
+ childTree = getWidget().new TreeNode();
+ updateNodeFromUIDL(childTree, childUidl);
+ getWidget().body.add(childTree);
+ childTree.addStyleDependentName("root");
+ childTree.childNodeContainer.addStyleDependentName("root");
+ }
+ if (childTree != null && childUidl != null) {
+ boolean leaf = !childUidl.getTag().equals("node");
+ childTree.addStyleDependentName(leaf ? "leaf-last" : "last");
+ childTree.childNodeContainer.addStyleDependentName("last");
+ }
+ final String selectMode = uidl.getStringAttribute("selectmode");
+ getWidget().selectable = !"none".equals(selectMode);
+ getWidget().isMultiselect = "multi".equals(selectMode);
+
+ if (getWidget().isMultiselect) {
+ getWidget().multiSelectMode = uidl
+ .getIntAttribute("multiselectmode");
+ }
+
+ getWidget().selectedIds = uidl
+ .getStringArrayVariableAsSet("selected");
+
+ // Update lastSelection and focusedNode to point to *actual* nodes again
+ // after the old ones have been cleared from the body. This fixes focus
+ // and keyboard navigation issues as described in #7057 and other
+ // tickets.
+ if (getWidget().lastSelection != null) {
+ getWidget().lastSelection = getWidget()
+ .getNodeByKey(getWidget().lastSelection.key);
+ }
+ if (getWidget().focusedNode != null) {
+ getWidget().setFocusedNode(
+ getWidget().getNodeByKey(
+ getWidget().focusedNode.key));
+ }
+
+ if (getWidget().lastSelection == null
+ && getWidget().focusedNode == null
+ && !getWidget().selectedIds.isEmpty()) {
+ getWidget().setFocusedNode(
+ getWidget().getNodeByKey(
+ getWidget().selectedIds.iterator()
+ .next()));
+ getWidget().focusedNode.setFocused(false);
+ }
+
+ getWidget().rendering = false;
+
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VTree.class);
+ }
+
+ @Override
+ public VTree getWidget() {
+ return (VTree) super.getWidget();
+ }
+
+ private void handleUpdate(UIDL uidl) {
+ final TreeNode rootNode = getWidget().getNodeByKey(
+ uidl.getStringAttribute("rootKey"));
+ if (rootNode != null) {
+ if (!rootNode.getState()) {
+ // expanding node happened server side
+ rootNode.setState(true, false);
+ }
+ renderChildNodes(rootNode, (Iterator) uidl.getChildIterator());
+ }
+ }
+
+ /**
+ * Registers action for the root and also for individual nodes
+ *
+ * @param uidl
+ */
+ private void updateActionMap(UIDL uidl) {
+ final Iterator<?> it = uidl.getChildIterator();
+ while (it.hasNext()) {
+ final UIDL action = (UIDL) it.next();
+ final String key = action.getStringAttribute("key");
+ final String caption = action
+ .getStringAttribute(ATTRIBUTE_ACTION_CAPTION);
+ String iconUrl = null;
+ if (action.hasAttribute(ATTRIBUTE_ACTION_ICON)) {
+ iconUrl = getConnection().translateVaadinUri(
+ action.getStringAttribute(ATTRIBUTE_ACTION_ICON));
+ }
+ getWidget().registerAction(key, caption, iconUrl);
+ }
+
+ }
+
+ public void updateNodeFromUIDL(TreeNode treeNode, UIDL uidl) {
+ String nodeKey = uidl.getStringAttribute("key");
+ treeNode.setText(uidl.getStringAttribute(ATTRIBUTE_NODE_CAPTION));
+ treeNode.key = nodeKey;
+
+ getWidget().registerNode(treeNode);
+
+ if (uidl.hasAttribute("al")) {
+ treeNode.actionKeys = uidl.getStringArrayAttribute("al");
+ }
+
+ if (uidl.getTag().equals("node")) {
+ if (uidl.getChildCount() == 0) {
+ treeNode.childNodeContainer.setVisible(false);
+ } else {
+ renderChildNodes(treeNode, (Iterator) uidl.getChildIterator());
+ treeNode.childrenLoaded = true;
+ }
+ } else {
+ treeNode.addStyleName(TreeNode.CLASSNAME + "-leaf");
+ }
+ if (uidl.hasAttribute(ATTRIBUTE_NODE_STYLE)) {
+ treeNode.setNodeStyleName(uidl
+ .getStringAttribute(ATTRIBUTE_NODE_STYLE));
+ }
+
+ String description = uidl.getStringAttribute("descr");
+ if (description != null && getConnection() != null) {
+ // Set tooltip
+ TooltipInfo info = new TooltipInfo(description);
+ getConnection().registerTooltip(this, nodeKey, info);
+ } else {
+ // Remove possible previous tooltip
+ getConnection().registerTooltip(this, nodeKey, null);
+ }
+
+ if (uidl.getBooleanAttribute("expanded") && !treeNode.getState()) {
+ treeNode.setState(true, false);
+ }
+
+ if (uidl.getBooleanAttribute("selected")) {
+ treeNode.setSelected(true);
+ // ensure that identifier is in selectedIds array (this may be a
+ // partial update)
+ getWidget().selectedIds.add(nodeKey);
+ }
+
+ treeNode.setIcon(uidl.getStringAttribute(ATTRIBUTE_NODE_ICON));
+ }
+
+ void renderChildNodes(TreeNode containerNode, Iterator<UIDL> i) {
+ containerNode.childNodeContainer.clear();
+ containerNode.childNodeContainer.setVisible(true);
+ while (i.hasNext()) {
+ final UIDL childUidl = i.next();
+ // actions are in bit weird place, don't mix them with children,
+ // but current node's actions
+ if ("actions".equals(childUidl.getTag())) {
+ updateActionMap(childUidl);
+ continue;
+ }
+ final TreeNode childTree = getWidget().new TreeNode();
+ updateNodeFromUIDL(childTree, childUidl);
+ containerNode.childNodeContainer.add(childTree);
+ if (!i.hasNext()) {
+ childTree
+ .addStyleDependentName(childTree.isLeaf() ? "leaf-last"
+ : "last");
+ childTree.childNodeContainer.addStyleDependentName("last");
+ }
+ }
+ containerNode.childrenLoaded = true;
+ }
+}
--- /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.terminal.gwt.client.ApplicationConnection;
+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;
+
+public class TreeTableConnector extends TableConnector {
+ public static final String ATTRIBUTE_HIERARCHY_COLUMN_INDEX = "hci";
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ FocusableScrollPanel widget = null;
+ int scrollPosition = 0;
+ if (getWidget().collapseRequest) {
+ widget = (FocusableScrollPanel) getWidget().getWidget(1);
+ scrollPosition = widget.getScrollPosition();
+ }
+ getWidget().animationsEnabled = uidl.getBooleanAttribute("animate");
+ getWidget().colIndexOfHierarchy = uidl
+ .hasAttribute(ATTRIBUTE_HIERARCHY_COLUMN_INDEX) ? uidl
+ .getIntAttribute(ATTRIBUTE_HIERARCHY_COLUMN_INDEX) : 0;
+ int oldTotalRows = getWidget().getTotalRows();
+ super.updateFromUIDL(uidl, client);
+ if (getWidget().collapseRequest) {
+ if (getWidget().collapsedRowKey != null
+ && getWidget().scrollBody != null) {
+ VScrollTableRow row = getWidget().getRenderedRowByKey(
+ getWidget().collapsedRowKey);
+ if (row != null) {
+ getWidget().setRowFocus(row);
+ getWidget().focus();
+ }
+ }
+
+ int scrollPosition2 = widget.getScrollPosition();
+ if (scrollPosition != scrollPosition2) {
+ widget.setScrollPosition(scrollPosition);
+ }
+
+ // check which rows are needed from the server and initiate a
+ // deferred fetch
+ getWidget().onScroll(null);
+ }
+ // Recalculate table size if collapse request, or if page length is zero
+ // (not sent by server) and row count changes (#7908).
+ if (getWidget().collapseRequest
+ || (!uidl.hasAttribute("pagelength") && getWidget()
+ .getTotalRows() != oldTotalRows)) {
+ /*
+ * Ensure that possibly removed/added scrollbars are considered.
+ * Triggers row calculations, removes cached rows etc. Basically
+ * cleans up state. Be careful if touching this, you will break
+ * pageLength=0 if you remove this.
+ */
+ getWidget().triggerLazyColumnAdjustment(true);
+
+ getWidget().collapseRequest = false;
+ }
+ if (uidl.hasAttribute("focusedRow")) {
+ String key = uidl.getStringAttribute("focusedRow");
+ getWidget().setRowFocus(getWidget().getRenderedRowByKey(key));
+ getWidget().focusParentResponsePending = false;
+ } else if (uidl.hasAttribute("clearFocusPending")) {
+ // Special case to detect a response to a focusParent request that
+ // does not return any focusedRow because the selected node has no
+ // parent
+ getWidget().focusParentResponsePending = false;
+ }
+
+ while (!getWidget().collapseRequest
+ && !getWidget().focusParentResponsePending
+ && !getWidget().pendingNavigationEvents.isEmpty()) {
+ // Keep replaying any queued events as long as we don't have any
+ // potential content changes pending
+ PendingNavigationEvent event = getWidget().pendingNavigationEvents
+ .removeFirst();
+ getWidget()
+ .handleNavigation(event.keycode, event.ctrl, event.shift);
+ }
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VTreeTable.class);
+ }
+
+ @Override
+ public VTreeTable getWidget() {
+ return (VTreeTable) super.getWidget();
+ }
+}
--- /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.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.UIDL;
+
+public class TwinColSelectConnector extends OptionGroupBaseConnector {
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ // Captions are updated before super call to ensure the widths are set
+ // correctly
+ if (isRealUpdate(uidl)) {
+ getWidget().updateCaptions(uidl);
+ }
+
+ super.updateFromUIDL(uidl, client);
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VTwinColSelect.class);
+ }
+
+ @Override
+ public VTwinColSelect getWidget() {
+ return (VTwinColSelect) super.getWidget();
+ }
+}
--- /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.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.UIDL;
+import com.vaadin.terminal.gwt.client.VUIDLBrowser;
+
+public class UnknownComponentConnector extends AbstractComponentConnector {
+
+ @Override
+ protected boolean delegateCaptionHandling() {
+ return false;
+ }
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ super.updateFromUIDL(uidl, client);
+ 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:");
+ if (getWidget().uidlTree != null) {
+ getWidget().uidlTree.removeFromParent();
+ }
+
+ getWidget().uidlTree = new VUIDLBrowser(uidl,
+ client.getConfiguration());
+ getWidget().uidlTree.open(true);
+ getWidget().uidlTree.setText("Unrendered UIDL");
+ getWidget().panel.add(getWidget().uidlTree);
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VUnknownComponent.class);
+ }
+
+ @Override
+ public VUnknownComponent getWidget() {
+ return (VUnknownComponent) super.getWidget();
+ }
+
+ public void setServerSideClassName(String serverClassName) {
+ getWidget().setServerSideClassName(serverClassName);
+ }
+}
--- /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.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.UIDL;
+
+public class UploadConnector extends AbstractComponentConnector {
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+ if (uidl.hasAttribute("notStarted")) {
+ getWidget().t.schedule(400);
+ return;
+ }
+ if (uidl.hasAttribute("forceSubmit")) {
+ getWidget().submit();
+ return;
+ }
+ getWidget().setImmediate(getState().isImmediate());
+ getWidget().client = client;
+ getWidget().paintableId = uidl.getId();
+ getWidget().nextUploadId = uidl.getIntAttribute("nextid");
+ final String action = client.translateVaadinUri(uidl
+ .getStringVariable("action"));
+ getWidget().element.setAction(action);
+ if (uidl.hasAttribute("buttoncaption")) {
+ getWidget().submitButton.setText(uidl
+ .getStringAttribute("buttoncaption"));
+ getWidget().submitButton.setVisible(true);
+ } else {
+ getWidget().submitButton.setVisible(false);
+ }
+ getWidget().fu.setName(getWidget().paintableId
+ + "_file");
+
+ if (getState().isDisabled() || getState().isReadOnly()) {
+ getWidget().disableUpload();
+ } else if (!uidl.getBooleanAttribute("state")) {
+ // Enable the button only if an upload is not in progress
+ getWidget().enableUpload();
+ getWidget().ensureTargetFrame();
+ }
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VUpload.class);
+ }
+
+ @Override
+ public VUpload getWidget() {
+ return (VUpload) super.getWidget();
+ }
+}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import java.util.HashSet;
-import java.util.Iterator;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.dom.client.Style;
-import com.google.gwt.dom.client.Style.Unit;
-import com.google.gwt.event.dom.client.DomEvent.Type;
-import com.google.gwt.event.shared.EventHandler;
-import com.google.gwt.event.shared.HandlerRegistration;
-import com.google.gwt.user.client.Element;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.DirectionalManagedLayout;
-import com.vaadin.terminal.gwt.client.EventId;
-import com.vaadin.terminal.gwt.client.UIDL;
-import com.vaadin.terminal.gwt.client.ComponentConnector;
-import com.vaadin.terminal.gwt.client.ui.VAbsoluteLayout.AbsoluteWrapper;
-
-public class VAbsoluteLayoutPaintable extends AbstractComponentContainerConnector
- implements DirectionalManagedLayout {
-
- private LayoutClickEventHandler clickEventHandler = new LayoutClickEventHandler(
- this, EventId.LAYOUT_CLICK) {
-
- @Override
- protected ComponentConnector getChildComponent(Element element) {
- return getWidget().getComponent(element);
- }
-
- @Override
- protected <H extends EventHandler> HandlerRegistration registerHandler(
- H handler, Type<H> type) {
- return getWidget().addDomHandler(handler, type);
- }
- };
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidget().client = client;
- // TODO margin handling
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- clickEventHandler.handleEventHandlerRegistration(client);
-
- HashSet<String> unrenderedPids = new HashSet<String>(
- getWidget().pidToComponentWrappper.keySet());
-
- for (Iterator<Object> childIterator = uidl.getChildIterator(); childIterator
- .hasNext();) {
- UIDL cc = (UIDL) childIterator.next();
- if (cc.getTag().equals("cc")) {
- UIDL componentUIDL = cc.getChildUIDL(0);
- unrenderedPids.remove(componentUIDL.getId());
- getWidget().getWrapper(client, componentUIDL)
- .updateFromUIDL(cc);
- }
- }
-
- for (String pid : unrenderedPids) {
- AbsoluteWrapper absoluteWrapper = getWidget().pidToComponentWrappper
- .get(pid);
- getWidget().pidToComponentWrappper.remove(pid);
- absoluteWrapper.destroy();
- }
- }
-
- public void updateCaption(ComponentConnector component, UIDL uidl) {
- AbsoluteWrapper parent2 = (AbsoluteWrapper) (component
- .getWidget()).getParent();
- parent2.updateCaption(uidl);
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VAbsoluteLayout.class);
- }
-
- @Override
- public VAbsoluteLayout getWidget() {
- return (VAbsoluteLayout) super.getWidget();
- }
-
- public void layoutVertically() {
- VAbsoluteLayout layout = getWidget();
- for (ComponentConnector paintable : getChildren()) {
- Widget widget = paintable.getWidget();
- AbsoluteWrapper wrapper = (AbsoluteWrapper) widget.getParent();
- Style wrapperStyle = wrapper.getElement().getStyle();
-
- if (paintable.isRelativeHeight()) {
- int h;
- if (wrapper.top != null && wrapper.bottom != null) {
- h = wrapper.getOffsetHeight();
- } else if (wrapper.bottom != null) {
- // top not defined, available space 0... bottom of
- // wrapper
- h = wrapper.getElement().getOffsetTop()
- + wrapper.getOffsetHeight();
- } else {
- // top defined or both undefined, available space ==
- // canvas - top
- h = layout.canvas.getOffsetHeight()
- - wrapper.getElement().getOffsetTop();
- }
- wrapperStyle.setHeight(h, Unit.PX);
- } else {
- wrapperStyle.clearHeight();
- }
-
- wrapper.updateCaptionPosition();
- }
- }
-
- public void layoutHorizontally() {
- VAbsoluteLayout layout = getWidget();
- for (ComponentConnector paintable : getChildren()) {
- Widget widget = paintable.getWidget();
- AbsoluteWrapper wrapper = (AbsoluteWrapper) widget.getParent();
- Style wrapperStyle = wrapper.getElement().getStyle();
-
- if (paintable.isRelativeWidth()) {
- int w;
- if (wrapper.left != null && wrapper.right != null) {
- w = wrapper.getOffsetWidth();
- } else if (wrapper.right != null) {
- // left == null
- // available width == right edge == offsetleft + width
- w = wrapper.getOffsetWidth()
- + wrapper.getElement().getOffsetLeft();
- } else {
- // left != null && right == null || left == null &&
- // right == null
- // available width == canvas width - offset left
- w = layout.canvas.getOffsetWidth()
- - wrapper.getElement().getOffsetLeft();
- }
- wrapperStyle.setWidth(w, Unit.PX);
- } else {
- wrapperStyle.clearWidth();
- }
-
- wrapper.updateCaptionPosition();
- }
- }
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.google.gwt.dom.client.NativeEvent;
-import com.google.gwt.event.dom.client.DomEvent.Type;
-import com.google.gwt.event.shared.EventHandler;
-import com.google.gwt.event.shared.HandlerRegistration;
-import com.google.gwt.user.client.Element;
-import com.google.gwt.user.client.Event;
-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.ConnectorMap;
-import com.vaadin.terminal.gwt.client.ComponentConnector;
-
-public abstract class VAbstractSplitPanelPaintable extends
- AbstractComponentContainerConnector implements SimpleManagedLayout {
-
- public static final String SPLITTER_CLICK_EVENT_IDENTIFIER = "sp_click";
-
- public void updateCaption(ComponentConnector component, UIDL uidl) {
- // TODO Implement caption handling
- }
-
- ClickEventHandler clickEventHandler = new ClickEventHandler(this,
- SPLITTER_CLICK_EVENT_IDENTIFIER) {
-
- @Override
- protected <H extends EventHandler> HandlerRegistration registerHandler(
- H handler, Type<H> type) {
- if ((Event.getEventsSunk(getWidget().splitter) & Event
- .getTypeInt(type.getName())) != 0) {
- // If we are already sinking the event for the splitter we do
- // not want to additionally sink it for the root element
- return getWidget().addHandler(handler, type);
- } else {
- return getWidget().addDomHandler(handler, type);
- }
- }
-
- @Override
- public void onContextMenu(
- com.google.gwt.event.dom.client.ContextMenuEvent event) {
- Element target = event.getNativeEvent().getEventTarget().cast();
- if (getWidget().splitter.isOrHasChild(target)) {
- super.onContextMenu(event);
- }
- };
-
- @Override
- protected void fireClick(NativeEvent event) {
- Element target = event.getEventTarget().cast();
- if (getWidget().splitter.isOrHasChild(target)) {
- super.fireClick(event);
- }
- }
-
- @Override
- protected Element getRelativeToElement() {
- return null;
- }
-
- };
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidget().client = client;
- getWidget().id = uidl.getId();
-
- getWidget().immediate = getState().isImmediate();
-
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
- getWidget().setEnabled(!getState().isDisabled());
-
- clickEventHandler.handleEventHandlerRegistration(client);
- if (getState().hasStyles()) {
- getWidget().componentStyleNames = getState().getStyle()
- .split(" ");
- } else {
- getWidget().componentStyleNames = new String[0];
- }
-
- getWidget().setLocked(uidl.getBooleanAttribute("locked"));
-
- getWidget().setPositionReversed(
- uidl.getBooleanAttribute("reversed"));
-
- getWidget().setStylenames();
-
- getWidget().position = uidl.getStringAttribute("position");
-
- final ComponentConnector newFirstChildPaintable = client
- .getPaintable(uidl.getChildUIDL(0));
- final ComponentConnector newSecondChildPaintable = client
- .getPaintable(uidl.getChildUIDL(1));
- Widget newFirstChild = newFirstChildPaintable.getWidget();
- Widget newSecondChild = newSecondChildPaintable.getWidget();
-
- if (getWidget().firstChild != newFirstChild) {
- if (getWidget().firstChild != null) {
- client.unregisterPaintable(ConnectorMap.get(client)
- .getConnector(getWidget().firstChild));
- }
- getWidget().setFirstWidget(newFirstChild);
- }
- if (getWidget().secondChild != newSecondChild) {
- if (getWidget().secondChild != null) {
- client.unregisterPaintable(ConnectorMap.get(client)
- .getConnector(getWidget().secondChild));
- }
- getWidget().setSecondWidget(newSecondChild);
- }
- newFirstChildPaintable.updateFromUIDL(uidl.getChildUIDL(0), client);
- newSecondChildPaintable.updateFromUIDL(uidl.getChildUIDL(1), client);
-
- // This is needed at least for cases like #3458 to take
- // appearing/disappearing scrollbars into account.
- client.runDescendentsLayout(getWidget());
-
- getLayoutManager().setNeedsUpdate(this);
- }
-
- public void layout() {
- VAbstractSplitPanel splitPanel = getWidget();
- splitPanel.setSplitPosition(splitPanel.position);
- splitPanel.updateSizes();
- }
-
- @Override
- public VAbstractSplitPanel getWidget() {
- return (VAbstractSplitPanel) super.getWidget();
- }
-
- @Override
- protected abstract VAbstractSplitPanel createWidget();
-
-}
// TODO need to call this because the caption does not have an owner
caption.updateCaptionWithoutOwner(
uidl,
- uidl.getStringAttribute(VTabsheetBasePaintable.ATTRIBUTE_TAB_CAPTION),
- uidl.hasAttribute(VTabsheetBasePaintable.ATTRIBUTE_TAB_DISABLED),
- uidl.hasAttribute(VTabsheetBasePaintable.ATTRIBUTE_TAB_DESCRIPTION));
+ uidl.getStringAttribute(TabsheetBaseConnector.ATTRIBUTE_TAB_CAPTION),
+ uidl.hasAttribute(TabsheetBaseConnector.ATTRIBUTE_TAB_DISABLED),
+ uidl.hasAttribute(TabsheetBaseConnector.ATTRIBUTE_TAB_DESCRIPTION));
}
public int getWidgetWidth() {
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import java.util.Iterator;
-
-import com.google.gwt.core.client.GWT;
-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.ComponentConnector;
-import com.vaadin.terminal.gwt.client.ui.VAccordion.StackItem;
-
-public class VAccordionPaintable extends VTabsheetBasePaintable implements
- SimpleManagedLayout {
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidget().selectedUIDLItemIndex = -1;
- super.updateFromUIDL(uidl, client);
- /*
- * Render content after all tabs have been created and we know how large
- * the content area is
- */
- if (getWidget().selectedUIDLItemIndex >= 0) {
- StackItem selectedItem = getWidget().getStackItem(
- getWidget().selectedUIDLItemIndex);
- UIDL selectedTabUIDL = getWidget().lazyUpdateMap
- .remove(selectedItem);
- getWidget().open(
- getWidget().selectedUIDLItemIndex);
-
- selectedItem.setContent(selectedTabUIDL);
- } else if (isRealUpdate(uidl)
- && getWidget().openTab != null) {
- getWidget().close(getWidget().openTab);
- }
-
- getWidget().iLayout();
- // finally render possible hidden tabs
- if (getWidget().lazyUpdateMap.size() > 0) {
- for (Iterator iterator = getWidget().lazyUpdateMap
- .keySet().iterator(); iterator.hasNext();) {
- StackItem item = (StackItem) iterator.next();
- item.setContent(getWidget().lazyUpdateMap.get(item));
- }
- getWidget().lazyUpdateMap.clear();
- }
-
- getWidget().renderInformation
- .updateSize(getWidget().getElement());
- }
-
- @Override
- public VAccordion getWidget() {
- return (VAccordion) super.getWidget();
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VAccordion.class);
- }
-
- public void updateCaption(ComponentConnector component, UIDL uidl) {
- /* Accordion does not render its children's captions */
- }
-
- public void layout() {
- VAccordion accordion = getWidget();
-
- accordion.updateOpenTabSize();
-
- if (isUndefinedHeight()) {
- accordion.openTab.setHeightFromWidget();
- }
- accordion.iLayout();
-
- }
-
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.dom.client.Style;
-import com.google.gwt.dom.client.Style.Unit;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.BrowserInfo;
-import com.vaadin.terminal.gwt.client.UIDL;
-
-public class VAudioPaintable extends VMediaBasePaintable {
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
- Style style = getWidget().getElement().getStyle();
-
- // Make sure that the controls are not clipped if visible.
- if (shouldShowControls(uidl)
- && (style.getHeight() == null || "".equals(style.getHeight()))) {
- if (BrowserInfo.get().isChrome()) {
- style.setHeight(32, Unit.PX);
- } else {
- style.setHeight(25, Unit.PX);
- }
- }
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VAudio.class);
- }
-
-}
import com.vaadin.terminal.gwt.client.MouseEventDetails;
import com.vaadin.terminal.gwt.client.Util;
import com.vaadin.terminal.gwt.client.VTooltip;
-import com.vaadin.terminal.gwt.client.ui.VButtonPaintable.ButtonClientToServerRpc;
+import com.vaadin.terminal.gwt.client.ui.ButtonConnector.ButtonClientToServerRpc;
public class VButton extends FocusWidget implements ClickHandler, FocusHandler,
BlurHandler {
protected HandlerRegistration blurHandlerRegistration;
protected int clickShortcut = 0;
- //TODO Move this to VButtonPaintable
+ // TODO Move this to VButtonPaintable
ButtonClientToServerRpc buttonRpcProxy;
public VButton() {
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.user.client.DOM;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.ComponentState;
-import com.vaadin.terminal.gwt.client.EventHelper;
-import com.vaadin.terminal.gwt.client.UIDL;
-import com.vaadin.terminal.gwt.client.communication.ClientToServerRpc;
-
-public class VButtonPaintable extends AbstractComponentConnector {
-
- /**
- * RPC interface for calls from client to server.
- *
- * @since 7.0
- */
- public interface ButtonClientToServerRpc extends ClientToServerRpc {
- /**
- * Button click event.
- *
- * @param mouseEventDetails
- * serialized mouse event details
- */
- public void click(String mouseEventDetails);
-
- /**
- * Indicate to the server that the client has disabled the button as a
- * result of a click.
- */
- public void disableOnClick();
- }
-
- @Override
- protected boolean delegateCaptionHandling() {
- return false;
- }
-
- @Override
- public void init() {
- super.init();
- ButtonClientToServerRpc rpcProxy = GWT
- .create(ButtonClientToServerRpc.class);
- getWidget().buttonRpcProxy = initRPC(rpcProxy);
- }
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
-
- // Ensure correct implementation,
- // but don't let container manage caption etc.
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- getWidget().focusHandlerRegistration = EventHelper
- .updateFocusHandler(this, client,
- getWidget().focusHandlerRegistration);
- getWidget().blurHandlerRegistration = EventHelper
- .updateBlurHandler(this, client,
- getWidget().blurHandlerRegistration);
-
- // Save details
- getWidget().client = client;
- getWidget().paintableId = uidl.getId();
-
- // Set text
- getWidget().setText(getState().getCaption());
-
- getWidget().disableOnClick = getState().isDisableOnClick();
-
- // handle error
- if (uidl.hasAttribute("error")) {
- if (getWidget().errorIndicatorElement == null) {
- getWidget().errorIndicatorElement = DOM
- .createSpan();
- getWidget().errorIndicatorElement
- .setClassName("v-errorindicator");
- }
- getWidget().wrapper.insertBefore(
- getWidget().errorIndicatorElement,
- getWidget().captionElement);
-
- } else if (getWidget().errorIndicatorElement != null) {
- getWidget().wrapper
- .removeChild(getWidget().errorIndicatorElement);
- getWidget().errorIndicatorElement = null;
- }
-
- if (uidl.hasAttribute(ATTRIBUTE_ICON)) {
- if (getWidget().icon == null) {
- getWidget().icon = new Icon(client);
- getWidget().wrapper.insertBefore(
- getWidget().icon.getElement(),
- getWidget().captionElement);
- }
- getWidget().icon.setUri(uidl
- .getStringAttribute(ATTRIBUTE_ICON));
- } else {
- if (getWidget().icon != null) {
- getWidget().wrapper
- .removeChild(getWidget().icon.getElement());
- getWidget().icon = null;
- }
- }
-
- getWidget().clickShortcut = getState()
- .getClickShortcutKeyCode();
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VButton.class);
- }
-
- @Override
- public VButton getWidget() {
- return (VButton) super.getWidget();
- }
-
- @Override
- public ButtonState getState() {
- return (ButtonState) super.getState();
- }
-
- @Override
- protected ComponentState createState() {
- return GWT.create(ButtonState.class);
- }
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.user.client.DOM;
-import com.google.gwt.user.client.Event;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.EventHelper;
-import com.vaadin.terminal.gwt.client.UIDL;
-import com.vaadin.terminal.gwt.client.VTooltip;
-
-public class VCheckBoxPaintable extends AbstractComponentConnector {
-
- @Override
- protected boolean delegateCaptionHandling() {
- return false;
- }
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- // Save details
- getWidget().client = client;
- getWidget().id = uidl.getId();
-
- // Ensure correct implementation
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- getWidget().focusHandlerRegistration = EventHelper
- .updateFocusHandler(this, client,
- getWidget().focusHandlerRegistration);
- getWidget().blurHandlerRegistration = EventHelper
- .updateBlurHandler(this, client,
- getWidget().blurHandlerRegistration);
-
- if (uidl.hasAttribute("error")) {
- if (getWidget().errorIndicatorElement == null) {
- getWidget().errorIndicatorElement = DOM
- .createSpan();
- getWidget().errorIndicatorElement
- .setInnerHTML(" ");
- DOM.setElementProperty(
- getWidget().errorIndicatorElement,
- "className", "v-errorindicator");
- DOM.appendChild(getWidget().getElement(),
- getWidget().errorIndicatorElement);
- DOM.sinkEvents(getWidget().errorIndicatorElement,
- VTooltip.TOOLTIP_EVENTS | Event.ONCLICK);
- } else {
- DOM.setStyleAttribute(
- getWidget().errorIndicatorElement,
- "display", "");
- }
- } else if (getWidget().errorIndicatorElement != null) {
- DOM.setStyleAttribute(
- getWidget().errorIndicatorElement, "display",
- "none");
- }
-
- if (getState().isReadOnly()) {
- getWidget().setEnabled(false);
- }
-
- if (uidl.hasAttribute(ATTRIBUTE_ICON)) {
- if (getWidget().icon == null) {
- getWidget().icon = new Icon(client);
- DOM.insertChild(getWidget().getElement(),
- getWidget().icon.getElement(), 1);
- getWidget().icon
- .sinkEvents(VTooltip.TOOLTIP_EVENTS);
- getWidget().icon.sinkEvents(Event.ONCLICK);
- }
- getWidget().icon.setUri(uidl
- .getStringAttribute(ATTRIBUTE_ICON));
- } else if (getWidget().icon != null) {
- // detach icon
- DOM.removeChild(getWidget().getElement(),
- getWidget().icon.getElement());
- getWidget().icon = null;
- }
-
- // Set text
- getWidget().setText(getState().getCaption());
- getWidget()
- .setValue(
- uidl.getBooleanVariable(getWidget().VARIABLE_STATE));
- getWidget().immediate = getState().isImmediate();
- }
-
- @Override
- public VCheckBox getWidget() {
- return (VCheckBox) super.getWidget();
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VCheckBox.class);
- }
-
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.event.dom.client.DomEvent.Type;
-import com.google.gwt.event.shared.EventHandler;
-import com.google.gwt.event.shared.HandlerRegistration;
-import com.google.gwt.user.client.Element;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.EventId;
-import com.vaadin.terminal.gwt.client.UIDL;
-import com.vaadin.terminal.gwt.client.ComponentConnector;
-
-public class VCssLayoutPaintable extends AbstractComponentContainerConnector {
-
- private LayoutClickEventHandler clickEventHandler = new LayoutClickEventHandler(
- this, EventId.LAYOUT_CLICK) {
-
- @Override
- protected ComponentConnector getChildComponent(Element element) {
- return getWidget().panel.getComponent(element);
- }
-
- @Override
- protected <H extends EventHandler> HandlerRegistration registerHandler(
- H handler, Type<H> type) {
- return getWidget().addDomHandler(handler, type);
- }
- };
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
-
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
- clickEventHandler.handleEventHandlerRegistration(client);
-
- getWidget().setMarginAndSpacingStyles(
- new VMarginInfo(uidl.getIntAttribute("margins")),
- uidl.hasAttribute("spacing"));
- getWidget().panel.updateFromUIDL(uidl, client);
- }
-
- @Override
- public VCssLayout getWidget() {
- return (VCssLayout) super.getWidget();
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VCssLayout.class);
- }
-
- public void updateCaption(ComponentConnector component, UIDL uidl) {
- getWidget().panel.updateCaption(component, uidl);
- }
-
-}
+++ /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.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.UIDL;
-import com.vaadin.terminal.gwt.client.ConnectorMap;
-import com.vaadin.terminal.gwt.client.ComponentConnector;
-
-public class VCustomComponentPaintable extends
- AbstractComponentContainerConnector {
-
- @Override
- public void updateFromUIDL(UIDL uidl, final ApplicationConnection client) {
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
- final UIDL child = uidl.getChildUIDL(0);
- if (child != null) {
- final ComponentConnector paintable = client.getPaintable(child);
- Widget widget = paintable.getWidget();
- if (widget != getWidget().getWidget()) {
- if (getWidget().getWidget() != null) {
- client.unregisterPaintable(ConnectorMap.get(client)
- .getConnector(getWidget().getWidget()));
- getWidget().clear();
- }
- getWidget().setWidget(widget);
- }
- paintable.updateFromUIDL(child, client);
- }
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VCustomComponent.class);
- }
-
- @Override
- public VCustomComponent getWidget() {
- return (VCustomComponent) super.getWidget();
- }
-
- public void updateCaption(ComponentConnector component, UIDL uidl) {
- // NOP, custom component dont render composition roots caption
- }
-
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Set;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.user.client.DOM;
-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.ComponentConnector;
-
-public class VCustomLayoutPaintable extends AbstractComponentContainerConnector
- implements SimpleManagedLayout {
-
- /** Update the layout from UIDL */
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidget().client = client;
- // ApplicationConnection manages generic component features
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- getWidget().pid = uidl.getId();
- if (!getWidget().hasTemplate()) {
- // Update HTML template only once
- getWidget().initializeHTML(uidl, client);
- }
-
- // Evaluate scripts
- VCustomLayout.eval(getWidget().scripts);
- getWidget().scripts = null;
-
- // TODO Check if this is needed
- client.runDescendentsLayout(getWidget());
-
- Set<Widget> oldWidgets = new HashSet<Widget>();
- oldWidgets.addAll(getWidget().locationToWidget.values());
-
- // For all contained widgets
- for (final Iterator<?> i = uidl.getChildIterator(); i.hasNext();) {
- final UIDL uidlForChild = (UIDL) i.next();
- if (uidlForChild.getTag().equals("location")) {
- final String location = uidlForChild.getStringAttribute("name");
- UIDL childUIDL = uidlForChild.getChildUIDL(0);
- final ComponentConnector childPaintable = client
- .getPaintable(childUIDL);
- Widget childWidget = childPaintable.getWidget();
- try {
- getWidget().setWidget(childWidget, location);
- childPaintable.updateFromUIDL(childUIDL, client);
- } catch (final IllegalArgumentException e) {
- // If no location is found, this component is not visible
- }
- oldWidgets.remove(childWidget);
- }
- }
- for (Iterator<Widget> iterator = oldWidgets.iterator(); iterator
- .hasNext();) {
- Widget oldWidget = iterator.next();
- if (oldWidget.isAttached()) {
- // slot of this widget is emptied, remove it
- getWidget().remove(oldWidget);
- }
- }
-
- // TODO Check if this is needed
- client.runDescendentsLayout(getWidget());
-
- }
-
- @Override
- public VCustomLayout getWidget() {
- return (VCustomLayout) super.getWidget();
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VCustomLayout.class);
- }
-
- public void updateCaption(ComponentConnector paintable, UIDL uidl) {
- getWidget().updateCaption(paintable, uidl);
-
- }
-
- public void layout() {
- getWidget().iLayoutJS(
- DOM.getFirstChild(getWidget().getElement()));
- }
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import java.util.Date;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.DateTimeService;
-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;
-
-public class VDateFieldCalendarPaintable extends VDateFieldPaintable {
-
- @Override
- @SuppressWarnings("deprecation")
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- super.updateFromUIDL(uidl, client);
- getWidget().calendarPanel
- .setShowISOWeekNumbers(getWidget()
- .isShowISOWeekNumbers());
- getWidget().calendarPanel
- .setDateTimeService(getWidget()
- .getDateTimeService());
- getWidget().calendarPanel
- .setResolution(getWidget().getCurrentResolution());
- Date currentDate = getWidget().getCurrentDate();
- if (currentDate != null) {
- getWidget().calendarPanel.setDate(new Date(currentDate
- .getTime()));
- } else {
- getWidget().calendarPanel.setDate(null);
- }
-
- if (getWidget().currentResolution > VDateField.RESOLUTION_DAY) {
- getWidget().calendarPanel
- .setTimeChangeListener(new TimeChangeListener() {
- public void changed(int hour, int min, int sec, int msec) {
- Date d = getWidget().getDate();
- if (d == null) {
- // date currently null, use the value from
- // calendarPanel
- // (~ client time at the init of the widget)
- d = (Date) getWidget().calendarPanel
- .getDate().clone();
- }
- d.setHours(hour);
- d.setMinutes(min);
- d.setSeconds(sec);
- DateTimeService.setMilliseconds(d, msec);
-
- // Always update time changes to the server
- getWidget().calendarPanel.setDate(d);
- getWidget().updateValueFromPanel();
- }
- });
- }
-
- if (getWidget().currentResolution <= VDateField.RESOLUTION_MONTH) {
- getWidget().calendarPanel
- .setFocusChangeListener(new FocusChangeListener() {
- public void focusChanged(Date date) {
- Date date2 = new Date();
- if (getWidget().calendarPanel.getDate() != null) {
- date2.setTime(getWidget().calendarPanel
- .getDate().getTime());
- }
- /*
- * Update the value of calendarPanel
- */
- date2.setYear(date.getYear());
- date2.setMonth(date.getMonth());
- getWidget().calendarPanel
- .setDate(date2);
- /*
- * Then update the value from panel to server
- */
- getWidget().updateValueFromPanel();
- }
- });
- } else {
- getWidget().calendarPanel.setFocusChangeListener(null);
- }
-
- // Update possible changes
- getWidget().calendarPanel.renderCalendar();
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VDateFieldCalendar.class);
- }
-
- @Override
- public VDateFieldCalendar getWidget() {
- return (VDateFieldCalendar) super.getWidget();
- }
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import java.util.Date;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.LocaleNotLoadedException;
-import com.vaadin.terminal.gwt.client.UIDL;
-import com.vaadin.terminal.gwt.client.VConsole;
-
-public class VDateFieldPaintable extends AbstractComponentConnector {
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- // Ensure correct implementation and let layout manage caption
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- // Save details
- getWidget().client = client;
- getWidget().paintableId = uidl.getId();
- getWidget().immediate = getState().isImmediate();
-
- getWidget().readonly = getState().isReadOnly();
- getWidget().enabled = !getState().isDisabled();
-
- if (uidl.hasAttribute("locale")) {
- final String locale = uidl.getStringAttribute("locale");
- try {
- getWidget().dts.setLocale(locale);
- getWidget().currentLocale = locale;
- } catch (final LocaleNotLoadedException e) {
- getWidget().currentLocale = getWidget().dts
- .getLocale();
- VConsole.error("Tried to use an unloaded locale \"" + locale
- + "\". Using default locale ("
- + getWidget().currentLocale + ").");
- VConsole.error(e);
- }
- }
-
- // We show week numbers only if the week starts with Monday, as ISO 8601
- // specifies
- getWidget().showISOWeekNumbers = uidl
- .getBooleanAttribute(VDateField.WEEK_NUMBERS)
- && getWidget().dts.getFirstDayOfWeek() == 1;
-
- int newResolution;
- if (uidl.hasVariable("sec")) {
- newResolution = VDateField.RESOLUTION_SEC;
- } else if (uidl.hasVariable("min")) {
- newResolution = VDateField.RESOLUTION_MIN;
- } else if (uidl.hasVariable("hour")) {
- newResolution = VDateField.RESOLUTION_HOUR;
- } else if (uidl.hasVariable("day")) {
- newResolution = VDateField.RESOLUTION_DAY;
- } else if (uidl.hasVariable("month")) {
- newResolution = VDateField.RESOLUTION_MONTH;
- } else {
- newResolution = VDateField.RESOLUTION_YEAR;
- }
-
- getWidget().currentResolution = newResolution;
-
- // Add stylename that indicates current resolution
- getWidget()
- .addStyleName(
- VDateField.CLASSNAME
- + "-"
- + VDateField
- .resolutionToString(getWidget().currentResolution));
-
- final int year = uidl.getIntVariable("year");
- final int month = (getWidget().currentResolution >= VDateField.RESOLUTION_MONTH) ? uidl
- .getIntVariable("month") : -1;
- final int day = (getWidget().currentResolution >= VDateField.RESOLUTION_DAY) ? uidl
- .getIntVariable("day") : -1;
- final int hour = (getWidget().currentResolution >= VDateField.RESOLUTION_HOUR) ? uidl
- .getIntVariable("hour") : 0;
- final int min = (getWidget().currentResolution >= VDateField.RESOLUTION_MIN) ? uidl
- .getIntVariable("min") : 0;
- final int sec = (getWidget().currentResolution >= VDateField.RESOLUTION_SEC) ? uidl
- .getIntVariable("sec") : 0;
-
- // Construct new date for this datefield (only if not null)
- if (year > -1) {
- getWidget().setCurrentDate(
- new Date((long) getWidget().getTime(year,
- month, day, hour, min, sec, 0)));
- } else {
- getWidget().setCurrentDate(null);
- }
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VDateField.class);
- }
-
- @Override
- public VDateField getWidget() {
- return (VDateField) super.getWidget();
- }
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import java.util.HashMap;
-import java.util.Set;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.UIDL;
-
-public class VDragAndDropWrapperPaintable extends VCustomComponentPaintable {
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidget().client = client;
- super.updateFromUIDL(uidl, client);
- if (isRealUpdate(uidl) && !uidl.hasAttribute("hidden")) {
- UIDL acceptCrit = uidl.getChildByTagName("-ac");
- if (acceptCrit == null) {
- getWidget().dropHandler = null;
- } else {
- if (getWidget().dropHandler == null) {
- getWidget().dropHandler = getWidget().new CustomDropHandler();
- }
- getWidget().dropHandler
- .updateAcceptRules(acceptCrit);
- }
-
- Set<String> variableNames = uidl.getVariableNames();
- for (String fileId : variableNames) {
- if (fileId.startsWith("rec-")) {
- String receiverUrl = uidl.getStringVariable(fileId);
- fileId = fileId.substring(4);
- if (getWidget().fileIdToReceiver == null) {
- getWidget().fileIdToReceiver = new HashMap<String, String>();
- }
- if ("".equals(receiverUrl)) {
- Integer id = Integer.parseInt(fileId);
- int indexOf = getWidget().fileIds
- .indexOf(id);
- if (indexOf != -1) {
- getWidget().files.remove(indexOf);
- getWidget().fileIds.remove(indexOf);
- }
- } else {
- getWidget().fileIdToReceiver.put(fileId,
- receiverUrl);
- }
- }
- }
- getWidget().startNextUpload();
-
- getWidget().dragStartMode = uidl
- .getIntAttribute(VDragAndDropWrapper.DRAG_START_MODE);
- getWidget().initDragStartMode();
- getWidget().html5DataFlavors = uidl
- .getMapAttribute(VDragAndDropWrapper.HTML5_DATA_FLAVORS);
- }
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VDragAndDropWrapper.class);
- }
-
- @Override
- public VDragAndDropWrapper getWidget() {
- return (VDragAndDropWrapper) super.getWidget();
- }
-
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-
-package com.vaadin.terminal.gwt.client.ui;
-
-import java.util.Map;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.dom.client.Document;
-import com.google.gwt.dom.client.Node;
-import com.google.gwt.dom.client.NodeList;
-import com.google.gwt.dom.client.ObjectElement;
-import com.google.gwt.dom.client.Style;
-import com.google.gwt.event.dom.client.DomEvent.Type;
-import com.google.gwt.event.shared.EventHandler;
-import com.google.gwt.event.shared.HandlerRegistration;
-import com.google.gwt.user.client.DOM;
-import com.google.gwt.user.client.Element;
-import com.google.gwt.user.client.Event;
-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.VConsole;
-import com.vaadin.terminal.gwt.client.VTooltip;
-
-public class VEmbeddedPaintable extends AbstractComponentConnector {
-
- public static final String CLICK_EVENT_IDENTIFIER = "click";
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- // Save details
- getWidget().client = client;
-
- boolean clearBrowserElement = true;
-
- clickEventHandler.handleEventHandlerRegistration(client);
-
- if (uidl.hasAttribute("type")) {
- getWidget().type = uidl.getStringAttribute("type");
- if (getWidget().type.equals("image")) {
- getWidget().addStyleName(
- VEmbedded.CLASSNAME + "-image");
- Element el = null;
- boolean created = false;
- NodeList<Node> nodes = getWidget().getElement()
- .getChildNodes();
- if (nodes != null && nodes.getLength() == 1) {
- Node n = nodes.getItem(0);
- if (n.getNodeType() == Node.ELEMENT_NODE) {
- Element e = (Element) n;
- if (e.getTagName().equals("IMG")) {
- el = e;
- }
- }
- }
- if (el == null) {
- getWidget().setHTML("");
- el = DOM.createImg();
- created = true;
- DOM.sinkEvents(el, Event.ONLOAD);
- }
-
- // Set attributes
- Style style = el.getStyle();
- style.setProperty("width", getState().getWidth());
- style.setProperty("height", getState().getHeight());
-
- DOM.setElementProperty(el, "src", getWidget()
- .getSrc(uidl, client));
-
- if (created) {
- // insert in dom late
- getWidget().getElement().appendChild(el);
- }
-
- /*
- * Sink tooltip events so tooltip is displayed when hovering the
- * image.
- */
- getWidget().sinkEvents(VTooltip.TOOLTIP_EVENTS);
-
- } else if (getWidget().type.equals("browser")) {
- getWidget().addStyleName(
- VEmbedded.CLASSNAME + "-browser");
- if (getWidget().browserElement == null) {
- getWidget().setHTML(
- "<iframe width=\"100%\" height=\"100%\" frameborder=\"0\""
- + " allowTransparency=\"true\" src=\"\""
- + " name=\"" + uidl.getId()
- + "\"></iframe>");
- getWidget().browserElement = DOM
- .getFirstChild(getWidget().getElement());
- }
- DOM.setElementAttribute(getWidget().browserElement,
- "src", getWidget().getSrc(uidl, client));
- clearBrowserElement = false;
- } else {
- VConsole.log("Unknown Embedded type '"
- + getWidget().type + "'");
- }
- } else if (uidl.hasAttribute("mimetype")) {
- final String mime = uidl.getStringAttribute("mimetype");
- if (mime.equals("application/x-shockwave-flash")) {
- // Handle embedding of Flash
- getWidget().addStyleName(
- VEmbedded.CLASSNAME + "-flash");
- getWidget().setHTML(
- getWidget().createFlashEmbed(uidl));
-
- } else if (mime.equals("image/svg+xml")) {
- getWidget().addStyleName(
- VEmbedded.CLASSNAME + "-svg");
- String data;
- Map<String, String> parameters = VEmbedded.getParameters(uidl);
- if (parameters.get("data") == null) {
- data = getWidget().getSrc(uidl, client);
- } else {
- data = "data:image/svg+xml," + parameters.get("data");
- }
- getWidget().setHTML("");
- ObjectElement obj = Document.get().createObjectElement();
- obj.setType(mime);
- obj.setData(data);
- if (!isUndefinedWidth()) {
- obj.getStyle().setProperty("width", "100%");
- }
- if (!isUndefinedHeight()) {
- obj.getStyle().setProperty("height", "100%");
- }
- if (uidl.hasAttribute("classid")) {
- obj.setAttribute("classid",
- uidl.getStringAttribute("classid"));
- }
- if (uidl.hasAttribute("codebase")) {
- obj.setAttribute("codebase",
- uidl.getStringAttribute("codebase"));
- }
- if (uidl.hasAttribute("codetype")) {
- obj.setAttribute("codetype",
- uidl.getStringAttribute("codetype"));
- }
- if (uidl.hasAttribute("archive")) {
- obj.setAttribute("archive",
- uidl.getStringAttribute("archive"));
- }
- if (uidl.hasAttribute("standby")) {
- obj.setAttribute("standby",
- uidl.getStringAttribute("standby"));
- }
- getWidget().getElement().appendChild(obj);
-
- } else {
- VConsole.log("Unknown Embedded mimetype '" + mime + "'");
- }
- } else {
- VConsole.log("Unknown Embedded; no type or mimetype attribute");
- }
-
- if (clearBrowserElement) {
- getWidget().browserElement = null;
- }
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VEmbedded.class);
- }
-
- @Override
- public VEmbedded getWidget() {
- return (VEmbedded) super.getWidget();
- }
-
- protected final ClickEventHandler clickEventHandler = new ClickEventHandler(
- this, CLICK_EVENT_IDENTIFIER) {
-
- @Override
- protected <H extends EventHandler> HandlerRegistration registerHandler(
- H handler, Type<H> type) {
- return getWidget().addDomHandler(handler, type);
- }
-
- };
-
-}
\ No newline at end of file
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import java.util.Iterator;
-
-import com.google.gwt.core.client.GWT;
-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.Util;
-import com.vaadin.terminal.gwt.client.ui.VFilterSelect.FilterSelectSuggestion;
-
-public class VFilterSelectPaintable extends AbstractComponentConnector implements
- SimpleManagedLayout {
-
- /*
- * (non-Javadoc)
- *
- * @see
- * com.vaadin.terminal.gwt.client.Paintable#updateFromUIDL(com.vaadin.terminal
- * .gwt.client.UIDL, com.vaadin.terminal.gwt.client.ApplicationConnection)
- */
- @Override
- @SuppressWarnings("deprecation")
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- // Save details
- getWidget().client = client;
- getWidget().paintableId = uidl.getId();
-
- getWidget().readonly = getState().isReadOnly();
- getWidget().enabled = !getState().isDisabled();
-
- getWidget().tb.setEnabled(getWidget().enabled);
- getWidget().updateReadOnly();
-
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- // Inverse logic here to make the default case (text input enabled)
- // work without additional UIDL messages
- boolean noTextInput = uidl
- .hasAttribute(VFilterSelect.ATTR_NO_TEXT_INPUT)
- && uidl.getBooleanAttribute(VFilterSelect.ATTR_NO_TEXT_INPUT);
- getWidget().setTextInputEnabled(!noTextInput);
-
- // not a FocusWidget -> needs own tabindex handling
- if (uidl.hasAttribute("tabindex")) {
- getWidget().tb.setTabIndex(uidl
- .getIntAttribute("tabindex"));
- }
-
- if (uidl.hasAttribute("filteringmode")) {
- getWidget().filteringmode = uidl
- .getIntAttribute("filteringmode");
- }
-
- getWidget().immediate = getState().isImmediate();
-
- getWidget().nullSelectionAllowed = uidl
- .hasAttribute("nullselect");
-
- getWidget().nullSelectItem = uidl
- .hasAttribute("nullselectitem")
- && uidl.getBooleanAttribute("nullselectitem");
-
- getWidget().currentPage = uidl.getIntVariable("page");
-
- if (uidl.hasAttribute("pagelength")) {
- getWidget().pageLength = uidl
- .getIntAttribute("pagelength");
- }
-
- if (uidl.hasAttribute(VFilterSelect.ATTR_INPUTPROMPT)) {
- // input prompt changed from server
- getWidget().inputPrompt = uidl
- .getStringAttribute(VFilterSelect.ATTR_INPUTPROMPT);
- } else {
- getWidget().inputPrompt = "";
- }
-
- getWidget().suggestionPopup.updateStyleNames(uidl,
- getState());
-
- getWidget().allowNewItem = uidl
- .hasAttribute("allownewitem");
- getWidget().lastNewItemString = null;
-
- getWidget().currentSuggestions.clear();
- if (!getWidget().waitingForFilteringResponse) {
- /*
- * Clear the current suggestions as the server response always
- * includes the new ones. Exception is when filtering, then we need
- * to retain the value if the user does not select any of the
- * options matching the filter.
- */
- getWidget().currentSuggestion = null;
- /*
- * Also ensure no old items in menu. Unless cleared the old values
- * may cause odd effects on blur events. Suggestions in menu might
- * not necessary exist in select at all anymore.
- */
- getWidget().suggestionPopup.menu.clearItems();
-
- }
-
- final UIDL options = uidl.getChildUIDL(0);
- if (uidl.hasAttribute("totalMatches")) {
- getWidget().totalMatches = uidl
- .getIntAttribute("totalMatches");
- } else {
- getWidget().totalMatches = 0;
- }
-
- // used only to calculate minimum popup width
- String captions = Util.escapeHTML(getWidget().inputPrompt);
-
- for (final Iterator<?> i = options.getChildIterator(); i.hasNext();) {
- final UIDL optionUidl = (UIDL) i.next();
- final FilterSelectSuggestion suggestion = getWidget().new FilterSelectSuggestion(
- optionUidl);
- getWidget().currentSuggestions.add(suggestion);
- if (optionUidl.hasAttribute("selected")) {
- if (!getWidget().waitingForFilteringResponse
- || getWidget().popupOpenerClicked) {
- String newSelectedOptionKey = Integer.toString(suggestion
- .getOptionKey());
- if (!newSelectedOptionKey
- .equals(getWidget().selectedOptionKey)
- || suggestion.getReplacementString().equals(
- getWidget().tb.getText())) {
- // Update text field if we've got a new selection
- // Also update if we've got the same text to retain old
- // text selection behavior
- getWidget().setPromptingOff(
- suggestion.getReplacementString());
- getWidget().selectedOptionKey = newSelectedOptionKey;
- }
- }
- getWidget().currentSuggestion = suggestion;
- getWidget().setSelectedItemIcon(
- suggestion.getIconUri());
- }
-
- // Collect captions so we can calculate minimum width for textarea
- if (captions.length() > 0) {
- captions += "|";
- }
- captions += Util.escapeHTML(suggestion.getReplacementString());
- }
-
- if ((!getWidget().waitingForFilteringResponse || getWidget().popupOpenerClicked)
- && uidl.hasVariable("selected")
- && uidl.getStringArrayVariable("selected").length == 0) {
- // select nulled
- if (!getWidget().waitingForFilteringResponse
- || !getWidget().popupOpenerClicked) {
- if (!getWidget().focused) {
- /*
- * client.updateComponent overwrites all styles so we must
- * ALWAYS set the prompting style at this point, even though
- * we think it has been set already...
- */
- getWidget().prompting = false;
- getWidget().setPromptingOn();
- } else {
- // we have focus in field, prompting can't be set on,
- // instead just clear the input
- getWidget().tb.setValue("");
- }
- }
- getWidget().setSelectedItemIcon(null);
- getWidget().selectedOptionKey = null;
- }
-
- if (getWidget().waitingForFilteringResponse
- && getWidget().lastFilter.toLowerCase().equals(
- uidl.getStringVariable("filter"))) {
- getWidget().suggestionPopup.showSuggestions(
- getWidget().currentSuggestions,
- getWidget().currentPage,
- getWidget().totalMatches);
- getWidget().waitingForFilteringResponse = false;
- if (!getWidget().popupOpenerClicked
- && getWidget().selectPopupItemWhenResponseIsReceived != VFilterSelect.Select.NONE) {
- // we're paging w/ arrows
- if (getWidget().selectPopupItemWhenResponseIsReceived == VFilterSelect.Select.LAST) {
- getWidget().suggestionPopup.menu
- .selectLastItem();
- } else {
- getWidget().suggestionPopup.menu
- .selectFirstItem();
- }
-
- // This is used for paging so we update the keyboard selection
- // variable as well.
- MenuItem activeMenuItem = getWidget().suggestionPopup.menu
- .getSelectedItem();
- getWidget().suggestionPopup.menu
- .setKeyboardSelectedItem(activeMenuItem);
-
- // Update text field to contain the correct text
- getWidget()
- .setTextboxText(activeMenuItem.getText());
- getWidget().tb.setSelectionRange(
- getWidget().lastFilter.length(),
- activeMenuItem.getText().length()
- - getWidget().lastFilter.length());
-
- getWidget().selectPopupItemWhenResponseIsReceived = VFilterSelect.Select.NONE; // reset
- }
- if (getWidget().updateSelectionWhenReponseIsReceived) {
- getWidget().suggestionPopup.menu
- .doPostFilterSelectedItemAction();
- }
- }
-
- // Calculate minumum textarea width
- getWidget().suggestionPopupMinWidth = getWidget()
- .minWidth(captions);
-
- getWidget().popupOpenerClicked = false;
-
- if (!getWidget().initDone) {
- getWidget().updateRootWidth();
- }
-
- // Focus dependent style names are lost during the update, so we add
- // them here back again
- if (getWidget().focused) {
- getWidget().addStyleDependentName("focus");
- }
-
- getWidget().initDone = true;
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VFilterSelect.class);
- }
-
- @Override
- public VFilterSelect getWidget() {
- return (VFilterSelect) super.getWidget();
- }
-
- public void layout() {
- VFilterSelect widget = getWidget();
- if (widget.initDone) {
- widget.updateRootWidth();
- }
- }
-}
+++ /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.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.UIDL;
-import com.vaadin.terminal.gwt.client.ComponentConnector;
-
-public class VFormLayoutPaintable extends AbstractComponentContainerConnector {
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidget().client = client;
-
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- getWidget().table.updateFromUIDL(uidl, client);
- }
-
- public void updateCaption(ComponentConnector component, UIDL uidl) {
- getWidget().table.updateCaption(component, uidl);
- }
-
- @Override
- public VFormLayout getWidget() {
- return (VFormLayout) super.getWidget();
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VFormLayout.class);
- }
-
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.dom.client.Style.Unit;
-import com.google.gwt.event.dom.client.KeyDownEvent;
-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.ConnectorMap;
-import com.vaadin.terminal.gwt.client.ComponentConnector;
-
-public class VFormPaintable extends AbstractComponentContainerConnector implements
- SimpleManagedLayout {
-
- @Override
- public void init() {
- VForm form = getWidget();
- getLayoutManager().registerDependency(this, form.footerContainer);
- }
-
- @Override
- protected boolean delegateCaptionHandling() {
- return false;
- }
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidget().client = client;
- getWidget().id = uidl.getId();
-
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- boolean legendEmpty = true;
- if (getState().getCaption() != null) {
- getWidget().caption.setInnerText(getState()
- .getCaption());
- legendEmpty = false;
- } else {
- getWidget().caption.setInnerText("");
- }
- if (uidl.hasAttribute(ATTRIBUTE_ICON)) {
- if (getWidget().icon == null) {
- getWidget().icon = new Icon(client);
- getWidget().legend
- .insertFirst(getWidget().icon.getElement());
- }
- getWidget().icon.setUri(uidl
- .getStringAttribute(ATTRIBUTE_ICON));
- legendEmpty = false;
- } else {
- if (getWidget().icon != null) {
- getWidget().legend
- .removeChild(getWidget().icon.getElement());
- }
- }
- if (legendEmpty) {
- getWidget().addStyleDependentName("nocaption");
- } else {
- getWidget().removeStyleDependentName("nocaption");
- }
-
- if (uidl.hasAttribute("error")) {
- final UIDL errorUidl = uidl.getErrors();
- getWidget().errorMessage.updateFromUIDL(errorUidl);
- getWidget().errorMessage.setVisible(true);
- } else {
- getWidget().errorMessage.setVisible(false);
- }
-
- if (getState().hasDescription()) {
- getWidget().desc.setInnerHTML(getState()
- .getDescription());
- if (getWidget().desc.getParentElement() == null) {
- getWidget().fieldSet.insertAfter(
- getWidget().desc,
- getWidget().legend);
- }
- } else {
- getWidget().desc.setInnerHTML("");
- if (getWidget().desc.getParentElement() != null) {
- getWidget().fieldSet
- .removeChild(getWidget().desc);
- }
- }
-
- // first render footer so it will be easier to handle relative height of
- // main layout
- if (uidl.getChildCount() > 1
- && !uidl.getChildUIDL(1).getTag().equals("actions")) {
- // render footer
- ComponentConnector newFooter = client.getPaintable(uidl
- .getChildUIDL(1));
- Widget newFooterWidget = newFooter.getWidget();
- if (getWidget().footer == null) {
- getWidget().add(newFooter.getWidget(),
- getWidget().footerContainer);
- getWidget().footer = newFooterWidget;
- } else if (newFooter != getWidget().footer) {
- getWidget().remove(getWidget().footer);
- client.unregisterPaintable(ConnectorMap.get(getConnection())
- .getConnector(getWidget().footer));
- getWidget().add(newFooter.getWidget(),
- getWidget().footerContainer);
- }
- getWidget().footer = newFooterWidget;
- newFooter.updateFromUIDL(uidl.getChildUIDL(1), client);
- } else {
- if (getWidget().footer != null) {
- getWidget().remove(getWidget().footer);
- client.unregisterPaintable(ConnectorMap.get(getConnection())
- .getConnector(getWidget().footer));
- }
- }
-
- final UIDL layoutUidl = uidl.getChildUIDL(0);
- ComponentConnector newLayout = client.getPaintable(layoutUidl);
- Widget newLayoutWidget = newLayout.getWidget();
- if (getWidget().lo == null) {
- // Layout not rendered before
- getWidget().lo = newLayoutWidget;
- getWidget().add(newLayoutWidget,
- getWidget().fieldContainer);
- } else if (getWidget().lo != newLayoutWidget) {
- // Layout has changed
- client.unregisterPaintable(ConnectorMap.get(getConnection())
- .getConnector(getWidget().lo));
- getWidget().remove(getWidget().lo);
- getWidget().lo = newLayoutWidget;
- getWidget().add(newLayoutWidget,
- getWidget().fieldContainer);
- }
- newLayout.updateFromUIDL(layoutUidl, client);
-
- // also recalculates size of the footer if undefined size form - see
- // #3710
- client.runDescendentsLayout(getWidget());
-
- // We may have actions attached
- if (uidl.getChildCount() > 1) {
- UIDL childUidl = uidl.getChildByTagName("actions");
- if (childUidl != null) {
- if (getWidget().shortcutHandler == null) {
- getWidget().shortcutHandler = new ShortcutActionHandler(
- getId(), client);
- getWidget().keyDownRegistration = getWidget()
- .addDomHandler(getWidget(),
- KeyDownEvent.getType());
- }
- getWidget().shortcutHandler
- .updateActionMap(childUidl);
- }
- } else if (getWidget().shortcutHandler != null) {
- getWidget().keyDownRegistration.removeHandler();
- getWidget().shortcutHandler = null;
- getWidget().keyDownRegistration = null;
- }
- }
-
- public void updateCaption(ComponentConnector component, UIDL uidl) {
- // NOP form don't render caption for neither field layout nor footer
- // layout
- }
-
- @Override
- public VForm getWidget() {
- return (VForm) super.getWidget();
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VForm.class);
- }
-
- public void layout() {
- VForm form = getWidget();
-
- int footerHeight = getLayoutManager().getOuterHeight(
- form.footerContainer);
-
- form.fieldContainer.getStyle().setPaddingBottom(footerHeight, Unit.PX);
- form.footerContainer.getStyle().setMarginTop(-footerHeight, Unit.PX);
- }
-
-}
import com.vaadin.terminal.gwt.client.ConnectorMap;
import com.vaadin.terminal.gwt.client.ComponentConnector;
import com.vaadin.terminal.gwt.client.ui.layout.VLayoutSlot;
-import com.vaadin.terminal.gwt.client.ui.layout.VPaintableLayoutSlot;
+import com.vaadin.terminal.gwt.client.ui.layout.ComponentConnectorLayoutSlot;
public class VGridLayout extends ComplexPanel {
private AlignmentInfo alignment;
- VPaintableLayoutSlot slot;
+ ComponentConnectorLayoutSlot slot;
public void updateFromUidl(UIDL cellUidl) {
// Set cell width
ComponentConnector paintable = client.getPaintable(childUidl);
if (slot == null || slot.getPaintable() != paintable) {
- slot = new VPaintableLayoutSlot(CLASSNAME, paintable);
+ slot = new ComponentConnectorLayoutSlot(CLASSNAME, paintable);
Element slotWrapper = slot.getWrapperElement();
getElement().appendChild(slotWrapper);
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import java.util.HashSet;
-import java.util.Iterator;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.event.dom.client.DomEvent.Type;
-import com.google.gwt.event.shared.EventHandler;
-import com.google.gwt.event.shared.HandlerRegistration;
-import com.google.gwt.user.client.Element;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.DirectionalManagedLayout;
-import com.vaadin.terminal.gwt.client.EventId;
-import com.vaadin.terminal.gwt.client.UIDL;
-import com.vaadin.terminal.gwt.client.VCaption;
-import com.vaadin.terminal.gwt.client.ConnectorMap;
-import com.vaadin.terminal.gwt.client.ComponentConnector;
-import com.vaadin.terminal.gwt.client.ui.VGridLayout.Cell;
-import com.vaadin.terminal.gwt.client.ui.layout.VLayoutSlot;
-
-public class VGridLayoutPaintable extends AbstractComponentContainerConnector
- implements DirectionalManagedLayout {
- private LayoutClickEventHandler clickEventHandler = new LayoutClickEventHandler(
- this, EventId.LAYOUT_CLICK) {
-
- @Override
- protected ComponentConnector getChildComponent(Element element) {
- return getWidget().getComponent(element);
- }
-
- @Override
- protected <H extends EventHandler> HandlerRegistration registerHandler(
- H handler, Type<H> type) {
- return getWidget().addDomHandler(handler, type);
- }
- };
-
- @Override
- public void init() {
- getLayoutManager().registerDependency(this,
- getWidget().spacingMeasureElement);
- }
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- VGridLayout layout = getWidget();
- layout.client = client;
-
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
- clickEventHandler.handleEventHandlerRegistration(client);
-
- int cols = uidl.getIntAttribute("w");
- int rows = uidl.getIntAttribute("h");
-
- layout.columnWidths = new int[cols];
- layout.rowHeights = new int[rows];
-
- if (layout.cells == null) {
- layout.cells = new Cell[cols][rows];
- } else if (layout.cells.length != cols
- || layout.cells[0].length != rows) {
- Cell[][] newCells = new Cell[cols][rows];
- for (int i = 0; i < layout.cells.length; i++) {
- for (int j = 0; j < layout.cells[i].length; j++) {
- if (i < cols && j < rows) {
- newCells[i][j] = layout.cells[i][j];
- }
- }
- }
- layout.cells = newCells;
- }
-
- final int[] alignments = uidl.getIntArrayAttribute("alignments");
- int alignmentIndex = 0;
-
- HashSet<Widget> nonRenderedWidgets = new HashSet<Widget>(
- layout.widgetToCell.keySet());
-
- for (final Iterator<?> i = uidl.getChildIterator(); i.hasNext();) {
- final UIDL r = (UIDL) i.next();
- if ("gr".equals(r.getTag())) {
- for (final Iterator<?> j = r.getChildIterator(); j.hasNext();) {
- final UIDL c = (UIDL) j.next();
- if ("gc".equals(c.getTag())) {
- Cell cell = layout.getCell(c);
- if (cell.hasContent()) {
- cell.setAlignment(new AlignmentInfo(
- alignments[alignmentIndex++]));
- nonRenderedWidgets.remove(cell.slot.getWidget());
- }
- }
- }
- }
- }
-
- layout.colExpandRatioArray = uidl.getIntArrayAttribute("colExpand");
- layout.rowExpandRatioArray = uidl.getIntArrayAttribute("rowExpand");
-
- // clean non rendered components
- for (Widget w : nonRenderedWidgets) {
- Cell cell = layout.widgetToCell.remove(w);
- cell.slot.setCaption(null);
-
- if (w.getParent() == layout) {
- w.removeFromParent();
- ConnectorMap paintableMap = ConnectorMap.get(client);
- paintableMap.unregisterConnector(paintableMap.getConnector(w));
- }
- cell.slot.getWrapperElement().removeFromParent();
- }
-
- int bitMask = uidl.getIntAttribute("margins");
- layout.updateMarginStyleNames(new VMarginInfo(bitMask));
-
- layout.updateSpacingStyleName(uidl.getBooleanAttribute("spacing"));
-
- getLayoutManager().setNeedsUpdate(this);
- }
-
- public void updateCaption(ComponentConnector paintable, UIDL uidl) {
- VGridLayout layout = getWidget();
- if (VCaption.isNeeded(uidl, paintable.getState())) {
- Cell cell = layout.widgetToCell.get(paintable
- .getWidget());
- VLayoutSlot layoutSlot = cell.slot;
- VCaption caption = layoutSlot.getCaption();
- if (caption == null) {
- caption = new VCaption(paintable, getConnection());
-
- Widget widget = paintable.getWidget();
-
- layout.setCaption(widget, caption);
- }
- caption.updateCaption(uidl);
- } else {
- layout.setCaption(paintable.getWidget(), null);
- }
- }
-
- @Override
- public VGridLayout getWidget() {
- return (VGridLayout) super.getWidget();
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VGridLayout.class);
- }
-
- public void layoutVertically() {
- getWidget().updateHeight();
- }
-
- public void layoutHorizontally() {
- getWidget().updateWidth();
- }
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.google.gwt.core.client.GWT;
-
-public class VHorizontalLayoutPaintable extends
- VMeasuringOrderedLayoutPaintable {
-
- @Override
- public VHorizontalLayout getWidget() {
- return (VHorizontalLayout) super.getWidget();
- }
-
- @Override
- protected VHorizontalLayout createWidget() {
- return GWT.create(VHorizontalLayout.class);
- }
-
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.google.gwt.core.client.GWT;
-
-public class VHorizontalSplitPanelPaintable extends
- VAbstractSplitPanelPaintable {
-
- @Override
- protected VAbstractSplitPanel createWidget() {
- return GWT.create(VSplitPanelHorizontal.class);
- }
-
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.user.client.DOM;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.UIDL;
-
-public class VLinkPaintable extends AbstractComponentConnector {
-
- @Override
- protected boolean delegateCaptionHandling() {
- return false;
- }
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
-
- // Ensure correct implementation,
- // but don't let container manage caption etc.
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- getWidget().client = client;
-
- getWidget().enabled = !getState().isDisabled();
- getWidget().readonly = getState().isReadOnly();
-
- if (uidl.hasAttribute("name")) {
- getWidget().target = uidl.getStringAttribute("name");
- getWidget().anchor.setAttribute("target",
- getWidget().target);
- }
- if (uidl.hasAttribute("src")) {
- getWidget().src = client.translateVaadinUri(uidl
- .getStringAttribute("src"));
- getWidget().anchor.setAttribute("href",
- getWidget().src);
- }
-
- if (uidl.hasAttribute("border")) {
- if ("none".equals(uidl.getStringAttribute("border"))) {
- getWidget().borderStyle = VLink.BORDER_STYLE_NONE;
- } else {
- getWidget().borderStyle = VLink.BORDER_STYLE_MINIMAL;
- }
- } else {
- getWidget().borderStyle = VLink.BORDER_STYLE_DEFAULT;
- }
-
- getWidget().targetHeight = uidl
- .hasAttribute("targetHeight") ? uidl
- .getIntAttribute("targetHeight") : -1;
- getWidget().targetWidth = uidl.hasAttribute("targetWidth") ? uidl
- .getIntAttribute("targetWidth") : -1;
-
- // Set link caption
- getWidget().captionElement.setInnerText(getState()
- .getCaption());
-
- // handle error
- if (uidl.hasAttribute("error")) {
- if (getWidget().errorIndicatorElement == null) {
- getWidget().errorIndicatorElement = DOM.createDiv();
- DOM.setElementProperty(
- getWidget().errorIndicatorElement,
- "className", "v-errorindicator");
- }
- DOM.insertChild(getWidget().getElement(),
- getWidget().errorIndicatorElement, 0);
- } else if (getWidget().errorIndicatorElement != null) {
- DOM.setStyleAttribute(
- getWidget().errorIndicatorElement, "display",
- "none");
- }
-
- if (uidl.hasAttribute(ATTRIBUTE_ICON)) {
- if (getWidget().icon == null) {
- getWidget().icon = new Icon(client);
- getWidget().anchor.insertBefore(
- getWidget().icon.getElement(),
- getWidget().captionElement);
- }
- getWidget().icon.setUri(uidl
- .getStringAttribute(ATTRIBUTE_ICON));
- }
-
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VLink.class);
- }
-
- @Override
- public VLink getWidget() {
- return (VLink) super.getWidget();
- }
-}
+++ /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;
-
-public class VListSelectPaintable extends VOptionGroupBasePaintable {
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VListSelect.class);
- }
-
- @Override
- public VListSelect getWidget() {
- return (VListSelect) super.getWidget();
- }
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import java.util.HashSet;
-import java.util.Iterator;
-
-import com.google.gwt.dom.client.Node;
-import com.google.gwt.dom.client.Style;
-import com.google.gwt.user.client.Element;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.DirectionalManagedLayout;
-import com.vaadin.terminal.gwt.client.LayoutManager;
-import com.vaadin.terminal.gwt.client.UIDL;
-import com.vaadin.terminal.gwt.client.VCaption;
-import com.vaadin.terminal.gwt.client.ConnectorMap;
-import com.vaadin.terminal.gwt.client.ComponentConnector;
-import com.vaadin.terminal.gwt.client.ValueMap;
-import com.vaadin.terminal.gwt.client.ui.layout.VLayoutSlot;
-import com.vaadin.terminal.gwt.client.ui.layout.VPaintableLayoutSlot;
-
-public abstract class VMeasuringOrderedLayoutPaintable extends
- AbstractComponentContainerConnector implements DirectionalManagedLayout {
-
- @Override
- public void init() {
- getLayoutManager().registerDependency(this,
- getWidget().spacingMeasureElement);
- }
-
- public void updateCaption(ComponentConnector component, UIDL uidl) {
- VMeasuringOrderedLayout layout = getWidget();
- if (VCaption.isNeeded(uidl, component.getState())) {
- VLayoutSlot layoutSlot = layout.getSlotForChild(component
- .getWidget());
- VCaption caption = layoutSlot.getCaption();
- if (caption == null) {
- caption = new VCaption(component, getConnection());
-
- Widget widget = component.getWidget();
-
- layout.setCaption(widget, caption);
- }
- caption.updateCaption(uidl);
- } else {
- layout.setCaption(component.getWidget(), null);
- }
- }
-
- @Override
- public VMeasuringOrderedLayout getWidget() {
- return (VMeasuringOrderedLayout) super.getWidget();
- }
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- HashSet<ComponentConnector> previousChildren = new HashSet<ComponentConnector>(
- getChildren());
-
- VMeasuringOrderedLayout layout = getWidget();
-
- ValueMap expandRatios = uidl.getMapAttribute("expandRatios");
- ValueMap alignments = uidl.getMapAttribute("alignments");
-
- int currentIndex = 0;
- // TODO Support reordering elements!
- for (final Iterator<Object> it = uidl.getChildIterator(); it.hasNext();) {
- final UIDL childUIDL = (UIDL) it.next();
- final ComponentConnector child = client.getPaintable(childUIDL);
- Widget widget = child.getWidget();
-
- VLayoutSlot slot = layout.getSlotForChild(widget);
-
- if (widget.getParent() != layout) {
- slot = new VPaintableLayoutSlot(getWidget()
- .getStylePrimaryName(), child);
- }
- layout.addOrMove(slot, currentIndex++);
-
- String pid = child.getId();
-
- AlignmentInfo alignment;
- if (alignments.containsKey(pid)) {
- alignment = new AlignmentInfo(alignments.getInt(pid));
- } else {
- alignment = AlignmentInfo.TOP_LEFT;
- }
- slot.setAlignment(alignment);
-
- double expandRatio;
- if (expandRatios.containsKey(pid)) {
- expandRatio = expandRatios.getRawNumber(pid);
- } else {
- expandRatio = 0;
- }
- slot.setExpandRatio(expandRatio);
-
- if (!childUIDL.getBooleanAttribute("cached")) {
- child.updateFromUIDL(childUIDL, client);
- }
-
- previousChildren.remove(child);
- }
-
- for (ComponentConnector child : previousChildren) {
- Widget widget = child.getWidget();
-
- // Don't remove and unregister if it has been moved to a different
- // parent. Slot element will be left behind, but that is taken care
- // of later
- if (widget.getParent() == getWidget()) {
- layout.removeSlot(layout.getSlotForChild(widget));
-
- ConnectorMap vPaintableMap = ConnectorMap.get(client);
- vPaintableMap.unregisterConnector(child);
- }
- }
-
- // Remove empty layout slots left behind after children have moved to
- // other paintables
- while (true) {
- int childCount = layout.getElement().getChildCount();
- if (childCount <= 1) {
- // Stop if no more slots (spacing element is always present)
- break;
- }
-
- Node lastSlot = layout.getElement().getChild(childCount - 2);
- if (lastSlot.getChildCount() == 0) {
- // Remove if empty
- lastSlot.removeFromParent();
- } else {
- // Stop searching when last slot is not empty
- break;
- }
- }
-
- int bitMask = uidl.getIntAttribute("margins");
- layout.updateMarginStyleNames(new VMarginInfo(bitMask));
-
- layout.updateSpacingStyleName(uidl.getBooleanAttribute("spacing"));
-
- getLayoutManager().setNeedsUpdate(this);
- }
-
- private int getSizeForInnerSize(int size, boolean isVertical) {
- LayoutManager layoutManager = getLayoutManager();
- Element element = getWidget().getElement();
- if (isVertical) {
- return size + layoutManager.getBorderHeight(element)
- + layoutManager.getPaddingHeight(element);
- } else {
- return size + layoutManager.getBorderWidth(element)
- + layoutManager.getPaddingWidth(element);
- }
- }
-
- private static String getSizeProperty(boolean isVertical) {
- return isVertical ? "height" : "width";
- }
-
- private boolean isUndefinedInDirection(boolean isVertical) {
- if (isVertical) {
- return isUndefinedHeight();
- } else {
- return isUndefinedWidth();
- }
- }
-
- private int getInnerSizeInDirection(boolean isVertical) {
- if (isVertical) {
- return getLayoutManager().getInnerHeight(
- getWidget().getElement());
- } else {
- return getLayoutManager().getInnerWidth(
- getWidget().getElement());
- }
- }
-
- private void layoutPrimaryDirection() {
- VMeasuringOrderedLayout layout = getWidget();
- boolean isVertical = layout.isVertical;
- boolean isUndefined = isUndefinedInDirection(isVertical);
-
- int startPadding = getStartPadding(isVertical);
- int spacingSize = getSpacingInDirection(isVertical);
- int allocatedSize;
-
- if (isUndefined) {
- allocatedSize = -1;
- } else {
- allocatedSize = getInnerSizeInDirection(isVertical);
- }
-
- allocatedSize = layout.layoutPrimaryDirection(spacingSize,
- allocatedSize, startPadding);
-
- Style ownStyle = getWidget().getElement().getStyle();
- if (isUndefined) {
- ownStyle.setPropertyPx(getSizeProperty(isVertical),
- getSizeForInnerSize(allocatedSize, isVertical));
- } else {
- ownStyle.setProperty(getSizeProperty(isVertical),
- getDefinedSize(isVertical));
- }
- }
-
- private int getSpacingInDirection(boolean isVertical) {
- if (isVertical) {
- return getLayoutManager().getOuterHeight(
- getWidget().spacingMeasureElement);
- } else {
- return getLayoutManager().getOuterWidth(
- getWidget().spacingMeasureElement);
- }
- }
-
- private void layoutSecondaryDirection() {
- VMeasuringOrderedLayout layout = getWidget();
- boolean isVertical = layout.isVertical;
- boolean isUndefined = isUndefinedInDirection(!isVertical);
-
- int startPadding = getStartPadding(!isVertical);
-
- int allocatedSize;
- if (isUndefined) {
- allocatedSize = -1;
- } else {
- allocatedSize = getInnerSizeInDirection(!isVertical);
- }
-
- allocatedSize = layout.layoutSecondaryDirection(allocatedSize,
- startPadding);
-
- Style ownStyle = getWidget().getElement().getStyle();
-
- if (isUndefined) {
- ownStyle.setPropertyPx(
- getSizeProperty(!getWidget().isVertical),
- getSizeForInnerSize(allocatedSize,
- !getWidget().isVertical));
- } else {
- ownStyle.setProperty(
- getSizeProperty(!getWidget().isVertical),
- getDefinedSize(!getWidget().isVertical));
- }
- }
-
- private String getDefinedSize(boolean isVertical) {
- if (isVertical) {
- return getDeclaredHeight();
- } else {
- return getDeclaredWidth();
- }
- }
-
- private int getStartPadding(boolean isVertical) {
- if (isVertical) {
- return getLayoutManager().getPaddingTop(
- getWidget().getElement());
- } else {
- return getLayoutManager().getPaddingLeft(
- getWidget().getElement());
- }
- }
-
- public void layoutHorizontally() {
- if (getWidget().isVertical) {
- layoutSecondaryDirection();
- } else {
- layoutPrimaryDirection();
- }
- }
-
- public void layoutVertically() {
- if (getWidget().isVertical) {
- layoutPrimaryDirection();
- } else {
- layoutSecondaryDirection();
- }
- }
-
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.UIDL;
-import com.vaadin.terminal.gwt.client.Util;
-
-public abstract class VMediaBasePaintable extends AbstractComponentConnector {
-
- public static final String TAG_SOURCE = "src";
-
- public static final String ATTR_PAUSE = "pause";
- public static final String ATTR_PLAY = "play";
- public static final String ATTR_MUTED = "muted";
- public static final String ATTR_CONTROLS = "ctrl";
- public static final String ATTR_AUTOPLAY = "auto";
- public static final String ATTR_RESOURCE = "res";
- public static final String ATTR_RESOURCE_TYPE = "type";
- public static final String ATTR_HTML = "html";
- public static final String ATTR_ALT_TEXT = "alt";
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- getWidget().setControls(shouldShowControls(uidl));
- getWidget().setAutoplay(shouldAutoplay(uidl));
- getWidget().setMuted(isMediaMuted(uidl));
-
- // Add all sources
- for (int ix = 0; ix < uidl.getChildCount(); ix++) {
- UIDL child = uidl.getChildUIDL(ix);
- if (TAG_SOURCE.equals(child.getTag())) {
- getWidget().addSource(getSourceUrl(child),
- getSourceType(child));
- }
- }
- setAltText(uidl);
-
- evalPauseCommand(uidl);
- evalPlayCommand(uidl);
- }
-
- protected boolean shouldShowControls(UIDL uidl) {
- return uidl.getBooleanAttribute(ATTR_CONTROLS);
- }
-
- private boolean shouldAutoplay(UIDL uidl) {
- return uidl.getBooleanAttribute(ATTR_AUTOPLAY);
- }
-
- private boolean isMediaMuted(UIDL uidl) {
- return uidl.getBooleanAttribute(ATTR_MUTED);
- }
-
- private boolean allowHtmlContent(UIDL uidl) {
- return uidl.getBooleanAttribute(ATTR_HTML);
- }
-
- private void evalPlayCommand(UIDL uidl) {
- if (uidl.hasAttribute(ATTR_PLAY)) {
- getWidget().play();
- }
- }
-
- private void evalPauseCommand(UIDL uidl) {
- if (uidl.hasAttribute(ATTR_PAUSE)) {
- getWidget().pause();
- }
- }
-
- @Override
- public VMediaBase getWidget() {
- return (VMediaBase) super.getWidget();
- }
-
- /**
- * @param uidl
- * @return the URL of a resource to be used as a source for the media
- */
- private String getSourceUrl(UIDL uidl) {
- String url = getConnection().translateVaadinUri(
- uidl.getStringAttribute(VMediaBasePaintable.ATTR_RESOURCE));
- if (url == null) {
- return "";
- }
- return url;
- }
-
- /**
- * @param uidl
- * @return the mime type of the media
- */
- private String getSourceType(UIDL uidl) {
- return uidl.getStringAttribute(VMediaBasePaintable.ATTR_RESOURCE_TYPE);
- }
-
- private void setAltText(UIDL uidl) {
- String alt = uidl.getStringAttribute(VMediaBasePaintable.ATTR_ALT_TEXT);
-
- if (alt == null || "".equals(alt)) {
- alt = getWidget().getDefaultAltHtml();
- } else if (!allowHtmlContent(uidl)) {
- alt = Util.escapeHTML(alt);
- }
- getWidget().setAltText(alt);
- }
-
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import java.util.Iterator;
-import java.util.Stack;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.user.client.Command;
-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.Util;
-import com.vaadin.terminal.gwt.client.ui.VMenuBar.CustomMenuItem;
-
-public class VMenuBarPaintable extends AbstractComponentConnector implements
- SimpleManagedLayout {
- /**
- * This method must be implemented to update the client-side component from
- * UIDL data received from server.
- *
- * This method is called when the page is loaded for the first time, and
- * every time UI changes in the component are received from the server.
- */
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- // This call should be made first. Ensure correct implementation,
- // and let the containing layout manage caption, etc.
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- getWidget().htmlContentAllowed = uidl
- .hasAttribute(VMenuBar.HTML_CONTENT_ALLOWED);
-
- getWidget().openRootOnHover = uidl
- .getBooleanAttribute(VMenuBar.OPEN_ROOT_MENU_ON_HOWER);
-
- getWidget().enabled = !getState().isDisabled();
-
- // For future connections
- getWidget().client = client;
- getWidget().uidlId = uidl.getId();
-
- // Empty the menu every time it receives new information
- if (!getWidget().getItems().isEmpty()) {
- getWidget().clearItems();
- }
-
- UIDL options = uidl.getChildUIDL(0);
-
- if (null != getState() && !getState().isUndefinedWidth()) {
- UIDL moreItemUIDL = options.getChildUIDL(0);
- StringBuffer itemHTML = new StringBuffer();
-
- if (moreItemUIDL.hasAttribute("icon")) {
- itemHTML.append("<img src=\""
- + Util.escapeAttribute(client
- .translateVaadinUri(moreItemUIDL
- .getStringAttribute("icon")))
- + "\" class=\"" + Icon.CLASSNAME + "\" alt=\"\" />");
- }
-
- String moreItemText = moreItemUIDL.getStringAttribute("text");
- if ("".equals(moreItemText)) {
- moreItemText = "►";
- }
- itemHTML.append(moreItemText);
-
- getWidget().moreItem = GWT.create(CustomMenuItem.class);
- getWidget().moreItem.setHTML(itemHTML.toString());
- getWidget().moreItem.setCommand(VMenuBar.emptyCommand);
-
- getWidget().collapsedRootItems = new VMenuBar(true,
- getWidget());
- getWidget().moreItem
- .setSubMenu(getWidget().collapsedRootItems);
- getWidget().moreItem.addStyleName(VMenuBar.CLASSNAME
- + "-more-menuitem");
- }
-
- UIDL uidlItems = uidl.getChildUIDL(1);
- Iterator<Object> itr = uidlItems.getChildIterator();
- Stack<Iterator<Object>> iteratorStack = new Stack<Iterator<Object>>();
- Stack<VMenuBar> menuStack = new Stack<VMenuBar>();
- VMenuBar currentMenu = getWidget();
-
- while (itr.hasNext()) {
- UIDL item = (UIDL) itr.next();
- CustomMenuItem currentItem = null;
-
- final int itemId = item.getIntAttribute("id");
-
- boolean itemHasCommand = item.hasAttribute("command");
- boolean itemIsCheckable = item
- .hasAttribute(VMenuBar.ATTRIBUTE_CHECKED);
-
- String itemHTML = getWidget().buildItemHTML(item);
-
- Command cmd = null;
- if (!item.hasAttribute("separator")) {
- if (itemHasCommand || itemIsCheckable) {
- // Construct a command that fires onMenuClick(int) with the
- // item's id-number
- cmd = new Command() {
- public void execute() {
- getWidget().hostReference
- .onMenuClick(itemId);
- }
- };
- }
- }
-
- currentItem = currentMenu.addItem(itemHTML.toString(), cmd);
- currentItem.updateFromUIDL(item, client);
-
- if (item.getChildCount() > 0) {
- menuStack.push(currentMenu);
- iteratorStack.push(itr);
- itr = item.getChildIterator();
- currentMenu = new VMenuBar(true, currentMenu);
- // this is the top-level style that also propagates to items -
- // any item specific styles are set above in
- // currentItem.updateFromUIDL(item, client)
- if (getState().hasStyles()) {
- for (String style : getState().getStyle().split(" ")) {
- currentMenu.addStyleDependentName(style);
- }
- }
- currentItem.setSubMenu(currentMenu);
- }
-
- while (!itr.hasNext() && !iteratorStack.empty()) {
- boolean hasCheckableItem = false;
- for (CustomMenuItem menuItem : currentMenu.getItems()) {
- hasCheckableItem = hasCheckableItem
- || menuItem.isCheckable();
- }
- if (hasCheckableItem) {
- currentMenu.addStyleDependentName("check-column");
- } else {
- currentMenu.removeStyleDependentName("check-column");
- }
-
- itr = iteratorStack.pop();
- currentMenu = menuStack.pop();
- }
- }// while
-
- getWidget().iLayout(false);
-
- }// updateFromUIDL
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VMenuBar.class);
- }
-
- @Override
- public VMenuBar getWidget() {
- return (VMenuBar) super.getWidget();
- }
-
- public void layout() {
- getWidget().iLayout();
- }
-}
import com.vaadin.terminal.gwt.client.MouseEventDetails;
import com.vaadin.terminal.gwt.client.Util;
import com.vaadin.terminal.gwt.client.VTooltip;
-import com.vaadin.terminal.gwt.client.ui.VButtonPaintable.ButtonClientToServerRpc;
+import com.vaadin.terminal.gwt.client.ui.ButtonConnector.ButtonClientToServerRpc;
public class VNativeButton extends Button implements ClickHandler,
FocusHandler, BlurHandler {
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.user.client.DOM;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.ComponentState;
-import com.vaadin.terminal.gwt.client.EventHelper;
-import com.vaadin.terminal.gwt.client.UIDL;
-import com.vaadin.terminal.gwt.client.ui.VButtonPaintable.ButtonClientToServerRpc;
-
-public class VNativeButtonPaintable extends AbstractComponentConnector {
-
- @Override
- public void init() {
- super.init();
-
- ButtonClientToServerRpc rpcProxy = GWT
- .create(ButtonClientToServerRpc.class);
- getWidget().buttonRpcProxy = initRPC(rpcProxy);
- }
-
- @Override
- protected boolean delegateCaptionHandling() {
- return false;
- }
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
-
- // Ensure correct implementation,
- // but don't let container manage caption etc.
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- getWidget().disableOnClick = getState().isDisableOnClick();
- getWidget().focusHandlerRegistration = EventHelper
- .updateFocusHandler(this, client,
- getWidget().focusHandlerRegistration);
- getWidget().blurHandlerRegistration = EventHelper
- .updateBlurHandler(this, client,
- getWidget().blurHandlerRegistration);
-
- // Save details
- getWidget().client = client;
- getWidget().paintableId = uidl.getId();
-
- // Set text
- getWidget().setText(getState().getCaption());
-
- // handle error
- if (uidl.hasAttribute("error")) {
- if (getWidget().errorIndicatorElement == null) {
- getWidget().errorIndicatorElement = DOM
- .createSpan();
- getWidget().errorIndicatorElement
- .setClassName("v-errorindicator");
- }
- getWidget().getElement().insertBefore(
- getWidget().errorIndicatorElement,
- getWidget().captionElement);
-
- } else if (getWidget().errorIndicatorElement != null) {
- getWidget().getElement().removeChild(
- getWidget().errorIndicatorElement);
- getWidget().errorIndicatorElement = null;
- }
-
- if (uidl.hasAttribute(ATTRIBUTE_ICON)) {
- if (getWidget().icon == null) {
- getWidget().icon = new Icon(client);
- getWidget().getElement().insertBefore(
- getWidget().icon.getElement(),
- getWidget().captionElement);
- }
- getWidget().icon.setUri(uidl
- .getStringAttribute(ATTRIBUTE_ICON));
- } else {
- if (getWidget().icon != null) {
- getWidget().getElement().removeChild(
- getWidget().icon.getElement());
- getWidget().icon = null;
- }
- }
-
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VNativeButton.class);
- }
-
- @Override
- public VNativeButton getWidget() {
- return (VNativeButton) super.getWidget();
- }
-
- @Override
- public ButtonState getState() {
- return (ButtonState) super.getState();
- }
-
- @Override
- protected ComponentState createState() {
- return GWT.create(ButtonState.class);
- }
-}
+++ /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;
-
-public class VNativeSelectPaintable extends VOptionGroupBasePaintable {
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VNativeSelect.class);
- }
-
- @Override
- public VNativeSelect getWidget() {
- return (VNativeSelect) super.getWidget();
- }
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.UIDL;
-
-public abstract class VOptionGroupBasePaintable extends
- AbstractComponentConnector {
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
-
- // Save details
- getWidget().client = client;
- getWidget().paintableId = uidl.getId();
-
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- getWidget().selectedKeys = uidl
- .getStringArrayVariableAsSet("selected");
-
- getWidget().readonly = getState().isReadOnly();
- getWidget().disabled = getState().isDisabled();
- getWidget().multiselect = "multi".equals(uidl
- .getStringAttribute("selectmode"));
- getWidget().immediate = getState().isImmediate();
- getWidget().nullSelectionAllowed = uidl
- .getBooleanAttribute("nullselect");
- getWidget().nullSelectionItemAvailable = uidl
- .getBooleanAttribute("nullselectitem");
-
- if (uidl.hasAttribute("cols")) {
- getWidget().cols = uidl.getIntAttribute("cols");
- }
- if (uidl.hasAttribute("rows")) {
- getWidget().rows = uidl.getIntAttribute("rows");
- }
-
- final UIDL ops = uidl.getChildUIDL(0);
-
- if (getWidget().getColumns() > 0) {
- getWidget().container.setWidth(getWidget()
- .getColumns() + "em");
- if (getWidget().container != getWidget().optionsContainer) {
- getWidget().optionsContainer.setWidth("100%");
- }
- }
-
- getWidget().buildOptions(ops);
-
- if (uidl.getBooleanAttribute("allownewitem")) {
- if (getWidget().newItemField == null) {
- getWidget().newItemButton = new VNativeButton();
- getWidget().newItemButton.setText("+");
- getWidget().newItemButton
- .addClickHandler(getWidget());
- getWidget().newItemField = new VTextField();
- getWidget().newItemField
- .addKeyPressHandler(getWidget());
- }
- getWidget().newItemField
- .setEnabled(!getWidget().disabled
- && !getWidget().readonly);
- getWidget().newItemButton
- .setEnabled(!getWidget().disabled
- && !getWidget().readonly);
-
- if (getWidget().newItemField == null
- || getWidget().newItemField.getParent() != getWidget().container) {
- getWidget().container
- .add(getWidget().newItemField);
- getWidget().container
- .add(getWidget().newItemButton);
- final int w = getWidget().container
- .getOffsetWidth()
- - getWidget().newItemButton
- .getOffsetWidth();
- getWidget().newItemField.setWidth(Math.max(w, 0)
- + "px");
- }
- } else if (getWidget().newItemField != null) {
- getWidget().container
- .remove(getWidget().newItemField);
- getWidget().container
- .remove(getWidget().newItemButton);
- }
-
- getWidget().setTabIndex(
- uidl.hasAttribute("tabindex") ? uidl
- .getIntAttribute("tabindex") : 0);
-
- }
-
- @Override
- public VOptionGroupBase getWidget() {
- return (VOptionGroupBase) super.getWidget();
- }
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-
-package com.vaadin.terminal.gwt.client.ui;
-
-import java.util.ArrayList;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.event.shared.HandlerRegistration;
-import com.google.gwt.user.client.ui.CheckBox;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.EventId;
-import com.vaadin.terminal.gwt.client.UIDL;
-
-public class VOptionGroupPaintable extends VOptionGroupBasePaintable {
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidget().htmlContentAllowed = uidl
- .hasAttribute(VOptionGroup.HTML_CONTENT_ALLOWED);
-
- super.updateFromUIDL(uidl, client);
-
- getWidget().sendFocusEvents = client.hasEventListeners(
- this, EventId.FOCUS);
- getWidget().sendBlurEvents = client.hasEventListeners(this,
- EventId.BLUR);
-
- if (getWidget().focusHandlers != null) {
- for (HandlerRegistration reg : getWidget().focusHandlers) {
- reg.removeHandler();
- }
- getWidget().focusHandlers.clear();
- getWidget().focusHandlers = null;
-
- for (HandlerRegistration reg : getWidget().blurHandlers) {
- reg.removeHandler();
- }
- getWidget().blurHandlers.clear();
- getWidget().blurHandlers = null;
- }
-
- if (getWidget().sendFocusEvents
- || getWidget().sendBlurEvents) {
- getWidget().focusHandlers = new ArrayList<HandlerRegistration>();
- getWidget().blurHandlers = new ArrayList<HandlerRegistration>();
-
- // add focus and blur handlers to checkboxes / radio buttons
- for (Widget wid : getWidget().panel) {
- if (wid instanceof CheckBox) {
- getWidget().focusHandlers.add(((CheckBox) wid)
- .addFocusHandler(getWidget()));
- getWidget().blurHandlers.add(((CheckBox) wid)
- .addBlurHandler(getWidget()));
- }
- }
- }
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VOptionGroup.class);
- }
-
- @Override
- public VOptionGroup getWidget() {
- return (VOptionGroup) super.getWidget();
- }
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.dom.client.Style;
-import com.google.gwt.dom.client.Style.Unit;
-import com.google.gwt.event.dom.client.DomEvent.Type;
-import com.google.gwt.event.shared.EventHandler;
-import com.google.gwt.event.shared.HandlerRegistration;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.LayoutManager;
-import com.vaadin.terminal.gwt.client.UIDL;
-import com.vaadin.terminal.gwt.client.ComponentConnector;
-
-public class VPanelPaintable extends AbstractComponentContainerConnector
- implements SimpleManagedLayout, PostLayoutListener {
-
- public static final String CLICK_EVENT_IDENTIFIER = "click";
-
- private Integer uidlScrollTop;
-
- private ClickEventHandler clickEventHandler = new ClickEventHandler(this,
- CLICK_EVENT_IDENTIFIER) {
-
- @Override
- protected <H extends EventHandler> HandlerRegistration registerHandler(
- H handler, Type<H> type) {
- return getWidget().addDomHandler(handler, type);
- }
- };
-
- private Integer uidlScrollLeft;
-
- @Override
- public void init() {
- VPanel panel = getWidget();
- LayoutManager layoutManager = getLayoutManager();
-
- layoutManager.registerDependency(this, panel.captionNode);
- layoutManager.registerDependency(this, panel.bottomDecoration);
- layoutManager.registerDependency(this, panel.contentNode);
- }
-
- @Override
- protected boolean delegateCaptionHandling() {
- return false;
- }
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- if (isRealUpdate(uidl)) {
-
- // Handle caption displaying and style names, prior generics.
- // Affects size calculations
-
- // Restore default stylenames
- getWidget().contentNode.setClassName(VPanel.CLASSNAME
- + "-content");
- getWidget().bottomDecoration
- .setClassName(VPanel.CLASSNAME + "-deco");
- getWidget().captionNode.setClassName(VPanel.CLASSNAME
- + "-caption");
- boolean hasCaption = false;
- if (getState().getCaption() != null
- && !"".equals(getState().getCaption())) {
- getWidget().setCaption(getState().getCaption());
- hasCaption = true;
- } else {
- getWidget().setCaption("");
- getWidget().captionNode
- .setClassName(VPanel.CLASSNAME + "-nocaption");
- }
-
- // Add proper stylenames for all elements. This way we can prevent
- // unwanted CSS selector inheritance.
- final String captionBaseClass = VPanel.CLASSNAME
- + (hasCaption ? "-caption" : "-nocaption");
- final String contentBaseClass = VPanel.CLASSNAME + "-content";
- final String decoBaseClass = VPanel.CLASSNAME + "-deco";
- String captionClass = captionBaseClass;
- String contentClass = contentBaseClass;
- String decoClass = decoBaseClass;
- if (getState().hasStyles()) {
- final String[] styles = getState().getStyle().split(" ");
- for (int i = 0; i < styles.length; i++) {
- captionClass += " " + captionBaseClass + "-" + styles[i];
- contentClass += " " + contentBaseClass + "-" + styles[i];
- decoClass += " " + decoBaseClass + "-" + styles[i];
- }
- }
- getWidget().captionNode.setClassName(captionClass);
- getWidget().contentNode.setClassName(contentClass);
- getWidget().bottomDecoration.setClassName(decoClass);
- }
- // Ensure correct implementation
- super.updateFromUIDL(uidl, client);
-
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- clickEventHandler.handleEventHandlerRegistration(client);
-
- getWidget().client = client;
- getWidget().id = uidl.getId();
-
- getWidget().setIconUri(uidl, client);
-
- getWidget().handleError(uidl);
-
- // Render content
- final UIDL layoutUidl = uidl.getChildUIDL(0);
- final ComponentConnector newLayout = client.getPaintable(layoutUidl);
- if (newLayout != getWidget().layout) {
- if (getWidget().layout != null) {
- client.unregisterPaintable(getWidget().layout);
- }
- getWidget()
- .setWidget(newLayout.getWidget());
- getWidget().layout = newLayout;
- }
- getWidget().layout.updateFromUIDL(layoutUidl, client);
-
- // We may have actions attached to this panel
- if (uidl.getChildCount() > 1) {
- final int cnt = uidl.getChildCount();
- for (int i = 1; i < cnt; i++) {
- UIDL childUidl = uidl.getChildUIDL(i);
- if (childUidl.getTag().equals("actions")) {
- if (getWidget().shortcutHandler == null) {
- getWidget().shortcutHandler = new ShortcutActionHandler(
- getId(), client);
- }
- getWidget().shortcutHandler
- .updateActionMap(childUidl);
- }
- }
- }
-
- if (uidl.hasVariable("scrollTop")
- && uidl.getIntVariable("scrollTop") != getWidget().scrollTop) {
- // Sizes are not yet up to date, so changing the scroll position
- // is deferred to after the layout phase
- uidlScrollTop = new Integer(uidl.getIntVariable("scrollTop"));
- }
-
- if (uidl.hasVariable("scrollLeft")
- && uidl.getIntVariable("scrollLeft") != getWidget().scrollLeft) {
- // Sizes are not yet up to date, so changing the scroll position
- // is deferred to after the layout phase
- uidlScrollLeft = new Integer(uidl.getIntVariable("scrollLeft"));
- }
-
- // And apply tab index
- if (uidl.hasVariable("tabindex")) {
- getWidget().contentNode.setTabIndex(uidl
- .getIntVariable("tabindex"));
- }
- }
-
- public void updateCaption(ComponentConnector component, UIDL uidl) {
- // NOP: layouts caption, errors etc not rendered in Panel
- }
-
- @Override
- public VPanel getWidget() {
- return (VPanel) super.getWidget();
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VPanel.class);
- }
-
- public void layout() {
- updateSizes();
- }
-
- void updateSizes() {
- VPanel panel = getWidget();
-
- Style contentStyle = panel.contentNode.getStyle();
- if (isUndefinedHeight()) {
- contentStyle.clearHeight();
- } else {
- contentStyle.setHeight(100, Unit.PCT);
- }
-
- if (isUndefinedWidth()) {
- contentStyle.clearWidth();
- } else {
- contentStyle.setWidth(100, Unit.PCT);
- }
-
- LayoutManager layoutManager = getLayoutManager();
- int top = layoutManager.getOuterHeight(panel.captionNode);
- int bottom = layoutManager.getOuterHeight(panel.bottomDecoration);
-
- Style style = panel.getElement().getStyle();
- panel.captionNode.getStyle().setMarginTop(-top, Unit.PX);
- panel.bottomDecoration.getStyle().setMarginBottom(-bottom, Unit.PX);
- style.setPaddingTop(top, Unit.PX);
- style.setPaddingBottom(bottom, Unit.PX);
-
- // Update scroll positions
- panel.contentNode.setScrollTop(panel.scrollTop);
- panel.contentNode.setScrollLeft(panel.scrollLeft);
- // Read actual value back to ensure update logic is correct
- panel.scrollTop = panel.contentNode.getScrollTop();
- panel.scrollLeft = panel.contentNode.getScrollLeft();
- }
-
- public void postLayout() {
- VPanel panel = getWidget();
- if (uidlScrollTop != null) {
- panel.contentNode.setScrollTop(uidlScrollTop.intValue());
- // Read actual value back to ensure update logic is correct
- // TODO Does this trigger reflows?
- panel.scrollTop = panel.contentNode.getScrollTop();
- uidlScrollTop = null;
- }
-
- if (uidlScrollLeft != null) {
- panel.contentNode.setScrollLeft(uidlScrollLeft.intValue());
- // Read actual value back to ensure update logic is correct
- // TODO Does this trigger reflows?
- panel.scrollLeft = panel.contentNode.getScrollLeft();
- uidlScrollLeft = null;
- }
- }
-
-}
+++ /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.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.UIDL;
-
-public class VPasswordFieldPaintable extends VTextFieldPaintable {
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- super.updateFromUIDL(uidl, client);
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VPasswordField.class);
- }
-
- @Override
- public VPasswordField getWidget() {
- return (VPasswordField) super.getWidget();
- }
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-
-package com.vaadin.terminal.gwt.client.ui;
-
-import java.util.Date;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.DateTimeService;
-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;
-
-public class VPopupCalendarPaintable extends VTextualDatePaintable {
-
- /*
- * (non-Javadoc)
- *
- * @see
- * com.vaadin.terminal.gwt.client.ui.VTextualDate#updateFromUIDL(com.vaadin
- * .terminal.gwt.client.UIDL,
- * com.vaadin.terminal.gwt.client.ApplicationConnection)
- */
- @Override
- @SuppressWarnings("deprecation")
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- boolean lastReadOnlyState = getWidget().readonly;
- boolean lastEnabledState = getWidget().isEnabled();
-
- getWidget().parsable = uidl.getBooleanAttribute("parsable");
-
- super.updateFromUIDL(uidl, client);
-
- String popupStyleNames = getStyleNameFromUIDL(
- VPopupCalendar.POPUP_PRIMARY_STYLE_NAME, uidl, getState(),
- false);
- popupStyleNames += " "
- + VDateField.CLASSNAME
- + "-"
- + VPopupCalendar
- .resolutionToString(getWidget().currentResolution);
- getWidget().popup.setStyleName(popupStyleNames);
-
- getWidget().calendar
- .setDateTimeService(getWidget()
- .getDateTimeService());
- getWidget().calendar
- .setShowISOWeekNumbers(getWidget()
- .isShowISOWeekNumbers());
- if (getWidget().calendar.getResolution() != getWidget().currentResolution) {
- getWidget().calendar
- .setResolution(getWidget().currentResolution);
- if (getWidget().calendar.getDate() != null) {
- getWidget().calendar
- .setDate((Date) getWidget()
- .getCurrentDate().clone());
- // force re-render when changing resolution only
- getWidget().calendar.renderCalendar();
- }
- }
- getWidget().calendarToggle
- .setEnabled(getWidget().enabled);
-
- if (getWidget().currentResolution <= VPopupCalendar.RESOLUTION_MONTH) {
- getWidget().calendar
- .setFocusChangeListener(new FocusChangeListener() {
- public void focusChanged(Date date) {
- getWidget().updateValue(date);
- getWidget().buildDate();
- Date date2 = getWidget().calendar
- .getDate();
- date2.setYear(date.getYear());
- date2.setMonth(date.getMonth());
- }
- });
- } else {
- getWidget().calendar.setFocusChangeListener(null);
- }
-
- if (getWidget().currentResolution > VPopupCalendar.RESOLUTION_DAY) {
- getWidget().calendar
- .setTimeChangeListener(new TimeChangeListener() {
- public void changed(int hour, int min, int sec, int msec) {
- Date d = getWidget().getDate();
- if (d == null) {
- // date currently null, use the value from
- // calendarPanel
- // (~ client time at the init of the widget)
- d = (Date) getWidget().calendar
- .getDate().clone();
- }
- d.setHours(hour);
- d.setMinutes(min);
- d.setSeconds(sec);
- DateTimeService.setMilliseconds(d, msec);
-
- // Always update time changes to the server
- getWidget().updateValue(d);
-
- // Update text field
- getWidget().buildDate();
- }
- });
- }
-
- if (getWidget().readonly) {
- getWidget().calendarToggle
- .addStyleName(VPopupCalendar.CLASSNAME + "-button-readonly");
- } else {
- getWidget().calendarToggle
- .removeStyleName(VPopupCalendar.CLASSNAME
- + "-button-readonly");
- }
-
- getWidget().calendarToggle.setEnabled(true);
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VPopupCalendar.class);
- }
-
- @Override
- public VPopupCalendar getWidget() {
- return (VPopupCalendar) super.getWidget();
- }
-}
+++ /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.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.UIDL;
-import com.vaadin.terminal.gwt.client.VCaption;
-import com.vaadin.terminal.gwt.client.VCaptionWrapper;
-import com.vaadin.terminal.gwt.client.ComponentConnector;
-
-public class VPopupViewPaintable extends AbstractComponentContainerConnector {
-
- @Override
- protected boolean delegateCaptionHandling() {
- return false;
- }
-
- /**
- *
- *
- * @see com.vaadin.terminal.gwt.client.ComponentConnector#updateFromUIDL(com.vaadin.terminal.gwt.client.UIDL,
- * com.vaadin.terminal.gwt.client.ApplicationConnection)
- */
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- // This call should be made first. Ensure correct implementation,
- // and don't let the containing layout manage caption.
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
- // These are for future server connections
- getWidget().client = client;
- getWidget().uidlId = uidl.getId();
-
- getWidget().hostPopupVisible = uidl
- .getBooleanVariable("popupVisibility");
-
- getWidget().setHTML(uidl.getStringAttribute("html"));
-
- if (uidl.hasAttribute("hideOnMouseOut")) {
- getWidget().popup.setHideOnMouseOut(uidl
- .getBooleanAttribute("hideOnMouseOut"));
- }
-
- // Render the popup if visible and show it.
- if (getWidget().hostPopupVisible) {
- UIDL popupUIDL = uidl.getChildUIDL(0);
-
- // showPopupOnTop(popup, hostReference);
- getWidget().preparePopup(getWidget().popup);
- getWidget().popup.updateFromUIDL(popupUIDL, client);
- if (getState().hasStyles()) {
- final String[] styles = getState().getStyle().split(" ");
- final StringBuffer styleBuf = new StringBuffer();
- final String primaryName = getWidget().popup
- .getStylePrimaryName();
- styleBuf.append(primaryName);
- for (int i = 0; i < styles.length; i++) {
- styleBuf.append(" ");
- styleBuf.append(primaryName);
- styleBuf.append("-");
- styleBuf.append(styles[i]);
- }
- getWidget().popup.setStyleName(styleBuf.toString());
- } else {
- getWidget().popup
- .setStyleName(getWidget().popup
- .getStylePrimaryName());
- }
- getWidget().showPopup(getWidget().popup);
-
- // The popup shouldn't be visible, try to hide it.
- } else {
- getWidget().popup.hide();
- }
- }// updateFromUIDL
-
- public void updateCaption(ComponentConnector component, UIDL uidl) {
- if (VCaption.isNeeded(uidl, component.getState())) {
- if (getWidget().popup.captionWrapper != null) {
- getWidget().popup.captionWrapper
- .updateCaption(uidl);
- } else {
- getWidget().popup.captionWrapper = new VCaptionWrapper(
- component, getConnection());
- getWidget().popup
- .setWidget(getWidget().popup.captionWrapper);
- getWidget().popup.captionWrapper
- .updateCaption(uidl);
- }
- } else {
- if (getWidget().popup.captionWrapper != null) {
- getWidget().popup
- .setWidget(getWidget().popup.popupComponentWidget);
- }
- }
- }
-
- @Override
- public VPopupView getWidget() {
- return (VPopupView) super.getWidget();
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VPopupView.class);
- }
-
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.user.client.DOM;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.UIDL;
-
-public class VProgressIndicatorPaintable extends AbstractComponentConnector {
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
-
- // Ensure correct implementation,
- // but don't let container manage caption etc.
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- // Save details
- getWidget().client = client;
-
- getWidget().indeterminate = uidl
- .getBooleanAttribute("indeterminate");
-
- if (getWidget().indeterminate) {
- String basename = VProgressIndicator.CLASSNAME + "-indeterminate";
- getWidget().addStyleName(basename);
- if (getState().isDisabled()) {
- getWidget().addStyleName(basename + "-disabled");
- } else {
- getWidget().removeStyleName(basename + "-disabled");
- }
- } else {
- try {
- final float f = Float.parseFloat(uidl
- .getStringAttribute("state"));
- final int size = Math.round(100 * f);
- DOM.setStyleAttribute(getWidget().indicator,
- "width", size + "%");
- } catch (final Exception e) {
- }
- }
-
- if (!getState().isDisabled()) {
- getWidget().interval = uidl
- .getIntAttribute("pollinginterval");
- getWidget().poller
- .scheduleRepeating(getWidget().interval);
- }
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VProgressIndicator.class);
- }
-
- @Override
- public VProgressIndicator getWidget() {
- return (VProgressIndicator) super.getWidget();
- }
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.core.client.Scheduler;
-import com.google.gwt.dom.client.Style.Position;
-import com.google.gwt.user.client.Command;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.BrowserInfo;
-import com.vaadin.terminal.gwt.client.DirectionalManagedLayout;
-import com.vaadin.terminal.gwt.client.UIDL;
-import com.vaadin.terminal.gwt.client.Util;
-import com.vaadin.terminal.gwt.client.ComponentConnector;
-
-public class VScrollTablePaintable extends AbstractComponentContainerConnector
- implements DirectionalManagedLayout {
-
- /*
- * (non-Javadoc)
- *
- * @see
- * com.vaadin.terminal.gwt.client.Paintable#updateFromUIDL(com.vaadin.terminal
- * .gwt.client.UIDL, com.vaadin.terminal.gwt.client.ApplicationConnection)
- */
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidget().rendering = true;
-
- if (uidl.hasAttribute(VScrollTable.ATTRIBUTE_PAGEBUFFER_FIRST)) {
- getWidget().serverCacheFirst = uidl
- .getIntAttribute(VScrollTable.ATTRIBUTE_PAGEBUFFER_FIRST);
- getWidget().serverCacheLast = uidl
- .getIntAttribute(VScrollTable.ATTRIBUTE_PAGEBUFFER_LAST);
- } else {
- getWidget().serverCacheFirst = -1;
- getWidget().serverCacheLast = -1;
- }
- /*
- * We need to do this before updateComponent since updateComponent calls
- * this.setHeight() which will calculate a new body height depending on
- * the space available.
- */
- if (uidl.hasAttribute("colfooters")) {
- getWidget().showColFooters = uidl
- .getBooleanAttribute("colfooters");
- }
-
- getWidget().tFoot
- .setVisible(getWidget().showColFooters);
-
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- getWidget().rendering = false;
- return;
- }
-
- getWidget().enabled = !getState().isDisabled();
-
- if (BrowserInfo.get().isIE8() && !getWidget().enabled) {
- /*
- * The disabled shim will not cover the table body if it is relative
- * in IE8. See #7324
- */
- getWidget().scrollBodyPanel.getElement().getStyle()
- .setPosition(Position.STATIC);
- } else if (BrowserInfo.get().isIE8()) {
- getWidget().scrollBodyPanel.getElement().getStyle()
- .setPosition(Position.RELATIVE);
- }
-
- getWidget().client = client;
- getWidget().paintableId = uidl.getStringAttribute("id");
- getWidget().immediate = getState().isImmediate();
-
- int previousTotalRows = getWidget().totalRows;
- getWidget().updateTotalRows(uidl);
- boolean totalRowsChanged = (getWidget().totalRows != previousTotalRows);
-
- getWidget().updateDragMode(uidl);
-
- getWidget().updateSelectionProperties(uidl, getState());
-
- if (uidl.hasAttribute("alb")) {
- getWidget().bodyActionKeys = uidl
- .getStringArrayAttribute("alb");
- } else {
- // Need to clear the actions if the action handlers have been
- // removed
- getWidget().bodyActionKeys = null;
- }
-
- getWidget().setCacheRateFromUIDL(uidl);
-
- getWidget().recalcWidths = uidl
- .hasAttribute("recalcWidths");
- if (getWidget().recalcWidths) {
- getWidget().tHead.clear();
- getWidget().tFoot.clear();
- }
-
- getWidget().updatePageLength(uidl);
-
- getWidget().updateFirstVisibleAndScrollIfNeeded(uidl);
-
- getWidget().showRowHeaders = uidl
- .getBooleanAttribute("rowheaders");
- getWidget().showColHeaders = uidl
- .getBooleanAttribute("colheaders");
-
- getWidget().updateSortingProperties(uidl);
-
- boolean keyboardSelectionOverRowFetchInProgress = getWidget()
- .selectSelectedRows(uidl);
-
- getWidget().updateActionMap(uidl);
-
- getWidget().updateColumnProperties(uidl);
-
- UIDL ac = uidl.getChildByTagName("-ac");
- if (ac == null) {
- if (getWidget().dropHandler != null) {
- // remove dropHandler if not present anymore
- getWidget().dropHandler = null;
- }
- } else {
- if (getWidget().dropHandler == null) {
- getWidget().dropHandler = getWidget().new VScrollTableDropHandler();
- }
- getWidget().dropHandler.updateAcceptRules(ac);
- }
-
- UIDL partialRowAdditions = uidl.getChildByTagName("prows");
- UIDL partialRowUpdates = uidl.getChildByTagName("urows");
- if (partialRowUpdates != null || partialRowAdditions != null) {
- // we may have pending cache row fetch, cancel it. See #2136
- getWidget().rowRequestHandler.cancel();
-
- getWidget().updateRowsInBody(partialRowUpdates);
- getWidget().addAndRemoveRows(partialRowAdditions);
- } else {
- UIDL rowData = uidl.getChildByTagName("rows");
- if (rowData != null) {
- // we may have pending cache row fetch, cancel it. See #2136
- getWidget().rowRequestHandler.cancel();
-
- if (!getWidget().recalcWidths
- && getWidget().initializedAndAttached) {
- getWidget().updateBody(rowData,
- uidl.getIntAttribute("firstrow"),
- uidl.getIntAttribute("rows"));
- if (getWidget().headerChangedDuringUpdate) {
- getWidget().triggerLazyColumnAdjustment(
- true);
- } else if (!getWidget()
- .isScrollPositionVisible()
- || totalRowsChanged
- || getWidget().lastRenderedHeight != getWidget().scrollBody
- .getOffsetHeight()) {
- // webkits may still bug with their disturbing scrollbar
- // bug, see #3457
- // Run overflow fix for the scrollable area
- // #6698 - If there's a scroll going on, don't abort it
- // by changing overflows as the length of the contents
- // *shouldn't* have changed (unless the number of rows
- // or the height of the widget has also changed)
- Scheduler.get().scheduleDeferred(new Command() {
- public void execute() {
- Util.runWebkitOverflowAutoFix(getWidget().scrollBodyPanel
- .getElement());
- }
- });
- }
- } else {
- getWidget().initializeRows(uidl, rowData);
- }
- }
- }
-
- if (!getWidget().isSelectable()) {
- getWidget().scrollBody
- .addStyleName(VScrollTable.CLASSNAME + "-body-noselection");
- } else {
- getWidget().scrollBody
- .removeStyleName(VScrollTable.CLASSNAME
- + "-body-noselection");
- }
-
- getWidget().hideScrollPositionAnnotation();
- getWidget().purgeUnregistryBag();
-
- // selection is no in sync with server, avoid excessive server visits by
- // clearing to flag used during the normal operation
- if (!keyboardSelectionOverRowFetchInProgress) {
- getWidget().selectionChanged = false;
- }
-
- /*
- * This is called when the Home or page up button has been pressed in
- * selectable mode and the next selected row was not yet rendered in the
- * client
- */
- if (getWidget().selectFirstItemInNextRender
- || getWidget().focusFirstItemInNextRender) {
- getWidget().selectFirstRenderedRowInViewPort(
- getWidget().focusFirstItemInNextRender);
- getWidget().selectFirstItemInNextRender = getWidget().focusFirstItemInNextRender = false;
- }
-
- /*
- * This is called when the page down or end button has been pressed in
- * selectable mode and the next selected row was not yet rendered in the
- * client
- */
- if (getWidget().selectLastItemInNextRender
- || getWidget().focusLastItemInNextRender) {
- getWidget().selectLastRenderedRowInViewPort(
- getWidget().focusLastItemInNextRender);
- getWidget().selectLastItemInNextRender = getWidget().focusLastItemInNextRender = false;
- }
- getWidget().multiselectPending = false;
-
- if (getWidget().focusedRow != null) {
- if (!getWidget().focusedRow.isAttached()
- && !getWidget().rowRequestHandler.isRunning()) {
- // focused row has been orphaned, can't focus
- getWidget().focusRowFromBody();
- }
- }
-
- getWidget().tabIndex = uidl.hasAttribute("tabindex") ? uidl
- .getIntAttribute("tabindex") : 0;
- getWidget().setProperTabIndex();
-
- getWidget().resizeSortedColumnForSortIndicator();
-
- // Remember this to detect situations where overflow hack might be
- // needed during scrolling
- getWidget().lastRenderedHeight = getWidget().scrollBody
- .getOffsetHeight();
-
- getWidget().rendering = false;
- getWidget().headerChangedDuringUpdate = false;
-
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VScrollTable.class);
- }
-
- @Override
- public VScrollTable getWidget() {
- return (VScrollTable) super.getWidget();
- }
-
- public void updateCaption(ComponentConnector component, UIDL uidl) {
- // NOP, not rendered
- }
-
- public void layoutVertically() {
- getWidget().updateHeight();
- }
-
- public void layoutHorizontally() {
- getWidget().updateWidth();
- }
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.core.client.Scheduler;
-import com.google.gwt.user.client.Command;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.UIDL;
-
-public class VSliderPaintable extends AbstractComponentConnector {
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
-
- getWidget().client = client;
- getWidget().id = uidl.getId();
-
- // Ensure correct implementation
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- getWidget().immediate = getState().isImmediate();
- getWidget().disabled = getState().isDisabled();
- getWidget().readonly = getState().isReadOnly();
-
- getWidget().vertical = uidl.hasAttribute("vertical");
-
- // TODO should these style names be used?
- String style = getState().getStyle();
-
- if (getWidget().vertical) {
- getWidget().addStyleName(
- VSlider.CLASSNAME + "-vertical");
- } else {
- getWidget().removeStyleName(
- VSlider.CLASSNAME + "-vertical");
- }
-
- getWidget().min = uidl.getDoubleAttribute("min");
- getWidget().max = uidl.getDoubleAttribute("max");
- getWidget().resolution = uidl.getIntAttribute("resolution");
- getWidget().value = new Double(
- uidl.getDoubleVariable("value"));
-
- getWidget().setFeedbackValue(getWidget().value);
-
- getWidget().buildBase();
-
- if (!getWidget().vertical) {
- // Draw handle with a delay to allow base to gain maximum width
- Scheduler.get().scheduleDeferred(new Command() {
- public void execute() {
- getWidget().buildHandle();
- getWidget().setValue(
- getWidget().value, false);
- }
- });
- } else {
- getWidget().buildHandle();
- getWidget().setValue(getWidget().value,
- false);
- }
- }
-
- @Override
- public VSlider getWidget() {
- return (VSlider) super.getWidget();
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VSlider.class);
- }
-
-}
@Override
public boolean updateCaption(UIDL uidl) {
- if (uidl.hasAttribute(VTabsheetBasePaintable.ATTRIBUTE_TAB_DESCRIPTION)
+ if (uidl.hasAttribute(TabsheetBaseConnector.ATTRIBUTE_TAB_DESCRIPTION)
|| uidl.hasAttribute(AbstractComponentConnector.ATTRIBUTE_ERROR)) {
TooltipInfo tooltipInfo = new TooltipInfo();
tooltipInfo
.setTitle(uidl
- .getStringAttribute(VTabsheetBasePaintable.ATTRIBUTE_TAB_DESCRIPTION));
+ .getStringAttribute(TabsheetBaseConnector.ATTRIBUTE_TAB_DESCRIPTION));
if (uidl.hasAttribute(AbstractComponentConnector.ATTRIBUTE_ERROR)) {
tooltipInfo.setErrorUidl(uidl.getErrors());
}
// not have an owner
boolean ret = updateCaptionWithoutOwner(
uidl,
- uidl.getStringAttribute(VTabsheetBasePaintable.ATTRIBUTE_TAB_CAPTION),
- uidl.hasAttribute(VTabsheetBasePaintable.ATTRIBUTE_TAB_DISABLED),
- uidl.hasAttribute(VTabsheetBasePaintable.ATTRIBUTE_TAB_DESCRIPTION));
+ uidl.getStringAttribute(TabsheetBaseConnector.ATTRIBUTE_TAB_CAPTION),
+ uidl.hasAttribute(TabsheetBaseConnector.ATTRIBUTE_TAB_DISABLED),
+ uidl.hasAttribute(TabsheetBaseConnector.ATTRIBUTE_TAB_DESCRIPTION));
setClosable(uidl.hasAttribute("closable"));
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import java.util.ArrayList;
-import java.util.Iterator;
-
-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.ConnectorMap;
-import com.vaadin.terminal.gwt.client.ComponentConnector;
-
-public abstract class VTabsheetBasePaintable extends
- AbstractComponentContainerConnector {
-
- public static final String ATTRIBUTE_TAB_DISABLED = "disabled";
- public static final String ATTRIBUTE_TAB_DESCRIPTION = "description";
- public static final String ATTRIBUTE_TAB_CAPTION = "caption";
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidget().client = client;
-
- // Ensure correct implementation
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- // Update member references
- getWidget().id = uidl.getId();
- getWidget().disabled = getState().isDisabled();
-
- // Render content
- final UIDL tabs = uidl.getChildUIDL(0);
-
- // Paintables in the TabSheet before update
- ArrayList<Widget> oldWidgets = new ArrayList<Widget>();
- for (Iterator<Widget> iterator = getWidget()
- .getWidgetIterator(); iterator.hasNext();) {
- oldWidgets.add(iterator.next());
- }
-
- // Clear previous values
- getWidget().tabKeys.clear();
- getWidget().disabledTabKeys.clear();
-
- int index = 0;
- for (final Iterator<Object> it = tabs.getChildIterator(); it.hasNext();) {
- final UIDL tab = (UIDL) it.next();
- final String key = tab.getStringAttribute("key");
- final boolean selected = tab.getBooleanAttribute("selected");
- final boolean hidden = tab.getBooleanAttribute("hidden");
-
- if (tab.getBooleanAttribute(ATTRIBUTE_TAB_DISABLED)) {
- getWidget().disabledTabKeys.add(key);
- }
-
- getWidget().tabKeys.add(key);
-
- if (selected) {
- getWidget().activeTabIndex = index;
- }
- getWidget().renderTab(tab, index, selected, hidden);
- index++;
- }
-
- int tabCount = getWidget().getTabCount();
- while (tabCount-- > index) {
- getWidget().removeTab(index);
- }
-
- for (int i = 0; i < getWidget().getTabCount(); i++) {
- ComponentConnector p = getWidget().getTab(i);
- // During the initial rendering the paintable might be null (this is
- // weird...)
- if (p != null) {
- oldWidgets.remove(p.getWidget());
- }
- }
-
- // Perform unregister for any paintables removed during update
- for (Iterator<Widget> iterator = oldWidgets.iterator(); iterator
- .hasNext();) {
- Widget oldWidget = iterator.next();
- ComponentConnector oldPaintable = ConnectorMap.get(client)
- .getConnector(oldWidget);
- if (oldWidget.isAttached()) {
- oldWidget.removeFromParent();
- }
- ConnectorMap.get(client).unregisterConnector(oldPaintable);
- }
-
- }
-
- @Override
- public VTabsheetBase getWidget() {
- return (VTabsheetBase) super.getWidget();
- }
-
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.user.client.DOM;
-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.ComponentConnector;
-
-public class VTabsheetPaintable extends VTabsheetBasePaintable implements
- SimpleManagedLayout {
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
-
- if (isRealUpdate(uidl)) {
- // Handle stylename changes before generics (might affect size
- // calculations)
- getWidget().handleStyleNames(uidl, getState());
- }
-
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- // tabs; push or not
- if (!isUndefinedWidth()) {
- // FIXME: This makes tab sheet tabs go to 1px width on every update
- // and then back to original width
- // update width later, in updateTabScroller();
- DOM.setStyleAttribute(getWidget().tabs, "width", "1px");
- DOM.setStyleAttribute(getWidget().tabs, "overflow",
- "hidden");
- } else {
- getWidget().showAllTabs();
- DOM.setStyleAttribute(getWidget().tabs, "width", "");
- DOM.setStyleAttribute(getWidget().tabs, "overflow",
- "visible");
- getWidget().updateDynamicWidth();
- }
-
- if (!isUndefinedHeight()) {
- // Must update height after the styles have been set
- getWidget().updateContentNodeHeight();
- getWidget().updateOpenTabSize();
- }
-
- getWidget().iLayout();
-
- // Re run relative size update to ensure optimal scrollbars
- // TODO isolate to situation that visible tab has undefined height
- try {
- client.handleComponentRelativeSize(getWidget().tp
- .getWidget(getWidget().tp.getVisibleWidget()));
- } catch (Exception e) {
- // Ignore, most likely empty tabsheet
- }
-
- getWidget().waitingForResponse = false;
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VTabsheet.class);
- }
-
- @Override
- public VTabsheet getWidget() {
- return (VTabsheet) super.getWidget();
- }
-
- public void updateCaption(ComponentConnector component, UIDL uidl) {
- /* Tabsheet does not render its children's captions */
- }
-
- public void layout() {
- VTabsheet tabsheet = getWidget();
-
- tabsheet.updateContentNodeHeight();
-
- if (isUndefinedWidth()) {
- tabsheet.contentNode.getStyle().setProperty("width", "");
- } else {
- int contentWidth = tabsheet.getOffsetWidth()
- - tabsheet.getContentAreaBorderWidth();
- if (contentWidth < 0) {
- contentWidth = 0;
- }
- tabsheet.contentNode.getStyle().setProperty("width",
- contentWidth + "px");
- }
-
- tabsheet.updateOpenTabSize();
- tabsheet.iLayout();
-
- }
-
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.user.client.Event;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.UIDL;
-
-public class VTextAreaPaintable extends VTextFieldPaintable {
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- // Call parent renderer explicitly
- super.updateFromUIDL(uidl, client);
-
- if (uidl.hasAttribute("rows")) {
- getWidget().setRows(uidl.getIntAttribute("rows"));
- }
-
- if (getWidget().getMaxLength() >= 0) {
- getWidget().sinkEvents(Event.ONKEYUP);
- }
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VTextArea.class);
- }
-
- @Override
- public VTextArea getWidget() {
- return (VTextArea) super.getWidget();
- }
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.core.client.Scheduler;
-import com.google.gwt.user.client.Command;
-import com.google.gwt.user.client.Event;
-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.ShortcutActionHandler.BeforeShortcutActionListener;
-
-public class VTextFieldPaintable extends AbstractComponentConnector implements
- BeforeShortcutActionListener {
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- // Save details
- getWidget().client = client;
- getWidget().paintableId = uidl.getId();
-
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- getWidget().setReadOnly(getState().isReadOnly());
-
- getWidget().inputPrompt = uidl
- .getStringAttribute(VTextField.ATTR_INPUTPROMPT);
-
- getWidget().setMaxLength(
- uidl.hasAttribute("maxLength") ? uidl
- .getIntAttribute("maxLength") : -1);
-
- getWidget().immediate = getState().isImmediate();
-
- getWidget().listenTextChangeEvents = client
- .hasEventListeners(this, "ie");
- if (getWidget().listenTextChangeEvents) {
- getWidget().textChangeEventMode = uidl
- .getStringAttribute(VTextField.ATTR_TEXTCHANGE_EVENTMODE);
- if (getWidget().textChangeEventMode
- .equals(VTextField.TEXTCHANGE_MODE_EAGER)) {
- getWidget().textChangeEventTimeout = 1;
- } else {
- getWidget().textChangeEventTimeout = uidl
- .getIntAttribute(VTextField.ATTR_TEXTCHANGE_TIMEOUT);
- if (getWidget().textChangeEventTimeout < 1) {
- // Sanitize and allow lazy/timeout with timeout set to 0 to
- // work as eager
- getWidget().textChangeEventTimeout = 1;
- }
- }
- getWidget().sinkEvents(VTextField.TEXTCHANGE_EVENTS);
- getWidget().attachCutEventListener(
- getWidget().getElement());
- }
-
- if (uidl.hasAttribute("cols")) {
- getWidget().setColumns(
- new Integer(uidl.getStringAttribute("cols")).intValue());
- }
-
- final String text = uidl.getStringVariable("text");
-
- /*
- * We skip the text content update if field has been repainted, but text
- * has not been changed. Additional sanity check verifies there is no
- * change in the que (in which case we count more on the server side
- * value).
- */
- if (!(uidl
- .getBooleanAttribute(VTextField.ATTR_NO_VALUE_CHANGE_BETWEEN_PAINTS)
- && getWidget().valueBeforeEdit != null && text
- .equals(getWidget().valueBeforeEdit))) {
- getWidget().updateFieldContent(text);
- }
-
- if (uidl.hasAttribute("selpos")) {
- final int pos = uidl.getIntAttribute("selpos");
- final int length = uidl.getIntAttribute("sellen");
- /*
- * Gecko defers setting the text so we need to defer the selection.
- */
- Scheduler.get().scheduleDeferred(new Command() {
- public void execute() {
- getWidget().setSelectionRange(pos, length);
- }
- });
- }
-
- // Here for backward compatibility; to be moved to TextArea.
- // Optimization: server does not send attribute for the default 'true'
- // state.
- if (uidl.hasAttribute("wordwrap")
- && uidl.getBooleanAttribute("wordwrap") == false) {
- getWidget().setWordwrap(false);
- } else {
- getWidget().setWordwrap(true);
- }
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VTextField.class);
- }
-
- @Override
- public VTextField getWidget() {
- return (VTextField) super.getWidget();
- }
-
- public void onBeforeShortcutAction(Event e) {
- getWidget().valueChange(false);
- }
-
-}
+++ /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.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.UIDL;
-
-public class VTextualDatePaintable extends VDateFieldPaintable {
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- int origRes = getWidget().currentResolution;
- String oldLocale = getWidget().currentLocale;
- super.updateFromUIDL(uidl, client);
- if (origRes != getWidget().currentResolution
- || oldLocale != getWidget().currentLocale) {
- // force recreating format string
- getWidget().formatStr = null;
- }
- if (uidl.hasAttribute("format")) {
- getWidget().formatStr = uidl
- .getStringAttribute("format");
- }
-
- getWidget().inputPrompt = uidl
- .getStringAttribute(VTextualDate.ATTR_INPUTPROMPT);
-
- getWidget().lenient = !uidl.getBooleanAttribute("strict");
-
- getWidget().buildDate();
- // not a FocusWidget -> needs own tabindex handling
- if (uidl.hasAttribute("tabindex")) {
- getWidget().text.setTabIndex(uidl
- .getIntAttribute("tabindex"));
- }
-
- if (getWidget().readonly) {
- getWidget().text.addStyleDependentName("readonly");
- } else {
- getWidget().text.removeStyleDependentName("readonly");
- }
-
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VTextualDate.class);
- }
-
- @Override
- public VTextualDate getWidget() {
- return (VTextualDate) super.getWidget();
- }
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import java.util.Iterator;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.TooltipInfo;
-import com.vaadin.terminal.gwt.client.UIDL;
-import com.vaadin.terminal.gwt.client.ui.VTree.TreeNode;
-
-public class VTreePaintable extends AbstractComponentConnector {
-
- public static final String ATTRIBUTE_NODE_STYLE = "style";
- public static final String ATTRIBUTE_NODE_CAPTION = "caption";
- public static final String ATTRIBUTE_NODE_ICON = AbstractComponentConnector.ATTRIBUTE_ICON;
-
- public static final String ATTRIBUTE_ACTION_CAPTION = "caption";
- public static final String ATTRIBUTE_ACTION_ICON = AbstractComponentConnector.ATTRIBUTE_ICON;
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- // Ensure correct implementation and let container manage caption
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- getWidget().rendering = true;
-
- getWidget().client = client;
-
- if (uidl.hasAttribute("partialUpdate")) {
- handleUpdate(uidl);
- getWidget().rendering = false;
- return;
- }
-
- getWidget().paintableId = uidl.getId();
-
- getWidget().immediate = getState().isImmediate();
-
- getWidget().disabled = getState().isDisabled();
- getWidget().readonly = getState().isReadOnly();
-
- getWidget().dragMode = uidl.hasAttribute("dragMode") ? uidl
- .getIntAttribute("dragMode") : 0;
-
- getWidget().isNullSelectionAllowed = uidl
- .getBooleanAttribute("nullselect");
-
- if (uidl.hasAttribute("alb")) {
- getWidget().bodyActionKeys = uidl
- .getStringArrayAttribute("alb");
- }
-
- getWidget().body.clear();
- // clear out any references to nodes that no longer are attached
- getWidget().clearNodeToKeyMap();
- TreeNode childTree = null;
- UIDL childUidl = null;
- for (final Iterator<?> i = uidl.getChildIterator(); i.hasNext();) {
- childUidl = (UIDL) i.next();
- if ("actions".equals(childUidl.getTag())) {
- updateActionMap(childUidl);
- continue;
- } else if ("-ac".equals(childUidl.getTag())) {
- getWidget().updateDropHandler(childUidl);
- continue;
- }
- childTree = getWidget().new TreeNode();
- updateNodeFromUIDL(childTree, childUidl);
- getWidget().body.add(childTree);
- childTree.addStyleDependentName("root");
- childTree.childNodeContainer.addStyleDependentName("root");
- }
- if (childTree != null && childUidl != null) {
- boolean leaf = !childUidl.getTag().equals("node");
- childTree.addStyleDependentName(leaf ? "leaf-last" : "last");
- childTree.childNodeContainer.addStyleDependentName("last");
- }
- final String selectMode = uidl.getStringAttribute("selectmode");
- getWidget().selectable = !"none".equals(selectMode);
- getWidget().isMultiselect = "multi".equals(selectMode);
-
- if (getWidget().isMultiselect) {
- getWidget().multiSelectMode = uidl
- .getIntAttribute("multiselectmode");
- }
-
- getWidget().selectedIds = uidl
- .getStringArrayVariableAsSet("selected");
-
- // Update lastSelection and focusedNode to point to *actual* nodes again
- // after the old ones have been cleared from the body. This fixes focus
- // and keyboard navigation issues as described in #7057 and other
- // tickets.
- if (getWidget().lastSelection != null) {
- getWidget().lastSelection = getWidget()
- .getNodeByKey(getWidget().lastSelection.key);
- }
- if (getWidget().focusedNode != null) {
- getWidget().setFocusedNode(
- getWidget().getNodeByKey(
- getWidget().focusedNode.key));
- }
-
- if (getWidget().lastSelection == null
- && getWidget().focusedNode == null
- && !getWidget().selectedIds.isEmpty()) {
- getWidget().setFocusedNode(
- getWidget().getNodeByKey(
- getWidget().selectedIds.iterator()
- .next()));
- getWidget().focusedNode.setFocused(false);
- }
-
- getWidget().rendering = false;
-
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VTree.class);
- }
-
- @Override
- public VTree getWidget() {
- return (VTree) super.getWidget();
- }
-
- private void handleUpdate(UIDL uidl) {
- final TreeNode rootNode = getWidget().getNodeByKey(
- uidl.getStringAttribute("rootKey"));
- if (rootNode != null) {
- if (!rootNode.getState()) {
- // expanding node happened server side
- rootNode.setState(true, false);
- }
- renderChildNodes(rootNode, (Iterator) uidl.getChildIterator());
- }
- }
-
- /**
- * Registers action for the root and also for individual nodes
- *
- * @param uidl
- */
- private void updateActionMap(UIDL uidl) {
- final Iterator<?> it = uidl.getChildIterator();
- while (it.hasNext()) {
- final UIDL action = (UIDL) it.next();
- final String key = action.getStringAttribute("key");
- final String caption = action
- .getStringAttribute(ATTRIBUTE_ACTION_CAPTION);
- String iconUrl = null;
- if (action.hasAttribute(ATTRIBUTE_ACTION_ICON)) {
- iconUrl = getConnection().translateVaadinUri(
- action.getStringAttribute(ATTRIBUTE_ACTION_ICON));
- }
- getWidget().registerAction(key, caption, iconUrl);
- }
-
- }
-
- public void updateNodeFromUIDL(TreeNode treeNode, UIDL uidl) {
- String nodeKey = uidl.getStringAttribute("key");
- treeNode.setText(uidl.getStringAttribute(ATTRIBUTE_NODE_CAPTION));
- treeNode.key = nodeKey;
-
- getWidget().registerNode(treeNode);
-
- if (uidl.hasAttribute("al")) {
- treeNode.actionKeys = uidl.getStringArrayAttribute("al");
- }
-
- if (uidl.getTag().equals("node")) {
- if (uidl.getChildCount() == 0) {
- treeNode.childNodeContainer.setVisible(false);
- } else {
- renderChildNodes(treeNode, (Iterator) uidl.getChildIterator());
- treeNode.childrenLoaded = true;
- }
- } else {
- treeNode.addStyleName(TreeNode.CLASSNAME + "-leaf");
- }
- if (uidl.hasAttribute(ATTRIBUTE_NODE_STYLE)) {
- treeNode.setNodeStyleName(uidl
- .getStringAttribute(ATTRIBUTE_NODE_STYLE));
- }
-
- String description = uidl.getStringAttribute("descr");
- if (description != null && getConnection() != null) {
- // Set tooltip
- TooltipInfo info = new TooltipInfo(description);
- getConnection().registerTooltip(this, nodeKey, info);
- } else {
- // Remove possible previous tooltip
- getConnection().registerTooltip(this, nodeKey, null);
- }
-
- if (uidl.getBooleanAttribute("expanded") && !treeNode.getState()) {
- treeNode.setState(true, false);
- }
-
- if (uidl.getBooleanAttribute("selected")) {
- treeNode.setSelected(true);
- // ensure that identifier is in selectedIds array (this may be a
- // partial update)
- getWidget().selectedIds.add(nodeKey);
- }
-
- treeNode.setIcon(uidl.getStringAttribute(ATTRIBUTE_NODE_ICON));
- }
-
- void renderChildNodes(TreeNode containerNode, Iterator<UIDL> i) {
- containerNode.childNodeContainer.clear();
- containerNode.childNodeContainer.setVisible(true);
- while (i.hasNext()) {
- final UIDL childUidl = i.next();
- // actions are in bit weird place, don't mix them with children,
- // but current node's actions
- if ("actions".equals(childUidl.getTag())) {
- updateActionMap(childUidl);
- continue;
- }
- final TreeNode childTree = getWidget().new TreeNode();
- updateNodeFromUIDL(childTree, childUidl);
- containerNode.childNodeContainer.add(childTree);
- if (!i.hasNext()) {
- childTree
- .addStyleDependentName(childTree.isLeaf() ? "leaf-last"
- : "last");
- childTree.childNodeContainer.addStyleDependentName("last");
- }
- }
- containerNode.childrenLoaded = true;
- }
-}
+++ /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.terminal.gwt.client.ApplicationConnection;
-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;
-
-public class VTreeTablePaintable extends VScrollTablePaintable {
- public static final String ATTRIBUTE_HIERARCHY_COLUMN_INDEX = "hci";
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- FocusableScrollPanel widget = null;
- int scrollPosition = 0;
- if (getWidget().collapseRequest) {
- widget = (FocusableScrollPanel) getWidget()
- .getWidget(1);
- scrollPosition = widget.getScrollPosition();
- }
- getWidget().animationsEnabled = uidl
- .getBooleanAttribute("animate");
- getWidget().colIndexOfHierarchy = uidl
- .hasAttribute(ATTRIBUTE_HIERARCHY_COLUMN_INDEX) ? uidl
- .getIntAttribute(ATTRIBUTE_HIERARCHY_COLUMN_INDEX) : 0;
- int oldTotalRows = getWidget().getTotalRows();
- super.updateFromUIDL(uidl, client);
- if (getWidget().collapseRequest) {
- if (getWidget().collapsedRowKey != null
- && getWidget().scrollBody != null) {
- VScrollTableRow row = getWidget()
- .getRenderedRowByKey(
- getWidget().collapsedRowKey);
- if (row != null) {
- getWidget().setRowFocus(row);
- getWidget().focus();
- }
- }
-
- int scrollPosition2 = widget.getScrollPosition();
- if (scrollPosition != scrollPosition2) {
- widget.setScrollPosition(scrollPosition);
- }
-
- // check which rows are needed from the server and initiate a
- // deferred fetch
- getWidget().onScroll(null);
- }
- // Recalculate table size if collapse request, or if page length is zero
- // (not sent by server) and row count changes (#7908).
- if (getWidget().collapseRequest
- || (!uidl.hasAttribute("pagelength") && getWidget()
- .getTotalRows() != oldTotalRows)) {
- /*
- * Ensure that possibly removed/added scrollbars are considered.
- * Triggers row calculations, removes cached rows etc. Basically
- * cleans up state. Be careful if touching this, you will break
- * pageLength=0 if you remove this.
- */
- getWidget().triggerLazyColumnAdjustment(true);
-
- getWidget().collapseRequest = false;
- }
- if (uidl.hasAttribute("focusedRow")) {
- String key = uidl.getStringAttribute("focusedRow");
- getWidget().setRowFocus(
- getWidget().getRenderedRowByKey(key));
- getWidget().focusParentResponsePending = false;
- } else if (uidl.hasAttribute("clearFocusPending")) {
- // Special case to detect a response to a focusParent request that
- // does not return any focusedRow because the selected node has no
- // parent
- getWidget().focusParentResponsePending = false;
- }
-
- while (!getWidget().collapseRequest
- && !getWidget().focusParentResponsePending
- && !getWidget().pendingNavigationEvents.isEmpty()) {
- // Keep replaying any queued events as long as we don't have any
- // potential content changes pending
- PendingNavigationEvent event = getWidget().pendingNavigationEvents
- .removeFirst();
- getWidget().handleNavigation(event.keycode, event.ctrl,
- event.shift);
- }
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VTreeTable.class);
- }
-
- @Override
- public VTreeTable getWidget() {
- return (VTreeTable) super.getWidget();
- }
-}
+++ /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.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.UIDL;
-
-public class VTwinColSelectPaintable extends VOptionGroupBasePaintable {
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- // Captions are updated before super call to ensure the widths are set
- // correctly
- if (isRealUpdate(uidl)) {
- getWidget().updateCaptions(uidl);
- }
-
- super.updateFromUIDL(uidl, client);
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VTwinColSelect.class);
- }
-
- @Override
- public VTwinColSelect getWidget() {
- return (VTwinColSelect) super.getWidget();
- }
-}
+++ /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.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.UIDL;
-import com.vaadin.terminal.gwt.client.VUIDLBrowser;
-
-public class VUnknownComponentPaintable extends AbstractComponentConnector {
-
- @Override
- protected boolean delegateCaptionHandling() {
- return false;
- }
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- super.updateFromUIDL(uidl, client);
- 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:");
- if (getWidget().uidlTree != null) {
- getWidget().uidlTree.removeFromParent();
- }
-
- getWidget().uidlTree = new VUIDLBrowser(uidl,
- client.getConfiguration());
- getWidget().uidlTree.open(true);
- getWidget().uidlTree.setText("Unrendered UIDL");
- getWidget().panel.add(getWidget().uidlTree);
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VUnknownComponent.class);
- }
-
- @Override
- public VUnknownComponent getWidget() {
- return (VUnknownComponent) super.getWidget();
- }
-
- public void setServerSideClassName(String serverClassName) {
- getWidget().setServerSideClassName(serverClassName);
- }
-}
+++ /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.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.UIDL;
-
-public class VUploadPaintable extends AbstractComponentConnector {
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
- if (uidl.hasAttribute("notStarted")) {
- getWidget().t.schedule(400);
- return;
- }
- if (uidl.hasAttribute("forceSubmit")) {
- getWidget().submit();
- return;
- }
- getWidget().setImmediate(getState().isImmediate());
- getWidget().client = client;
- getWidget().paintableId = uidl.getId();
- getWidget().nextUploadId = uidl.getIntAttribute("nextid");
- final String action = client.translateVaadinUri(uidl
- .getStringVariable("action"));
- getWidget().element.setAction(action);
- if (uidl.hasAttribute("buttoncaption")) {
- getWidget().submitButton.setText(uidl
- .getStringAttribute("buttoncaption"));
- getWidget().submitButton.setVisible(true);
- } else {
- getWidget().submitButton.setVisible(false);
- }
- getWidget().fu.setName(getWidget().paintableId
- + "_file");
-
- if (getState().isDisabled() || getState().isReadOnly()) {
- getWidget().disableUpload();
- } else if (!uidl.getBooleanAttribute("state")) {
- // Enable the button only if an upload is not in progress
- getWidget().enableUpload();
- getWidget().ensureTargetFrame();
- }
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VUpload.class);
- }
-
- @Override
- public VUpload getWidget() {
- return (VUpload) super.getWidget();
- }
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.google.gwt.core.client.GWT;
-
-public class VVerticalLayoutPaintable extends VMeasuringOrderedLayoutPaintable {
-
- @Override
- public VVerticalLayout getWidget() {
- return (VVerticalLayout) super.getWidget();
- }
-
- @Override
- protected VVerticalLayout createWidget() {
- return GWT.create(VVerticalLayout.class);
- }
-
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.google.gwt.core.client.GWT;
-
-public class VVerticalSplitPanelPaintable extends VAbstractSplitPanelPaintable {
-
- @Override
- protected VAbstractSplitPanel createWidget() {
- return GWT.create(VSplitPanelVertical.class);
- }
-
-}
+++ /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.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.UIDL;
-
-public class VVideoPaintable extends VMediaBasePaintable {
- public static final String ATTR_POSTER = "poster";
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
- super.updateFromUIDL(uidl, client);
- setPosterFromUIDL(uidl);
- }
-
- private void setPosterFromUIDL(UIDL uidl) {
- if (uidl.hasAttribute(ATTR_POSTER)) {
- getWidget().setPoster(
- getConnection().translateVaadinUri(
- uidl.getStringAttribute(ATTR_POSTER)));
- }
- }
-
- @Override
- public VVideo getWidget() {
- return (VVideo) super.getWidget();
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VVideo.class);
- }
-
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import java.util.HashSet;
-import java.util.Iterator;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.core.client.Scheduler;
-import com.google.gwt.event.dom.client.DomEvent.Type;
-import com.google.gwt.event.shared.EventHandler;
-import com.google.gwt.event.shared.HandlerRegistration;
-import com.google.gwt.user.client.Command;
-import com.google.gwt.user.client.DOM;
-import com.google.gwt.user.client.Event;
-import com.google.gwt.user.client.History;
-import com.google.gwt.user.client.Window;
-import com.google.gwt.user.client.ui.RootPanel;
-import com.google.gwt.user.client.ui.Widget;
-import com.vaadin.terminal.gwt.client.ApplicationConnection;
-import com.vaadin.terminal.gwt.client.BrowserInfo;
-import com.vaadin.terminal.gwt.client.Focusable;
-import com.vaadin.terminal.gwt.client.UIDL;
-import com.vaadin.terminal.gwt.client.Util;
-import com.vaadin.terminal.gwt.client.VConsole;
-import com.vaadin.terminal.gwt.client.ConnectorMap;
-import com.vaadin.terminal.gwt.client.ComponentConnector;
-
-public class VViewPaintable extends AbstractComponentContainerConnector {
-
- private static final String CLICK_EVENT_IDENTIFIER = VPanelPaintable.CLICK_EVENT_IDENTIFIER;
-
- @Override
- public void updateFromUIDL(final UIDL uidl, ApplicationConnection client) {
- getWidget().rendering = true;
- // As VView is not created in the same way as all other paintables we
- // have to set the id here
- setId(uidl.getId());
- getWidget().id = uidl.getId();
- boolean firstPaint = getWidget().connection == null;
- getWidget().connection = client;
-
- getWidget().immediate = getState().isImmediate();
- getWidget().resizeLazy = uidl
- .hasAttribute(VView.RESIZE_LAZY);
- String newTheme = uidl.getStringAttribute("theme");
- if (getWidget().theme != null
- && !newTheme.equals(getWidget().theme)) {
- // Complete page refresh is needed due css can affect layout
- // calculations etc
- getWidget().reloadHostPage();
- } else {
- getWidget().theme = newTheme;
- }
- // this also implicitly removes old styles
- getWidget().setStyleName(
- getWidget().getStylePrimaryName() + " "
- + getState().getStyle());
-
- clickEventHandler.handleEventHandlerRegistration(client);
-
- if (!getWidget().isEmbedded()
- && getState().getCaption() != null) {
- // only change window title if we're in charge of the whole page
- com.google.gwt.user.client.Window.setTitle(getState().getCaption());
- }
-
- // Process children
- int childIndex = 0;
-
- // Open URL:s
- boolean isClosed = false; // was this window closed?
- while (childIndex < uidl.getChildCount()
- && "open".equals(uidl.getChildUIDL(childIndex).getTag())) {
- final UIDL open = uidl.getChildUIDL(childIndex);
- final String url = client.translateVaadinUri(open
- .getStringAttribute("src"));
- final String target = open.getStringAttribute("name");
- if (target == null) {
- // source will be opened to this browser window, but we may have
- // to finish rendering this window in case this is a download
- // (and window stays open).
- Scheduler.get().scheduleDeferred(new Command() {
- public void execute() {
- VView.goTo(url);
- }
- });
- } else if ("_self".equals(target)) {
- // This window is closing (for sure). Only other opens are
- // relevant in this change. See #3558, #2144
- isClosed = true;
- VView.goTo(url);
- } else {
- String options;
- if (open.hasAttribute("border")) {
- if (open.getStringAttribute("border").equals("minimal")) {
- options = "menubar=yes,location=no,status=no";
- } else {
- options = "menubar=no,location=no,status=no";
- }
-
- } else {
- options = "resizable=yes,menubar=yes,toolbar=yes,directories=yes,location=yes,scrollbars=yes,status=yes";
- }
-
- if (open.hasAttribute("width")) {
- int w = open.getIntAttribute("width");
- options += ",width=" + w;
- }
- if (open.hasAttribute("height")) {
- int h = open.getIntAttribute("height");
- options += ",height=" + h;
- }
-
- Window.open(url, target, options);
- }
- childIndex++;
- }
- if (isClosed) {
- // don't render the content, something else will be opened to this
- // browser view
- getWidget().rendering = false;
- return;
- }
-
- // Draw this application level window
- UIDL childUidl = uidl.getChildUIDL(childIndex);
- final ComponentConnector lo = client.getPaintable(childUidl);
-
- if (getWidget().layout != null) {
- if (getWidget().layout != lo) {
- // remove old
- client.unregisterPaintable(getWidget().layout);
- // add new
- getWidget().setWidget(lo.getWidget());
- getWidget().layout = lo;
- }
- } else {
- getWidget().setWidget(lo.getWidget());
- getWidget().layout = lo;
- }
-
- getWidget().layout.updateFromUIDL(childUidl, client);
-
- // Save currently open subwindows to track which will need to be closed
- final HashSet<VWindow> removedSubWindows = new HashSet<VWindow>(
- getWidget().subWindows);
-
- // Handle other UIDL children
- while ((childUidl = uidl.getChildUIDL(++childIndex)) != null) {
- String tag = childUidl.getTag().intern();
- if (tag == "actions") {
- if (getWidget().actionHandler == null) {
- getWidget().actionHandler = new ShortcutActionHandler(
- getWidget().id, client);
- }
- getWidget().actionHandler
- .updateActionMap(childUidl);
- } else if (tag == "execJS") {
- String script = childUidl.getStringAttribute("script");
- VView.eval(script);
- } else if (tag == "notifications") {
- for (final Iterator<?> it = childUidl.getChildIterator(); it
- .hasNext();) {
- final UIDL notification = (UIDL) it.next();
- VNotification.showNotification(client, notification);
- }
- } else {
- // subwindows
- final VWindowPaintable w = (VWindowPaintable) client
- .getPaintable(childUidl);
- VWindow windowWidget = w.getWidget();
- if (getWidget().subWindows.contains(windowWidget)) {
- removedSubWindows.remove(windowWidget);
- } else {
- getWidget().subWindows.add(windowWidget);
- }
- w.updateFromUIDL(childUidl, client);
- }
- }
-
- // Close old windows which where not in UIDL anymore
- for (final Iterator<VWindow> rem = removedSubWindows.iterator(); rem
- .hasNext();) {
- final VWindow w = rem.next();
- client.unregisterPaintable(ConnectorMap.get(getConnection())
- .getConnector(w));
- getWidget().subWindows.remove(w);
- w.hide();
- }
-
- if (uidl.hasAttribute("focused")) {
- // set focused component when render phase is finished
- Scheduler.get().scheduleDeferred(new Command() {
- public void execute() {
- ComponentConnector paintable = (ComponentConnector) uidl
- .getPaintableAttribute("focused", getConnection());
-
- final Widget toBeFocused = paintable
- .getWidget();
- /*
- * Two types of Widgets can be focused, either implementing
- * GWT HasFocus of a thinner Vaadin specific Focusable
- * interface.
- */
- if (toBeFocused instanceof com.google.gwt.user.client.ui.Focusable) {
- final com.google.gwt.user.client.ui.Focusable toBeFocusedWidget = (com.google.gwt.user.client.ui.Focusable) toBeFocused;
- toBeFocusedWidget.setFocus(true);
- } else if (toBeFocused instanceof Focusable) {
- ((Focusable) toBeFocused).focus();
- } else {
- VConsole.log("Could not focus component");
- }
- }
- });
- }
-
- // Add window listeners on first paint, to prevent premature
- // variablechanges
- if (firstPaint) {
- Window.addWindowClosingHandler(getWidget());
- Window.addResizeHandler(getWidget());
- }
-
- getWidget().onResize();
-
- // finally set scroll position from UIDL
- if (uidl.hasVariable("scrollTop")) {
- getWidget().scrollable = true;
- getWidget().scrollTop = uidl
- .getIntVariable("scrollTop");
- DOM.setElementPropertyInt(getWidget().getElement(),
- "scrollTop", getWidget().scrollTop);
- getWidget().scrollLeft = uidl
- .getIntVariable("scrollLeft");
- DOM.setElementPropertyInt(getWidget().getElement(),
- "scrollLeft", getWidget().scrollLeft);
- } else {
- getWidget().scrollable = false;
- }
-
- // Safari workaround must be run after scrollTop is updated as it sets
- // scrollTop using a deferred command.
- if (BrowserInfo.get().isSafari()) {
- Util.runWebkitOverflowAutoFix(getWidget().getElement());
- }
-
- getWidget().scrollIntoView(uidl);
-
- if (uidl.hasAttribute(VView.FRAGMENT_VARIABLE)) {
- getWidget().currentFragment = uidl
- .getStringAttribute(VView.FRAGMENT_VARIABLE);
- if (!getWidget().currentFragment.equals(History
- .getToken())) {
- History.newItem(getWidget().currentFragment, true);
- }
- } else {
- // Initial request for which the server doesn't yet have a fragment
- // (and haven't shown any interest in getting one)
- getWidget().currentFragment = History.getToken();
-
- // Include current fragment in the next request
- client.updateVariable(getWidget().id,
- VView.FRAGMENT_VARIABLE,
- getWidget().currentFragment, false);
- }
-
- getWidget().rendering = false;
- }
-
- public void init(String rootPanelId,
- ApplicationConnection applicationConnection) {
- DOM.sinkEvents(getWidget().getElement(), Event.ONKEYDOWN
- | Event.ONSCROLL);
-
- // iview is focused when created so element needs tabIndex
- // 1 due 0 is at the end of natural tabbing order
- DOM.setElementProperty(getWidget().getElement(),
- "tabIndex", "1");
-
- RootPanel root = RootPanel.get(rootPanelId);
-
- // Remove the v-app-loading or any splash screen added inside the div by
- // the user
- root.getElement().setInnerHTML("");
- // For backwards compatibility with static index pages only.
- // No longer added by AbstractApplicationServlet/Portlet
- root.removeStyleName("v-app-loading");
-
- String themeUri = applicationConnection.getConfiguration()
- .getThemeUri();
- String themeName = themeUri.substring(themeUri.lastIndexOf('/'));
- themeName = themeName.replaceAll("[^a-zA-Z0-9]", "");
- root.addStyleName("v-theme-" + themeName);
-
- root.add(getWidget());
-
- if (applicationConnection.getConfiguration().isStandalone()) {
- // set focus to iview element by default to listen possible keyboard
- // shortcuts. For embedded applications this is unacceptable as we
- // don't want to steal focus from the main page nor we don't want
- // side-effects from focusing (scrollIntoView).
- getWidget().getElement().focus();
- }
- }
-
- private ClickEventHandler clickEventHandler = new ClickEventHandler(this,
- CLICK_EVENT_IDENTIFIER) {
-
- @Override
- protected <H extends EventHandler> HandlerRegistration registerHandler(
- H handler, Type<H> type) {
- return getWidget().addDomHandler(handler, type);
- }
- };
-
- public void updateCaption(ComponentConnector component, UIDL uidl) {
- // NOP The main view never draws caption for its layout
- }
-
- @Override
- public VView getWidget() {
- return (VView) super.getWidget();
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VView.class);
- }
-
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.event.dom.client.DomEvent.Type;
-import com.google.gwt.event.shared.EventHandler;
-import com.google.gwt.event.shared.HandlerRegistration;
-import com.google.gwt.user.client.DOM;
-import com.google.gwt.user.client.Event;
-import com.google.gwt.user.client.Window;
-import com.google.gwt.user.client.ui.Frame;
-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.Util;
-import com.vaadin.terminal.gwt.client.ComponentConnector;
-import com.vaadin.terminal.gwt.client.ui.ShortcutActionHandler.BeforeShortcutActionListener;
-
-public class VWindowPaintable extends AbstractComponentContainerConnector
- implements BeforeShortcutActionListener, SimpleManagedLayout,
- PostLayoutListener {
-
- private static final String CLICK_EVENT_IDENTIFIER = VPanelPaintable.CLICK_EVENT_IDENTIFIER;
-
- private ClickEventHandler clickEventHandler = new ClickEventHandler(this,
- CLICK_EVENT_IDENTIFIER) {
-
- @Override
- protected <H extends EventHandler> HandlerRegistration registerHandler(
- H handler, Type<H> type) {
- return getWidget().addDomHandler(handler, type);
- }
- };
-
- @Override
- protected boolean delegateCaptionHandling() {
- return false;
- };
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidget().id = uidl.getId();
- getWidget().client = client;
-
- // Workaround needed for Testing Tools (GWT generates window DOM
- // slightly different in different browsers).
- DOM.setElementProperty(getWidget().closeBox, "id",
- getWidget().id + "_window_close");
-
- if (uidl.hasAttribute("invisible")) {
- getWidget().hide();
- return;
- }
-
- if (isRealUpdate(uidl)) {
- if (uidl.getBooleanAttribute("modal") != getWidget().vaadinModality) {
- getWidget().setVaadinModality(
- !getWidget().vaadinModality);
- }
- if (!getWidget().isAttached()) {
- getWidget().setVisible(false); // hide until
- // possible centering
- getWidget().show();
- }
- if (uidl.getBooleanAttribute("resizable") != getWidget().resizable) {
- getWidget().setResizable(
- !getWidget().resizable);
- }
- getWidget().resizeLazy = uidl
- .hasAttribute(VView.RESIZE_LAZY);
-
- getWidget().setDraggable(
- !uidl.hasAttribute("fixedposition"));
-
- // Caption must be set before required header size is measured. If
- // the caption attribute is missing the caption should be cleared.
- getWidget()
- .setCaption(
- getState().getCaption(),
- uidl.getStringAttribute(AbstractComponentConnector.ATTRIBUTE_ICON));
- }
-
- getWidget().visibilityChangesDisabled = true;
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
- getWidget().visibilityChangesDisabled = false;
-
- clickEventHandler.handleEventHandlerRegistration(client);
-
- getWidget().immediate = getState().isImmediate();
-
- getWidget().setClosable(!getState().isReadOnly());
-
- // Initialize the position form UIDL
- int positionx = uidl.getIntVariable("positionx");
- int positiony = uidl.getIntVariable("positiony");
- if (positionx >= 0 || positiony >= 0) {
- if (positionx < 0) {
- positionx = 0;
- }
- if (positiony < 0) {
- positiony = 0;
- }
- getWidget().setPopupPosition(positionx, positiony);
- }
-
- boolean showingUrl = false;
- int childIndex = 0;
- UIDL childUidl = uidl.getChildUIDL(childIndex++);
- while ("open".equals(childUidl.getTag())) {
- // TODO multiple opens with the same target will in practice just
- // open the last one - should we fix that somehow?
- final String parsedUri = client.translateVaadinUri(childUidl
- .getStringAttribute("src"));
- if (!childUidl.hasAttribute("name")) {
- final Frame frame = new Frame();
- DOM.setStyleAttribute(frame.getElement(), "width", "100%");
- DOM.setStyleAttribute(frame.getElement(), "height", "100%");
- DOM.setStyleAttribute(frame.getElement(), "border", "0px");
- frame.setUrl(parsedUri);
- getWidget().contentPanel.setWidget(frame);
- showingUrl = true;
- } else {
- final String target = childUidl.getStringAttribute("name");
- Window.open(parsedUri, target, "");
- }
- childUidl = uidl.getChildUIDL(childIndex++);
- }
-
- final ComponentConnector lo = client.getPaintable(childUidl);
- if (getWidget().layout != null) {
- if (getWidget().layout != lo) {
- // remove old
- client.unregisterPaintable(getWidget().layout);
- getWidget().contentPanel
- .remove(getWidget().layout
- .getWidget());
- // add new
- if (!showingUrl) {
- getWidget().contentPanel.setWidget(lo
- .getWidget());
- }
- getWidget().layout = lo;
- }
- } else if (!showingUrl) {
- getWidget().contentPanel.setWidget(lo
- .getWidget());
- getWidget().layout = lo;
- }
-
- getWidget().dynamicWidth = getState().isUndefinedWidth();
- getWidget().dynamicHeight = getState().isUndefinedHeight();
-
- getWidget().layoutRelativeWidth = uidl
- .hasAttribute("layoutRelativeWidth");
- getWidget().layoutRelativeHeight = uidl
- .hasAttribute("layoutRelativeHeight");
-
- if (getWidget().dynamicWidth
- && getWidget().layoutRelativeWidth) {
- /*
- * Relative layout width, fix window width before rendering (width
- * according to caption)
- */
- getWidget().setNaturalWidth();
- }
-
- getWidget().layout.updateFromUIDL(childUidl, client);
- if (!getWidget().dynamicHeight
- && getWidget().layoutRelativeWidth) {
- /*
- * Relative layout width, and fixed height. Must update the size to
- * be able to take scrollbars into account (layout gets narrower
- * space if it is higher than the window) -> only vertical scrollbar
- */
- client.runDescendentsLayout(getWidget());
- }
-
- /*
- * No explicit width is set and the layout does not have relative width
- * so fix the size according to the layout.
- */
- if (getWidget().dynamicWidth
- && !getWidget().layoutRelativeWidth) {
- getWidget().setNaturalWidth();
- }
-
- if (getWidget().dynamicHeight
- && getWidget().layoutRelativeHeight) {
- // Prevent resizing until height has been fixed
- getWidget().resizable = false;
- }
-
- // we may have actions and notifications
- if (uidl.getChildCount() > 1) {
- final int cnt = uidl.getChildCount();
- for (int i = 1; i < cnt; i++) {
- childUidl = uidl.getChildUIDL(i);
- if (childUidl.getTag().equals("actions")) {
- if (getWidget().shortcutHandler == null) {
- getWidget().shortcutHandler = new ShortcutActionHandler(
- getId(), client);
- }
- getWidget().shortcutHandler
- .updateActionMap(childUidl);
- }
- }
-
- }
-
- // setting scrollposition must happen after children is rendered
- getWidget().contentPanel.setScrollPosition(uidl
- .getIntVariable("scrollTop"));
- getWidget().contentPanel.setHorizontalScrollPosition(uidl
- .getIntVariable("scrollLeft"));
-
- // Center this window on screen if requested
- // This has to be here because we might not know the content size before
- // everything is painted into the window
- if (uidl.getBooleanAttribute("center")) {
- // mark as centered - this is unset on move/resize
- getWidget().centered = true;
- getWidget().center();
- } else {
- // don't try to center the window anymore
- getWidget().centered = false;
- }
- getWidget().updateShadowSizeAndPosition();
- getWidget().setVisible(true);
-
- boolean sizeReduced = false;
- // ensure window is not larger than browser window
- if (getWidget().getOffsetWidth() > Window.getClientWidth()) {
- getWidget().setWidth(Window.getClientWidth() + "px");
- sizeReduced = true;
- }
- if (getWidget().getOffsetHeight() > Window
- .getClientHeight()) {
- getWidget().setHeight(Window.getClientHeight() + "px");
- sizeReduced = true;
- }
-
- if (getWidget().dynamicHeight
- && getWidget().layoutRelativeHeight) {
- /*
- * Window height is undefined, layout is 100% high so the layout
- * should define the initial window height but on resize the layout
- * should be as high as the window. We fix the height to deal with
- * this.
- */
-
- int h = getWidget().contents.getOffsetHeight()
- + getWidget().getExtraHeight();
- int w = getWidget().getElement().getOffsetWidth();
-
- client.updateVariable(getId(), "height", h, false);
- client.updateVariable(getId(), "width", w, true);
- }
-
- if (sizeReduced) {
- // If we changed the size we need to update the size of the child
- // component if it is relative (#3407)
- client.runDescendentsLayout(getWidget());
- }
-
- Util.runWebkitOverflowAutoFix(getWidget().contentPanel
- .getElement());
-
- client.getView().getWidget().scrollIntoView(uidl);
-
- if (uidl.hasAttribute("bringToFront")) {
- /*
- * Focus as a side-efect. Will be overridden by
- * ApplicationConnection if another component was focused by the
- * server side.
- */
- getWidget().contentPanel.focus();
- getWidget().bringToFrontSequence = uidl
- .getIntAttribute("bringToFront");
- VWindow.deferOrdering();
- }
- }
-
- public void updateCaption(ComponentConnector component, UIDL uidl) {
- // NOP, window has own caption, layout captio not rendered
- }
-
- public void onBeforeShortcutAction(Event e) {
- // NOP, nothing to update just avoid workaround ( causes excess
- // blur/focus )
- }
-
- @Override
- public VWindow getWidget() {
- return (VWindow) super.getWidget();
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VWindow.class);
- }
-
- public void layout() {
- getWidget().requestLayout();
- }
-
- public void postLayout() {
- VWindow window = getWidget();
- if (window.centered) {
- window.center();
- window.updateShadowSizeAndPosition();
- }
- }
-
-}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.core.client.GWT;
+
+public class VerticalLayoutConnector extends AbstractOrderedLayoutConnector {
+
+ @Override
+ public VVerticalLayout getWidget() {
+ return (VVerticalLayout) super.getWidget();
+ }
+
+ @Override
+ protected VVerticalLayout createWidget() {
+ return GWT.create(VVerticalLayout.class);
+ }
+
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.core.client.GWT;
+
+public class VerticalSplitPanelConnector extends AbstractSplitPanelConnector {
+
+ @Override
+ protected VAbstractSplitPanel createWidget() {
+ return GWT.create(VSplitPanelVertical.class);
+ }
+
+}
--- /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.terminal.gwt.client.ApplicationConnection;
+import com.vaadin.terminal.gwt.client.UIDL;
+
+public class VideoConnector extends MediaBaseConnector {
+ public static final String ATTR_POSTER = "poster";
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+ super.updateFromUIDL(uidl, client);
+ setPosterFromUIDL(uidl);
+ }
+
+ private void setPosterFromUIDL(UIDL uidl) {
+ if (uidl.hasAttribute(ATTR_POSTER)) {
+ getWidget().setPoster(
+ getConnection().translateVaadinUri(
+ uidl.getStringAttribute(ATTR_POSTER)));
+ }
+ }
+
+ @Override
+ public VVideo getWidget() {
+ return (VVideo) super.getWidget();
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VVideo.class);
+ }
+
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.event.dom.client.DomEvent.Type;
+import com.google.gwt.event.shared.EventHandler;
+import com.google.gwt.event.shared.HandlerRegistration;
+import com.google.gwt.user.client.DOM;
+import com.google.gwt.user.client.Event;
+import com.google.gwt.user.client.Window;
+import com.google.gwt.user.client.ui.Frame;
+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.Util;
+import com.vaadin.terminal.gwt.client.ComponentConnector;
+import com.vaadin.terminal.gwt.client.ui.ShortcutActionHandler.BeforeShortcutActionListener;
+
+public class WindowConnector extends AbstractComponentContainerConnector
+ implements BeforeShortcutActionListener, SimpleManagedLayout,
+ PostLayoutListener {
+
+ private static final String CLICK_EVENT_IDENTIFIER = PanelConnector.CLICK_EVENT_IDENTIFIER;
+
+ private ClickEventHandler clickEventHandler = new ClickEventHandler(this,
+ CLICK_EVENT_IDENTIFIER) {
+
+ @Override
+ protected <H extends EventHandler> HandlerRegistration registerHandler(
+ H handler, Type<H> type) {
+ return getWidget().addDomHandler(handler, type);
+ }
+ };
+
+ @Override
+ protected boolean delegateCaptionHandling() {
+ return false;
+ };
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ getWidget().id = uidl.getId();
+ getWidget().client = client;
+
+ // Workaround needed for Testing Tools (GWT generates window DOM
+ // slightly different in different browsers).
+ DOM.setElementProperty(getWidget().closeBox, "id",
+ getWidget().id + "_window_close");
+
+ if (uidl.hasAttribute("invisible")) {
+ getWidget().hide();
+ return;
+ }
+
+ if (isRealUpdate(uidl)) {
+ if (uidl.getBooleanAttribute("modal") != getWidget().vaadinModality) {
+ getWidget().setVaadinModality(
+ !getWidget().vaadinModality);
+ }
+ if (!getWidget().isAttached()) {
+ getWidget().setVisible(false); // hide until
+ // possible centering
+ getWidget().show();
+ }
+ if (uidl.getBooleanAttribute("resizable") != getWidget().resizable) {
+ getWidget().setResizable(
+ !getWidget().resizable);
+ }
+ getWidget().resizeLazy = uidl
+ .hasAttribute(VView.RESIZE_LAZY);
+
+ getWidget().setDraggable(
+ !uidl.hasAttribute("fixedposition"));
+
+ // Caption must be set before required header size is measured. If
+ // the caption attribute is missing the caption should be cleared.
+ getWidget()
+ .setCaption(
+ getState().getCaption(),
+ uidl.getStringAttribute(AbstractComponentConnector.ATTRIBUTE_ICON));
+ }
+
+ getWidget().visibilityChangesDisabled = true;
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+ getWidget().visibilityChangesDisabled = false;
+
+ clickEventHandler.handleEventHandlerRegistration(client);
+
+ getWidget().immediate = getState().isImmediate();
+
+ getWidget().setClosable(!getState().isReadOnly());
+
+ // Initialize the position form UIDL
+ int positionx = uidl.getIntVariable("positionx");
+ int positiony = uidl.getIntVariable("positiony");
+ if (positionx >= 0 || positiony >= 0) {
+ if (positionx < 0) {
+ positionx = 0;
+ }
+ if (positiony < 0) {
+ positiony = 0;
+ }
+ getWidget().setPopupPosition(positionx, positiony);
+ }
+
+ boolean showingUrl = false;
+ int childIndex = 0;
+ UIDL childUidl = uidl.getChildUIDL(childIndex++);
+ while ("open".equals(childUidl.getTag())) {
+ // TODO multiple opens with the same target will in practice just
+ // open the last one - should we fix that somehow?
+ final String parsedUri = client.translateVaadinUri(childUidl
+ .getStringAttribute("src"));
+ if (!childUidl.hasAttribute("name")) {
+ final Frame frame = new Frame();
+ DOM.setStyleAttribute(frame.getElement(), "width", "100%");
+ DOM.setStyleAttribute(frame.getElement(), "height", "100%");
+ DOM.setStyleAttribute(frame.getElement(), "border", "0px");
+ frame.setUrl(parsedUri);
+ getWidget().contentPanel.setWidget(frame);
+ showingUrl = true;
+ } else {
+ final String target = childUidl.getStringAttribute("name");
+ Window.open(parsedUri, target, "");
+ }
+ childUidl = uidl.getChildUIDL(childIndex++);
+ }
+
+ final ComponentConnector lo = client.getPaintable(childUidl);
+ if (getWidget().layout != null) {
+ if (getWidget().layout != lo) {
+ // remove old
+ client.unregisterPaintable(getWidget().layout);
+ getWidget().contentPanel
+ .remove(getWidget().layout
+ .getWidget());
+ // add new
+ if (!showingUrl) {
+ getWidget().contentPanel.setWidget(lo
+ .getWidget());
+ }
+ getWidget().layout = lo;
+ }
+ } else if (!showingUrl) {
+ getWidget().contentPanel.setWidget(lo
+ .getWidget());
+ getWidget().layout = lo;
+ }
+
+ getWidget().dynamicWidth = getState().isUndefinedWidth();
+ getWidget().dynamicHeight = getState().isUndefinedHeight();
+
+ getWidget().layoutRelativeWidth = uidl
+ .hasAttribute("layoutRelativeWidth");
+ getWidget().layoutRelativeHeight = uidl
+ .hasAttribute("layoutRelativeHeight");
+
+ if (getWidget().dynamicWidth
+ && getWidget().layoutRelativeWidth) {
+ /*
+ * Relative layout width, fix window width before rendering (width
+ * according to caption)
+ */
+ getWidget().setNaturalWidth();
+ }
+
+ getWidget().layout.updateFromUIDL(childUidl, client);
+ if (!getWidget().dynamicHeight
+ && getWidget().layoutRelativeWidth) {
+ /*
+ * Relative layout width, and fixed height. Must update the size to
+ * be able to take scrollbars into account (layout gets narrower
+ * space if it is higher than the window) -> only vertical scrollbar
+ */
+ client.runDescendentsLayout(getWidget());
+ }
+
+ /*
+ * No explicit width is set and the layout does not have relative width
+ * so fix the size according to the layout.
+ */
+ if (getWidget().dynamicWidth
+ && !getWidget().layoutRelativeWidth) {
+ getWidget().setNaturalWidth();
+ }
+
+ if (getWidget().dynamicHeight
+ && getWidget().layoutRelativeHeight) {
+ // Prevent resizing until height has been fixed
+ getWidget().resizable = false;
+ }
+
+ // we may have actions and notifications
+ if (uidl.getChildCount() > 1) {
+ final int cnt = uidl.getChildCount();
+ for (int i = 1; i < cnt; i++) {
+ childUidl = uidl.getChildUIDL(i);
+ if (childUidl.getTag().equals("actions")) {
+ if (getWidget().shortcutHandler == null) {
+ getWidget().shortcutHandler = new ShortcutActionHandler(
+ getId(), client);
+ }
+ getWidget().shortcutHandler
+ .updateActionMap(childUidl);
+ }
+ }
+
+ }
+
+ // setting scrollposition must happen after children is rendered
+ getWidget().contentPanel.setScrollPosition(uidl
+ .getIntVariable("scrollTop"));
+ getWidget().contentPanel.setHorizontalScrollPosition(uidl
+ .getIntVariable("scrollLeft"));
+
+ // Center this window on screen if requested
+ // This has to be here because we might not know the content size before
+ // everything is painted into the window
+ if (uidl.getBooleanAttribute("center")) {
+ // mark as centered - this is unset on move/resize
+ getWidget().centered = true;
+ getWidget().center();
+ } else {
+ // don't try to center the window anymore
+ getWidget().centered = false;
+ }
+ getWidget().updateShadowSizeAndPosition();
+ getWidget().setVisible(true);
+
+ boolean sizeReduced = false;
+ // ensure window is not larger than browser window
+ if (getWidget().getOffsetWidth() > Window.getClientWidth()) {
+ getWidget().setWidth(Window.getClientWidth() + "px");
+ sizeReduced = true;
+ }
+ if (getWidget().getOffsetHeight() > Window
+ .getClientHeight()) {
+ getWidget().setHeight(Window.getClientHeight() + "px");
+ sizeReduced = true;
+ }
+
+ if (getWidget().dynamicHeight
+ && getWidget().layoutRelativeHeight) {
+ /*
+ * Window height is undefined, layout is 100% high so the layout
+ * should define the initial window height but on resize the layout
+ * should be as high as the window. We fix the height to deal with
+ * this.
+ */
+
+ int h = getWidget().contents.getOffsetHeight()
+ + getWidget().getExtraHeight();
+ int w = getWidget().getElement().getOffsetWidth();
+
+ client.updateVariable(getId(), "height", h, false);
+ client.updateVariable(getId(), "width", w, true);
+ }
+
+ if (sizeReduced) {
+ // If we changed the size we need to update the size of the child
+ // component if it is relative (#3407)
+ client.runDescendentsLayout(getWidget());
+ }
+
+ Util.runWebkitOverflowAutoFix(getWidget().contentPanel
+ .getElement());
+
+ client.getView().getWidget().scrollIntoView(uidl);
+
+ if (uidl.hasAttribute("bringToFront")) {
+ /*
+ * Focus as a side-efect. Will be overridden by
+ * ApplicationConnection if another component was focused by the
+ * server side.
+ */
+ getWidget().contentPanel.focus();
+ getWidget().bringToFrontSequence = uidl
+ .getIntAttribute("bringToFront");
+ VWindow.deferOrdering();
+ }
+ }
+
+ public void updateCaption(ComponentConnector component, UIDL uidl) {
+ // NOP, window has own caption, layout captio not rendered
+ }
+
+ public void onBeforeShortcutAction(Event e) {
+ // NOP, nothing to update just avoid workaround ( causes excess
+ // blur/focus )
+ }
+
+ @Override
+ public VWindow getWidget() {
+ return (VWindow) super.getWidget();
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VWindow.class);
+ }
+
+ public void layout() {
+ getWidget().requestLayout();
+ }
+
+ public void postLayout() {
+ VWindow window = getWidget();
+ if (window.centered) {
+ window.center();
+ window.updateShadowSizeAndPosition();
+ }
+ }
+
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui.label;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.dom.client.Document;
+import com.google.gwt.dom.client.PreElement;
+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.Util;
+import com.vaadin.terminal.gwt.client.ui.AbstractComponentConnector;
+
+public class LabelConnector extends AbstractComponentConnector {
+ public LabelConnector() {
+ }
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ super.updateFromUIDL(uidl, client);
+ getWidget().setConnection(client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ boolean sinkOnloads = false;
+
+ final String mode = uidl.getStringAttribute("mode");
+ if (mode == null || "text".equals(mode)) {
+ getWidget().setText(uidl.getChildString(0));
+ } else if ("pre".equals(mode)) {
+ PreElement preElement = Document.get().createPreElement();
+ preElement.setInnerText(uidl.getChildUIDL(0).getChildString(0));
+ // clear existing content
+ getWidget().setHTML("");
+ // add preformatted text to dom
+ getWidget().getElement().appendChild(preElement);
+ } else if ("uidl".equals(mode)) {
+ getWidget().setHTML(uidl.getChildrenAsXML());
+ } else if ("xhtml".equals(mode)) {
+ UIDL content = uidl.getChildUIDL(0).getChildUIDL(0);
+ if (content.getChildCount() > 0) {
+ getWidget().setHTML(content.getChildString(0));
+ } else {
+ getWidget().setHTML("");
+ }
+ sinkOnloads = true;
+ } else if ("xml".equals(mode)) {
+ getWidget().setHTML(uidl.getChildUIDL(0).getChildString(0));
+ } else if ("raw".equals(mode)) {
+ getWidget().setHTML(uidl.getChildUIDL(0).getChildString(0));
+ sinkOnloads = true;
+ } else {
+ getWidget().setText("");
+ }
+ if (sinkOnloads) {
+ Util.sinkOnloadForImages(getWidget().getElement());
+ }
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VLabel.class);
+ }
+
+ @Override
+ public VLabel getWidget() {
+ return (VLabel) super.getWidget();
+ }
+
+}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui.label;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.dom.client.Document;
-import com.google.gwt.dom.client.PreElement;
-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.Util;
-import com.vaadin.terminal.gwt.client.ui.AbstractComponentConnector;
-
-public class VLabelPaintable extends AbstractComponentConnector {
- public VLabelPaintable() {
- }
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- super.updateFromUIDL(uidl, client);
- getWidget().setConnection(client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- boolean sinkOnloads = false;
-
- final String mode = uidl.getStringAttribute("mode");
- if (mode == null || "text".equals(mode)) {
- getWidget().setText(uidl.getChildString(0));
- } else if ("pre".equals(mode)) {
- PreElement preElement = Document.get().createPreElement();
- preElement.setInnerText(uidl.getChildUIDL(0).getChildString(0));
- // clear existing content
- getWidget().setHTML("");
- // add preformatted text to dom
- getWidget().getElement().appendChild(preElement);
- } else if ("uidl".equals(mode)) {
- getWidget().setHTML(uidl.getChildrenAsXML());
- } else if ("xhtml".equals(mode)) {
- UIDL content = uidl.getChildUIDL(0).getChildUIDL(0);
- if (content.getChildCount() > 0) {
- getWidget().setHTML(content.getChildString(0));
- } else {
- getWidget().setHTML("");
- }
- sinkOnloads = true;
- } else if ("xml".equals(mode)) {
- getWidget().setHTML(
- uidl.getChildUIDL(0).getChildString(0));
- } else if ("raw".equals(mode)) {
- getWidget().setHTML(
- uidl.getChildUIDL(0).getChildString(0));
- sinkOnloads = true;
- } else {
- getWidget().setText("");
- }
- if (sinkOnloads) {
- Util.sinkOnloadForImages(getWidget().getElement());
- }
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VLabel.class);
- }
-
- @Override
- public VLabel getWidget() {
- return (VLabel) super.getWidget();
- }
-
-}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui.layout;
+
+import com.vaadin.terminal.gwt.client.LayoutManager;
+import com.vaadin.terminal.gwt.client.VCaption;
+import com.vaadin.terminal.gwt.client.ComponentConnector;
+import com.vaadin.terminal.gwt.client.ui.ManagedLayout;
+
+public class ComponentConnectorLayoutSlot extends VLayoutSlot {
+
+ final ComponentConnector paintable;
+ private LayoutManager layoutManager;
+
+ public ComponentConnectorLayoutSlot(String baseClassName, ComponentConnector paintable) {
+ super(baseClassName, paintable.getWidget());
+ this.paintable = paintable;
+ layoutManager = paintable.getLayoutManager();
+ }
+
+ public ComponentConnector getPaintable() {
+ return paintable;
+ }
+
+ @Override
+ protected int getCaptionHeight() {
+ VCaption caption = getCaption();
+ return caption != null ? layoutManager.getOuterHeight(caption
+ .getElement()) : 0;
+ }
+
+ @Override
+ protected int getCaptionWidth() {
+ VCaption caption = getCaption();
+ return caption != null ? layoutManager.getOuterWidth(caption
+ .getElement()) : 0;
+ }
+
+ @Override
+ public void setCaption(VCaption caption) {
+ VCaption oldCaption = getCaption();
+ if (oldCaption != null) {
+ layoutManager.unregisterDependency(
+ (ManagedLayout) paintable.getParent(),
+ oldCaption.getElement());
+ }
+ super.setCaption(caption);
+ if (caption != null) {
+ layoutManager
+ .registerDependency((ManagedLayout) paintable.getParent(),
+ caption.getElement());
+ }
+ }
+
+ @Override
+ public int getWidgetHeight() {
+ return layoutManager.getOuterHeight(paintable.getWidget()
+ .getElement());
+ }
+
+ @Override
+ public int getWidgetWidth() {
+ return layoutManager.getOuterWidth(paintable.getWidget()
+ .getElement());
+ }
+
+ @Override
+ public boolean isUndefinedHeight() {
+ return paintable.isUndefinedHeight();
+ }
+
+ @Override
+ public boolean isUndefinedWidth() {
+ return paintable.isUndefinedWidth();
+ }
+
+ @Override
+ public boolean isRelativeHeight() {
+ return paintable.isRelativeHeight();
+ }
+
+ @Override
+ public boolean isRelativeWidth() {
+ return paintable.isRelativeWidth();
+ }
+}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui.layout;
-
-import com.vaadin.terminal.gwt.client.LayoutManager;
-import com.vaadin.terminal.gwt.client.VCaption;
-import com.vaadin.terminal.gwt.client.ComponentConnector;
-import com.vaadin.terminal.gwt.client.ui.ManagedLayout;
-
-public class VPaintableLayoutSlot extends VLayoutSlot {
-
- final ComponentConnector paintable;
- private LayoutManager layoutManager;
-
- public VPaintableLayoutSlot(String baseClassName, ComponentConnector paintable) {
- super(baseClassName, paintable.getWidget());
- this.paintable = paintable;
- layoutManager = paintable.getLayoutManager();
- }
-
- public ComponentConnector getPaintable() {
- return paintable;
- }
-
- @Override
- protected int getCaptionHeight() {
- VCaption caption = getCaption();
- return caption != null ? layoutManager.getOuterHeight(caption
- .getElement()) : 0;
- }
-
- @Override
- protected int getCaptionWidth() {
- VCaption caption = getCaption();
- return caption != null ? layoutManager.getOuterWidth(caption
- .getElement()) : 0;
- }
-
- @Override
- public void setCaption(VCaption caption) {
- VCaption oldCaption = getCaption();
- if (oldCaption != null) {
- layoutManager.unregisterDependency(
- (ManagedLayout) paintable.getParent(),
- oldCaption.getElement());
- }
- super.setCaption(caption);
- if (caption != null) {
- layoutManager
- .registerDependency((ManagedLayout) paintable.getParent(),
- caption.getElement());
- }
- }
-
- @Override
- public int getWidgetHeight() {
- return layoutManager.getOuterHeight(paintable.getWidget()
- .getElement());
- }
-
- @Override
- public int getWidgetWidth() {
- return layoutManager.getOuterWidth(paintable.getWidget()
- .getElement());
- }
-
- @Override
- public boolean isUndefinedHeight() {
- return paintable.isUndefinedHeight();
- }
-
- @Override
- public boolean isUndefinedWidth() {
- return paintable.isUndefinedWidth();
- }
-
- @Override
- public boolean isRelativeHeight() {
- return paintable.isRelativeHeight();
- }
-
- @Override
- public boolean isRelativeWidth() {
- return paintable.isRelativeWidth();
- }
-}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.terminal.gwt.client.ui.richtextarea;
+
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.user.client.Event;
+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.AbstractComponentConnector;
+import com.vaadin.terminal.gwt.client.ui.ShortcutActionHandler.BeforeShortcutActionListener;
+
+public class RichTextAreaConnector extends AbstractComponentConnector implements
+ BeforeShortcutActionListener {
+
+ @Override
+ public void updateFromUIDL(final UIDL uidl, ApplicationConnection client) {
+ getWidget().client = client;
+ getWidget().id = uidl.getId();
+
+ if (uidl.hasVariable("text")) {
+ getWidget().currentValue = uidl.getStringVariable("text");
+ if (getWidget().rta.isAttached()) {
+ getWidget().rta.setHTML(getWidget().currentValue);
+ } else {
+ getWidget().html.setHTML(getWidget().currentValue);
+ }
+ }
+ if (isRealUpdate(uidl)) {
+ getWidget().setEnabled(!getState().isDisabled());
+ }
+
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+
+ getWidget().setReadOnly(getState().isReadOnly());
+ getWidget().immediate = getState().isImmediate();
+ int newMaxLength = uidl.hasAttribute("maxLength") ? uidl
+ .getIntAttribute("maxLength") : -1;
+ if (newMaxLength >= 0) {
+ if (getWidget().maxLength == -1) {
+ getWidget().keyPressHandler = getWidget().rta
+ .addKeyPressHandler(getWidget());
+ }
+ getWidget().maxLength = newMaxLength;
+ } else if (getWidget().maxLength != -1) {
+ getWidget().getElement().setAttribute("maxlength", "");
+ getWidget().maxLength = -1;
+ getWidget().keyPressHandler.removeHandler();
+ }
+
+ if (uidl.hasAttribute("selectAll")) {
+ getWidget().selectAll();
+ }
+
+ }
+
+ public void onBeforeShortcutAction(Event e) {
+ getWidget().synchronizeContentToServer();
+ }
+
+ @Override
+ public VRichTextArea getWidget() {
+ return (VRichTextArea) super.getWidget();
+ };
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VRichTextArea.class);
+ }
+
+}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.terminal.gwt.client.ui.richtextarea;
-
-import com.google.gwt.core.client.GWT;
-import com.google.gwt.user.client.Event;
-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.ShortcutActionHandler.BeforeShortcutActionListener;
-import com.vaadin.terminal.gwt.client.ui.AbstractComponentConnector;
-
-public class VRichTextAreaPaintable extends AbstractComponentConnector implements
- BeforeShortcutActionListener {
-
- @Override
- public void updateFromUIDL(final UIDL uidl, ApplicationConnection client) {
- getWidget().client = client;
- getWidget().id = uidl.getId();
-
- if (uidl.hasVariable("text")) {
- getWidget().currentValue = uidl
- .getStringVariable("text");
- if (getWidget().rta.isAttached()) {
- getWidget().rta
- .setHTML(getWidget().currentValue);
- } else {
- getWidget().html
- .setHTML(getWidget().currentValue);
- }
- }
- if (isRealUpdate(uidl)) {
- getWidget().setEnabled(!getState().isDisabled());
- }
-
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
-
- getWidget().setReadOnly(getState().isReadOnly());
- getWidget().immediate = getState().isImmediate();
- int newMaxLength = uidl.hasAttribute("maxLength") ? uidl
- .getIntAttribute("maxLength") : -1;
- if (newMaxLength >= 0) {
- if (getWidget().maxLength == -1) {
- getWidget().keyPressHandler = getWidget().rta
- .addKeyPressHandler(getWidget());
- }
- getWidget().maxLength = newMaxLength;
- } else if (getWidget().maxLength != -1) {
- getWidget().getElement().setAttribute("maxlength", "");
- getWidget().maxLength = -1;
- getWidget().keyPressHandler.removeHandler();
- }
-
- if (uidl.hasAttribute("selectAll")) {
- getWidget().selectAll();
- }
-
- }
-
- public void onBeforeShortcutAction(Event e) {
- getWidget().synchronizeContentToServer();
- }
-
- @Override
- public VRichTextArea getWidget() {
- return (VRichTextArea) super.getWidget();
- };
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VRichTextArea.class);
- }
-
-}
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.ui.VViewPaintable;
+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;
*/
public class WidgetMapGenerator extends Generator {
- private static String paintableClassName = ComponentConnector.class.getName();
+ private static String paintableClassName = ComponentConnector.class
+ .getName();
private String packageName;
private String className;
if (widgetsWithInstantiator.contains(clientClass)) {
continue;
}
- if (clientClass == VViewPaintable.class) {
- // VView's are not instantiated by widgetset
+ if (clientClass == RootConnector.class) {
+ // Roots are not instantiated by widgetset
continue;
}
if (!first) {
sourceWriter.println(".class;}");
sourceWriter.print("else ");
}
- sourceWriter
- .println("return com.vaadin.terminal.gwt.client.ui.VUnknownComponentPaintable.class;");
+ sourceWriter.println("return "
+ + UnknownComponentConnector.class.getName() + ".class;");
sourceWriter.outdent();
sourceWriter.println("}");
Class<? extends Paintable> class1) {
Class<? extends com.vaadin.terminal.gwt.client.ComponentConnector> clientClass;
if (Root.class == class1) {
- clientClass = VViewPaintable.class;
+ clientClass = RootConnector.class;
} else {
ClientWidget annotation = class1.getAnnotation(ClientWidget.class);
clientClass = annotation.value();
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.Sizeable;
import com.vaadin.terminal.gwt.client.EventId;
-import com.vaadin.terminal.gwt.client.ui.VAbsoluteLayoutPaintable;
+import com.vaadin.terminal.gwt.client.ui.AbsoluteLayoutConnector;
/**
* AbsoluteLayout is a layout implementation that mimics html absolute
*
*/
@SuppressWarnings("serial")
-@ClientWidget(VAbsoluteLayoutPaintable.class)
+@ClientWidget(AbsoluteLayoutConnector.class)
public class AbsoluteLayout extends AbstractLayout implements
LayoutClickNotifier {
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.Resource;
-import com.vaadin.terminal.gwt.client.ui.VMediaBasePaintable;
+import com.vaadin.terminal.gwt.client.ui.MediaBaseConnector;
/**
* Abstract base class for the HTML5 media components.
@Override
public void paintContent(PaintTarget target) throws PaintException {
super.paintContent(target);
- target.addAttribute(VMediaBasePaintable.ATTR_CONTROLS, isShowControls());
+ target.addAttribute(MediaBaseConnector.ATTR_CONTROLS, isShowControls());
if (getAltText() != null) {
- target.addAttribute(VMediaBasePaintable.ATTR_ALT_TEXT, getAltText());
+ target.addAttribute(MediaBaseConnector.ATTR_ALT_TEXT, getAltText());
}
- target.addAttribute(VMediaBasePaintable.ATTR_HTML,
+ target.addAttribute(MediaBaseConnector.ATTR_HTML,
isHtmlContentAllowed());
- target.addAttribute(VMediaBasePaintable.ATTR_AUTOPLAY, isAutoplay());
+ target.addAttribute(MediaBaseConnector.ATTR_AUTOPLAY, isAutoplay());
for (Resource r : getSources()) {
- target.startTag(VMediaBasePaintable.TAG_SOURCE);
- target.addAttribute(VMediaBasePaintable.ATTR_RESOURCE, r);
- target.addAttribute(VMediaBasePaintable.ATTR_RESOURCE_TYPE,
+ target.startTag(MediaBaseConnector.TAG_SOURCE);
+ target.addAttribute(MediaBaseConnector.ATTR_RESOURCE, r);
+ target.addAttribute(MediaBaseConnector.ATTR_RESOURCE_TYPE,
r.getMIMEType());
- target.endTag(VMediaBasePaintable.TAG_SOURCE);
+ target.endTag(MediaBaseConnector.TAG_SOURCE);
}
- target.addAttribute(VMediaBasePaintable.ATTR_MUTED, isMuted());
+ target.addAttribute(MediaBaseConnector.ATTR_MUTED, isMuted());
if (play) {
- target.addAttribute(VMediaBasePaintable.ATTR_PLAY, true);
+ target.addAttribute(MediaBaseConnector.ATTR_PLAY, true);
play = false;
}
if (pause) {
- target.addAttribute(VMediaBasePaintable.ATTR_PAUSE, true);
+ target.addAttribute(MediaBaseConnector.ATTR_PAUSE, true);
pause = false;
}
}
import com.vaadin.terminal.gwt.client.ui.dd.VIsOverId;
import com.vaadin.terminal.gwt.client.ui.dd.VItemIdIs;
import com.vaadin.terminal.gwt.client.ui.dd.VerticalDropLocation;
+import com.vaadin.ui.AbstractSelect.ItemCaptionMode;
/**
* <p>
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.Sizeable;
import com.vaadin.terminal.gwt.client.MouseEventDetails;
-import com.vaadin.terminal.gwt.client.ui.VAbstractSplitPanelPaintable;
+import com.vaadin.terminal.gwt.client.ui.AbstractSplitPanelConnector;
import com.vaadin.tools.ReflectTools;
/**
private boolean locked = false;
- private static final String SPLITTER_CLICK_EVENT = VAbstractSplitPanelPaintable.SPLITTER_CLICK_EVENT_IDENTIFIER;
+ private static final String SPLITTER_CLICK_EVENT = AbstractSplitPanelConnector.SPLITTER_CLICK_EVENT_IDENTIFIER;
/**
* Modifiable and Serializable Iterator for the components, used by
*/
package com.vaadin.ui;
-import com.vaadin.terminal.gwt.client.ui.VAccordionPaintable;
+import com.vaadin.terminal.gwt.client.ui.AccordionConnector;
/**
* An accordion is a component similar to a {@link TabSheet}, but with a
*
* @see TabSheet
*/
-@ClientWidget(VAccordionPaintable.class)
+@ClientWidget(AccordionConnector.class)
public class Accordion extends TabSheet {
}
package com.vaadin.ui;
import com.vaadin.terminal.Resource;
-import com.vaadin.terminal.gwt.client.ui.VAudioPaintable;
+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(VAudioPaintable.class)
+@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.ButtonClientToServerRpc;
import com.vaadin.terminal.gwt.client.ui.ButtonState;
-import com.vaadin.terminal.gwt.client.ui.VButtonPaintable;
-import com.vaadin.terminal.gwt.client.ui.VButtonPaintable.ButtonClientToServerRpc;
import com.vaadin.terminal.gwt.server.RpcTarget;
import com.vaadin.tools.ReflectTools;
import com.vaadin.ui.ClientWidget.LoadStyle;
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(value = VButtonPaintable.class, loadStyle = LoadStyle.EAGER)
+@ClientWidget(value = ButtonConnector.class, loadStyle = LoadStyle.EAGER)
public class Button extends AbstractComponent implements
FieldEvents.BlurNotifier, FieldEvents.FocusNotifier, Focusable,
Action.ShortcutNotifier, RpcTarget {
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(com.vaadin.terminal.gwt.client.ui.VCheckBoxPaintable.class)
+@ClientWidget(CheckBoxConnector.class)
public class CheckBox extends AbstractField<Boolean> {
/**
* Creates a new checkbox.
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;
-import com.vaadin.terminal.gwt.client.ui.VFilterSelectPaintable;
/**
* A filtering dropdown single-select. Suitable for newItemsAllowed, but it's
*
*/
@SuppressWarnings("serial")
-@ClientWidget(VFilterSelectPaintable.class)
+@ClientWidget(ComboBoxConnector.class)
public class ComboBox extends Select {
private String inputPrompt = null;
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.Paintable;
import com.vaadin.terminal.gwt.client.EventId;
-import com.vaadin.terminal.gwt.client.ui.VCssLayoutPaintable;
+import com.vaadin.terminal.gwt.client.ui.CssLayoutConnector;
/**
* CssLayout is a layout component that can be used in browser environment only.
* @since 6.1 brought in from "FastLayouts" incubator project
*
*/
-@ClientWidget(VCssLayoutPaintable.class)
+@ClientWidget(CssLayoutConnector.class)
public class CssLayout extends AbstractLayout implements LayoutClickNotifier {
private static final String CLICK_EVENT = EventId.LAYOUT_CLICK;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.gwt.client.ui.VCustomComponentPaintable;
+import com.vaadin.terminal.gwt.client.ui.CustomComponentConnector;
import com.vaadin.ui.ClientWidget.LoadStyle;
/**
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(value = VCustomComponentPaintable.class, loadStyle = LoadStyle.EAGER)
+@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.VCustomComponentPaintable;
+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(VCustomComponentPaintable.class)
+@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.VCustomLayoutPaintable;
+import com.vaadin.terminal.gwt.client.ui.CustomLayoutConnector;
/**
* <p>
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(VCustomLayoutPaintable.class)
+@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;
-import com.vaadin.terminal.gwt.client.ui.VPopupCalendarPaintable;
/**
* <p>
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(VPopupCalendarPaintable.class)
+@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.VDragAndDropWrapperPaintable;
import com.vaadin.terminal.gwt.client.ui.dd.HorizontalDropLocation;
import com.vaadin.terminal.gwt.client.ui.dd.VerticalDropLocation;
@SuppressWarnings("serial")
-@ClientWidget(VDragAndDropWrapperPaintable.class)
+@ClientWidget(DragAndDropWrapperConnector.class)
public class DragAndDropWrapper extends CustomComponent implements DropTarget,
DragSource {
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.Resource;
import com.vaadin.terminal.gwt.client.MouseEventDetails;
-import com.vaadin.terminal.gwt.client.ui.VEmbeddedPaintable;
+import com.vaadin.terminal.gwt.client.ui.EmbeddedConnector;
/**
* Component for embedding external objects.
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(VEmbeddedPaintable.class)
+@ClientWidget(EmbeddedConnector.class)
public class Embedded extends AbstractComponent {
- private static final String CLICK_EVENT = VEmbeddedPaintable.CLICK_EVENT_IDENTIFIER;
+ private static final String CLICK_EVENT = EmbeddedConnector.CLICK_EVENT_IDENTIFIER;
/**
* General object type.
import com.vaadin.terminal.ErrorMessage;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.gwt.client.ui.VFormPaintable;
+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(VFormPaintable.class)
+@ClientWidget(FormConnector.class)
@Deprecated
public class Form extends AbstractField<Object> implements Item.Editor,
Buffered, Item, Validatable, Action.Notifier {
package com.vaadin.ui;
-import com.vaadin.terminal.gwt.client.ui.VFormLayoutPaintable;
+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(VFormLayoutPaintable.class)
+@ClientWidget(FormLayoutConnector.class)
public class FormLayout extends AbstractOrderedLayout {
public FormLayout() {
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.gwt.client.EventId;
-import com.vaadin.terminal.gwt.client.ui.VGridLayoutPaintable;
+import com.vaadin.terminal.gwt.client.ui.GridLayoutConnector;
/**
* <p>
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(VGridLayoutPaintable.class)
+@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.VHorizontalLayoutPaintable;
+import com.vaadin.terminal.gwt.client.ui.HorizontalLayoutConnector;
import com.vaadin.ui.ClientWidget.LoadStyle;
/**
* @since 5.3
*/
@SuppressWarnings("serial")
-@ClientWidget(value = VHorizontalLayoutPaintable.class, loadStyle = LoadStyle.EAGER)
+@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.VHorizontalSplitPanelPaintable;
+import com.vaadin.terminal.gwt.client.ui.HorizontalSplitPanelConnector;
import com.vaadin.ui.ClientWidget.LoadStyle;
/**
* @VERSION@
* @since 6.5
*/
-@ClientWidget(value = VHorizontalSplitPanelPaintable.class, loadStyle = LoadStyle.EAGER)
+@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.VDateFieldCalendarPaintable;
+import com.vaadin.terminal.gwt.client.ui.InlineDateFieldConnector;
/**
* <p>
* @VERSION@
* @since 5.0
*/
-@ClientWidget(VDateFieldCalendarPaintable.class)
+@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.VLabelPaintable;
+import com.vaadin.terminal.gwt.client.ui.label.LabelConnector;
import com.vaadin.ui.ClientWidget.LoadStyle;
/**
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(value = VLabelPaintable.class, loadStyle = LoadStyle.EAGER)
+@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.VLinkPaintable;
+import com.vaadin.terminal.gwt.client.ui.LinkConnector;
/**
* Link is used to create external or internal URL links.
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(VLinkPaintable.class)
+@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.VListSelectPaintable;
+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(VListSelectPaintable.class)
+@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.terminal.gwt.client.ui.VMenuBarPaintable;
import com.vaadin.ui.ClientWidget.LoadStyle;
/**
* </p>
*/
@SuppressWarnings("serial")
-@ClientWidget(value = VMenuBarPaintable.class, loadStyle = LoadStyle.LAZY)
+@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.VNativeButtonPaintable;
+import com.vaadin.terminal.gwt.client.ui.NativeButtonConnector;
@SuppressWarnings("serial")
-@ClientWidget(VNativeButtonPaintable.class)
+@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.VNativeSelectPaintable;
+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(VNativeSelectPaintable.class)
+@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;
-import com.vaadin.terminal.gwt.client.ui.VOptionGroupPaintable;
/**
* Configures select to be used as an option group.
*/
@SuppressWarnings("serial")
-@ClientWidget(VOptionGroupPaintable.class)
+@ClientWidget(OptionGroupConnector.class)
public class OptionGroup extends AbstractSelect implements
FieldEvents.BlurNotifier, FieldEvents.FocusNotifier {
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.Scrollable;
import com.vaadin.terminal.gwt.client.MouseEventDetails;
-import com.vaadin.terminal.gwt.client.ui.VPanelPaintable;
+import com.vaadin.terminal.gwt.client.ui.PanelConnector;
import com.vaadin.ui.Component.Focusable;
import com.vaadin.ui.themes.Reindeer;
import com.vaadin.ui.themes.Runo;
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(VPanelPaintable.class)
+@ClientWidget(PanelConnector.class)
public class Panel extends AbstractComponentContainer implements Scrollable,
ComponentContainer.ComponentAttachListener,
ComponentContainer.ComponentDetachListener, Action.Notifier, Focusable {
- private static final String CLICK_EVENT = VPanelPaintable.CLICK_EVENT_IDENTIFIER;
+ private static final String CLICK_EVENT = PanelConnector.CLICK_EVENT_IDENTIFIER;
/**
* Removes extra decorations from the Panel.
package com.vaadin.ui;
import com.vaadin.data.Property;
-import com.vaadin.terminal.gwt.client.ui.VPasswordFieldPaintable;
+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(VPasswordFieldPaintable.class)
+@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.VPopupViewPaintable;
+import com.vaadin.terminal.gwt.client.ui.PopupViewConnector;
/**
*
* @author Vaadin Ltd.
*/
@SuppressWarnings("serial")
-@ClientWidget(VPopupViewPaintable.class)
+@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.VProgressIndicatorPaintable;
+import com.vaadin.terminal.gwt.client.ui.ProgressIndicatorConnector;
/**
* <code>ProgressIndicator</code> is component that shows user state of a
* @since 4
*/
@SuppressWarnings("serial")
-@ClientWidget(VProgressIndicatorPaintable.class)
+@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.VRichTextAreaPaintable;
+import com.vaadin.terminal.gwt.client.ui.richtextarea.RichTextAreaConnector;
import com.vaadin.ui.ClientWidget.LoadStyle;
/**
* {@link RichTextArea} may produce unexpected results as formatting is counted
* into length of field.
*/
-@ClientWidget(value = VRichTextAreaPaintable.class, loadStyle = LoadStyle.LAZY)
+@ClientWidget(value = RichTextAreaConnector.class, loadStyle = LoadStyle.LAZY)
public class RichTextArea extends AbstractField<String> {
/**
*
* @since 7.0
*/
-// @ClientWidget(VView.class) - Can't have annotation because of eager
+// @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.PaintTarget;
import com.vaadin.terminal.Resource;
import com.vaadin.terminal.gwt.client.ui.AbstractComponentConnector;
-import com.vaadin.terminal.gwt.client.ui.VFilterSelectPaintable;
+import com.vaadin.terminal.gwt.client.ui.ComboBoxConnector;
/**
* <p>
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(VFilterSelectPaintable.class)
+@ClientWidget(ComboBoxConnector.class)
public class Select extends AbstractSelect implements AbstractSelect.Filtering,
FieldEvents.BlurNotifier, FieldEvents.FocusNotifier {
// Hide the error indicator if needed
if (shouldHideErrors()) {
- target.addAttribute(AbstractComponentConnector.ATTRIBUTE_HIDEERRORS,
- true);
+ target.addAttribute(
+ AbstractComponentConnector.ATTRIBUTE_HIDEERRORS, true);
}
}
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.gwt.client.ui.VSliderPaintable;
+import com.vaadin.terminal.gwt.client.ui.SliderConnector;
/**
* A component for selecting a numerical value within a range.
*
* @author Vaadin Ltd.
*/
-@ClientWidget(VSliderPaintable.class)
+@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.AbstractComponentConnector;
+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.terminal.gwt.client.ui.VTabsheetBasePaintable;
-import com.vaadin.terminal.gwt.client.ui.VTabsheetPaintable;
import com.vaadin.terminal.gwt.server.CommunicationManager;
import com.vaadin.ui.themes.Reindeer;
import com.vaadin.ui.themes.Runo;
* @VERSION@
* @since 3.0
*/
-@ClientWidget(VTabsheetPaintable.class)
+@ClientWidget(TabsheetConnector.class)
public class TabSheet extends AbstractComponentContainer {
/**
target.startTag("tab");
if (!tab.isEnabled() && tab.isVisible()) {
target.addAttribute(
- VTabsheetBasePaintable.ATTRIBUTE_TAB_DISABLED, true);
+ TabsheetBaseConnector.ATTRIBUTE_TAB_DISABLED, true);
}
if (!tab.isVisible()) {
final String caption = tab.getCaption();
if (caption != null && caption.length() > 0) {
target.addAttribute(
- VTabsheetBasePaintable.ATTRIBUTE_TAB_CAPTION, caption);
+ TabsheetBaseConnector.ATTRIBUTE_TAB_CAPTION, caption);
}
final String description = tab.getDescription();
if (description != null) {
target.addAttribute(
- VTabsheetBasePaintable.ATTRIBUTE_TAB_DESCRIPTION,
+ TabsheetBaseConnector.ATTRIBUTE_TAB_DESCRIPTION,
description);
}
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.VScrollTablePaintable;
import com.vaadin.terminal.gwt.client.ui.dd.VLazyInitItemIdentifiers;
/**
* @since 3.0
*/
@SuppressWarnings({ "deprecation" })
-@ClientWidget(VScrollTablePaintable.class)
+@ClientWidget(TableConnector.class)
public class Table extends AbstractSelect implements Action.Container,
Container.Ordered, Container.Sortable, ItemClickSource,
ItemClickNotifier, DragSource, DropTarget {
import com.vaadin.data.Property;
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
-import com.vaadin.terminal.gwt.client.ui.VTextAreaPaintable;
+import com.vaadin.terminal.gwt.client.ui.TextAreaConnector;
/**
* A text field that supports multi line editing.
*/
-@ClientWidget(VTextAreaPaintable.class)
+@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.VTextFieldPaintable;
+import com.vaadin.terminal.gwt.client.ui.TextFieldConnector;
import com.vaadin.ui.ClientWidget.LoadStyle;
/**
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(value = VTextFieldPaintable.class, loadStyle = LoadStyle.EAGER)
+@ClientWidget(value = TextFieldConnector.class, loadStyle = LoadStyle.EAGER)
public class TextField extends AbstractTextField {
/**
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.Resource;
import com.vaadin.terminal.gwt.client.MouseEventDetails;
+import com.vaadin.terminal.gwt.client.ui.TreeConnector;
import com.vaadin.terminal.gwt.client.ui.VTree;
-import com.vaadin.terminal.gwt.client.ui.VTreePaintable;
import com.vaadin.terminal.gwt.client.ui.dd.VLazyInitItemIdentifiers;
import com.vaadin.terminal.gwt.client.ui.dd.VTargetInSubtree;
import com.vaadin.terminal.gwt.client.ui.dd.VerticalDropLocation;
* @since 3.0
*/
@SuppressWarnings({ "serial", "deprecation" })
-@ClientWidget(VTreePaintable.class)
+@ClientWidget(TreeConnector.class)
public class Tree extends AbstractSelect implements Container.Hierarchical,
Action.Container, ItemClickSource, ItemClickNotifier, DragSource,
DropTarget {
if (itemStyleGenerator != null) {
String stylename = itemStyleGenerator.getStyle(itemId);
if (stylename != null) {
- target.addAttribute(
- VTreePaintable.ATTRIBUTE_NODE_STYLE, stylename);
+ target.addAttribute(TreeConnector.ATTRIBUTE_NODE_STYLE,
+ stylename);
}
}
}
// Adds the attributes
- target.addAttribute(VTreePaintable.ATTRIBUTE_NODE_CAPTION,
+ target.addAttribute(TreeConnector.ATTRIBUTE_NODE_CAPTION,
getItemCaption(itemId));
final Resource icon = getItemIcon(itemId);
if (icon != null) {
- target.addAttribute(VTreePaintable.ATTRIBUTE_NODE_ICON,
+ target.addAttribute(TreeConnector.ATTRIBUTE_NODE_ICON,
getItemIcon(itemId));
}
final String key = itemIdMapper.key(itemId);
final Action a = i.next();
target.startTag("action");
if (a.getCaption() != null) {
- target.addAttribute(
- VTreePaintable.ATTRIBUTE_ACTION_CAPTION,
+ target.addAttribute(TreeConnector.ATTRIBUTE_ACTION_CAPTION,
a.getCaption());
}
if (a.getIcon() != null) {
- target.addAttribute(VTreePaintable.ATTRIBUTE_ACTION_ICON,
+ target.addAttribute(TreeConnector.ATTRIBUTE_ACTION_ICON,
a.getIcon());
}
target.addAttribute("key", actionMapper.key(a));
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.Resource;
-import com.vaadin.terminal.gwt.client.ui.VTreeTablePaintable;
+import com.vaadin.terminal.gwt.client.ui.TreeTableConnector;
import com.vaadin.ui.Tree.CollapseEvent;
import com.vaadin.ui.Tree.CollapseListener;
import com.vaadin.ui.Tree.ExpandEvent;
* share UI state in the container.
*/
@SuppressWarnings({ "serial" })
-@ClientWidget(VTreeTablePaintable.class)
+@ClientWidget(TreeTableConnector.class)
public class TreeTable extends Table implements Hierarchical {
private static final Logger logger = Logger.getLogger(TreeTable.class
Object object = visibleColumns2[i];
if (hierarchyColumnId.equals(object)) {
target.addAttribute(
- VTreeTablePaintable.ATTRIBUTE_HIERARCHY_COLUMN_INDEX,
+ TreeTableConnector.ATTRIBUTE_HIERARCHY_COLUMN_INDEX,
i);
break;
}
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;
-import com.vaadin.terminal.gwt.client.ui.VTwinColSelectPaintable;
/**
* Multiselect component with two lists: left side for available items and right
* side for selected items.
*/
@SuppressWarnings("serial")
-@ClientWidget(VTwinColSelectPaintable.class)
+@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.VUploadPaintable;
+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;
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(value = VUploadPaintable.class, loadStyle = LoadStyle.LAZY)
+@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.VVerticalLayoutPaintable;
+import com.vaadin.terminal.gwt.client.ui.VerticalLayoutConnector;
import com.vaadin.ui.ClientWidget.LoadStyle;
/**
* @since 5.3
*/
@SuppressWarnings("serial")
-@ClientWidget(value = VVerticalLayoutPaintable.class, loadStyle = LoadStyle.EAGER)
+@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.VVerticalSplitPanelPaintable;
+import com.vaadin.terminal.gwt.client.ui.VerticalSplitPanelConnector;
import com.vaadin.ui.ClientWidget.LoadStyle;
/**
* </pre>
*
*/
-@ClientWidget(value = VVerticalSplitPanelPaintable.class, loadStyle = LoadStyle.EAGER)
+@ClientWidget(value = VerticalSplitPanelConnector.class, loadStyle = LoadStyle.EAGER)
public class VerticalSplitPanel extends AbstractSplitPanel {
public VerticalSplitPanel() {
import com.vaadin.terminal.PaintException;
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.Resource;
-import com.vaadin.terminal.gwt.client.ui.VVideoPaintable;
+import com.vaadin.terminal.gwt.client.ui.VideoConnector;
/**
* The Video component translates into an HTML5 <video> element and as
* @author Vaadin Ltd
* @since 6.7.0
*/
-@ClientWidget(VVideoPaintable.class)
+@ClientWidget(VideoConnector.class)
public class Video extends AbstractMedia {
private Resource poster;
public void paintContent(PaintTarget target) throws PaintException {
super.paintContent(target);
if (getPoster() != null) {
- target.addAttribute(VVideoPaintable.ATTR_POSTER, getPoster());
+ target.addAttribute(VideoConnector.ATTR_POSTER, getPoster());
}
}
}
import com.vaadin.terminal.PaintTarget;
import com.vaadin.terminal.Sizeable;
import com.vaadin.terminal.gwt.client.ui.VView;
-import com.vaadin.terminal.gwt.client.ui.VWindowPaintable;
+import com.vaadin.terminal.gwt.client.ui.WindowConnector;
/**
* A component that represents an application (browser native) window or a sub
* @since 3.0
*/
@SuppressWarnings("serial")
-@ClientWidget(VWindowPaintable.class)
+@ClientWidget(WindowConnector.class)
public class Window extends Panel implements FocusNotifier, BlurNotifier {
/**
* Check the @ClientWidget
*
*/
- @ClientWidget(VMyDropTargetPaintable.class)
+ @ClientWidget(MyDropTargetConnector.class)
class MyDropTarget extends AbstractComponent implements DropTarget {
public DropHandler getDropHandler() {
return new DropHandler() {
* operations that are controlled via server side api.
*
*/
- @ClientWidget(VMyDragSourcePaintable.class)
+ @ClientWidget(MyDragSourceConnector.class)
public class MyDragSource extends AbstractComponent implements Component {
}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.tests.dd;
+
+import com.google.gwt.core.client.GWT;
+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.AbstractComponentConnector;
+
+public class MyDragSourceConnector extends AbstractComponentConnector {
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VMyDragSource.class);
+ }
+
+}
--- /dev/null
+/*
+@VaadinApache2LicenseForJavaFiles@
+ */
+package com.vaadin.tests.dd;
+
+import com.google.gwt.core.client.GWT;
+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.AbstractComponentConnector;
+
+public class MyDropTargetConnector extends AbstractComponentConnector {
+
+ @Override
+ public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ super.updateFromUIDL(uidl, client);
+ if (!isRealUpdate(uidl)) {
+ return;
+ }
+ getWidget().client = client;
+ }
+
+ @Override
+ public VMyDropTarget getWidget() {
+ return (VMyDropTarget) super.getWidget();
+ }
+
+ @Override
+ protected Widget createWidget() {
+ return GWT.create(VMyDropTarget.class);
+ }
+
+}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.tests.dd;
-
-import com.google.gwt.core.client.GWT;
-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.AbstractComponentConnector;
-
-public class VMyDragSourcePaintable extends AbstractComponentConnector {
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VMyDragSource.class);
- }
-
-}
+++ /dev/null
-/*
-@VaadinApache2LicenseForJavaFiles@
- */
-package com.vaadin.tests.dd;
-
-import com.google.gwt.core.client.GWT;
-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.AbstractComponentConnector;
-
-public class VMyDropTargetPaintable extends AbstractComponentConnector {
-
- @Override
- public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- super.updateFromUIDL(uidl, client);
- if (!isRealUpdate(uidl)) {
- return;
- }
- getWidget().client = client;
- }
-
- @Override
- public VMyDropTarget getWidget() {
- return (VMyDropTarget) super.getWidget();
- }
-
- @Override
- protected Widget createWidget() {
- return GWT.create(VMyDropTarget.class);
- }
-
-}
projects / vaadin-framework.git / commitdiff