if (loadElement == null) {
loadElement = DOM.createDiv();
DOM.setStyleAttribute(loadElement, "position", "absolute");
- DOM.appendChild(view.getWidgetForPaintable().getElement(),
+ DOM.appendChild(view.getWidget().getElement(),
loadElement);
VConsole.log("inserting load indicator");
}
meta = json.getValueMap("meta");
if (meta.containsKey("repaintAll")) {
repaintAll = true;
- view.getWidgetForPaintable().clear();
+ view.getWidget().clear();
getPaintableMap().clear();
if (meta.containsKey("invalidLayouts")) {
validatingLayouts = true;
@Override
public void run() {
VConsole.log("Running re-layout of " + view.getClass().getName());
- runDescendentsLayout(view.getWidgetForPaintable());
+ runDescendentsLayout(view.getWidget());
isPending = false;
}
};
// find the Paintable for all but very special cases (like
// overlays).
w = ((VPaintableWidget) VPaintableMap.get(client).getPaintable(pid))
- .getWidgetForPaintable();
+ .getWidget();
/*
* Still if the Paintable contains a widget that implements
} else if (w instanceof VWindow) {
VWindow win = (VWindow) w;
ArrayList<VWindow> subWindowList = client.getView()
- .getWidgetForPaintable().getSubWindowList();
+ .getWidget().getSubWindowList();
int indexOfSubWindow = subWindowList.indexOf(win);
return PARENTCHILD_SEPARATOR + "VWindow[" + indexOfSubWindow + "]";
} else if (w instanceof RootPanel) {
if (part.equals(ROOT_ID)) {
w = RootPanel.get();
} else if (part.equals("")) {
- w = client.getView().getWidgetForPaintable();
+ w = client.getView().getWidget();
} else if (w == null) {
// Must be static pid (PID_S*)
w = ((VPaintableWidget) VPaintableMap.get(client).getPaintable(
- part)).getWidgetForPaintable();
+ part)).getWidget();
} else if (part.startsWith("domChild[")) {
// The target widget has been found and the rest identifies the
// element
* compatibility
*/
if (widgetClassName.equals("VWindow")) {
- iterator = client.getView().getWidgetForPaintable()
+ iterator = client.getView().getWidget()
.getSubWindowList().iterator();
} else if (widgetClassName.equals("VContextMenu")) {
return client.getContextMenu();
}-*/;
private static final MeasuredSize getMeasuredSize(VPaintableWidget paintable) {
- Element element = paintable.getWidgetForPaintable().getElement();
+ Element element = paintable.getWidget().getElement();
MeasuredSize measuredSize = getMeasuredSize(element, null);
if (measuredSize == null) {
measuredSize = new MeasuredSize();
private void measureElements(VPaintableWidget[] paintableWidgets) {
for (VPaintableWidget paintableWidget : paintableWidgets) {
- Element element = paintableWidget.getWidgetForPaintable()
+ Element element = paintableWidget.getWidget()
.getElement();
MeasuredSize measuredSize = getMeasuredSize(paintableWidget);
measuredAndUpdate(element, measuredSize);
* the responsibility of reacting to ONLOAD from VCaption to layouts
*/
if (owner != null) {
- Util.notifyParentOfSizeChange(owner.getWidgetForPaintable(),
- true);
+ Util.notifyParentOfSizeChange(owner.getWidget(), true);
} else {
VConsole.log("Warning: Icon load event was not propagated because VCaption owner is unknown.");
}
caption = new VCaption(toBeWrapped, client);
add(caption);
paintable = toBeWrapped;
- add(paintable.getWidgetForPaintable());
+ add(paintable.getWidget());
setStyleName(CLASSNAME);
}
for (ApplicationConnection a : ApplicationConfiguration
.getRunningApplications()) {
VPaintableWidget paintable = Util.getPaintableForElement(a,
- a.getView().getWidgetForPaintable(), eventTarget);
+ a.getView().getWidget(), eventTarget);
if (paintable == null) {
paintable = Util.getPaintableForElement(a,
RootPanel.get(), eventTarget);
for (ApplicationConnection a : ApplicationConfiguration
.getRunningApplications()) {
VPaintableWidget paintable = Util.getPaintableForElement(a,
- a.getView().getWidgetForPaintable(), eventTarget);
+ a.getView().getWidget(), eventTarget);
if (paintable == null) {
paintable = Util.getPaintableForElement(a,
RootPanel.get(), eventTarget);
private void printClientSideDetectedIssues(
Set<VPaintableWidget> zeroHeightComponents, ApplicationConnection ac) {
for (final VPaintableWidget paintable : zeroHeightComponents) {
- final Widget layout = paintable.getParent().getWidgetForPaintable();
+ final Widget layout = paintable.getParent().getWidget();
VerticalPanel errorDetails = new VerticalPanel();
errorDetails.add(new Label("" + Util.getSimpleName(paintable)
emphasisInUi.addClickHandler(new ClickHandler() {
public void onClick(ClickEvent event) {
if (paintable != null) {
- Element element2 = paintable.getWidgetForPaintable()
+ Element element2 = paintable.getWidget()
.getElement();
Widget.setStyleName(element2, "invalidlayout",
emphasisInUi.getValue());
@Deprecated
public Widget getWidget(VPaintableWidget paintable) {
- return paintable.getWidgetForPaintable();
+ return paintable.getWidget();
}
@Deprecated
idToPaintable.put(pid, paintable);
if (paintable instanceof VPaintableWidget) {
VPaintableWidget pw = (VPaintableWidget) paintable;
- setPid(pw.getWidgetForPaintable().getElement(), pid);
+ setPid(pw.getWidget().getElement(), pid);
}
}
public Element getElement(String pid) {
VPaintable p = getPaintable(pid);
if (p instanceof VPaintableWidget) {
- return ((VPaintableWidget) p).getWidgetForPaintable().getElement();
+ return ((VPaintableWidget) p).getWidget().getElement();
}
return null;
String id = getPid(p);
Widget widget = null;
if (p instanceof VPaintableWidget) {
- widget = ((VPaintableWidget) p).getWidgetForPaintable();
+ widget = ((VPaintableWidget) p).getWidget();
}
if (id == null) {
Widget widget = null;
if (paintable instanceof VPaintableWidget) {
widget = ((VPaintableWidget) paintable)
- .getWidgetForPaintable();
+ .getWidget();
}
// check if can be cleaned
/**
* TODO: Rename to getWidget
*/
- public Widget getWidgetForPaintable();
+ public Widget getWidget();
/**
* Returns the parent {@link VPaintableWidgetContainer}
static void highlight(VPaintableWidget paintable) {
if (paintable != null) {
- Widget w = paintable.getWidgetForPaintable();
+ Widget w = paintable.getWidget();
Style style = highlight.getStyle();
style.setTop(w.getAbsoluteTop(), Unit.PX);
style.setLeft(w.getAbsoluteLeft(), Unit.PX);
* or null if no relative coordinates can be calculated.
*/
protected Element getRelativeToElement() {
- return paintable.getWidgetForPaintable().getElement();
+ return paintable.getWidget().getElement();
}
}
\ No newline at end of file
public void updateFromUIDL(UIDL componentUIDL) {
setPosition(componentUIDL.getStringAttribute("css"));
- if (getWidget() != paintable.getWidgetForPaintable()) {
- setWidget(paintable.getWidgetForPaintable());
+ if (getWidget() != paintable.getWidget()) {
+ setWidget(paintable.getWidget());
}
UIDL childUIDL = componentUIDL.getChildUIDL(0);
paintable.updateFromUIDL(childUIDL, client);
// have changed this could be optimized (check if wrapper size
// has changed)
client.handleComponentRelativeSize(paintable
- .getWidgetForPaintable());
+ .getWidget());
}
}
@Override
protected VPaintableWidget getChildComponent(Element element) {
- return getWidgetForPaintable().getComponent(element);
+ return getWidget().getComponent(element);
}
@Override
protected <H extends EventHandler> HandlerRegistration registerHandler(
H handler, Type<H> type) {
- return getWidgetForPaintable().addDomHandler(handler, type);
+ return getWidget().addDomHandler(handler, type);
}
};
@Override
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidgetForPaintable().client = client;
+ getWidget().client = client;
// TODO margin handling
super.updateFromUIDL(uidl, client);
if (!isRealUpdate(uidl)) {
clickEventHandler.handleEventHandlerRegistration(client);
HashSet<String> unrenderedPids = new HashSet<String>(
- getWidgetForPaintable().pidToComponentWrappper.keySet());
+ getWidget().pidToComponentWrappper.keySet());
for (Iterator<Object> childIterator = uidl.getChildIterator(); childIterator
.hasNext();) {
if (cc.getTag().equals("cc")) {
UIDL componentUIDL = cc.getChildUIDL(0);
unrenderedPids.remove(componentUIDL.getId());
- getWidgetForPaintable().getWrapper(client, componentUIDL)
+ getWidget().getWrapper(client, componentUIDL)
.updateFromUIDL(cc);
}
}
for (String pid : unrenderedPids) {
- AbsoluteWrapper absoluteWrapper = getWidgetForPaintable().pidToComponentWrappper
+ AbsoluteWrapper absoluteWrapper = getWidget().pidToComponentWrappper
.get(pid);
- getWidgetForPaintable().pidToComponentWrappper.remove(pid);
+ getWidget().pidToComponentWrappper.remove(pid);
absoluteWrapper.destroy();
}
}
public void updateCaption(VPaintableWidget component, UIDL uidl) {
AbsoluteWrapper parent2 = (AbsoluteWrapper) (component
- .getWidgetForPaintable()).getParent();
+ .getWidget()).getParent();
parent2.updateCaption(uidl);
}
}
@Override
- public VAbsoluteLayout getWidgetForPaintable() {
- return (VAbsoluteLayout) super.getWidgetForPaintable();
+ public VAbsoluteLayout getWidget() {
+ return (VAbsoluteLayout) super.getWidget();
}
public void layoutVertically() {
- VAbsoluteLayout layout = getWidgetForPaintable();
+ VAbsoluteLayout layout = getWidget();
for (VPaintableWidget paintable : getChildren()) {
- Widget widget = paintable.getWidgetForPaintable();
+ Widget widget = paintable.getWidget();
AbsoluteWrapper wrapper = (AbsoluteWrapper) widget.getParent();
Style wrapperStyle = wrapper.getElement().getStyle();
}
public void layoutHorizontally() {
- VAbsoluteLayout layout = getWidgetForPaintable();
+ VAbsoluteLayout layout = getWidget();
for (VPaintableWidget paintable : getChildren()) {
- Widget widget = paintable.getWidgetForPaintable();
+ Widget widget = paintable.getWidget();
AbsoluteWrapper wrapper = (AbsoluteWrapper) widget.getParent();
Style wrapperStyle = wrapper.getElement().getStyle();
*
* @return The widget associated with this paintable
*/
- public Widget getWidgetForPaintable() {
+ public Widget getWidget() {
if (widget == null) {
widget = createWidget();
}
// FIXME: Hierarchy should be set by framework instead of looked up here
VPaintableMap paintableMap = VPaintableMap.get(getConnection());
- Widget w = getWidgetForPaintable();
+ Widget w = getWidget();
while (true) {
w = w.getParent();
if (w == null) {
setVisible(!uidl.getBooleanAttribute("invisible"), uidl);
if (uidl.getId().startsWith("PID_S")) {
- DOM.setElementProperty(getWidgetForPaintable().getElement(), "id",
+ DOM.setElementProperty(getWidget().getElement(), "id",
uidl.getId().substring(5));
}
* first setting tabindex, then enabled state.
*/
if (uidl.hasAttribute("tabindex")
- && getWidgetForPaintable() instanceof Focusable) {
- ((Focusable) getWidgetForPaintable()).setTabIndex(uidl
+ && getWidget() instanceof Focusable) {
+ ((Focusable) getWidget()).setTabIndex(uidl
.getIntAttribute("tabindex"));
}
setEnabled(!getState().isDisabled());
// Style names
- String styleName = getStyleNameFromUIDL(getWidgetForPaintable()
+ String styleName = getStyleNameFromUIDL(getWidget()
.getStylePrimaryName(), uidl, getState(),
- getWidgetForPaintable() instanceof Field);
- getWidgetForPaintable().setStyleName(styleName);
+ getWidget() instanceof Field);
+ getWidget().setStyleName(styleName);
// Update tooltip
TooltipInfo tooltipInfo = paintableMap.getTooltipInfo(this, null);
declaredHeight = h;
// Set defined sizes
- Widget component = getWidgetForPaintable();
+ Widget component = getWidget();
component.setStyleName("v-undefined-width", isUndefinedWidth());
component.setStyleName("v-undefined-height", isUndefinedHeight());
protected void setEnabled(boolean enabled) {
this.enabled = enabled;
- if (getWidgetForPaintable() instanceof FocusWidget) {
- FocusWidget fw = (FocusWidget) getWidgetForPaintable();
+ if (getWidget() instanceof FocusWidget) {
+ FocusWidget fw = (FocusWidget) getWidget();
fw.setEnabled(enabled);
}
boolean wasVisible = this.visible;
this.visible = visible;
- getWidgetForPaintable().setVisible(visible);
+ getWidget().setVisible(visible);
if (wasVisible != visible) {
// Changed invisibile <-> visible
if (wasVisible && delegateCaptionHandling()) {
public Collection<VPaintableWidget> getChildren() {
Collection<VPaintableWidget> children = new ArrayList<VPaintableWidget>();
- addDescendantPaintables(getWidgetForPaintable(), children,
+ addDescendantPaintables(getWidget(), children,
VPaintableMap.get(getConnection()));
return children;
@Override
protected <H extends EventHandler> HandlerRegistration registerHandler(
H handler, Type<H> type) {
- if ((Event.getEventsSunk(getWidgetForPaintable().splitter) & Event
+ 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 getWidgetForPaintable().addHandler(handler, type);
+ return getWidget().addHandler(handler, type);
} else {
- return getWidgetForPaintable().addDomHandler(handler, type);
+ return getWidget().addDomHandler(handler, type);
}
}
public void onContextMenu(
com.google.gwt.event.dom.client.ContextMenuEvent event) {
Element target = event.getNativeEvent().getEventTarget().cast();
- if (getWidgetForPaintable().splitter.isOrHasChild(target)) {
+ if (getWidget().splitter.isOrHasChild(target)) {
super.onContextMenu(event);
}
};
@Override
protected void fireClick(NativeEvent event) {
Element target = event.getEventTarget().cast();
- if (getWidgetForPaintable().splitter.isOrHasChild(target)) {
+ if (getWidget().splitter.isOrHasChild(target)) {
super.fireClick(event);
}
}
@Override
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidgetForPaintable().client = client;
- getWidgetForPaintable().id = uidl.getId();
+ getWidget().client = client;
+ getWidget().id = uidl.getId();
- getWidgetForPaintable().immediate = getState().isImmediate();
+ getWidget().immediate = getState().isImmediate();
super.updateFromUIDL(uidl, client);
if (!isRealUpdate(uidl)) {
return;
}
- getWidgetForPaintable().setEnabled(!getState().isDisabled());
+ getWidget().setEnabled(!getState().isDisabled());
clickEventHandler.handleEventHandlerRegistration(client);
if (getState().hasStyles()) {
- getWidgetForPaintable().componentStyleNames = getState().getStyle()
+ getWidget().componentStyleNames = getState().getStyle()
.split(" ");
} else {
- getWidgetForPaintable().componentStyleNames = new String[0];
+ getWidget().componentStyleNames = new String[0];
}
- getWidgetForPaintable().setLocked(uidl.getBooleanAttribute("locked"));
+ getWidget().setLocked(uidl.getBooleanAttribute("locked"));
- getWidgetForPaintable().setPositionReversed(
+ getWidget().setPositionReversed(
uidl.getBooleanAttribute("reversed"));
- getWidgetForPaintable().setStylenames();
+ getWidget().setStylenames();
- getWidgetForPaintable().position = uidl.getStringAttribute("position");
+ getWidget().position = uidl.getStringAttribute("position");
final VPaintableWidget newFirstChildPaintable = client
.getPaintable(uidl.getChildUIDL(0));
final VPaintableWidget newSecondChildPaintable = client
.getPaintable(uidl.getChildUIDL(1));
- Widget newFirstChild = newFirstChildPaintable.getWidgetForPaintable();
- Widget newSecondChild = newSecondChildPaintable.getWidgetForPaintable();
+ Widget newFirstChild = newFirstChildPaintable.getWidget();
+ Widget newSecondChild = newSecondChildPaintable.getWidget();
- if (getWidgetForPaintable().firstChild != newFirstChild) {
- if (getWidgetForPaintable().firstChild != null) {
+ if (getWidget().firstChild != newFirstChild) {
+ if (getWidget().firstChild != null) {
client.unregisterPaintable(VPaintableMap.get(client)
- .getPaintable(getWidgetForPaintable().firstChild));
+ .getPaintable(getWidget().firstChild));
}
- getWidgetForPaintable().setFirstWidget(newFirstChild);
+ getWidget().setFirstWidget(newFirstChild);
}
- if (getWidgetForPaintable().secondChild != newSecondChild) {
- if (getWidgetForPaintable().secondChild != null) {
+ if (getWidget().secondChild != newSecondChild) {
+ if (getWidget().secondChild != null) {
client.unregisterPaintable(VPaintableMap.get(client)
- .getPaintable(getWidgetForPaintable().secondChild));
+ .getPaintable(getWidget().secondChild));
}
- getWidgetForPaintable().setSecondWidget(newSecondChild);
+ 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(getWidgetForPaintable());
+ client.runDescendentsLayout(getWidget());
getLayoutManager().setNeedsUpdate(this);
}
public void layout() {
- VAbstractSplitPanel splitPanel = getWidgetForPaintable();
+ VAbstractSplitPanel splitPanel = getWidget();
splitPanel.setSplitPosition(splitPanel.position);
splitPanel.updateSizes();
}
@Override
- public VAbstractSplitPanel getWidgetForPaintable() {
- return (VAbstractSplitPanel) super.getWidgetForPaintable();
+ public VAbstractSplitPanel getWidget() {
+ return (VAbstractSplitPanel) super.getWidget();
}
@Override
public void setContent(UIDL contentUidl) {
final VPaintableWidget newPntbl = client.getPaintable(contentUidl);
- Widget newWidget = newPntbl.getWidgetForPaintable();
+ Widget newWidget = newPntbl.getWidget();
if (getChildWidget() == null) {
add(newWidget, content);
widgets.add(newWidget);
* updated to report correct size.
*/
client.handleComponentRelativeSize(newPntbl
- .getWidgetForPaintable());
+ .getWidget());
}
if (isOpen() && isDynamicHeight()) {
setHeightFromWidget();
}
public boolean contains(VPaintableWidget p) {
- return (getChildWidget() == p.getWidgetForPaintable());
+ return (getChildWidget() == p.getWidget());
}
public boolean isCaptionVisible() {
@Override
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidgetForPaintable().selectedUIDLItemIndex = -1;
+ 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 (getWidgetForPaintable().selectedUIDLItemIndex >= 0) {
- StackItem selectedItem = getWidgetForPaintable().getStackItem(
- getWidgetForPaintable().selectedUIDLItemIndex);
- UIDL selectedTabUIDL = getWidgetForPaintable().lazyUpdateMap
+ if (getWidget().selectedUIDLItemIndex >= 0) {
+ StackItem selectedItem = getWidget().getStackItem(
+ getWidget().selectedUIDLItemIndex);
+ UIDL selectedTabUIDL = getWidget().lazyUpdateMap
.remove(selectedItem);
- getWidgetForPaintable().open(
- getWidgetForPaintable().selectedUIDLItemIndex);
+ getWidget().open(
+ getWidget().selectedUIDLItemIndex);
selectedItem.setContent(selectedTabUIDL);
} else if (isRealUpdate(uidl)
- && getWidgetForPaintable().openTab != null) {
- getWidgetForPaintable().close(getWidgetForPaintable().openTab);
+ && getWidget().openTab != null) {
+ getWidget().close(getWidget().openTab);
}
- getWidgetForPaintable().iLayout();
+ getWidget().iLayout();
// finally render possible hidden tabs
- if (getWidgetForPaintable().lazyUpdateMap.size() > 0) {
- for (Iterator iterator = getWidgetForPaintable().lazyUpdateMap
+ if (getWidget().lazyUpdateMap.size() > 0) {
+ for (Iterator iterator = getWidget().lazyUpdateMap
.keySet().iterator(); iterator.hasNext();) {
StackItem item = (StackItem) iterator.next();
- item.setContent(getWidgetForPaintable().lazyUpdateMap.get(item));
+ item.setContent(getWidget().lazyUpdateMap.get(item));
}
- getWidgetForPaintable().lazyUpdateMap.clear();
+ getWidget().lazyUpdateMap.clear();
}
- getWidgetForPaintable().renderInformation
- .updateSize(getWidgetForPaintable().getElement());
+ getWidget().renderInformation
+ .updateSize(getWidget().getElement());
}
@Override
- public VAccordion getWidgetForPaintable() {
- return (VAccordion) super.getWidgetForPaintable();
+ public VAccordion getWidget() {
+ return (VAccordion) super.getWidget();
}
@Override
}
public void layout() {
- VAccordion accordion = getWidgetForPaintable();
+ VAccordion accordion = getWidget();
accordion.updateOpenTabSize();
if (!isRealUpdate(uidl)) {
return;
}
- Style style = getWidgetForPaintable().getElement().getStyle();
+ Style style = getWidget().getElement().getStyle();
// Make sure that the controls are not clipped if visible.
if (shouldShowControls(uidl)
super.init();
ButtonClientToServerRpc rpcProxy = GWT
.create(ButtonClientToServerRpc.class);
- getWidgetForPaintable().buttonRpcProxy = initRPC(rpcProxy);
+ getWidget().buttonRpcProxy = initRPC(rpcProxy);
}
@Override
return;
}
- getWidgetForPaintable().focusHandlerRegistration = EventHelper
+ getWidget().focusHandlerRegistration = EventHelper
.updateFocusHandler(this, client,
- getWidgetForPaintable().focusHandlerRegistration);
- getWidgetForPaintable().blurHandlerRegistration = EventHelper
+ getWidget().focusHandlerRegistration);
+ getWidget().blurHandlerRegistration = EventHelper
.updateBlurHandler(this, client,
- getWidgetForPaintable().blurHandlerRegistration);
+ getWidget().blurHandlerRegistration);
// Save details
- getWidgetForPaintable().client = client;
- getWidgetForPaintable().paintableId = uidl.getId();
+ getWidget().client = client;
+ getWidget().paintableId = uidl.getId();
// Set text
- getWidgetForPaintable().setText(getState().getCaption());
+ getWidget().setText(getState().getCaption());
- getWidgetForPaintable().disableOnClick = getState().isDisableOnClick();
+ getWidget().disableOnClick = getState().isDisableOnClick();
// handle error
if (uidl.hasAttribute("error")) {
- if (getWidgetForPaintable().errorIndicatorElement == null) {
- getWidgetForPaintable().errorIndicatorElement = DOM
+ if (getWidget().errorIndicatorElement == null) {
+ getWidget().errorIndicatorElement = DOM
.createSpan();
- getWidgetForPaintable().errorIndicatorElement
+ getWidget().errorIndicatorElement
.setClassName("v-errorindicator");
}
- getWidgetForPaintable().wrapper.insertBefore(
- getWidgetForPaintable().errorIndicatorElement,
- getWidgetForPaintable().captionElement);
-
- } else if (getWidgetForPaintable().errorIndicatorElement != null) {
- getWidgetForPaintable().wrapper
- .removeChild(getWidgetForPaintable().errorIndicatorElement);
- getWidgetForPaintable().errorIndicatorElement = null;
+ 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 (getWidgetForPaintable().icon == null) {
- getWidgetForPaintable().icon = new Icon(client);
- getWidgetForPaintable().wrapper.insertBefore(
- getWidgetForPaintable().icon.getElement(),
- getWidgetForPaintable().captionElement);
+ if (getWidget().icon == null) {
+ getWidget().icon = new Icon(client);
+ getWidget().wrapper.insertBefore(
+ getWidget().icon.getElement(),
+ getWidget().captionElement);
}
- getWidgetForPaintable().icon.setUri(uidl
+ getWidget().icon.setUri(uidl
.getStringAttribute(ATTRIBUTE_ICON));
} else {
- if (getWidgetForPaintable().icon != null) {
- getWidgetForPaintable().wrapper
- .removeChild(getWidgetForPaintable().icon.getElement());
- getWidgetForPaintable().icon = null;
+ if (getWidget().icon != null) {
+ getWidget().wrapper
+ .removeChild(getWidget().icon.getElement());
+ getWidget().icon = null;
}
}
- getWidgetForPaintable().clickShortcut = getState()
+ getWidget().clickShortcut = getState()
.getClickShortcutKeyCode();
}
}
@Override
- public VButton getWidgetForPaintable() {
- return (VButton) super.getWidgetForPaintable();
+ public VButton getWidget() {
+ return (VButton) super.getWidget();
}
@Override
@Override
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
// Save details
- getWidgetForPaintable().client = client;
- getWidgetForPaintable().id = uidl.getId();
+ getWidget().client = client;
+ getWidget().id = uidl.getId();
// Ensure correct implementation
super.updateFromUIDL(uidl, client);
return;
}
- getWidgetForPaintable().focusHandlerRegistration = EventHelper
+ getWidget().focusHandlerRegistration = EventHelper
.updateFocusHandler(this, client,
- getWidgetForPaintable().focusHandlerRegistration);
- getWidgetForPaintable().blurHandlerRegistration = EventHelper
+ getWidget().focusHandlerRegistration);
+ getWidget().blurHandlerRegistration = EventHelper
.updateBlurHandler(this, client,
- getWidgetForPaintable().blurHandlerRegistration);
+ getWidget().blurHandlerRegistration);
if (uidl.hasAttribute("error")) {
- if (getWidgetForPaintable().errorIndicatorElement == null) {
- getWidgetForPaintable().errorIndicatorElement = DOM
+ if (getWidget().errorIndicatorElement == null) {
+ getWidget().errorIndicatorElement = DOM
.createSpan();
- getWidgetForPaintable().errorIndicatorElement
+ getWidget().errorIndicatorElement
.setInnerHTML(" ");
DOM.setElementProperty(
- getWidgetForPaintable().errorIndicatorElement,
+ getWidget().errorIndicatorElement,
"className", "v-errorindicator");
- DOM.appendChild(getWidgetForPaintable().getElement(),
- getWidgetForPaintable().errorIndicatorElement);
- DOM.sinkEvents(getWidgetForPaintable().errorIndicatorElement,
+ DOM.appendChild(getWidget().getElement(),
+ getWidget().errorIndicatorElement);
+ DOM.sinkEvents(getWidget().errorIndicatorElement,
VTooltip.TOOLTIP_EVENTS | Event.ONCLICK);
} else {
DOM.setStyleAttribute(
- getWidgetForPaintable().errorIndicatorElement,
+ getWidget().errorIndicatorElement,
"display", "");
}
- } else if (getWidgetForPaintable().errorIndicatorElement != null) {
+ } else if (getWidget().errorIndicatorElement != null) {
DOM.setStyleAttribute(
- getWidgetForPaintable().errorIndicatorElement, "display",
+ getWidget().errorIndicatorElement, "display",
"none");
}
if (getState().isReadOnly()) {
- getWidgetForPaintable().setEnabled(false);
+ getWidget().setEnabled(false);
}
if (uidl.hasAttribute(ATTRIBUTE_ICON)) {
- if (getWidgetForPaintable().icon == null) {
- getWidgetForPaintable().icon = new Icon(client);
- DOM.insertChild(getWidgetForPaintable().getElement(),
- getWidgetForPaintable().icon.getElement(), 1);
- getWidgetForPaintable().icon
+ if (getWidget().icon == null) {
+ getWidget().icon = new Icon(client);
+ DOM.insertChild(getWidget().getElement(),
+ getWidget().icon.getElement(), 1);
+ getWidget().icon
.sinkEvents(VTooltip.TOOLTIP_EVENTS);
- getWidgetForPaintable().icon.sinkEvents(Event.ONCLICK);
+ getWidget().icon.sinkEvents(Event.ONCLICK);
}
- getWidgetForPaintable().icon.setUri(uidl
+ getWidget().icon.setUri(uidl
.getStringAttribute(ATTRIBUTE_ICON));
- } else if (getWidgetForPaintable().icon != null) {
+ } else if (getWidget().icon != null) {
// detach icon
- DOM.removeChild(getWidgetForPaintable().getElement(),
- getWidgetForPaintable().icon.getElement());
- getWidgetForPaintable().icon = null;
+ DOM.removeChild(getWidget().getElement(),
+ getWidget().icon.getElement());
+ getWidget().icon = null;
}
// Set text
- getWidgetForPaintable().setText(getState().getCaption());
- getWidgetForPaintable()
+ getWidget().setText(getState().getCaption());
+ getWidget()
.setValue(
- uidl.getBooleanVariable(getWidgetForPaintable().VARIABLE_STATE));
- getWidgetForPaintable().immediate = getState().isImmediate();
+ uidl.getBooleanVariable(getWidget().VARIABLE_STATE));
+ getWidget().immediate = getState().isImmediate();
}
@Override
- public VCheckBox getWidgetForPaintable() {
- return (VCheckBox) super.getWidgetForPaintable();
+ public VCheckBox getWidget() {
+ return (VCheckBox) super.getWidget();
}
@Override
.hasNext();) {
final UIDL r = (UIDL) i.next();
final VPaintableWidget child = client.getPaintable(r);
- final Widget widget = child.getWidgetForPaintable();
+ final Widget widget = child.getWidget();
if (widget.getParent() == this) {
oldWidgets.remove(widget);
VCaption vCaption = widgetToCaption.get(widget);
}
public void updateCaption(VPaintableWidget paintable, UIDL uidl) {
- Widget widget = paintable.getWidgetForPaintable();
+ Widget widget = paintable.getWidget();
VCaption caption = widgetToCaption.get(widget);
if (VCaption.isNeeded(uidl, paintable.getState())) {
if (caption == null) {
@Override
protected VPaintableWidget getChildComponent(Element element) {
- return getWidgetForPaintable().panel.getComponent(element);
+ return getWidget().panel.getComponent(element);
}
@Override
protected <H extends EventHandler> HandlerRegistration registerHandler(
H handler, Type<H> type) {
- return getWidgetForPaintable().addDomHandler(handler, type);
+ return getWidget().addDomHandler(handler, type);
}
};
}
clickEventHandler.handleEventHandlerRegistration(client);
- getWidgetForPaintable().setMarginAndSpacingStyles(
+ getWidget().setMarginAndSpacingStyles(
new VMarginInfo(uidl.getIntAttribute("margins")),
uidl.hasAttribute("spacing"));
- getWidgetForPaintable().panel.updateFromUIDL(uidl, client);
+ getWidget().panel.updateFromUIDL(uidl, client);
}
@Override
- public VCssLayout getWidgetForPaintable() {
- return (VCssLayout) super.getWidgetForPaintable();
+ public VCssLayout getWidget() {
+ return (VCssLayout) super.getWidget();
}
@Override
}
public void updateCaption(VPaintableWidget component, UIDL uidl) {
- getWidgetForPaintable().panel.updateCaption(component, uidl);
+ getWidget().panel.updateCaption(component, uidl);
}
}
final UIDL child = uidl.getChildUIDL(0);
if (child != null) {
final VPaintableWidget paintable = client.getPaintable(child);
- Widget widget = paintable.getWidgetForPaintable();
- if (widget != getWidgetForPaintable().getWidget()) {
- if (getWidgetForPaintable().getWidget() != null) {
+ Widget widget = paintable.getWidget();
+ if (widget != getWidget().getWidget()) {
+ if (getWidget().getWidget() != null) {
client.unregisterPaintable(VPaintableMap.get(client)
- .getPaintable(getWidgetForPaintable().getWidget()));
- getWidgetForPaintable().clear();
+ .getPaintable(getWidget().getWidget()));
+ getWidget().clear();
}
- getWidgetForPaintable().setWidget(widget);
+ getWidget().setWidget(widget);
}
paintable.updateFromUIDL(child, client);
}
}
@Override
- public VCustomComponent getWidgetForPaintable() {
- return (VCustomComponent) super.getWidgetForPaintable();
+ public VCustomComponent getWidget() {
+ return (VCustomComponent) super.getWidget();
}
public void updateCaption(VPaintableWidget component, UIDL uidl) {
/** Update caption for given widget */
public void updateCaption(VPaintableWidget paintable, UIDL uidl) {
VCaptionWrapper wrapper = paintableToCaptionWrapper.get(paintable);
- Widget widget = paintable.getWidgetForPaintable();
+ Widget widget = paintable.getWidget();
if (VCaption.isNeeded(uidl, paintable.getState())) {
if (wrapper == null) {
// Add a wrapper between the layout and the child widget
/** Update the layout from UIDL */
@Override
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidgetForPaintable().client = client;
+ getWidget().client = client;
// ApplicationConnection manages generic component features
super.updateFromUIDL(uidl, client);
if (!isRealUpdate(uidl)) {
return;
}
- getWidgetForPaintable().pid = uidl.getId();
- if (!getWidgetForPaintable().hasTemplate()) {
+ getWidget().pid = uidl.getId();
+ if (!getWidget().hasTemplate()) {
// Update HTML template only once
- getWidgetForPaintable().initializeHTML(uidl, client);
+ getWidget().initializeHTML(uidl, client);
}
// Evaluate scripts
- VCustomLayout.eval(getWidgetForPaintable().scripts);
- getWidgetForPaintable().scripts = null;
+ VCustomLayout.eval(getWidget().scripts);
+ getWidget().scripts = null;
// TODO Check if this is needed
- client.runDescendentsLayout(getWidgetForPaintable());
+ client.runDescendentsLayout(getWidget());
Set<Widget> oldWidgets = new HashSet<Widget>();
- oldWidgets.addAll(getWidgetForPaintable().locationToWidget.values());
+ oldWidgets.addAll(getWidget().locationToWidget.values());
// For all contained widgets
for (final Iterator<?> i = uidl.getChildIterator(); i.hasNext();) {
UIDL childUIDL = uidlForChild.getChildUIDL(0);
final VPaintableWidget childPaintable = client
.getPaintable(childUIDL);
- Widget childWidget = childPaintable.getWidgetForPaintable();
+ Widget childWidget = childPaintable.getWidget();
try {
- getWidgetForPaintable().setWidget(childWidget, location);
+ getWidget().setWidget(childWidget, location);
childPaintable.updateFromUIDL(childUIDL, client);
} catch (final IllegalArgumentException e) {
// If no location is found, this component is not visible
Widget oldWidget = iterator.next();
if (oldWidget.isAttached()) {
// slot of this widget is emptied, remove it
- getWidgetForPaintable().remove(oldWidget);
+ getWidget().remove(oldWidget);
}
}
// TODO Check if this is needed
- client.runDescendentsLayout(getWidgetForPaintable());
+ client.runDescendentsLayout(getWidget());
}
@Override
- public VCustomLayout getWidgetForPaintable() {
- return (VCustomLayout) super.getWidgetForPaintable();
+ public VCustomLayout getWidget() {
+ return (VCustomLayout) super.getWidget();
}
@Override
}
public void updateCaption(VPaintableWidget paintable, UIDL uidl) {
- getWidgetForPaintable().updateCaption(paintable, uidl);
+ getWidget().updateCaption(paintable, uidl);
}
public void layout() {
- getWidgetForPaintable().iLayoutJS(
- DOM.getFirstChild(getWidgetForPaintable().getElement()));
+ getWidget().iLayoutJS(
+ DOM.getFirstChild(getWidget().getElement()));
}
}
@SuppressWarnings("deprecation")
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
super.updateFromUIDL(uidl, client);
- getWidgetForPaintable().calendarPanel
- .setShowISOWeekNumbers(getWidgetForPaintable()
+ getWidget().calendarPanel
+ .setShowISOWeekNumbers(getWidget()
.isShowISOWeekNumbers());
- getWidgetForPaintable().calendarPanel
- .setDateTimeService(getWidgetForPaintable()
+ getWidget().calendarPanel
+ .setDateTimeService(getWidget()
.getDateTimeService());
- getWidgetForPaintable().calendarPanel
- .setResolution(getWidgetForPaintable().getCurrentResolution());
- Date currentDate = getWidgetForPaintable().getCurrentDate();
+ getWidget().calendarPanel
+ .setResolution(getWidget().getCurrentResolution());
+ Date currentDate = getWidget().getCurrentDate();
if (currentDate != null) {
- getWidgetForPaintable().calendarPanel.setDate(new Date(currentDate
+ getWidget().calendarPanel.setDate(new Date(currentDate
.getTime()));
} else {
- getWidgetForPaintable().calendarPanel.setDate(null);
+ getWidget().calendarPanel.setDate(null);
}
- if (getWidgetForPaintable().currentResolution > VDateField.RESOLUTION_DAY) {
- getWidgetForPaintable().calendarPanel
+ if (getWidget().currentResolution > VDateField.RESOLUTION_DAY) {
+ getWidget().calendarPanel
.setTimeChangeListener(new TimeChangeListener() {
public void changed(int hour, int min, int sec, int msec) {
- Date d = getWidgetForPaintable().getDate();
+ 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) getWidgetForPaintable().calendarPanel
+ d = (Date) getWidget().calendarPanel
.getDate().clone();
}
d.setHours(hour);
DateTimeService.setMilliseconds(d, msec);
// Always update time changes to the server
- getWidgetForPaintable().calendarPanel.setDate(d);
- getWidgetForPaintable().updateValueFromPanel();
+ getWidget().calendarPanel.setDate(d);
+ getWidget().updateValueFromPanel();
}
});
}
- if (getWidgetForPaintable().currentResolution <= VDateField.RESOLUTION_MONTH) {
- getWidgetForPaintable().calendarPanel
+ if (getWidget().currentResolution <= VDateField.RESOLUTION_MONTH) {
+ getWidget().calendarPanel
.setFocusChangeListener(new FocusChangeListener() {
public void focusChanged(Date date) {
Date date2 = new Date();
- if (getWidgetForPaintable().calendarPanel.getDate() != null) {
- date2.setTime(getWidgetForPaintable().calendarPanel
+ if (getWidget().calendarPanel.getDate() != null) {
+ date2.setTime(getWidget().calendarPanel
.getDate().getTime());
}
/*
*/
date2.setYear(date.getYear());
date2.setMonth(date.getMonth());
- getWidgetForPaintable().calendarPanel
+ getWidget().calendarPanel
.setDate(date2);
/*
* Then update the value from panel to server
*/
- getWidgetForPaintable().updateValueFromPanel();
+ getWidget().updateValueFromPanel();
}
});
} else {
- getWidgetForPaintable().calendarPanel.setFocusChangeListener(null);
+ getWidget().calendarPanel.setFocusChangeListener(null);
}
// Update possible changes
- getWidgetForPaintable().calendarPanel.renderCalendar();
+ getWidget().calendarPanel.renderCalendar();
}
@Override
}
@Override
- public VDateFieldCalendar getWidgetForPaintable() {
- return (VDateFieldCalendar) super.getWidgetForPaintable();
+ public VDateFieldCalendar getWidget() {
+ return (VDateFieldCalendar) super.getWidget();
}
}
}
// Save details
- getWidgetForPaintable().client = client;
- getWidgetForPaintable().paintableId = uidl.getId();
- getWidgetForPaintable().immediate = getState().isImmediate();
+ getWidget().client = client;
+ getWidget().paintableId = uidl.getId();
+ getWidget().immediate = getState().isImmediate();
- getWidgetForPaintable().readonly = getState().isReadOnly();
- getWidgetForPaintable().enabled = !getState().isDisabled();
+ getWidget().readonly = getState().isReadOnly();
+ getWidget().enabled = !getState().isDisabled();
if (uidl.hasAttribute("locale")) {
final String locale = uidl.getStringAttribute("locale");
try {
- getWidgetForPaintable().dts.setLocale(locale);
- getWidgetForPaintable().currentLocale = locale;
+ getWidget().dts.setLocale(locale);
+ getWidget().currentLocale = locale;
} catch (final LocaleNotLoadedException e) {
- getWidgetForPaintable().currentLocale = getWidgetForPaintable().dts
+ getWidget().currentLocale = getWidget().dts
.getLocale();
VConsole.error("Tried to use an unloaded locale \"" + locale
+ "\". Using default locale ("
- + getWidgetForPaintable().currentLocale + ").");
+ + getWidget().currentLocale + ").");
VConsole.error(e);
}
}
// We show week numbers only if the week starts with Monday, as ISO 8601
// specifies
- getWidgetForPaintable().showISOWeekNumbers = uidl
+ getWidget().showISOWeekNumbers = uidl
.getBooleanAttribute(VDateField.WEEK_NUMBERS)
- && getWidgetForPaintable().dts.getFirstDayOfWeek() == 1;
+ && getWidget().dts.getFirstDayOfWeek() == 1;
int newResolution;
if (uidl.hasVariable("sec")) {
newResolution = VDateField.RESOLUTION_YEAR;
}
- getWidgetForPaintable().currentResolution = newResolution;
+ getWidget().currentResolution = newResolution;
// Add stylename that indicates current resolution
- getWidgetForPaintable()
+ getWidget()
.addStyleName(
VDateField.CLASSNAME
+ "-"
+ VDateField
- .resolutionToString(getWidgetForPaintable().currentResolution));
+ .resolutionToString(getWidget().currentResolution));
final int year = uidl.getIntVariable("year");
- final int month = (getWidgetForPaintable().currentResolution >= VDateField.RESOLUTION_MONTH) ? uidl
+ final int month = (getWidget().currentResolution >= VDateField.RESOLUTION_MONTH) ? uidl
.getIntVariable("month") : -1;
- final int day = (getWidgetForPaintable().currentResolution >= VDateField.RESOLUTION_DAY) ? uidl
+ final int day = (getWidget().currentResolution >= VDateField.RESOLUTION_DAY) ? uidl
.getIntVariable("day") : -1;
- final int hour = (getWidgetForPaintable().currentResolution >= VDateField.RESOLUTION_HOUR) ? uidl
+ final int hour = (getWidget().currentResolution >= VDateField.RESOLUTION_HOUR) ? uidl
.getIntVariable("hour") : 0;
- final int min = (getWidgetForPaintable().currentResolution >= VDateField.RESOLUTION_MIN) ? uidl
+ final int min = (getWidget().currentResolution >= VDateField.RESOLUTION_MIN) ? uidl
.getIntVariable("min") : 0;
- final int sec = (getWidgetForPaintable().currentResolution >= VDateField.RESOLUTION_SEC) ? uidl
+ 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) {
- getWidgetForPaintable().setCurrentDate(
- new Date((long) getWidgetForPaintable().getTime(year,
+ getWidget().setCurrentDate(
+ new Date((long) getWidget().getTime(year,
month, day, hour, min, sec, 0)));
} else {
- getWidgetForPaintable().setCurrentDate(null);
+ getWidget().setCurrentDate(null);
}
}
}
@Override
- public VDateField getWidgetForPaintable() {
- return (VDateField) super.getWidgetForPaintable();
+ public VDateField getWidget() {
+ return (VDateField) super.getWidget();
}
}
VPaintableWidget paintable = Util.findPaintable(client,
(Element) event.getEventTarget().cast());
- Widget widget = paintable.getWidgetForPaintable();
+ Widget widget = paintable.getWidget();
transferable.setData("component", paintable);
VDragEvent dragEvent = VDragAndDropManager.get().startDrag(
transferable, event, true);
@Override
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidgetForPaintable().client = client;
+ getWidget().client = client;
super.updateFromUIDL(uidl, client);
if (isRealUpdate(uidl) && !uidl.hasAttribute("hidden")) {
UIDL acceptCrit = uidl.getChildByTagName("-ac");
if (acceptCrit == null) {
- getWidgetForPaintable().dropHandler = null;
+ getWidget().dropHandler = null;
} else {
- if (getWidgetForPaintable().dropHandler == null) {
- getWidgetForPaintable().dropHandler = getWidgetForPaintable().new CustomDropHandler();
+ if (getWidget().dropHandler == null) {
+ getWidget().dropHandler = getWidget().new CustomDropHandler();
}
- getWidgetForPaintable().dropHandler
+ getWidget().dropHandler
.updateAcceptRules(acceptCrit);
}
if (fileId.startsWith("rec-")) {
String receiverUrl = uidl.getStringVariable(fileId);
fileId = fileId.substring(4);
- if (getWidgetForPaintable().fileIdToReceiver == null) {
- getWidgetForPaintable().fileIdToReceiver = new HashMap<String, String>();
+ if (getWidget().fileIdToReceiver == null) {
+ getWidget().fileIdToReceiver = new HashMap<String, String>();
}
if ("".equals(receiverUrl)) {
Integer id = Integer.parseInt(fileId);
- int indexOf = getWidgetForPaintable().fileIds
+ int indexOf = getWidget().fileIds
.indexOf(id);
if (indexOf != -1) {
- getWidgetForPaintable().files.remove(indexOf);
- getWidgetForPaintable().fileIds.remove(indexOf);
+ getWidget().files.remove(indexOf);
+ getWidget().fileIds.remove(indexOf);
}
} else {
- getWidgetForPaintable().fileIdToReceiver.put(fileId,
+ getWidget().fileIdToReceiver.put(fileId,
receiverUrl);
}
}
}
- getWidgetForPaintable().startNextUpload();
+ getWidget().startNextUpload();
- getWidgetForPaintable().dragStartMode = uidl
+ getWidget().dragStartMode = uidl
.getIntAttribute(VDragAndDropWrapper.DRAG_START_MODE);
- getWidgetForPaintable().initDragStartMode();
- getWidgetForPaintable().html5DataFlavors = uidl
+ getWidget().initDragStartMode();
+ getWidget().html5DataFlavors = uidl
.getMapAttribute(VDragAndDropWrapper.HTML5_DATA_FLAVORS);
}
}
}
@Override
- public VDragAndDropWrapper getWidgetForPaintable() {
- return (VDragAndDropWrapper) super.getWidgetForPaintable();
+ public VDragAndDropWrapper getWidget() {
+ return (VDragAndDropWrapper) super.getWidget();
}
}
}
// Save details
- getWidgetForPaintable().client = client;
+ getWidget().client = client;
boolean clearBrowserElement = true;
clickEventHandler.handleEventHandlerRegistration(client);
if (uidl.hasAttribute("type")) {
- getWidgetForPaintable().type = uidl.getStringAttribute("type");
- if (getWidgetForPaintable().type.equals("image")) {
- getWidgetForPaintable().addStyleName(
+ getWidget().type = uidl.getStringAttribute("type");
+ if (getWidget().type.equals("image")) {
+ getWidget().addStyleName(
VEmbedded.CLASSNAME + "-image");
Element el = null;
boolean created = false;
- NodeList<Node> nodes = getWidgetForPaintable().getElement()
+ NodeList<Node> nodes = getWidget().getElement()
.getChildNodes();
if (nodes != null && nodes.getLength() == 1) {
Node n = nodes.getItem(0);
}
}
if (el == null) {
- getWidgetForPaintable().setHTML("");
+ getWidget().setHTML("");
el = DOM.createImg();
created = true;
DOM.sinkEvents(el, Event.ONLOAD);
style.setProperty("width", getState().getWidth());
style.setProperty("height", getState().getHeight());
- DOM.setElementProperty(el, "src", getWidgetForPaintable()
+ DOM.setElementProperty(el, "src", getWidget()
.getSrc(uidl, client));
if (created) {
// insert in dom late
- getWidgetForPaintable().getElement().appendChild(el);
+ getWidget().getElement().appendChild(el);
}
/*
* Sink tooltip events so tooltip is displayed when hovering the
* image.
*/
- getWidgetForPaintable().sinkEvents(VTooltip.TOOLTIP_EVENTS);
+ getWidget().sinkEvents(VTooltip.TOOLTIP_EVENTS);
- } else if (getWidgetForPaintable().type.equals("browser")) {
- getWidgetForPaintable().addStyleName(
+ } else if (getWidget().type.equals("browser")) {
+ getWidget().addStyleName(
VEmbedded.CLASSNAME + "-browser");
- if (getWidgetForPaintable().browserElement == null) {
- getWidgetForPaintable().setHTML(
+ if (getWidget().browserElement == null) {
+ getWidget().setHTML(
"<iframe width=\"100%\" height=\"100%\" frameborder=\"0\""
+ " allowTransparency=\"true\" src=\"\""
+ " name=\"" + uidl.getId()
+ "\"></iframe>");
- getWidgetForPaintable().browserElement = DOM
- .getFirstChild(getWidgetForPaintable().getElement());
+ getWidget().browserElement = DOM
+ .getFirstChild(getWidget().getElement());
}
- DOM.setElementAttribute(getWidgetForPaintable().browserElement,
- "src", getWidgetForPaintable().getSrc(uidl, client));
+ DOM.setElementAttribute(getWidget().browserElement,
+ "src", getWidget().getSrc(uidl, client));
clearBrowserElement = false;
} else {
VConsole.log("Unknown Embedded type '"
- + getWidgetForPaintable().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
- getWidgetForPaintable().addStyleName(
+ getWidget().addStyleName(
VEmbedded.CLASSNAME + "-flash");
- getWidgetForPaintable().setHTML(
- getWidgetForPaintable().createFlashEmbed(uidl));
+ getWidget().setHTML(
+ getWidget().createFlashEmbed(uidl));
} else if (mime.equals("image/svg+xml")) {
- getWidgetForPaintable().addStyleName(
+ getWidget().addStyleName(
VEmbedded.CLASSNAME + "-svg");
String data;
Map<String, String> parameters = VEmbedded.getParameters(uidl);
if (parameters.get("data") == null) {
- data = getWidgetForPaintable().getSrc(uidl, client);
+ data = getWidget().getSrc(uidl, client);
} else {
data = "data:image/svg+xml," + parameters.get("data");
}
- getWidgetForPaintable().setHTML("");
+ getWidget().setHTML("");
ObjectElement obj = Document.get().createObjectElement();
obj.setType(mime);
obj.setData(data);
obj.setAttribute("standby",
uidl.getStringAttribute("standby"));
}
- getWidgetForPaintable().getElement().appendChild(obj);
+ getWidget().getElement().appendChild(obj);
} else {
VConsole.log("Unknown Embedded mimetype '" + mime + "'");
}
if (clearBrowserElement) {
- getWidgetForPaintable().browserElement = null;
+ getWidget().browserElement = null;
}
}
}
@Override
- public VEmbedded getWidgetForPaintable() {
- return (VEmbedded) super.getWidgetForPaintable();
+ public VEmbedded getWidget() {
+ return (VEmbedded) super.getWidget();
}
protected final ClickEventHandler clickEventHandler = new ClickEventHandler(
@Override
protected <H extends EventHandler> HandlerRegistration registerHandler(
H handler, Type<H> type) {
- return getWidgetForPaintable().addDomHandler(handler, type);
+ return getWidget().addDomHandler(handler, type);
}
};
@SuppressWarnings("deprecation")
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
// Save details
- getWidgetForPaintable().client = client;
- getWidgetForPaintable().paintableId = uidl.getId();
+ getWidget().client = client;
+ getWidget().paintableId = uidl.getId();
- getWidgetForPaintable().readonly = getState().isReadOnly();
- getWidgetForPaintable().enabled = !getState().isDisabled();
+ getWidget().readonly = getState().isReadOnly();
+ getWidget().enabled = !getState().isDisabled();
- getWidgetForPaintable().tb.setEnabled(getWidgetForPaintable().enabled);
- getWidgetForPaintable().updateReadOnly();
+ getWidget().tb.setEnabled(getWidget().enabled);
+ getWidget().updateReadOnly();
super.updateFromUIDL(uidl, client);
if (!isRealUpdate(uidl)) {
boolean noTextInput = uidl
.hasAttribute(VFilterSelect.ATTR_NO_TEXT_INPUT)
&& uidl.getBooleanAttribute(VFilterSelect.ATTR_NO_TEXT_INPUT);
- getWidgetForPaintable().setTextInputEnabled(!noTextInput);
+ getWidget().setTextInputEnabled(!noTextInput);
// not a FocusWidget -> needs own tabindex handling
if (uidl.hasAttribute("tabindex")) {
- getWidgetForPaintable().tb.setTabIndex(uidl
+ getWidget().tb.setTabIndex(uidl
.getIntAttribute("tabindex"));
}
if (uidl.hasAttribute("filteringmode")) {
- getWidgetForPaintable().filteringmode = uidl
+ getWidget().filteringmode = uidl
.getIntAttribute("filteringmode");
}
- getWidgetForPaintable().immediate = getState().isImmediate();
+ getWidget().immediate = getState().isImmediate();
- getWidgetForPaintable().nullSelectionAllowed = uidl
+ getWidget().nullSelectionAllowed = uidl
.hasAttribute("nullselect");
- getWidgetForPaintable().nullSelectItem = uidl
+ getWidget().nullSelectItem = uidl
.hasAttribute("nullselectitem")
&& uidl.getBooleanAttribute("nullselectitem");
- getWidgetForPaintable().currentPage = uidl.getIntVariable("page");
+ getWidget().currentPage = uidl.getIntVariable("page");
if (uidl.hasAttribute("pagelength")) {
- getWidgetForPaintable().pageLength = uidl
+ getWidget().pageLength = uidl
.getIntAttribute("pagelength");
}
if (uidl.hasAttribute(VFilterSelect.ATTR_INPUTPROMPT)) {
// input prompt changed from server
- getWidgetForPaintable().inputPrompt = uidl
+ getWidget().inputPrompt = uidl
.getStringAttribute(VFilterSelect.ATTR_INPUTPROMPT);
} else {
- getWidgetForPaintable().inputPrompt = "";
+ getWidget().inputPrompt = "";
}
- getWidgetForPaintable().suggestionPopup.updateStyleNames(uidl,
+ getWidget().suggestionPopup.updateStyleNames(uidl,
getState());
- getWidgetForPaintable().allowNewItem = uidl
+ getWidget().allowNewItem = uidl
.hasAttribute("allownewitem");
- getWidgetForPaintable().lastNewItemString = null;
+ getWidget().lastNewItemString = null;
- getWidgetForPaintable().currentSuggestions.clear();
- if (!getWidgetForPaintable().waitingForFilteringResponse) {
+ 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.
*/
- getWidgetForPaintable().currentSuggestion = null;
+ 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.
*/
- getWidgetForPaintable().suggestionPopup.menu.clearItems();
+ getWidget().suggestionPopup.menu.clearItems();
}
final UIDL options = uidl.getChildUIDL(0);
if (uidl.hasAttribute("totalMatches")) {
- getWidgetForPaintable().totalMatches = uidl
+ getWidget().totalMatches = uidl
.getIntAttribute("totalMatches");
} else {
- getWidgetForPaintable().totalMatches = 0;
+ getWidget().totalMatches = 0;
}
// used only to calculate minimum popup width
- String captions = Util.escapeHTML(getWidgetForPaintable().inputPrompt);
+ String captions = Util.escapeHTML(getWidget().inputPrompt);
for (final Iterator<?> i = options.getChildIterator(); i.hasNext();) {
final UIDL optionUidl = (UIDL) i.next();
- final FilterSelectSuggestion suggestion = getWidgetForPaintable().new FilterSelectSuggestion(
+ final FilterSelectSuggestion suggestion = getWidget().new FilterSelectSuggestion(
optionUidl);
- getWidgetForPaintable().currentSuggestions.add(suggestion);
+ getWidget().currentSuggestions.add(suggestion);
if (optionUidl.hasAttribute("selected")) {
- if (!getWidgetForPaintable().waitingForFilteringResponse
- || getWidgetForPaintable().popupOpenerClicked) {
+ if (!getWidget().waitingForFilteringResponse
+ || getWidget().popupOpenerClicked) {
String newSelectedOptionKey = Integer.toString(suggestion
.getOptionKey());
if (!newSelectedOptionKey
- .equals(getWidgetForPaintable().selectedOptionKey)
+ .equals(getWidget().selectedOptionKey)
|| suggestion.getReplacementString().equals(
- getWidgetForPaintable().tb.getText())) {
+ 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
- getWidgetForPaintable().setPromptingOff(
+ getWidget().setPromptingOff(
suggestion.getReplacementString());
- getWidgetForPaintable().selectedOptionKey = newSelectedOptionKey;
+ getWidget().selectedOptionKey = newSelectedOptionKey;
}
}
- getWidgetForPaintable().currentSuggestion = suggestion;
- getWidgetForPaintable().setSelectedItemIcon(
+ getWidget().currentSuggestion = suggestion;
+ getWidget().setSelectedItemIcon(
suggestion.getIconUri());
}
captions += Util.escapeHTML(suggestion.getReplacementString());
}
- if ((!getWidgetForPaintable().waitingForFilteringResponse || getWidgetForPaintable().popupOpenerClicked)
+ if ((!getWidget().waitingForFilteringResponse || getWidget().popupOpenerClicked)
&& uidl.hasVariable("selected")
&& uidl.getStringArrayVariable("selected").length == 0) {
// select nulled
- if (!getWidgetForPaintable().waitingForFilteringResponse
- || !getWidgetForPaintable().popupOpenerClicked) {
- if (!getWidgetForPaintable().focused) {
+ 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...
*/
- getWidgetForPaintable().prompting = false;
- getWidgetForPaintable().setPromptingOn();
+ getWidget().prompting = false;
+ getWidget().setPromptingOn();
} else {
// we have focus in field, prompting can't be set on,
// instead just clear the input
- getWidgetForPaintable().tb.setValue("");
+ getWidget().tb.setValue("");
}
}
- getWidgetForPaintable().setSelectedItemIcon(null);
- getWidgetForPaintable().selectedOptionKey = null;
+ getWidget().setSelectedItemIcon(null);
+ getWidget().selectedOptionKey = null;
}
- if (getWidgetForPaintable().waitingForFilteringResponse
- && getWidgetForPaintable().lastFilter.toLowerCase().equals(
+ if (getWidget().waitingForFilteringResponse
+ && getWidget().lastFilter.toLowerCase().equals(
uidl.getStringVariable("filter"))) {
- getWidgetForPaintable().suggestionPopup.showSuggestions(
- getWidgetForPaintable().currentSuggestions,
- getWidgetForPaintable().currentPage,
- getWidgetForPaintable().totalMatches);
- getWidgetForPaintable().waitingForFilteringResponse = false;
- if (!getWidgetForPaintable().popupOpenerClicked
- && getWidgetForPaintable().selectPopupItemWhenResponseIsReceived != VFilterSelect.Select.NONE) {
+ 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 (getWidgetForPaintable().selectPopupItemWhenResponseIsReceived == VFilterSelect.Select.LAST) {
- getWidgetForPaintable().suggestionPopup.menu
+ if (getWidget().selectPopupItemWhenResponseIsReceived == VFilterSelect.Select.LAST) {
+ getWidget().suggestionPopup.menu
.selectLastItem();
} else {
- getWidgetForPaintable().suggestionPopup.menu
+ getWidget().suggestionPopup.menu
.selectFirstItem();
}
// This is used for paging so we update the keyboard selection
// variable as well.
- MenuItem activeMenuItem = getWidgetForPaintable().suggestionPopup.menu
+ MenuItem activeMenuItem = getWidget().suggestionPopup.menu
.getSelectedItem();
- getWidgetForPaintable().suggestionPopup.menu
+ getWidget().suggestionPopup.menu
.setKeyboardSelectedItem(activeMenuItem);
// Update text field to contain the correct text
- getWidgetForPaintable()
+ getWidget()
.setTextboxText(activeMenuItem.getText());
- getWidgetForPaintable().tb.setSelectionRange(
- getWidgetForPaintable().lastFilter.length(),
+ getWidget().tb.setSelectionRange(
+ getWidget().lastFilter.length(),
activeMenuItem.getText().length()
- - getWidgetForPaintable().lastFilter.length());
+ - getWidget().lastFilter.length());
- getWidgetForPaintable().selectPopupItemWhenResponseIsReceived = VFilterSelect.Select.NONE; // reset
+ getWidget().selectPopupItemWhenResponseIsReceived = VFilterSelect.Select.NONE; // reset
}
- if (getWidgetForPaintable().updateSelectionWhenReponseIsReceived) {
- getWidgetForPaintable().suggestionPopup.menu
+ if (getWidget().updateSelectionWhenReponseIsReceived) {
+ getWidget().suggestionPopup.menu
.doPostFilterSelectedItemAction();
}
}
// Calculate minumum textarea width
- getWidgetForPaintable().suggestionPopupMinWidth = getWidgetForPaintable()
+ getWidget().suggestionPopupMinWidth = getWidget()
.minWidth(captions);
- getWidgetForPaintable().popupOpenerClicked = false;
+ getWidget().popupOpenerClicked = false;
- if (!getWidgetForPaintable().initDone) {
- getWidgetForPaintable().updateRootWidth();
+ if (!getWidget().initDone) {
+ getWidget().updateRootWidth();
}
// Focus dependent style names are lost during the update, so we add
// them here back again
- if (getWidgetForPaintable().focused) {
- getWidgetForPaintable().addStyleDependentName("focus");
+ if (getWidget().focused) {
+ getWidget().addStyleDependentName("focus");
}
- getWidgetForPaintable().initDone = true;
+ getWidget().initDone = true;
}
@Override
}
@Override
- public VFilterSelect getWidgetForPaintable() {
- return (VFilterSelect) super.getWidgetForPaintable();
+ public VFilterSelect getWidget() {
+ return (VFilterSelect) super.getWidget();
}
public void layout() {
- VFilterSelect widget = getWidgetForPaintable();
+ VFilterSelect widget = getWidget();
if (widget.initDone) {
widget.updateRootWidth();
}
final UIDL childUidl = (UIDL) it.next();
final VPaintableWidget childPaintable = client
.getPaintable(childUidl);
- Widget childWidget = childPaintable.getWidgetForPaintable();
+ Widget childWidget = childPaintable.getWidget();
Caption caption = widgetToCaption.get(childWidget);
if (caption == null) {
caption = new Caption(childPaintable, client);
public void updateCaption(VPaintableWidget paintable, UIDL uidl) {
final Caption c = widgetToCaption.get(paintable
- .getWidgetForPaintable());
+ .getWidget());
if (c != null) {
c.updateCaption(uidl, paintable.getState());
}
final ErrorFlag e = widgetToError.get(paintable
- .getWidgetForPaintable());
+ .getWidget());
if (e != null) {
e.updateFromUIDL(uidl, paintable);
}
public class VFormLayoutPaintable extends VAbstractPaintableWidgetContainer {
@Override
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidgetForPaintable().client = client;
+ getWidget().client = client;
super.updateFromUIDL(uidl, client);
if (!isRealUpdate(uidl)) {
return;
}
- getWidgetForPaintable().table.updateFromUIDL(uidl, client);
+ getWidget().table.updateFromUIDL(uidl, client);
}
public void updateCaption(VPaintableWidget component, UIDL uidl) {
- getWidgetForPaintable().table.updateCaption(component, uidl);
+ getWidget().table.updateCaption(component, uidl);
}
@Override
- public VFormLayout getWidgetForPaintable() {
- return (VFormLayout) super.getWidgetForPaintable();
+ public VFormLayout getWidget() {
+ return (VFormLayout) super.getWidget();
}
@Override
@Override
public void init() {
- VForm form = getWidgetForPaintable();
+ VForm form = getWidget();
getLayoutManager().registerDependency(this, form.footerContainer);
}
@Override
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidgetForPaintable().client = client;
- getWidgetForPaintable().id = uidl.getId();
+ getWidget().client = client;
+ getWidget().id = uidl.getId();
super.updateFromUIDL(uidl, client);
if (!isRealUpdate(uidl)) {
boolean legendEmpty = true;
if (getState().getCaption() != null) {
- getWidgetForPaintable().caption.setInnerText(getState()
+ getWidget().caption.setInnerText(getState()
.getCaption());
legendEmpty = false;
} else {
- getWidgetForPaintable().caption.setInnerText("");
+ getWidget().caption.setInnerText("");
}
if (uidl.hasAttribute(ATTRIBUTE_ICON)) {
- if (getWidgetForPaintable().icon == null) {
- getWidgetForPaintable().icon = new Icon(client);
- getWidgetForPaintable().legend
- .insertFirst(getWidgetForPaintable().icon.getElement());
+ if (getWidget().icon == null) {
+ getWidget().icon = new Icon(client);
+ getWidget().legend
+ .insertFirst(getWidget().icon.getElement());
}
- getWidgetForPaintable().icon.setUri(uidl
+ getWidget().icon.setUri(uidl
.getStringAttribute(ATTRIBUTE_ICON));
legendEmpty = false;
} else {
- if (getWidgetForPaintable().icon != null) {
- getWidgetForPaintable().legend
- .removeChild(getWidgetForPaintable().icon.getElement());
+ if (getWidget().icon != null) {
+ getWidget().legend
+ .removeChild(getWidget().icon.getElement());
}
}
if (legendEmpty) {
- getWidgetForPaintable().addStyleDependentName("nocaption");
+ getWidget().addStyleDependentName("nocaption");
} else {
- getWidgetForPaintable().removeStyleDependentName("nocaption");
+ getWidget().removeStyleDependentName("nocaption");
}
if (uidl.hasAttribute("error")) {
final UIDL errorUidl = uidl.getErrors();
- getWidgetForPaintable().errorMessage.updateFromUIDL(errorUidl);
- getWidgetForPaintable().errorMessage.setVisible(true);
+ getWidget().errorMessage.updateFromUIDL(errorUidl);
+ getWidget().errorMessage.setVisible(true);
} else {
- getWidgetForPaintable().errorMessage.setVisible(false);
+ getWidget().errorMessage.setVisible(false);
}
if (getState().hasDescription()) {
- getWidgetForPaintable().desc.setInnerHTML(getState()
+ getWidget().desc.setInnerHTML(getState()
.getDescription());
- if (getWidgetForPaintable().desc.getParentElement() == null) {
- getWidgetForPaintable().fieldSet.insertAfter(
- getWidgetForPaintable().desc,
- getWidgetForPaintable().legend);
+ if (getWidget().desc.getParentElement() == null) {
+ getWidget().fieldSet.insertAfter(
+ getWidget().desc,
+ getWidget().legend);
}
} else {
- getWidgetForPaintable().desc.setInnerHTML("");
- if (getWidgetForPaintable().desc.getParentElement() != null) {
- getWidgetForPaintable().fieldSet
- .removeChild(getWidgetForPaintable().desc);
+ getWidget().desc.setInnerHTML("");
+ if (getWidget().desc.getParentElement() != null) {
+ getWidget().fieldSet
+ .removeChild(getWidget().desc);
}
}
// render footer
VPaintableWidget newFooter = client.getPaintable(uidl
.getChildUIDL(1));
- Widget newFooterWidget = newFooter.getWidgetForPaintable();
- if (getWidgetForPaintable().footer == null) {
- getWidgetForPaintable().add(newFooter.getWidgetForPaintable(),
- getWidgetForPaintable().footerContainer);
- getWidgetForPaintable().footer = newFooterWidget;
- } else if (newFooter != getWidgetForPaintable().footer) {
- getWidgetForPaintable().remove(getWidgetForPaintable().footer);
+ 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(VPaintableMap.get(getConnection())
- .getPaintable(getWidgetForPaintable().footer));
- getWidgetForPaintable().add(newFooter.getWidgetForPaintable(),
- getWidgetForPaintable().footerContainer);
+ .getPaintable(getWidget().footer));
+ getWidget().add(newFooter.getWidget(),
+ getWidget().footerContainer);
}
- getWidgetForPaintable().footer = newFooterWidget;
+ getWidget().footer = newFooterWidget;
newFooter.updateFromUIDL(uidl.getChildUIDL(1), client);
} else {
- if (getWidgetForPaintable().footer != null) {
- getWidgetForPaintable().remove(getWidgetForPaintable().footer);
+ if (getWidget().footer != null) {
+ getWidget().remove(getWidget().footer);
client.unregisterPaintable(VPaintableMap.get(getConnection())
- .getPaintable(getWidgetForPaintable().footer));
+ .getPaintable(getWidget().footer));
}
}
final UIDL layoutUidl = uidl.getChildUIDL(0);
VPaintableWidget newLayout = client.getPaintable(layoutUidl);
- Widget newLayoutWidget = newLayout.getWidgetForPaintable();
- if (getWidgetForPaintable().lo == null) {
+ Widget newLayoutWidget = newLayout.getWidget();
+ if (getWidget().lo == null) {
// Layout not rendered before
- getWidgetForPaintable().lo = newLayoutWidget;
- getWidgetForPaintable().add(newLayoutWidget,
- getWidgetForPaintable().fieldContainer);
- } else if (getWidgetForPaintable().lo != newLayoutWidget) {
+ getWidget().lo = newLayoutWidget;
+ getWidget().add(newLayoutWidget,
+ getWidget().fieldContainer);
+ } else if (getWidget().lo != newLayoutWidget) {
// Layout has changed
client.unregisterPaintable(VPaintableMap.get(getConnection())
- .getPaintable(getWidgetForPaintable().lo));
- getWidgetForPaintable().remove(getWidgetForPaintable().lo);
- getWidgetForPaintable().lo = newLayoutWidget;
- getWidgetForPaintable().add(newLayoutWidget,
- getWidgetForPaintable().fieldContainer);
+ .getPaintable(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(getWidgetForPaintable());
+ client.runDescendentsLayout(getWidget());
// We may have actions attached
if (uidl.getChildCount() > 1) {
UIDL childUidl = uidl.getChildByTagName("actions");
if (childUidl != null) {
- if (getWidgetForPaintable().shortcutHandler == null) {
- getWidgetForPaintable().shortcutHandler = new ShortcutActionHandler(
+ if (getWidget().shortcutHandler == null) {
+ getWidget().shortcutHandler = new ShortcutActionHandler(
getId(), client);
- getWidgetForPaintable().keyDownRegistration = getWidgetForPaintable()
- .addDomHandler(getWidgetForPaintable(),
+ getWidget().keyDownRegistration = getWidget()
+ .addDomHandler(getWidget(),
KeyDownEvent.getType());
}
- getWidgetForPaintable().shortcutHandler
+ getWidget().shortcutHandler
.updateActionMap(childUidl);
}
- } else if (getWidgetForPaintable().shortcutHandler != null) {
- getWidgetForPaintable().keyDownRegistration.removeHandler();
- getWidgetForPaintable().shortcutHandler = null;
- getWidgetForPaintable().keyDownRegistration = null;
+ } else if (getWidget().shortcutHandler != null) {
+ getWidget().keyDownRegistration.removeHandler();
+ getWidget().shortcutHandler = null;
+ getWidget().keyDownRegistration = null;
}
}
}
@Override
- public VForm getWidgetForPaintable() {
- return (VForm) super.getWidgetForPaintable();
+ public VForm getWidget() {
+ return (VForm) super.getWidget();
}
@Override
}
public void layout() {
- VForm form = getWidgetForPaintable();
+ VForm form = getWidget();
int footerHeight = getLayoutManager().getOuterHeight(
form.footerContainer);
Element slotWrapper = slot.getWrapperElement();
getElement().appendChild(slotWrapper);
- Widget widget = paintable.getWidgetForPaintable();
+ Widget widget = paintable.getWidget();
insert(widget, slotWrapper, getWidgetCount(), false);
Cell oldCell = widgetToCell.put(widget, this);
if (oldCell != null) {
@Override
protected VPaintableWidget getChildComponent(Element element) {
- return getWidgetForPaintable().getComponent(element);
+ return getWidget().getComponent(element);
}
@Override
protected <H extends EventHandler> HandlerRegistration registerHandler(
H handler, Type<H> type) {
- return getWidgetForPaintable().addDomHandler(handler, type);
+ return getWidget().addDomHandler(handler, type);
}
};
@Override
public void init() {
getLayoutManager().registerDependency(this,
- getWidgetForPaintable().spacingMeasureElement);
+ getWidget().spacingMeasureElement);
}
@Override
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- VGridLayout layout = getWidgetForPaintable();
+ VGridLayout layout = getWidget();
layout.client = client;
super.updateFromUIDL(uidl, client);
}
public void updateCaption(VPaintableWidget paintable, UIDL uidl) {
- VGridLayout layout = getWidgetForPaintable();
+ VGridLayout layout = getWidget();
if (VCaption.isNeeded(uidl, paintable.getState())) {
Cell cell = layout.widgetToCell.get(paintable
- .getWidgetForPaintable());
+ .getWidget());
VLayoutSlot layoutSlot = cell.slot;
VCaption caption = layoutSlot.getCaption();
if (caption == null) {
caption = new VCaption(paintable, getConnection());
- Widget widget = paintable.getWidgetForPaintable();
+ Widget widget = paintable.getWidget();
layout.setCaption(widget, caption);
}
caption.updateCaption(uidl);
} else {
- layout.setCaption(paintable.getWidgetForPaintable(), null);
+ layout.setCaption(paintable.getWidget(), null);
}
}
@Override
- public VGridLayout getWidgetForPaintable() {
- return (VGridLayout) super.getWidgetForPaintable();
+ public VGridLayout getWidget() {
+ return (VGridLayout) super.getWidget();
}
@Override
}
public void layoutVertically() {
- getWidgetForPaintable().updateHeight();
+ getWidget().updateHeight();
}
public void layoutHorizontally() {
- getWidgetForPaintable().updateWidth();
+ getWidget().updateWidth();
}
}
VMeasuringOrderedLayoutPaintable {
@Override
- public VHorizontalLayout getWidgetForPaintable() {
- return (VHorizontalLayout) super.getWidgetForPaintable();
+ public VHorizontalLayout getWidget() {
+ return (VHorizontalLayout) super.getWidget();
}
@Override
return;
}
- getWidgetForPaintable().client = client;
+ getWidget().client = client;
- getWidgetForPaintable().enabled = !getState().isDisabled();
- getWidgetForPaintable().readonly = getState().isReadOnly();
+ getWidget().enabled = !getState().isDisabled();
+ getWidget().readonly = getState().isReadOnly();
if (uidl.hasAttribute("name")) {
- getWidgetForPaintable().target = uidl.getStringAttribute("name");
- getWidgetForPaintable().anchor.setAttribute("target",
- getWidgetForPaintable().target);
+ getWidget().target = uidl.getStringAttribute("name");
+ getWidget().anchor.setAttribute("target",
+ getWidget().target);
}
if (uidl.hasAttribute("src")) {
- getWidgetForPaintable().src = client.translateVaadinUri(uidl
+ getWidget().src = client.translateVaadinUri(uidl
.getStringAttribute("src"));
- getWidgetForPaintable().anchor.setAttribute("href",
- getWidgetForPaintable().src);
+ getWidget().anchor.setAttribute("href",
+ getWidget().src);
}
if (uidl.hasAttribute("border")) {
if ("none".equals(uidl.getStringAttribute("border"))) {
- getWidgetForPaintable().borderStyle = VLink.BORDER_STYLE_NONE;
+ getWidget().borderStyle = VLink.BORDER_STYLE_NONE;
} else {
- getWidgetForPaintable().borderStyle = VLink.BORDER_STYLE_MINIMAL;
+ getWidget().borderStyle = VLink.BORDER_STYLE_MINIMAL;
}
} else {
- getWidgetForPaintable().borderStyle = VLink.BORDER_STYLE_DEFAULT;
+ getWidget().borderStyle = VLink.BORDER_STYLE_DEFAULT;
}
- getWidgetForPaintable().targetHeight = uidl
+ getWidget().targetHeight = uidl
.hasAttribute("targetHeight") ? uidl
.getIntAttribute("targetHeight") : -1;
- getWidgetForPaintable().targetWidth = uidl.hasAttribute("targetWidth") ? uidl
+ getWidget().targetWidth = uidl.hasAttribute("targetWidth") ? uidl
.getIntAttribute("targetWidth") : -1;
// Set link caption
- getWidgetForPaintable().captionElement.setInnerText(getState()
+ getWidget().captionElement.setInnerText(getState()
.getCaption());
// handle error
if (uidl.hasAttribute("error")) {
- if (getWidgetForPaintable().errorIndicatorElement == null) {
- getWidgetForPaintable().errorIndicatorElement = DOM.createDiv();
+ if (getWidget().errorIndicatorElement == null) {
+ getWidget().errorIndicatorElement = DOM.createDiv();
DOM.setElementProperty(
- getWidgetForPaintable().errorIndicatorElement,
+ getWidget().errorIndicatorElement,
"className", "v-errorindicator");
}
- DOM.insertChild(getWidgetForPaintable().getElement(),
- getWidgetForPaintable().errorIndicatorElement, 0);
- } else if (getWidgetForPaintable().errorIndicatorElement != null) {
+ DOM.insertChild(getWidget().getElement(),
+ getWidget().errorIndicatorElement, 0);
+ } else if (getWidget().errorIndicatorElement != null) {
DOM.setStyleAttribute(
- getWidgetForPaintable().errorIndicatorElement, "display",
+ getWidget().errorIndicatorElement, "display",
"none");
}
if (uidl.hasAttribute(ATTRIBUTE_ICON)) {
- if (getWidgetForPaintable().icon == null) {
- getWidgetForPaintable().icon = new Icon(client);
- getWidgetForPaintable().anchor.insertBefore(
- getWidgetForPaintable().icon.getElement(),
- getWidgetForPaintable().captionElement);
+ if (getWidget().icon == null) {
+ getWidget().icon = new Icon(client);
+ getWidget().anchor.insertBefore(
+ getWidget().icon.getElement(),
+ getWidget().captionElement);
}
- getWidgetForPaintable().icon.setUri(uidl
+ getWidget().icon.setUri(uidl
.getStringAttribute(ATTRIBUTE_ICON));
}
}
@Override
- public VLink getWidgetForPaintable() {
- return (VLink) super.getWidgetForPaintable();
+ public VLink getWidget() {
+ return (VLink) super.getWidget();
}
}
}
@Override
- public VListSelect getWidgetForPaintable() {
- return (VListSelect) super.getWidgetForPaintable();
+ public VListSelect getWidget() {
+ return (VListSelect) super.getWidget();
}
}
@Override
public void init() {
getLayoutManager().registerDependency(this,
- getWidgetForPaintable().spacingMeasureElement);
+ getWidget().spacingMeasureElement);
}
public void updateCaption(VPaintableWidget component, UIDL uidl) {
- VMeasuringOrderedLayout layout = getWidgetForPaintable();
+ VMeasuringOrderedLayout layout = getWidget();
if (VCaption.isNeeded(uidl, component.getState())) {
VLayoutSlot layoutSlot = layout.getSlotForChild(component
- .getWidgetForPaintable());
+ .getWidget());
VCaption caption = layoutSlot.getCaption();
if (caption == null) {
caption = new VCaption(component, getConnection());
- Widget widget = component.getWidgetForPaintable();
+ Widget widget = component.getWidget();
layout.setCaption(widget, caption);
}
caption.updateCaption(uidl);
} else {
- layout.setCaption(component.getWidgetForPaintable(), null);
+ layout.setCaption(component.getWidget(), null);
}
}
@Override
- public VMeasuringOrderedLayout getWidgetForPaintable() {
- return (VMeasuringOrderedLayout) super.getWidgetForPaintable();
+ public VMeasuringOrderedLayout getWidget() {
+ return (VMeasuringOrderedLayout) super.getWidget();
}
@Override
HashSet<VPaintableWidget> previousChildren = new HashSet<VPaintableWidget>(
getChildren());
- VMeasuringOrderedLayout layout = getWidgetForPaintable();
+ VMeasuringOrderedLayout layout = getWidget();
ValueMap expandRatios = uidl.getMapAttribute("expandRatios");
ValueMap alignments = uidl.getMapAttribute("alignments");
for (final Iterator<Object> it = uidl.getChildIterator(); it.hasNext();) {
final UIDL childUIDL = (UIDL) it.next();
final VPaintableWidget child = client.getPaintable(childUIDL);
- Widget widget = child.getWidgetForPaintable();
+ Widget widget = child.getWidget();
VLayoutSlot slot = layout.getSlotForChild(widget);
if (widget.getParent() != layout) {
- slot = new VPaintableLayoutSlot(getWidgetForPaintable()
+ slot = new VPaintableLayoutSlot(getWidget()
.getStylePrimaryName(), child);
}
layout.addOrMove(slot, currentIndex++);
}
for (VPaintableWidget child : previousChildren) {
- Widget widget = child.getWidgetForPaintable();
+ 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() == getWidgetForPaintable()) {
+ if (widget.getParent() == getWidget()) {
layout.removeSlot(layout.getSlotForChild(widget));
VPaintableMap vPaintableMap = VPaintableMap.get(client);
private int getSizeForInnerSize(int size, boolean isVertical) {
LayoutManager layoutManager = getLayoutManager();
- Element element = getWidgetForPaintable().getElement();
+ Element element = getWidget().getElement();
if (isVertical) {
return size + layoutManager.getBorderHeight(element)
+ layoutManager.getPaddingHeight(element);
private int getInnerSizeInDirection(boolean isVertical) {
if (isVertical) {
return getLayoutManager().getInnerHeight(
- getWidgetForPaintable().getElement());
+ getWidget().getElement());
} else {
return getLayoutManager().getInnerWidth(
- getWidgetForPaintable().getElement());
+ getWidget().getElement());
}
}
private void layoutPrimaryDirection() {
- VMeasuringOrderedLayout layout = getWidgetForPaintable();
+ VMeasuringOrderedLayout layout = getWidget();
boolean isVertical = layout.isVertical;
boolean isUndefined = isUndefinedInDirection(isVertical);
allocatedSize = layout.layoutPrimaryDirection(spacingSize,
allocatedSize, startPadding);
- Style ownStyle = getWidgetForPaintable().getElement().getStyle();
+ Style ownStyle = getWidget().getElement().getStyle();
if (isUndefined) {
ownStyle.setPropertyPx(getSizeProperty(isVertical),
getSizeForInnerSize(allocatedSize, isVertical));
private int getSpacingInDirection(boolean isVertical) {
if (isVertical) {
return getLayoutManager().getOuterHeight(
- getWidgetForPaintable().spacingMeasureElement);
+ getWidget().spacingMeasureElement);
} else {
return getLayoutManager().getOuterWidth(
- getWidgetForPaintable().spacingMeasureElement);
+ getWidget().spacingMeasureElement);
}
}
private void layoutSecondaryDirection() {
- VMeasuringOrderedLayout layout = getWidgetForPaintable();
+ VMeasuringOrderedLayout layout = getWidget();
boolean isVertical = layout.isVertical;
boolean isUndefined = isUndefinedInDirection(!isVertical);
allocatedSize = layout.layoutSecondaryDirection(allocatedSize,
startPadding);
- Style ownStyle = getWidgetForPaintable().getElement().getStyle();
+ Style ownStyle = getWidget().getElement().getStyle();
if (isUndefined) {
ownStyle.setPropertyPx(
- getSizeProperty(!getWidgetForPaintable().isVertical),
+ getSizeProperty(!getWidget().isVertical),
getSizeForInnerSize(allocatedSize,
- !getWidgetForPaintable().isVertical));
+ !getWidget().isVertical));
} else {
ownStyle.setProperty(
- getSizeProperty(!getWidgetForPaintable().isVertical),
- getDefinedSize(!getWidgetForPaintable().isVertical));
+ getSizeProperty(!getWidget().isVertical),
+ getDefinedSize(!getWidget().isVertical));
}
}
private int getStartPadding(boolean isVertical) {
if (isVertical) {
return getLayoutManager().getPaddingTop(
- getWidgetForPaintable().getElement());
+ getWidget().getElement());
} else {
return getLayoutManager().getPaddingLeft(
- getWidgetForPaintable().getElement());
+ getWidget().getElement());
}
}
public void layoutHorizontally() {
- if (getWidgetForPaintable().isVertical) {
+ if (getWidget().isVertical) {
layoutSecondaryDirection();
} else {
layoutPrimaryDirection();
}
public void layoutVertically() {
- if (getWidgetForPaintable().isVertical) {
+ if (getWidget().isVertical) {
layoutPrimaryDirection();
} else {
layoutSecondaryDirection();
return;
}
- getWidgetForPaintable().setControls(shouldShowControls(uidl));
- getWidgetForPaintable().setAutoplay(shouldAutoplay(uidl));
- getWidgetForPaintable().setMuted(isMediaMuted(uidl));
+ 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())) {
- getWidgetForPaintable().addSource(getSourceUrl(child),
+ getWidget().addSource(getSourceUrl(child),
getSourceType(child));
}
}
private void evalPlayCommand(UIDL uidl) {
if (uidl.hasAttribute(ATTR_PLAY)) {
- getWidgetForPaintable().play();
+ getWidget().play();
}
}
private void evalPauseCommand(UIDL uidl) {
if (uidl.hasAttribute(ATTR_PAUSE)) {
- getWidgetForPaintable().pause();
+ getWidget().pause();
}
}
@Override
- public VMediaBase getWidgetForPaintable() {
- return (VMediaBase) super.getWidgetForPaintable();
+ public VMediaBase getWidget() {
+ return (VMediaBase) super.getWidget();
}
/**
String alt = uidl.getStringAttribute(VMediaBasePaintable.ATTR_ALT_TEXT);
if (alt == null || "".equals(alt)) {
- alt = getWidgetForPaintable().getDefaultAltHtml();
+ alt = getWidget().getDefaultAltHtml();
} else if (!allowHtmlContent(uidl)) {
alt = Util.escapeHTML(alt);
}
- getWidgetForPaintable().setAltText(alt);
+ getWidget().setAltText(alt);
}
}
return;
}
- getWidgetForPaintable().htmlContentAllowed = uidl
+ getWidget().htmlContentAllowed = uidl
.hasAttribute(VMenuBar.HTML_CONTENT_ALLOWED);
- getWidgetForPaintable().openRootOnHover = uidl
+ getWidget().openRootOnHover = uidl
.getBooleanAttribute(VMenuBar.OPEN_ROOT_MENU_ON_HOWER);
- getWidgetForPaintable().enabled = !getState().isDisabled();
+ getWidget().enabled = !getState().isDisabled();
// For future connections
- getWidgetForPaintable().client = client;
- getWidgetForPaintable().uidlId = uidl.getId();
+ getWidget().client = client;
+ getWidget().uidlId = uidl.getId();
// Empty the menu every time it receives new information
- if (!getWidgetForPaintable().getItems().isEmpty()) {
- getWidgetForPaintable().clearItems();
+ if (!getWidget().getItems().isEmpty()) {
+ getWidget().clearItems();
}
UIDL options = uidl.getChildUIDL(0);
}
itemHTML.append(moreItemText);
- getWidgetForPaintable().moreItem = GWT.create(CustomMenuItem.class);
- getWidgetForPaintable().moreItem.setHTML(itemHTML.toString());
- getWidgetForPaintable().moreItem.setCommand(VMenuBar.emptyCommand);
+ getWidget().moreItem = GWT.create(CustomMenuItem.class);
+ getWidget().moreItem.setHTML(itemHTML.toString());
+ getWidget().moreItem.setCommand(VMenuBar.emptyCommand);
- getWidgetForPaintable().collapsedRootItems = new VMenuBar(true,
- getWidgetForPaintable());
- getWidgetForPaintable().moreItem
- .setSubMenu(getWidgetForPaintable().collapsedRootItems);
- getWidgetForPaintable().moreItem.addStyleName(VMenuBar.CLASSNAME
+ getWidget().collapsedRootItems = new VMenuBar(true,
+ getWidget());
+ getWidget().moreItem
+ .setSubMenu(getWidget().collapsedRootItems);
+ getWidget().moreItem.addStyleName(VMenuBar.CLASSNAME
+ "-more-menuitem");
}
Iterator<Object> itr = uidlItems.getChildIterator();
Stack<Iterator<Object>> iteratorStack = new Stack<Iterator<Object>>();
Stack<VMenuBar> menuStack = new Stack<VMenuBar>();
- VMenuBar currentMenu = getWidgetForPaintable();
+ VMenuBar currentMenu = getWidget();
while (itr.hasNext()) {
UIDL item = (UIDL) itr.next();
boolean itemIsCheckable = item
.hasAttribute(VMenuBar.ATTRIBUTE_CHECKED);
- String itemHTML = getWidgetForPaintable().buildItemHTML(item);
+ String itemHTML = getWidget().buildItemHTML(item);
Command cmd = null;
if (!item.hasAttribute("separator")) {
// item's id-number
cmd = new Command() {
public void execute() {
- getWidgetForPaintable().hostReference
+ getWidget().hostReference
.onMenuClick(itemId);
}
};
}
}// while
- getWidgetForPaintable().iLayout(false);
+ getWidget().iLayout(false);
}// updateFromUIDL
}
@Override
- public VMenuBar getWidgetForPaintable() {
- return (VMenuBar) super.getWidgetForPaintable();
+ public VMenuBar getWidget() {
+ return (VMenuBar) super.getWidget();
}
public void layout() {
- getWidgetForPaintable().iLayout();
+ getWidget().iLayout();
}
}
ButtonClientToServerRpc rpcProxy = GWT
.create(ButtonClientToServerRpc.class);
- getWidgetForPaintable().buttonRpcProxy = initRPC(rpcProxy);
+ getWidget().buttonRpcProxy = initRPC(rpcProxy);
}
@Override
return;
}
- getWidgetForPaintable().disableOnClick = getState().isDisableOnClick();
- getWidgetForPaintable().focusHandlerRegistration = EventHelper
+ getWidget().disableOnClick = getState().isDisableOnClick();
+ getWidget().focusHandlerRegistration = EventHelper
.updateFocusHandler(this, client,
- getWidgetForPaintable().focusHandlerRegistration);
- getWidgetForPaintable().blurHandlerRegistration = EventHelper
+ getWidget().focusHandlerRegistration);
+ getWidget().blurHandlerRegistration = EventHelper
.updateBlurHandler(this, client,
- getWidgetForPaintable().blurHandlerRegistration);
+ getWidget().blurHandlerRegistration);
// Save details
- getWidgetForPaintable().client = client;
- getWidgetForPaintable().paintableId = uidl.getId();
+ getWidget().client = client;
+ getWidget().paintableId = uidl.getId();
// Set text
- getWidgetForPaintable().setText(getState().getCaption());
+ getWidget().setText(getState().getCaption());
// handle error
if (uidl.hasAttribute("error")) {
- if (getWidgetForPaintable().errorIndicatorElement == null) {
- getWidgetForPaintable().errorIndicatorElement = DOM
+ if (getWidget().errorIndicatorElement == null) {
+ getWidget().errorIndicatorElement = DOM
.createSpan();
- getWidgetForPaintable().errorIndicatorElement
+ getWidget().errorIndicatorElement
.setClassName("v-errorindicator");
}
- getWidgetForPaintable().getElement().insertBefore(
- getWidgetForPaintable().errorIndicatorElement,
- getWidgetForPaintable().captionElement);
-
- } else if (getWidgetForPaintable().errorIndicatorElement != null) {
- getWidgetForPaintable().getElement().removeChild(
- getWidgetForPaintable().errorIndicatorElement);
- getWidgetForPaintable().errorIndicatorElement = null;
+ 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 (getWidgetForPaintable().icon == null) {
- getWidgetForPaintable().icon = new Icon(client);
- getWidgetForPaintable().getElement().insertBefore(
- getWidgetForPaintable().icon.getElement(),
- getWidgetForPaintable().captionElement);
+ if (getWidget().icon == null) {
+ getWidget().icon = new Icon(client);
+ getWidget().getElement().insertBefore(
+ getWidget().icon.getElement(),
+ getWidget().captionElement);
}
- getWidgetForPaintable().icon.setUri(uidl
+ getWidget().icon.setUri(uidl
.getStringAttribute(ATTRIBUTE_ICON));
} else {
- if (getWidgetForPaintable().icon != null) {
- getWidgetForPaintable().getElement().removeChild(
- getWidgetForPaintable().icon.getElement());
- getWidgetForPaintable().icon = null;
+ if (getWidget().icon != null) {
+ getWidget().getElement().removeChild(
+ getWidget().icon.getElement());
+ getWidget().icon = null;
}
}
}
@Override
- public VNativeButton getWidgetForPaintable() {
- return (VNativeButton) super.getWidgetForPaintable();
+ public VNativeButton getWidget() {
+ return (VNativeButton) super.getWidget();
}
@Override
}
@Override
- public VNativeSelect getWidgetForPaintable() {
- return (VNativeSelect) super.getWidgetForPaintable();
+ public VNativeSelect getWidget() {
+ return (VNativeSelect) super.getWidget();
}
}
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
// Save details
- getWidgetForPaintable().client = client;
- getWidgetForPaintable().paintableId = uidl.getId();
+ getWidget().client = client;
+ getWidget().paintableId = uidl.getId();
super.updateFromUIDL(uidl, client);
if (!isRealUpdate(uidl)) {
return;
}
- getWidgetForPaintable().selectedKeys = uidl
+ getWidget().selectedKeys = uidl
.getStringArrayVariableAsSet("selected");
- getWidgetForPaintable().readonly = getState().isReadOnly();
- getWidgetForPaintable().disabled = getState().isDisabled();
- getWidgetForPaintable().multiselect = "multi".equals(uidl
+ getWidget().readonly = getState().isReadOnly();
+ getWidget().disabled = getState().isDisabled();
+ getWidget().multiselect = "multi".equals(uidl
.getStringAttribute("selectmode"));
- getWidgetForPaintable().immediate = getState().isImmediate();
- getWidgetForPaintable().nullSelectionAllowed = uidl
+ getWidget().immediate = getState().isImmediate();
+ getWidget().nullSelectionAllowed = uidl
.getBooleanAttribute("nullselect");
- getWidgetForPaintable().nullSelectionItemAvailable = uidl
+ getWidget().nullSelectionItemAvailable = uidl
.getBooleanAttribute("nullselectitem");
if (uidl.hasAttribute("cols")) {
- getWidgetForPaintable().cols = uidl.getIntAttribute("cols");
+ getWidget().cols = uidl.getIntAttribute("cols");
}
if (uidl.hasAttribute("rows")) {
- getWidgetForPaintable().rows = uidl.getIntAttribute("rows");
+ getWidget().rows = uidl.getIntAttribute("rows");
}
final UIDL ops = uidl.getChildUIDL(0);
- if (getWidgetForPaintable().getColumns() > 0) {
- getWidgetForPaintable().container.setWidth(getWidgetForPaintable()
+ if (getWidget().getColumns() > 0) {
+ getWidget().container.setWidth(getWidget()
.getColumns() + "em");
- if (getWidgetForPaintable().container != getWidgetForPaintable().optionsContainer) {
- getWidgetForPaintable().optionsContainer.setWidth("100%");
+ if (getWidget().container != getWidget().optionsContainer) {
+ getWidget().optionsContainer.setWidth("100%");
}
}
- getWidgetForPaintable().buildOptions(ops);
+ getWidget().buildOptions(ops);
if (uidl.getBooleanAttribute("allownewitem")) {
- if (getWidgetForPaintable().newItemField == null) {
- getWidgetForPaintable().newItemButton = new VNativeButton();
- getWidgetForPaintable().newItemButton.setText("+");
- getWidgetForPaintable().newItemButton
- .addClickHandler(getWidgetForPaintable());
- getWidgetForPaintable().newItemField = new VTextField();
- getWidgetForPaintable().newItemField
- .addKeyPressHandler(getWidgetForPaintable());
+ if (getWidget().newItemField == null) {
+ getWidget().newItemButton = new VNativeButton();
+ getWidget().newItemButton.setText("+");
+ getWidget().newItemButton
+ .addClickHandler(getWidget());
+ getWidget().newItemField = new VTextField();
+ getWidget().newItemField
+ .addKeyPressHandler(getWidget());
}
- getWidgetForPaintable().newItemField
- .setEnabled(!getWidgetForPaintable().disabled
- && !getWidgetForPaintable().readonly);
- getWidgetForPaintable().newItemButton
- .setEnabled(!getWidgetForPaintable().disabled
- && !getWidgetForPaintable().readonly);
-
- if (getWidgetForPaintable().newItemField == null
- || getWidgetForPaintable().newItemField.getParent() != getWidgetForPaintable().container) {
- getWidgetForPaintable().container
- .add(getWidgetForPaintable().newItemField);
- getWidgetForPaintable().container
- .add(getWidgetForPaintable().newItemButton);
- final int w = getWidgetForPaintable().container
+ 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()
- - getWidgetForPaintable().newItemButton
+ - getWidget().newItemButton
.getOffsetWidth();
- getWidgetForPaintable().newItemField.setWidth(Math.max(w, 0)
+ getWidget().newItemField.setWidth(Math.max(w, 0)
+ "px");
}
- } else if (getWidgetForPaintable().newItemField != null) {
- getWidgetForPaintable().container
- .remove(getWidgetForPaintable().newItemField);
- getWidgetForPaintable().container
- .remove(getWidgetForPaintable().newItemButton);
+ } else if (getWidget().newItemField != null) {
+ getWidget().container
+ .remove(getWidget().newItemField);
+ getWidget().container
+ .remove(getWidget().newItemButton);
}
- getWidgetForPaintable().setTabIndex(
+ getWidget().setTabIndex(
uidl.hasAttribute("tabindex") ? uidl
.getIntAttribute("tabindex") : 0);
}
@Override
- public VOptionGroupBase getWidgetForPaintable() {
- return (VOptionGroupBase) super.getWidgetForPaintable();
+ public VOptionGroupBase getWidget() {
+ return (VOptionGroupBase) super.getWidget();
}
}
@Override
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidgetForPaintable().htmlContentAllowed = uidl
+ getWidget().htmlContentAllowed = uidl
.hasAttribute(VOptionGroup.HTML_CONTENT_ALLOWED);
super.updateFromUIDL(uidl, client);
- getWidgetForPaintable().sendFocusEvents = client.hasEventListeners(
+ getWidget().sendFocusEvents = client.hasEventListeners(
this, EventId.FOCUS);
- getWidgetForPaintable().sendBlurEvents = client.hasEventListeners(this,
+ getWidget().sendBlurEvents = client.hasEventListeners(this,
EventId.BLUR);
- if (getWidgetForPaintable().focusHandlers != null) {
- for (HandlerRegistration reg : getWidgetForPaintable().focusHandlers) {
+ if (getWidget().focusHandlers != null) {
+ for (HandlerRegistration reg : getWidget().focusHandlers) {
reg.removeHandler();
}
- getWidgetForPaintable().focusHandlers.clear();
- getWidgetForPaintable().focusHandlers = null;
+ getWidget().focusHandlers.clear();
+ getWidget().focusHandlers = null;
- for (HandlerRegistration reg : getWidgetForPaintable().blurHandlers) {
+ for (HandlerRegistration reg : getWidget().blurHandlers) {
reg.removeHandler();
}
- getWidgetForPaintable().blurHandlers.clear();
- getWidgetForPaintable().blurHandlers = null;
+ getWidget().blurHandlers.clear();
+ getWidget().blurHandlers = null;
}
- if (getWidgetForPaintable().sendFocusEvents
- || getWidgetForPaintable().sendBlurEvents) {
- getWidgetForPaintable().focusHandlers = new ArrayList<HandlerRegistration>();
- getWidgetForPaintable().blurHandlers = new ArrayList<HandlerRegistration>();
+ 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 : getWidgetForPaintable().panel) {
+ for (Widget wid : getWidget().panel) {
if (wid instanceof CheckBox) {
- getWidgetForPaintable().focusHandlers.add(((CheckBox) wid)
- .addFocusHandler(getWidgetForPaintable()));
- getWidgetForPaintable().blurHandlers.add(((CheckBox) wid)
- .addBlurHandler(getWidgetForPaintable()));
+ getWidget().focusHandlers.add(((CheckBox) wid)
+ .addFocusHandler(getWidget()));
+ getWidget().blurHandlers.add(((CheckBox) wid)
+ .addBlurHandler(getWidget()));
}
}
}
}
@Override
- public VOptionGroup getWidgetForPaintable() {
- return (VOptionGroup) super.getWidgetForPaintable();
+ public VOptionGroup getWidget() {
+ return (VOptionGroup) super.getWidget();
}
}
@Override
protected <H extends EventHandler> HandlerRegistration registerHandler(
H handler, Type<H> type) {
- return getWidgetForPaintable().addDomHandler(handler, type);
+ return getWidget().addDomHandler(handler, type);
}
};
@Override
public void init() {
- VPanel panel = getWidgetForPaintable();
+ VPanel panel = getWidget();
LayoutManager layoutManager = getLayoutManager();
layoutManager.registerDependency(this, panel.captionNode);
// Affects size calculations
// Restore default stylenames
- getWidgetForPaintable().contentNode.setClassName(VPanel.CLASSNAME
+ getWidget().contentNode.setClassName(VPanel.CLASSNAME
+ "-content");
- getWidgetForPaintable().bottomDecoration
+ getWidget().bottomDecoration
.setClassName(VPanel.CLASSNAME + "-deco");
- getWidgetForPaintable().captionNode.setClassName(VPanel.CLASSNAME
+ getWidget().captionNode.setClassName(VPanel.CLASSNAME
+ "-caption");
boolean hasCaption = false;
if (getState().getCaption() != null
&& !"".equals(getState().getCaption())) {
- getWidgetForPaintable().setCaption(getState().getCaption());
+ getWidget().setCaption(getState().getCaption());
hasCaption = true;
} else {
- getWidgetForPaintable().setCaption("");
- getWidgetForPaintable().captionNode
+ getWidget().setCaption("");
+ getWidget().captionNode
.setClassName(VPanel.CLASSNAME + "-nocaption");
}
decoClass += " " + decoBaseClass + "-" + styles[i];
}
}
- getWidgetForPaintable().captionNode.setClassName(captionClass);
- getWidgetForPaintable().contentNode.setClassName(contentClass);
- getWidgetForPaintable().bottomDecoration.setClassName(decoClass);
+ getWidget().captionNode.setClassName(captionClass);
+ getWidget().contentNode.setClassName(contentClass);
+ getWidget().bottomDecoration.setClassName(decoClass);
}
// Ensure correct implementation
super.updateFromUIDL(uidl, client);
clickEventHandler.handleEventHandlerRegistration(client);
- getWidgetForPaintable().client = client;
- getWidgetForPaintable().id = uidl.getId();
+ getWidget().client = client;
+ getWidget().id = uidl.getId();
- getWidgetForPaintable().setIconUri(uidl, client);
+ getWidget().setIconUri(uidl, client);
- getWidgetForPaintable().handleError(uidl);
+ getWidget().handleError(uidl);
// Render content
final UIDL layoutUidl = uidl.getChildUIDL(0);
final VPaintableWidget newLayout = client.getPaintable(layoutUidl);
- if (newLayout != getWidgetForPaintable().layout) {
- if (getWidgetForPaintable().layout != null) {
- client.unregisterPaintable(getWidgetForPaintable().layout);
+ if (newLayout != getWidget().layout) {
+ if (getWidget().layout != null) {
+ client.unregisterPaintable(getWidget().layout);
}
- getWidgetForPaintable()
- .setWidget(newLayout.getWidgetForPaintable());
- getWidgetForPaintable().layout = newLayout;
+ getWidget()
+ .setWidget(newLayout.getWidget());
+ getWidget().layout = newLayout;
}
- getWidgetForPaintable().layout.updateFromUIDL(layoutUidl, client);
+ getWidget().layout.updateFromUIDL(layoutUidl, client);
// We may have actions attached to this panel
if (uidl.getChildCount() > 1) {
for (int i = 1; i < cnt; i++) {
UIDL childUidl = uidl.getChildUIDL(i);
if (childUidl.getTag().equals("actions")) {
- if (getWidgetForPaintable().shortcutHandler == null) {
- getWidgetForPaintable().shortcutHandler = new ShortcutActionHandler(
+ if (getWidget().shortcutHandler == null) {
+ getWidget().shortcutHandler = new ShortcutActionHandler(
getId(), client);
}
- getWidgetForPaintable().shortcutHandler
+ getWidget().shortcutHandler
.updateActionMap(childUidl);
}
}
}
if (uidl.hasVariable("scrollTop")
- && uidl.getIntVariable("scrollTop") != getWidgetForPaintable().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") != getWidgetForPaintable().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")) {
- getWidgetForPaintable().contentNode.setTabIndex(uidl
+ getWidget().contentNode.setTabIndex(uidl
.getIntVariable("tabindex"));
}
}
}
@Override
- public VPanel getWidgetForPaintable() {
- return (VPanel) super.getWidgetForPaintable();
+ public VPanel getWidget() {
+ return (VPanel) super.getWidget();
}
@Override
}
void updateSizes() {
- VPanel panel = getWidgetForPaintable();
+ VPanel panel = getWidget();
Style contentStyle = panel.contentNode.getStyle();
if (isUndefinedHeight()) {
}
public void postLayout() {
- VPanel panel = getWidgetForPaintable();
+ VPanel panel = getWidget();
if (uidlScrollTop != null) {
panel.contentNode.setScrollTop(uidlScrollTop.intValue());
// Read actual value back to ensure update logic is correct
}
@Override
- public VPasswordField getWidgetForPaintable() {
- return (VPasswordField) super.getWidgetForPaintable();
+ public VPasswordField getWidget() {
+ return (VPasswordField) super.getWidget();
}
}
@Override
@SuppressWarnings("deprecation")
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- boolean lastReadOnlyState = getWidgetForPaintable().readonly;
- boolean lastEnabledState = getWidgetForPaintable().isEnabled();
+ boolean lastReadOnlyState = getWidget().readonly;
+ boolean lastEnabledState = getWidget().isEnabled();
- getWidgetForPaintable().parsable = uidl.getBooleanAttribute("parsable");
+ getWidget().parsable = uidl.getBooleanAttribute("parsable");
super.updateFromUIDL(uidl, client);
+ VDateField.CLASSNAME
+ "-"
+ VPopupCalendar
- .resolutionToString(getWidgetForPaintable().currentResolution);
- getWidgetForPaintable().popup.setStyleName(popupStyleNames);
+ .resolutionToString(getWidget().currentResolution);
+ getWidget().popup.setStyleName(popupStyleNames);
- getWidgetForPaintable().calendar
- .setDateTimeService(getWidgetForPaintable()
+ getWidget().calendar
+ .setDateTimeService(getWidget()
.getDateTimeService());
- getWidgetForPaintable().calendar
- .setShowISOWeekNumbers(getWidgetForPaintable()
+ getWidget().calendar
+ .setShowISOWeekNumbers(getWidget()
.isShowISOWeekNumbers());
- if (getWidgetForPaintable().calendar.getResolution() != getWidgetForPaintable().currentResolution) {
- getWidgetForPaintable().calendar
- .setResolution(getWidgetForPaintable().currentResolution);
- if (getWidgetForPaintable().calendar.getDate() != null) {
- getWidgetForPaintable().calendar
- .setDate((Date) getWidgetForPaintable()
+ 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
- getWidgetForPaintable().calendar.renderCalendar();
+ getWidget().calendar.renderCalendar();
}
}
- getWidgetForPaintable().calendarToggle
- .setEnabled(getWidgetForPaintable().enabled);
+ getWidget().calendarToggle
+ .setEnabled(getWidget().enabled);
- if (getWidgetForPaintable().currentResolution <= VPopupCalendar.RESOLUTION_MONTH) {
- getWidgetForPaintable().calendar
+ if (getWidget().currentResolution <= VPopupCalendar.RESOLUTION_MONTH) {
+ getWidget().calendar
.setFocusChangeListener(new FocusChangeListener() {
public void focusChanged(Date date) {
- getWidgetForPaintable().updateValue(date);
- getWidgetForPaintable().buildDate();
- Date date2 = getWidgetForPaintable().calendar
+ getWidget().updateValue(date);
+ getWidget().buildDate();
+ Date date2 = getWidget().calendar
.getDate();
date2.setYear(date.getYear());
date2.setMonth(date.getMonth());
}
});
} else {
- getWidgetForPaintable().calendar.setFocusChangeListener(null);
+ getWidget().calendar.setFocusChangeListener(null);
}
- if (getWidgetForPaintable().currentResolution > VPopupCalendar.RESOLUTION_DAY) {
- getWidgetForPaintable().calendar
+ if (getWidget().currentResolution > VPopupCalendar.RESOLUTION_DAY) {
+ getWidget().calendar
.setTimeChangeListener(new TimeChangeListener() {
public void changed(int hour, int min, int sec, int msec) {
- Date d = getWidgetForPaintable().getDate();
+ 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) getWidgetForPaintable().calendar
+ d = (Date) getWidget().calendar
.getDate().clone();
}
d.setHours(hour);
DateTimeService.setMilliseconds(d, msec);
// Always update time changes to the server
- getWidgetForPaintable().updateValue(d);
+ getWidget().updateValue(d);
// Update text field
- getWidgetForPaintable().buildDate();
+ getWidget().buildDate();
}
});
}
- if (getWidgetForPaintable().readonly) {
- getWidgetForPaintable().calendarToggle
+ if (getWidget().readonly) {
+ getWidget().calendarToggle
.addStyleName(VPopupCalendar.CLASSNAME + "-button-readonly");
} else {
- getWidgetForPaintable().calendarToggle
+ getWidget().calendarToggle
.removeStyleName(VPopupCalendar.CLASSNAME
+ "-button-readonly");
}
- getWidgetForPaintable().calendarToggle.setEnabled(true);
+ getWidget().calendarToggle.setEnabled(true);
}
@Override
}
@Override
- public VPopupCalendar getWidgetForPaintable() {
- return (VPopupCalendar) super.getWidgetForPaintable();
+ public VPopupCalendar getWidget() {
+ return (VPopupCalendar) super.getWidget();
}
}
.getChildUIDL(0));
if (newPopupComponent != popupComponentPaintable) {
- Widget newWidget = newPopupComponent.getWidgetForPaintable();
+ Widget newWidget = newPopupComponent.getWidget();
setWidget(newWidget);
popupComponentWidget = newWidget;
popupComponentPaintable = newPopupComponent;
return;
}
// These are for future server connections
- getWidgetForPaintable().client = client;
- getWidgetForPaintable().uidlId = uidl.getId();
+ getWidget().client = client;
+ getWidget().uidlId = uidl.getId();
- getWidgetForPaintable().hostPopupVisible = uidl
+ getWidget().hostPopupVisible = uidl
.getBooleanVariable("popupVisibility");
- getWidgetForPaintable().setHTML(uidl.getStringAttribute("html"));
+ getWidget().setHTML(uidl.getStringAttribute("html"));
if (uidl.hasAttribute("hideOnMouseOut")) {
- getWidgetForPaintable().popup.setHideOnMouseOut(uidl
+ getWidget().popup.setHideOnMouseOut(uidl
.getBooleanAttribute("hideOnMouseOut"));
}
// Render the popup if visible and show it.
- if (getWidgetForPaintable().hostPopupVisible) {
+ if (getWidget().hostPopupVisible) {
UIDL popupUIDL = uidl.getChildUIDL(0);
// showPopupOnTop(popup, hostReference);
- getWidgetForPaintable().preparePopup(getWidgetForPaintable().popup);
- getWidgetForPaintable().popup.updateFromUIDL(popupUIDL, client);
+ 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 = getWidgetForPaintable().popup
+ final String primaryName = getWidget().popup
.getStylePrimaryName();
styleBuf.append(primaryName);
for (int i = 0; i < styles.length; i++) {
styleBuf.append("-");
styleBuf.append(styles[i]);
}
- getWidgetForPaintable().popup.setStyleName(styleBuf.toString());
+ getWidget().popup.setStyleName(styleBuf.toString());
} else {
- getWidgetForPaintable().popup
- .setStyleName(getWidgetForPaintable().popup
+ getWidget().popup
+ .setStyleName(getWidget().popup
.getStylePrimaryName());
}
- getWidgetForPaintable().showPopup(getWidgetForPaintable().popup);
+ getWidget().showPopup(getWidget().popup);
// The popup shouldn't be visible, try to hide it.
} else {
- getWidgetForPaintable().popup.hide();
+ getWidget().popup.hide();
}
}// updateFromUIDL
public void updateCaption(VPaintableWidget component, UIDL uidl) {
if (VCaption.isNeeded(uidl, component.getState())) {
- if (getWidgetForPaintable().popup.captionWrapper != null) {
- getWidgetForPaintable().popup.captionWrapper
+ if (getWidget().popup.captionWrapper != null) {
+ getWidget().popup.captionWrapper
.updateCaption(uidl);
} else {
- getWidgetForPaintable().popup.captionWrapper = new VCaptionWrapper(
+ getWidget().popup.captionWrapper = new VCaptionWrapper(
component, getConnection());
- getWidgetForPaintable().popup
- .setWidget(getWidgetForPaintable().popup.captionWrapper);
- getWidgetForPaintable().popup.captionWrapper
+ getWidget().popup
+ .setWidget(getWidget().popup.captionWrapper);
+ getWidget().popup.captionWrapper
.updateCaption(uidl);
}
} else {
- if (getWidgetForPaintable().popup.captionWrapper != null) {
- getWidgetForPaintable().popup
- .setWidget(getWidgetForPaintable().popup.popupComponentWidget);
+ if (getWidget().popup.captionWrapper != null) {
+ getWidget().popup
+ .setWidget(getWidget().popup.popupComponentWidget);
}
}
}
@Override
- public VPopupView getWidgetForPaintable() {
- return (VPopupView) super.getWidgetForPaintable();
+ public VPopupView getWidget() {
+ return (VPopupView) super.getWidget();
}
@Override
}
// Save details
- getWidgetForPaintable().client = client;
+ getWidget().client = client;
- getWidgetForPaintable().indeterminate = uidl
+ getWidget().indeterminate = uidl
.getBooleanAttribute("indeterminate");
- if (getWidgetForPaintable().indeterminate) {
+ if (getWidget().indeterminate) {
String basename = VProgressIndicator.CLASSNAME + "-indeterminate";
- getWidgetForPaintable().addStyleName(basename);
+ getWidget().addStyleName(basename);
if (getState().isDisabled()) {
- getWidgetForPaintable().addStyleName(basename + "-disabled");
+ getWidget().addStyleName(basename + "-disabled");
} else {
- getWidgetForPaintable().removeStyleName(basename + "-disabled");
+ getWidget().removeStyleName(basename + "-disabled");
}
} else {
try {
final float f = Float.parseFloat(uidl
.getStringAttribute("state"));
final int size = Math.round(100 * f);
- DOM.setStyleAttribute(getWidgetForPaintable().indicator,
+ DOM.setStyleAttribute(getWidget().indicator,
"width", size + "%");
} catch (final Exception e) {
}
}
if (!getState().isDisabled()) {
- getWidgetForPaintable().interval = uidl
+ getWidget().interval = uidl
.getIntAttribute("pollinginterval");
- getWidgetForPaintable().poller
- .scheduleRepeating(getWidgetForPaintable().interval);
+ getWidget().poller
+ .scheduleRepeating(getWidget().interval);
}
}
}
@Override
- public VProgressIndicator getWidgetForPaintable() {
- return (VProgressIndicator) super.getWidgetForPaintable();
+ public VProgressIndicator getWidget() {
+ return (VProgressIndicator) super.getWidget();
}
}
final VPaintableWidget cellContent = client
.getPaintable((UIDL) cell);
- addCell(uidl, cellContent.getWidgetForPaintable(),
+ addCell(uidl, cellContent.getWidget(),
aligns[col++], style, sorted);
paintComponent(cellContent, (UIDL) cell);
}
*/
@Override
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidgetForPaintable().rendering = true;
+ getWidget().rendering = true;
if (uidl.hasAttribute(VScrollTable.ATTRIBUTE_PAGEBUFFER_FIRST)) {
- getWidgetForPaintable().serverCacheFirst = uidl
+ getWidget().serverCacheFirst = uidl
.getIntAttribute(VScrollTable.ATTRIBUTE_PAGEBUFFER_FIRST);
- getWidgetForPaintable().serverCacheLast = uidl
+ getWidget().serverCacheLast = uidl
.getIntAttribute(VScrollTable.ATTRIBUTE_PAGEBUFFER_LAST);
} else {
- getWidgetForPaintable().serverCacheFirst = -1;
- getWidgetForPaintable().serverCacheLast = -1;
+ getWidget().serverCacheFirst = -1;
+ getWidget().serverCacheLast = -1;
}
/*
* We need to do this before updateComponent since updateComponent calls
* the space available.
*/
if (uidl.hasAttribute("colfooters")) {
- getWidgetForPaintable().showColFooters = uidl
+ getWidget().showColFooters = uidl
.getBooleanAttribute("colfooters");
}
- getWidgetForPaintable().tFoot
- .setVisible(getWidgetForPaintable().showColFooters);
+ getWidget().tFoot
+ .setVisible(getWidget().showColFooters);
super.updateFromUIDL(uidl, client);
if (!isRealUpdate(uidl)) {
- getWidgetForPaintable().rendering = false;
+ getWidget().rendering = false;
return;
}
- getWidgetForPaintable().enabled = !getState().isDisabled();
+ getWidget().enabled = !getState().isDisabled();
- if (BrowserInfo.get().isIE8() && !getWidgetForPaintable().enabled) {
+ if (BrowserInfo.get().isIE8() && !getWidget().enabled) {
/*
* The disabled shim will not cover the table body if it is relative
* in IE8. See #7324
*/
- getWidgetForPaintable().scrollBodyPanel.getElement().getStyle()
+ getWidget().scrollBodyPanel.getElement().getStyle()
.setPosition(Position.STATIC);
} else if (BrowserInfo.get().isIE8()) {
- getWidgetForPaintable().scrollBodyPanel.getElement().getStyle()
+ getWidget().scrollBodyPanel.getElement().getStyle()
.setPosition(Position.RELATIVE);
}
- getWidgetForPaintable().client = client;
- getWidgetForPaintable().paintableId = uidl.getStringAttribute("id");
- getWidgetForPaintable().immediate = getState().isImmediate();
+ getWidget().client = client;
+ getWidget().paintableId = uidl.getStringAttribute("id");
+ getWidget().immediate = getState().isImmediate();
- int previousTotalRows = getWidgetForPaintable().totalRows;
- getWidgetForPaintable().updateTotalRows(uidl);
- boolean totalRowsChanged = (getWidgetForPaintable().totalRows != previousTotalRows);
+ int previousTotalRows = getWidget().totalRows;
+ getWidget().updateTotalRows(uidl);
+ boolean totalRowsChanged = (getWidget().totalRows != previousTotalRows);
- getWidgetForPaintable().updateDragMode(uidl);
+ getWidget().updateDragMode(uidl);
- getWidgetForPaintable().updateSelectionProperties(uidl, getState());
+ getWidget().updateSelectionProperties(uidl, getState());
if (uidl.hasAttribute("alb")) {
- getWidgetForPaintable().bodyActionKeys = uidl
+ getWidget().bodyActionKeys = uidl
.getStringArrayAttribute("alb");
} else {
// Need to clear the actions if the action handlers have been
// removed
- getWidgetForPaintable().bodyActionKeys = null;
+ getWidget().bodyActionKeys = null;
}
- getWidgetForPaintable().setCacheRateFromUIDL(uidl);
+ getWidget().setCacheRateFromUIDL(uidl);
- getWidgetForPaintable().recalcWidths = uidl
+ getWidget().recalcWidths = uidl
.hasAttribute("recalcWidths");
- if (getWidgetForPaintable().recalcWidths) {
- getWidgetForPaintable().tHead.clear();
- getWidgetForPaintable().tFoot.clear();
+ if (getWidget().recalcWidths) {
+ getWidget().tHead.clear();
+ getWidget().tFoot.clear();
}
- getWidgetForPaintable().updatePageLength(uidl);
+ getWidget().updatePageLength(uidl);
- getWidgetForPaintable().updateFirstVisibleAndScrollIfNeeded(uidl);
+ getWidget().updateFirstVisibleAndScrollIfNeeded(uidl);
- getWidgetForPaintable().showRowHeaders = uidl
+ getWidget().showRowHeaders = uidl
.getBooleanAttribute("rowheaders");
- getWidgetForPaintable().showColHeaders = uidl
+ getWidget().showColHeaders = uidl
.getBooleanAttribute("colheaders");
- getWidgetForPaintable().updateSortingProperties(uidl);
+ getWidget().updateSortingProperties(uidl);
- boolean keyboardSelectionOverRowFetchInProgress = getWidgetForPaintable()
+ boolean keyboardSelectionOverRowFetchInProgress = getWidget()
.selectSelectedRows(uidl);
- getWidgetForPaintable().updateActionMap(uidl);
+ getWidget().updateActionMap(uidl);
- getWidgetForPaintable().updateColumnProperties(uidl);
+ getWidget().updateColumnProperties(uidl);
UIDL ac = uidl.getChildByTagName("-ac");
if (ac == null) {
- if (getWidgetForPaintable().dropHandler != null) {
+ if (getWidget().dropHandler != null) {
// remove dropHandler if not present anymore
- getWidgetForPaintable().dropHandler = null;
+ getWidget().dropHandler = null;
}
} else {
- if (getWidgetForPaintable().dropHandler == null) {
- getWidgetForPaintable().dropHandler = getWidgetForPaintable().new VScrollTableDropHandler();
+ if (getWidget().dropHandler == null) {
+ getWidget().dropHandler = getWidget().new VScrollTableDropHandler();
}
- getWidgetForPaintable().dropHandler.updateAcceptRules(ac);
+ 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
- getWidgetForPaintable().rowRequestHandler.cancel();
+ getWidget().rowRequestHandler.cancel();
- getWidgetForPaintable().updateRowsInBody(partialRowUpdates);
- getWidgetForPaintable().addAndRemoveRows(partialRowAdditions);
+ 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
- getWidgetForPaintable().rowRequestHandler.cancel();
+ getWidget().rowRequestHandler.cancel();
- if (!getWidgetForPaintable().recalcWidths
- && getWidgetForPaintable().initializedAndAttached) {
- getWidgetForPaintable().updateBody(rowData,
+ if (!getWidget().recalcWidths
+ && getWidget().initializedAndAttached) {
+ getWidget().updateBody(rowData,
uidl.getIntAttribute("firstrow"),
uidl.getIntAttribute("rows"));
- if (getWidgetForPaintable().headerChangedDuringUpdate) {
- getWidgetForPaintable().triggerLazyColumnAdjustment(
+ if (getWidget().headerChangedDuringUpdate) {
+ getWidget().triggerLazyColumnAdjustment(
true);
- } else if (!getWidgetForPaintable()
+ } else if (!getWidget()
.isScrollPositionVisible()
|| totalRowsChanged
- || getWidgetForPaintable().lastRenderedHeight != getWidgetForPaintable().scrollBody
+ || getWidget().lastRenderedHeight != getWidget().scrollBody
.getOffsetHeight()) {
// webkits may still bug with their disturbing scrollbar
// bug, see #3457
// or the height of the widget has also changed)
Scheduler.get().scheduleDeferred(new Command() {
public void execute() {
- Util.runWebkitOverflowAutoFix(getWidgetForPaintable().scrollBodyPanel
+ Util.runWebkitOverflowAutoFix(getWidget().scrollBodyPanel
.getElement());
}
});
}
} else {
- getWidgetForPaintable().initializeRows(uidl, rowData);
+ getWidget().initializeRows(uidl, rowData);
}
}
}
- if (!getWidgetForPaintable().isSelectable()) {
- getWidgetForPaintable().scrollBody
+ if (!getWidget().isSelectable()) {
+ getWidget().scrollBody
.addStyleName(VScrollTable.CLASSNAME + "-body-noselection");
} else {
- getWidgetForPaintable().scrollBody
+ getWidget().scrollBody
.removeStyleName(VScrollTable.CLASSNAME
+ "-body-noselection");
}
- getWidgetForPaintable().hideScrollPositionAnnotation();
- getWidgetForPaintable().purgeUnregistryBag();
+ 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) {
- getWidgetForPaintable().selectionChanged = false;
+ getWidget().selectionChanged = false;
}
/*
* selectable mode and the next selected row was not yet rendered in the
* client
*/
- if (getWidgetForPaintable().selectFirstItemInNextRender
- || getWidgetForPaintable().focusFirstItemInNextRender) {
- getWidgetForPaintable().selectFirstRenderedRowInViewPort(
- getWidgetForPaintable().focusFirstItemInNextRender);
- getWidgetForPaintable().selectFirstItemInNextRender = getWidgetForPaintable().focusFirstItemInNextRender = false;
+ if (getWidget().selectFirstItemInNextRender
+ || getWidget().focusFirstItemInNextRender) {
+ getWidget().selectFirstRenderedRowInViewPort(
+ getWidget().focusFirstItemInNextRender);
+ getWidget().selectFirstItemInNextRender = getWidget().focusFirstItemInNextRender = false;
}
/*
* selectable mode and the next selected row was not yet rendered in the
* client
*/
- if (getWidgetForPaintable().selectLastItemInNextRender
- || getWidgetForPaintable().focusLastItemInNextRender) {
- getWidgetForPaintable().selectLastRenderedRowInViewPort(
- getWidgetForPaintable().focusLastItemInNextRender);
- getWidgetForPaintable().selectLastItemInNextRender = getWidgetForPaintable().focusLastItemInNextRender = false;
+ if (getWidget().selectLastItemInNextRender
+ || getWidget().focusLastItemInNextRender) {
+ getWidget().selectLastRenderedRowInViewPort(
+ getWidget().focusLastItemInNextRender);
+ getWidget().selectLastItemInNextRender = getWidget().focusLastItemInNextRender = false;
}
- getWidgetForPaintable().multiselectPending = false;
+ getWidget().multiselectPending = false;
- if (getWidgetForPaintable().focusedRow != null) {
- if (!getWidgetForPaintable().focusedRow.isAttached()
- && !getWidgetForPaintable().rowRequestHandler.isRunning()) {
+ if (getWidget().focusedRow != null) {
+ if (!getWidget().focusedRow.isAttached()
+ && !getWidget().rowRequestHandler.isRunning()) {
// focused row has been orphaned, can't focus
- getWidgetForPaintable().focusRowFromBody();
+ getWidget().focusRowFromBody();
}
}
- getWidgetForPaintable().tabIndex = uidl.hasAttribute("tabindex") ? uidl
+ getWidget().tabIndex = uidl.hasAttribute("tabindex") ? uidl
.getIntAttribute("tabindex") : 0;
- getWidgetForPaintable().setProperTabIndex();
+ getWidget().setProperTabIndex();
- getWidgetForPaintable().resizeSortedColumnForSortIndicator();
+ getWidget().resizeSortedColumnForSortIndicator();
// Remember this to detect situations where overflow hack might be
// needed during scrolling
- getWidgetForPaintable().lastRenderedHeight = getWidgetForPaintable().scrollBody
+ getWidget().lastRenderedHeight = getWidget().scrollBody
.getOffsetHeight();
- getWidgetForPaintable().rendering = false;
- getWidgetForPaintable().headerChangedDuringUpdate = false;
+ getWidget().rendering = false;
+ getWidget().headerChangedDuringUpdate = false;
}
}
@Override
- public VScrollTable getWidgetForPaintable() {
- return (VScrollTable) super.getWidgetForPaintable();
+ public VScrollTable getWidget() {
+ return (VScrollTable) super.getWidget();
}
public void updateCaption(VPaintableWidget component, UIDL uidl) {
}
public void layoutVertically() {
- getWidgetForPaintable().updateHeight();
+ getWidget().updateHeight();
}
public void layoutHorizontally() {
- getWidgetForPaintable().updateWidth();
+ getWidget().updateWidth();
}
}
@Override
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidgetForPaintable().client = client;
- getWidgetForPaintable().id = uidl.getId();
+ getWidget().client = client;
+ getWidget().id = uidl.getId();
// Ensure correct implementation
super.updateFromUIDL(uidl, client);
return;
}
- getWidgetForPaintable().immediate = getState().isImmediate();
- getWidgetForPaintable().disabled = getState().isDisabled();
- getWidgetForPaintable().readonly = getState().isReadOnly();
+ getWidget().immediate = getState().isImmediate();
+ getWidget().disabled = getState().isDisabled();
+ getWidget().readonly = getState().isReadOnly();
- getWidgetForPaintable().vertical = uidl.hasAttribute("vertical");
+ getWidget().vertical = uidl.hasAttribute("vertical");
// TODO should these style names be used?
String style = getState().getStyle();
- if (getWidgetForPaintable().vertical) {
- getWidgetForPaintable().addStyleName(
+ if (getWidget().vertical) {
+ getWidget().addStyleName(
VSlider.CLASSNAME + "-vertical");
} else {
- getWidgetForPaintable().removeStyleName(
+ getWidget().removeStyleName(
VSlider.CLASSNAME + "-vertical");
}
- getWidgetForPaintable().min = uidl.getDoubleAttribute("min");
- getWidgetForPaintable().max = uidl.getDoubleAttribute("max");
- getWidgetForPaintable().resolution = uidl.getIntAttribute("resolution");
- getWidgetForPaintable().value = new Double(
+ getWidget().min = uidl.getDoubleAttribute("min");
+ getWidget().max = uidl.getDoubleAttribute("max");
+ getWidget().resolution = uidl.getIntAttribute("resolution");
+ getWidget().value = new Double(
uidl.getDoubleVariable("value"));
- getWidgetForPaintable().setFeedbackValue(getWidgetForPaintable().value);
+ getWidget().setFeedbackValue(getWidget().value);
- getWidgetForPaintable().buildBase();
+ getWidget().buildBase();
- if (!getWidgetForPaintable().vertical) {
+ if (!getWidget().vertical) {
// Draw handle with a delay to allow base to gain maximum width
Scheduler.get().scheduleDeferred(new Command() {
public void execute() {
- getWidgetForPaintable().buildHandle();
- getWidgetForPaintable().setValue(
- getWidgetForPaintable().value, false);
+ getWidget().buildHandle();
+ getWidget().setValue(
+ getWidget().value, false);
}
});
} else {
- getWidgetForPaintable().buildHandle();
- getWidgetForPaintable().setValue(getWidgetForPaintable().value,
+ getWidget().buildHandle();
+ getWidget().setValue(getWidget().value,
false);
}
}
@Override
- public VSlider getWidgetForPaintable() {
- return (VSlider) super.getWidgetForPaintable();
+ public VSlider getWidget() {
+ return (VSlider) super.getWidget();
}
@Override
if (tabUidl.getChildCount() > 0) {
tabContentUIDL = tabUidl.getChildUIDL(0);
tabContentPaintable = client.getPaintable(tabContentUIDL);
- tabContentWidget = tabContentPaintable.getWidgetForPaintable();
+ tabContentWidget = tabContentPaintable.getWidget();
}
if (tabContentPaintable != null) {
paintableMap.unregisterPaintable(paintableMap
.getPaintable(old));
}
- tp.insert(content.getWidgetForPaintable(), activeTabIndex);
+ tp.insert(content.getWidget(), activeTabIndex);
}
} else {
- tp.add(content.getWidgetForPaintable());
+ tp.add(content.getWidget());
}
tp.showWidget(activeTabIndex);
* report correct size to updateOpenTabSize().
*/
if (contentUIDL.getBooleanAttribute("cached")) {
- client.handleComponentRelativeSize(content.getWidgetForPaintable());
+ client.handleComponentRelativeSize(content.getWidget());
}
updateOpenTabSize();
VTabsheet.this.removeStyleDependentName("loading");
@Override
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidgetForPaintable().client = client;
+ getWidget().client = client;
// Ensure correct implementation
super.updateFromUIDL(uidl, client);
}
// Update member references
- getWidgetForPaintable().id = uidl.getId();
- getWidgetForPaintable().disabled = getState().isDisabled();
+ 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 = getWidgetForPaintable()
+ for (Iterator<Widget> iterator = getWidget()
.getWidgetIterator(); iterator.hasNext();) {
oldWidgets.add(iterator.next());
}
// Clear previous values
- getWidgetForPaintable().tabKeys.clear();
- getWidgetForPaintable().disabledTabKeys.clear();
+ getWidget().tabKeys.clear();
+ getWidget().disabledTabKeys.clear();
int index = 0;
for (final Iterator<Object> it = tabs.getChildIterator(); it.hasNext();) {
final boolean hidden = tab.getBooleanAttribute("hidden");
if (tab.getBooleanAttribute(ATTRIBUTE_TAB_DISABLED)) {
- getWidgetForPaintable().disabledTabKeys.add(key);
+ getWidget().disabledTabKeys.add(key);
}
- getWidgetForPaintable().tabKeys.add(key);
+ getWidget().tabKeys.add(key);
if (selected) {
- getWidgetForPaintable().activeTabIndex = index;
+ getWidget().activeTabIndex = index;
}
- getWidgetForPaintable().renderTab(tab, index, selected, hidden);
+ getWidget().renderTab(tab, index, selected, hidden);
index++;
}
- int tabCount = getWidgetForPaintable().getTabCount();
+ int tabCount = getWidget().getTabCount();
while (tabCount-- > index) {
- getWidgetForPaintable().removeTab(index);
+ getWidget().removeTab(index);
}
- for (int i = 0; i < getWidgetForPaintable().getTabCount(); i++) {
- VPaintableWidget p = getWidgetForPaintable().getTab(i);
+ for (int i = 0; i < getWidget().getTabCount(); i++) {
+ VPaintableWidget p = getWidget().getTab(i);
// During the initial rendering the paintable might be null (this is
// weird...)
if (p != null) {
- oldWidgets.remove(p.getWidgetForPaintable());
+ oldWidgets.remove(p.getWidget());
}
}
}
@Override
- public VTabsheetBase getWidgetForPaintable() {
- return (VTabsheetBase) super.getWidgetForPaintable();
+ public VTabsheetBase getWidget() {
+ return (VTabsheetBase) super.getWidget();
}
}
if (isRealUpdate(uidl)) {
// Handle stylename changes before generics (might affect size
// calculations)
- getWidgetForPaintable().handleStyleNames(uidl, getState());
+ getWidget().handleStyleNames(uidl, getState());
}
super.updateFromUIDL(uidl, client);
// 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(getWidgetForPaintable().tabs, "width", "1px");
- DOM.setStyleAttribute(getWidgetForPaintable().tabs, "overflow",
+ DOM.setStyleAttribute(getWidget().tabs, "width", "1px");
+ DOM.setStyleAttribute(getWidget().tabs, "overflow",
"hidden");
} else {
- getWidgetForPaintable().showAllTabs();
- DOM.setStyleAttribute(getWidgetForPaintable().tabs, "width", "");
- DOM.setStyleAttribute(getWidgetForPaintable().tabs, "overflow",
+ getWidget().showAllTabs();
+ DOM.setStyleAttribute(getWidget().tabs, "width", "");
+ DOM.setStyleAttribute(getWidget().tabs, "overflow",
"visible");
- getWidgetForPaintable().updateDynamicWidth();
+ getWidget().updateDynamicWidth();
}
if (!isUndefinedHeight()) {
// Must update height after the styles have been set
- getWidgetForPaintable().updateContentNodeHeight();
- getWidgetForPaintable().updateOpenTabSize();
+ getWidget().updateContentNodeHeight();
+ getWidget().updateOpenTabSize();
}
- getWidgetForPaintable().iLayout();
+ getWidget().iLayout();
// Re run relative size update to ensure optimal scrollbars
// TODO isolate to situation that visible tab has undefined height
try {
- client.handleComponentRelativeSize(getWidgetForPaintable().tp
- .getWidget(getWidgetForPaintable().tp.getVisibleWidget()));
+ client.handleComponentRelativeSize(getWidget().tp
+ .getWidget(getWidget().tp.getVisibleWidget()));
} catch (Exception e) {
// Ignore, most likely empty tabsheet
}
- getWidgetForPaintable().waitingForResponse = false;
+ getWidget().waitingForResponse = false;
}
@Override
}
@Override
- public VTabsheet getWidgetForPaintable() {
- return (VTabsheet) super.getWidgetForPaintable();
+ public VTabsheet getWidget() {
+ return (VTabsheet) super.getWidget();
}
public void updateCaption(VPaintableWidget component, UIDL uidl) {
}
public void layout() {
- VTabsheet tabsheet = getWidgetForPaintable();
+ VTabsheet tabsheet = getWidget();
tabsheet.updateContentNodeHeight();
super.updateFromUIDL(uidl, client);
if (uidl.hasAttribute("rows")) {
- getWidgetForPaintable().setRows(uidl.getIntAttribute("rows"));
+ getWidget().setRows(uidl.getIntAttribute("rows"));
}
- if (getWidgetForPaintable().getMaxLength() >= 0) {
- getWidgetForPaintable().sinkEvents(Event.ONKEYUP);
+ if (getWidget().getMaxLength() >= 0) {
+ getWidget().sinkEvents(Event.ONKEYUP);
}
}
}
@Override
- public VTextArea getWidgetForPaintable() {
- return (VTextArea) super.getWidgetForPaintable();
+ public VTextArea getWidget() {
+ return (VTextArea) super.getWidget();
}
}
@Override
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
// Save details
- getWidgetForPaintable().client = client;
- getWidgetForPaintable().paintableId = uidl.getId();
+ getWidget().client = client;
+ getWidget().paintableId = uidl.getId();
super.updateFromUIDL(uidl, client);
if (!isRealUpdate(uidl)) {
return;
}
- getWidgetForPaintable().setReadOnly(getState().isReadOnly());
+ getWidget().setReadOnly(getState().isReadOnly());
- getWidgetForPaintable().inputPrompt = uidl
+ getWidget().inputPrompt = uidl
.getStringAttribute(VTextField.ATTR_INPUTPROMPT);
- getWidgetForPaintable().setMaxLength(
+ getWidget().setMaxLength(
uidl.hasAttribute("maxLength") ? uidl
.getIntAttribute("maxLength") : -1);
- getWidgetForPaintable().immediate = getState().isImmediate();
+ getWidget().immediate = getState().isImmediate();
- getWidgetForPaintable().listenTextChangeEvents = client
+ getWidget().listenTextChangeEvents = client
.hasEventListeners(this, "ie");
- if (getWidgetForPaintable().listenTextChangeEvents) {
- getWidgetForPaintable().textChangeEventMode = uidl
+ if (getWidget().listenTextChangeEvents) {
+ getWidget().textChangeEventMode = uidl
.getStringAttribute(VTextField.ATTR_TEXTCHANGE_EVENTMODE);
- if (getWidgetForPaintable().textChangeEventMode
+ if (getWidget().textChangeEventMode
.equals(VTextField.TEXTCHANGE_MODE_EAGER)) {
- getWidgetForPaintable().textChangeEventTimeout = 1;
+ getWidget().textChangeEventTimeout = 1;
} else {
- getWidgetForPaintable().textChangeEventTimeout = uidl
+ getWidget().textChangeEventTimeout = uidl
.getIntAttribute(VTextField.ATTR_TEXTCHANGE_TIMEOUT);
- if (getWidgetForPaintable().textChangeEventTimeout < 1) {
+ if (getWidget().textChangeEventTimeout < 1) {
// Sanitize and allow lazy/timeout with timeout set to 0 to
// work as eager
- getWidgetForPaintable().textChangeEventTimeout = 1;
+ getWidget().textChangeEventTimeout = 1;
}
}
- getWidgetForPaintable().sinkEvents(VTextField.TEXTCHANGE_EVENTS);
- getWidgetForPaintable().attachCutEventListener(
- getWidgetForPaintable().getElement());
+ getWidget().sinkEvents(VTextField.TEXTCHANGE_EVENTS);
+ getWidget().attachCutEventListener(
+ getWidget().getElement());
}
if (uidl.hasAttribute("cols")) {
- getWidgetForPaintable().setColumns(
+ getWidget().setColumns(
new Integer(uidl.getStringAttribute("cols")).intValue());
}
*/
if (!(uidl
.getBooleanAttribute(VTextField.ATTR_NO_VALUE_CHANGE_BETWEEN_PAINTS)
- && getWidgetForPaintable().valueBeforeEdit != null && text
- .equals(getWidgetForPaintable().valueBeforeEdit))) {
- getWidgetForPaintable().updateFieldContent(text);
+ && getWidget().valueBeforeEdit != null && text
+ .equals(getWidget().valueBeforeEdit))) {
+ getWidget().updateFieldContent(text);
}
if (uidl.hasAttribute("selpos")) {
*/
Scheduler.get().scheduleDeferred(new Command() {
public void execute() {
- getWidgetForPaintable().setSelectionRange(pos, length);
+ getWidget().setSelectionRange(pos, length);
}
});
}
// state.
if (uidl.hasAttribute("wordwrap")
&& uidl.getBooleanAttribute("wordwrap") == false) {
- getWidgetForPaintable().setWordwrap(false);
+ getWidget().setWordwrap(false);
} else {
- getWidgetForPaintable().setWordwrap(true);
+ getWidget().setWordwrap(true);
}
}
}
@Override
- public VTextField getWidgetForPaintable() {
- return (VTextField) super.getWidgetForPaintable();
+ public VTextField getWidget() {
+ return (VTextField) super.getWidget();
}
public void onBeforeShortcutAction(Event e) {
- getWidgetForPaintable().valueChange(false);
+ getWidget().valueChange(false);
}
}
@Override
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- int origRes = getWidgetForPaintable().currentResolution;
- String oldLocale = getWidgetForPaintable().currentLocale;
+ int origRes = getWidget().currentResolution;
+ String oldLocale = getWidget().currentLocale;
super.updateFromUIDL(uidl, client);
- if (origRes != getWidgetForPaintable().currentResolution
- || oldLocale != getWidgetForPaintable().currentLocale) {
+ if (origRes != getWidget().currentResolution
+ || oldLocale != getWidget().currentLocale) {
// force recreating format string
- getWidgetForPaintable().formatStr = null;
+ getWidget().formatStr = null;
}
if (uidl.hasAttribute("format")) {
- getWidgetForPaintable().formatStr = uidl
+ getWidget().formatStr = uidl
.getStringAttribute("format");
}
- getWidgetForPaintable().inputPrompt = uidl
+ getWidget().inputPrompt = uidl
.getStringAttribute(VTextualDate.ATTR_INPUTPROMPT);
- getWidgetForPaintable().lenient = !uidl.getBooleanAttribute("strict");
+ getWidget().lenient = !uidl.getBooleanAttribute("strict");
- getWidgetForPaintable().buildDate();
+ getWidget().buildDate();
// not a FocusWidget -> needs own tabindex handling
if (uidl.hasAttribute("tabindex")) {
- getWidgetForPaintable().text.setTabIndex(uidl
+ getWidget().text.setTabIndex(uidl
.getIntAttribute("tabindex"));
}
- if (getWidgetForPaintable().readonly) {
- getWidgetForPaintable().text.addStyleDependentName("readonly");
+ if (getWidget().readonly) {
+ getWidget().text.addStyleDependentName("readonly");
} else {
- getWidgetForPaintable().text.removeStyleDependentName("readonly");
+ getWidget().text.removeStyleDependentName("readonly");
}
}
}
@Override
- public VTextualDate getWidgetForPaintable() {
- return (VTextualDate) super.getWidgetForPaintable();
+ public VTextualDate getWidget() {
+ return (VTextualDate) super.getWidget();
}
}
return;
}
- getWidgetForPaintable().rendering = true;
+ getWidget().rendering = true;
- getWidgetForPaintable().client = client;
+ getWidget().client = client;
if (uidl.hasAttribute("partialUpdate")) {
handleUpdate(uidl);
- getWidgetForPaintable().rendering = false;
+ getWidget().rendering = false;
return;
}
- getWidgetForPaintable().paintableId = uidl.getId();
+ getWidget().paintableId = uidl.getId();
- getWidgetForPaintable().immediate = getState().isImmediate();
+ getWidget().immediate = getState().isImmediate();
- getWidgetForPaintable().disabled = getState().isDisabled();
- getWidgetForPaintable().readonly = getState().isReadOnly();
+ getWidget().disabled = getState().isDisabled();
+ getWidget().readonly = getState().isReadOnly();
- getWidgetForPaintable().dragMode = uidl.hasAttribute("dragMode") ? uidl
+ getWidget().dragMode = uidl.hasAttribute("dragMode") ? uidl
.getIntAttribute("dragMode") : 0;
- getWidgetForPaintable().isNullSelectionAllowed = uidl
+ getWidget().isNullSelectionAllowed = uidl
.getBooleanAttribute("nullselect");
if (uidl.hasAttribute("alb")) {
- getWidgetForPaintable().bodyActionKeys = uidl
+ getWidget().bodyActionKeys = uidl
.getStringArrayAttribute("alb");
}
- getWidgetForPaintable().body.clear();
+ getWidget().body.clear();
// clear out any references to nodes that no longer are attached
- getWidgetForPaintable().clearNodeToKeyMap();
+ getWidget().clearNodeToKeyMap();
TreeNode childTree = null;
UIDL childUidl = null;
for (final Iterator<?> i = uidl.getChildIterator(); i.hasNext();) {
updateActionMap(childUidl);
continue;
} else if ("-ac".equals(childUidl.getTag())) {
- getWidgetForPaintable().updateDropHandler(childUidl);
+ getWidget().updateDropHandler(childUidl);
continue;
}
- childTree = getWidgetForPaintable().new TreeNode();
+ childTree = getWidget().new TreeNode();
updateNodeFromUIDL(childTree, childUidl);
- getWidgetForPaintable().body.add(childTree);
+ getWidget().body.add(childTree);
childTree.addStyleDependentName("root");
childTree.childNodeContainer.addStyleDependentName("root");
}
childTree.childNodeContainer.addStyleDependentName("last");
}
final String selectMode = uidl.getStringAttribute("selectmode");
- getWidgetForPaintable().selectable = !"none".equals(selectMode);
- getWidgetForPaintable().isMultiselect = "multi".equals(selectMode);
+ getWidget().selectable = !"none".equals(selectMode);
+ getWidget().isMultiselect = "multi".equals(selectMode);
- if (getWidgetForPaintable().isMultiselect) {
- getWidgetForPaintable().multiSelectMode = uidl
+ if (getWidget().isMultiselect) {
+ getWidget().multiSelectMode = uidl
.getIntAttribute("multiselectmode");
}
- getWidgetForPaintable().selectedIds = uidl
+ 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 (getWidgetForPaintable().lastSelection != null) {
- getWidgetForPaintable().lastSelection = getWidgetForPaintable()
- .getNodeByKey(getWidgetForPaintable().lastSelection.key);
- }
- if (getWidgetForPaintable().focusedNode != null) {
- getWidgetForPaintable().setFocusedNode(
- getWidgetForPaintable().getNodeByKey(
- getWidgetForPaintable().focusedNode.key));
- }
-
- if (getWidgetForPaintable().lastSelection == null
- && getWidgetForPaintable().focusedNode == null
- && !getWidgetForPaintable().selectedIds.isEmpty()) {
- getWidgetForPaintable().setFocusedNode(
- getWidgetForPaintable().getNodeByKey(
- getWidgetForPaintable().selectedIds.iterator()
+ 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()));
- getWidgetForPaintable().focusedNode.setFocused(false);
+ getWidget().focusedNode.setFocused(false);
}
- getWidgetForPaintable().rendering = false;
+ getWidget().rendering = false;
}
}
@Override
- public VTree getWidgetForPaintable() {
- return (VTree) super.getWidgetForPaintable();
+ public VTree getWidget() {
+ return (VTree) super.getWidget();
}
private void handleUpdate(UIDL uidl) {
- final TreeNode rootNode = getWidgetForPaintable().getNodeByKey(
+ final TreeNode rootNode = getWidget().getNodeByKey(
uidl.getStringAttribute("rootKey"));
if (rootNode != null) {
if (!rootNode.getState()) {
iconUrl = getConnection().translateVaadinUri(
action.getStringAttribute(ATTRIBUTE_ACTION_ICON));
}
- getWidgetForPaintable().registerAction(key, caption, iconUrl);
+ getWidget().registerAction(key, caption, iconUrl);
}
}
treeNode.setText(uidl.getStringAttribute(ATTRIBUTE_NODE_CAPTION));
treeNode.key = nodeKey;
- getWidgetForPaintable().registerNode(treeNode);
+ getWidget().registerNode(treeNode);
if (uidl.hasAttribute("al")) {
treeNode.actionKeys = uidl.getStringArrayAttribute("al");
treeNode.setSelected(true);
// ensure that identifier is in selectedIds array (this may be a
// partial update)
- getWidgetForPaintable().selectedIds.add(nodeKey);
+ getWidget().selectedIds.add(nodeKey);
}
treeNode.setIcon(uidl.getStringAttribute(ATTRIBUTE_NODE_ICON));
updateActionMap(childUidl);
continue;
}
- final TreeNode childTree = getWidgetForPaintable().new TreeNode();
+ final TreeNode childTree = getWidget().new TreeNode();
updateNodeFromUIDL(childTree, childUidl);
containerNode.childNodeContainer.add(childTree);
if (!i.hasNext()) {
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
FocusableScrollPanel widget = null;
int scrollPosition = 0;
- if (getWidgetForPaintable().collapseRequest) {
- widget = (FocusableScrollPanel) getWidgetForPaintable()
+ if (getWidget().collapseRequest) {
+ widget = (FocusableScrollPanel) getWidget()
.getWidget(1);
scrollPosition = widget.getScrollPosition();
}
- getWidgetForPaintable().animationsEnabled = uidl
+ getWidget().animationsEnabled = uidl
.getBooleanAttribute("animate");
- getWidgetForPaintable().colIndexOfHierarchy = uidl
+ getWidget().colIndexOfHierarchy = uidl
.hasAttribute(ATTRIBUTE_HIERARCHY_COLUMN_INDEX) ? uidl
.getIntAttribute(ATTRIBUTE_HIERARCHY_COLUMN_INDEX) : 0;
- int oldTotalRows = getWidgetForPaintable().getTotalRows();
+ int oldTotalRows = getWidget().getTotalRows();
super.updateFromUIDL(uidl, client);
- if (getWidgetForPaintable().collapseRequest) {
- if (getWidgetForPaintable().collapsedRowKey != null
- && getWidgetForPaintable().scrollBody != null) {
- VScrollTableRow row = getWidgetForPaintable()
+ if (getWidget().collapseRequest) {
+ if (getWidget().collapsedRowKey != null
+ && getWidget().scrollBody != null) {
+ VScrollTableRow row = getWidget()
.getRenderedRowByKey(
- getWidgetForPaintable().collapsedRowKey);
+ getWidget().collapsedRowKey);
if (row != null) {
- getWidgetForPaintable().setRowFocus(row);
- getWidgetForPaintable().focus();
+ getWidget().setRowFocus(row);
+ getWidget().focus();
}
}
// check which rows are needed from the server and initiate a
// deferred fetch
- getWidgetForPaintable().onScroll(null);
+ 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 (getWidgetForPaintable().collapseRequest
- || (!uidl.hasAttribute("pagelength") && getWidgetForPaintable()
+ if (getWidget().collapseRequest
+ || (!uidl.hasAttribute("pagelength") && getWidget()
.getTotalRows() != oldTotalRows)) {
/*
* Ensure that possibly removed/added scrollbars are considered.
* cleans up state. Be careful if touching this, you will break
* pageLength=0 if you remove this.
*/
- getWidgetForPaintable().triggerLazyColumnAdjustment(true);
+ getWidget().triggerLazyColumnAdjustment(true);
- getWidgetForPaintable().collapseRequest = false;
+ getWidget().collapseRequest = false;
}
if (uidl.hasAttribute("focusedRow")) {
String key = uidl.getStringAttribute("focusedRow");
- getWidgetForPaintable().setRowFocus(
- getWidgetForPaintable().getRenderedRowByKey(key));
- getWidgetForPaintable().focusParentResponsePending = false;
+ 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
- getWidgetForPaintable().focusParentResponsePending = false;
+ getWidget().focusParentResponsePending = false;
}
- while (!getWidgetForPaintable().collapseRequest
- && !getWidgetForPaintable().focusParentResponsePending
- && !getWidgetForPaintable().pendingNavigationEvents.isEmpty()) {
+ 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 = getWidgetForPaintable().pendingNavigationEvents
+ PendingNavigationEvent event = getWidget().pendingNavigationEvents
.removeFirst();
- getWidgetForPaintable().handleNavigation(event.keycode, event.ctrl,
+ getWidget().handleNavigation(event.keycode, event.ctrl,
event.shift);
}
}
}
@Override
- public VTreeTable getWidgetForPaintable() {
- return (VTreeTable) super.getWidgetForPaintable();
+ public VTreeTable getWidget() {
+ return (VTreeTable) super.getWidget();
}
}
// Captions are updated before super call to ensure the widths are set
// correctly
if (isRealUpdate(uidl)) {
- getWidgetForPaintable().updateCaptions(uidl);
+ getWidget().updateCaptions(uidl);
}
super.updateFromUIDL(uidl, client);
}
@Override
- public VTwinColSelect getWidgetForPaintable() {
- return (VTwinColSelect) super.getWidgetForPaintable();
+ public VTwinColSelect getWidget() {
+ return (VTwinColSelect) super.getWidget();
}
}
if (!isRealUpdate(uidl)) {
return;
}
- getWidgetForPaintable().setCaption(
+ getWidget().setCaption(
"Widgetset does not contain implementation for "
- + getWidgetForPaintable().serverClassName
+ + 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 (getWidgetForPaintable().uidlTree != null) {
- getWidgetForPaintable().uidlTree.removeFromParent();
+ if (getWidget().uidlTree != null) {
+ getWidget().uidlTree.removeFromParent();
}
- getWidgetForPaintable().uidlTree = new VUIDLBrowser(uidl,
+ getWidget().uidlTree = new VUIDLBrowser(uidl,
client.getConfiguration());
- getWidgetForPaintable().uidlTree.open(true);
- getWidgetForPaintable().uidlTree.setText("Unrendered UIDL");
- getWidgetForPaintable().panel.add(getWidgetForPaintable().uidlTree);
+ getWidget().uidlTree.open(true);
+ getWidget().uidlTree.setText("Unrendered UIDL");
+ getWidget().panel.add(getWidget().uidlTree);
}
@Override
}
@Override
- public VUnknownComponent getWidgetForPaintable() {
- return (VUnknownComponent) super.getWidgetForPaintable();
+ public VUnknownComponent getWidget() {
+ return (VUnknownComponent) super.getWidget();
}
public void setServerSideClassName(String serverClassName) {
- getWidgetForPaintable().setServerSideClassName(serverClassName);
+ getWidget().setServerSideClassName(serverClassName);
}
}
return;
}
if (uidl.hasAttribute("notStarted")) {
- getWidgetForPaintable().t.schedule(400);
+ getWidget().t.schedule(400);
return;
}
if (uidl.hasAttribute("forceSubmit")) {
- getWidgetForPaintable().submit();
+ getWidget().submit();
return;
}
- getWidgetForPaintable().setImmediate(getState().isImmediate());
- getWidgetForPaintable().client = client;
- getWidgetForPaintable().paintableId = uidl.getId();
- getWidgetForPaintable().nextUploadId = uidl.getIntAttribute("nextid");
+ getWidget().setImmediate(getState().isImmediate());
+ getWidget().client = client;
+ getWidget().paintableId = uidl.getId();
+ getWidget().nextUploadId = uidl.getIntAttribute("nextid");
final String action = client.translateVaadinUri(uidl
.getStringVariable("action"));
- getWidgetForPaintable().element.setAction(action);
+ getWidget().element.setAction(action);
if (uidl.hasAttribute("buttoncaption")) {
- getWidgetForPaintable().submitButton.setText(uidl
+ getWidget().submitButton.setText(uidl
.getStringAttribute("buttoncaption"));
- getWidgetForPaintable().submitButton.setVisible(true);
+ getWidget().submitButton.setVisible(true);
} else {
- getWidgetForPaintable().submitButton.setVisible(false);
+ getWidget().submitButton.setVisible(false);
}
- getWidgetForPaintable().fu.setName(getWidgetForPaintable().paintableId
+ getWidget().fu.setName(getWidget().paintableId
+ "_file");
if (getState().isDisabled() || getState().isReadOnly()) {
- getWidgetForPaintable().disableUpload();
+ getWidget().disableUpload();
} else if (!uidl.getBooleanAttribute("state")) {
// Enable the button only if an upload is not in progress
- getWidgetForPaintable().enableUpload();
- getWidgetForPaintable().ensureTargetFrame();
+ getWidget().enableUpload();
+ getWidget().ensureTargetFrame();
}
}
}
@Override
- public VUpload getWidgetForPaintable() {
- return (VUpload) super.getWidgetForPaintable();
+ public VUpload getWidget() {
+ return (VUpload) super.getWidget();
}
}
public class VVerticalLayoutPaintable extends VMeasuringOrderedLayoutPaintable {
@Override
- public VVerticalLayout getWidgetForPaintable() {
- return (VVerticalLayout) super.getWidgetForPaintable();
+ public VVerticalLayout getWidget() {
+ return (VVerticalLayout) super.getWidget();
}
@Override
private void setPosterFromUIDL(UIDL uidl) {
if (uidl.hasAttribute(ATTR_POSTER)) {
- getWidgetForPaintable().setPoster(
+ getWidget().setPoster(
getConnection().translateVaadinUri(
uidl.getStringAttribute(ATTR_POSTER)));
}
}
@Override
- public VVideo getWidgetForPaintable() {
- return (VVideo) super.getWidgetForPaintable();
+ public VVideo getWidget() {
+ return (VVideo) super.getWidget();
}
@Override
public void execute() {
final VPaintableWidget paintable = (VPaintableWidget) uidl
.getPaintableAttribute("scrollTo", connection);
- paintable.getWidgetForPaintable().getElement()
+ paintable.getWidget().getElement()
.scrollIntoView();
}
});
@Override
public void updateFromUIDL(final UIDL uidl, ApplicationConnection client) {
- getWidgetForPaintable().rendering = true;
+ 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());
- getWidgetForPaintable().id = uidl.getId();
- boolean firstPaint = getWidgetForPaintable().connection == null;
- getWidgetForPaintable().connection = client;
+ getWidget().id = uidl.getId();
+ boolean firstPaint = getWidget().connection == null;
+ getWidget().connection = client;
- getWidgetForPaintable().immediate = getState().isImmediate();
- getWidgetForPaintable().resizeLazy = uidl
+ getWidget().immediate = getState().isImmediate();
+ getWidget().resizeLazy = uidl
.hasAttribute(VView.RESIZE_LAZY);
String newTheme = uidl.getStringAttribute("theme");
- if (getWidgetForPaintable().theme != null
- && !newTheme.equals(getWidgetForPaintable().theme)) {
+ if (getWidget().theme != null
+ && !newTheme.equals(getWidget().theme)) {
// Complete page refresh is needed due css can affect layout
// calculations etc
- getWidgetForPaintable().reloadHostPage();
+ getWidget().reloadHostPage();
} else {
- getWidgetForPaintable().theme = newTheme;
+ getWidget().theme = newTheme;
}
// this also implicitly removes old styles
- getWidgetForPaintable().setStyleName(
- getWidgetForPaintable().getStylePrimaryName() + " "
+ getWidget().setStyleName(
+ getWidget().getStylePrimaryName() + " "
+ getState().getStyle());
clickEventHandler.handleEventHandlerRegistration(client);
- if (!getWidgetForPaintable().isEmbedded()
+ 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());
if (isClosed) {
// don't render the content, something else will be opened to this
// browser view
- getWidgetForPaintable().rendering = false;
+ getWidget().rendering = false;
return;
}
UIDL childUidl = uidl.getChildUIDL(childIndex);
final VPaintableWidget lo = client.getPaintable(childUidl);
- if (getWidgetForPaintable().layout != null) {
- if (getWidgetForPaintable().layout != lo) {
+ if (getWidget().layout != null) {
+ if (getWidget().layout != lo) {
// remove old
- client.unregisterPaintable(getWidgetForPaintable().layout);
+ client.unregisterPaintable(getWidget().layout);
// add new
- getWidgetForPaintable().setWidget(lo.getWidgetForPaintable());
- getWidgetForPaintable().layout = lo;
+ getWidget().setWidget(lo.getWidget());
+ getWidget().layout = lo;
}
} else {
- getWidgetForPaintable().setWidget(lo.getWidgetForPaintable());
- getWidgetForPaintable().layout = lo;
+ getWidget().setWidget(lo.getWidget());
+ getWidget().layout = lo;
}
- getWidgetForPaintable().layout.updateFromUIDL(childUidl, client);
+ getWidget().layout.updateFromUIDL(childUidl, client);
// Save currently open subwindows to track which will need to be closed
final HashSet<VWindow> removedSubWindows = new HashSet<VWindow>(
- getWidgetForPaintable().subWindows);
+ getWidget().subWindows);
// Handle other UIDL children
while ((childUidl = uidl.getChildUIDL(++childIndex)) != null) {
String tag = childUidl.getTag().intern();
if (tag == "actions") {
- if (getWidgetForPaintable().actionHandler == null) {
- getWidgetForPaintable().actionHandler = new ShortcutActionHandler(
- getWidgetForPaintable().id, client);
+ if (getWidget().actionHandler == null) {
+ getWidget().actionHandler = new ShortcutActionHandler(
+ getWidget().id, client);
}
- getWidgetForPaintable().actionHandler
+ getWidget().actionHandler
.updateActionMap(childUidl);
} else if (tag == "execJS") {
String script = childUidl.getStringAttribute("script");
// subwindows
final VWindowPaintable w = (VWindowPaintable) client
.getPaintable(childUidl);
- VWindow windowWidget = w.getWidgetForPaintable();
- if (getWidgetForPaintable().subWindows.contains(windowWidget)) {
+ VWindow windowWidget = w.getWidget();
+ if (getWidget().subWindows.contains(windowWidget)) {
removedSubWindows.remove(windowWidget);
} else {
- getWidgetForPaintable().subWindows.add(windowWidget);
+ getWidget().subWindows.add(windowWidget);
}
w.updateFromUIDL(childUidl, client);
}
final VWindow w = rem.next();
client.unregisterPaintable(VPaintableMap.get(getConnection())
.getPaintable(w));
- getWidgetForPaintable().subWindows.remove(w);
+ getWidget().subWindows.remove(w);
w.hide();
}
.getPaintableAttribute("focused", getConnection());
final Widget toBeFocused = paintable
- .getWidgetForPaintable();
+ .getWidget();
/*
* Two types of Widgets can be focused, either implementing
* GWT HasFocus of a thinner Vaadin specific Focusable
// Add window listeners on first paint, to prevent premature
// variablechanges
if (firstPaint) {
- Window.addWindowClosingHandler(getWidgetForPaintable());
- Window.addResizeHandler(getWidgetForPaintable());
+ Window.addWindowClosingHandler(getWidget());
+ Window.addResizeHandler(getWidget());
}
- getWidgetForPaintable().onResize();
+ getWidget().onResize();
// finally set scroll position from UIDL
if (uidl.hasVariable("scrollTop")) {
- getWidgetForPaintable().scrollable = true;
- getWidgetForPaintable().scrollTop = uidl
+ getWidget().scrollable = true;
+ getWidget().scrollTop = uidl
.getIntVariable("scrollTop");
- DOM.setElementPropertyInt(getWidgetForPaintable().getElement(),
- "scrollTop", getWidgetForPaintable().scrollTop);
- getWidgetForPaintable().scrollLeft = uidl
+ DOM.setElementPropertyInt(getWidget().getElement(),
+ "scrollTop", getWidget().scrollTop);
+ getWidget().scrollLeft = uidl
.getIntVariable("scrollLeft");
- DOM.setElementPropertyInt(getWidgetForPaintable().getElement(),
- "scrollLeft", getWidgetForPaintable().scrollLeft);
+ DOM.setElementPropertyInt(getWidget().getElement(),
+ "scrollLeft", getWidget().scrollLeft);
} else {
- getWidgetForPaintable().scrollable = false;
+ 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(getWidgetForPaintable().getElement());
+ Util.runWebkitOverflowAutoFix(getWidget().getElement());
}
- getWidgetForPaintable().scrollIntoView(uidl);
+ getWidget().scrollIntoView(uidl);
if (uidl.hasAttribute(VView.FRAGMENT_VARIABLE)) {
- getWidgetForPaintable().currentFragment = uidl
+ getWidget().currentFragment = uidl
.getStringAttribute(VView.FRAGMENT_VARIABLE);
- if (!getWidgetForPaintable().currentFragment.equals(History
+ if (!getWidget().currentFragment.equals(History
.getToken())) {
- History.newItem(getWidgetForPaintable().currentFragment, true);
+ 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)
- getWidgetForPaintable().currentFragment = History.getToken();
+ getWidget().currentFragment = History.getToken();
// Include current fragment in the next request
- client.updateVariable(getWidgetForPaintable().id,
+ client.updateVariable(getWidget().id,
VView.FRAGMENT_VARIABLE,
- getWidgetForPaintable().currentFragment, false);
+ getWidget().currentFragment, false);
}
- getWidgetForPaintable().rendering = false;
+ getWidget().rendering = false;
}
public void init(String rootPanelId,
ApplicationConnection applicationConnection) {
- DOM.sinkEvents(getWidgetForPaintable().getElement(), Event.ONKEYDOWN
+ 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(getWidgetForPaintable().getElement(),
+ DOM.setElementProperty(getWidget().getElement(),
"tabIndex", "1");
RootPanel root = RootPanel.get(rootPanelId);
themeName = themeName.replaceAll("[^a-zA-Z0-9]", "");
root.addStyleName("v-theme-" + themeName);
- root.add(getWidgetForPaintable());
+ 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).
- getWidgetForPaintable().getElement().focus();
+ getWidget().getElement().focus();
}
}
@Override
protected <H extends EventHandler> HandlerRegistration registerHandler(
H handler, Type<H> type) {
- return getWidgetForPaintable().addDomHandler(handler, type);
+ return getWidget().addDomHandler(handler, type);
}
};
}
@Override
- public VView getWidgetForPaintable() {
- return (VView) super.getWidgetForPaintable();
+ public VView getWidget() {
+ return (VView) super.getWidget();
}
@Override
private void updateContentsSize() {
// Update child widget dimensions
if (client != null) {
- client.handleComponentRelativeSize(layout.getWidgetForPaintable());
+ client.handleComponentRelativeSize(layout.getWidget());
client.runDescendentsLayout((HasWidgets) layout
- .getWidgetForPaintable());
+ .getWidget());
}
Util.runWebkitOverflowAutoFix(contentPanel.getElement());
setNaturalWidth();
}
// layout size change may affect its available space (scrollbars)
- client.handleComponentRelativeSize(layout.getWidgetForPaintable());
+ client.handleComponentRelativeSize(layout.getWidget());
}
public ShortcutActionHandler getShortcutActionHandler() {
@Override
protected <H extends EventHandler> HandlerRegistration registerHandler(
H handler, Type<H> type) {
- return getWidgetForPaintable().addDomHandler(handler, type);
+ return getWidget().addDomHandler(handler, type);
}
};
@Override
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
- getWidgetForPaintable().id = uidl.getId();
- getWidgetForPaintable().client = client;
+ getWidget().id = uidl.getId();
+ getWidget().client = client;
// Workaround needed for Testing Tools (GWT generates window DOM
// slightly different in different browsers).
- DOM.setElementProperty(getWidgetForPaintable().closeBox, "id",
- getWidgetForPaintable().id + "_window_close");
+ DOM.setElementProperty(getWidget().closeBox, "id",
+ getWidget().id + "_window_close");
if (uidl.hasAttribute("invisible")) {
- getWidgetForPaintable().hide();
+ getWidget().hide();
return;
}
if (isRealUpdate(uidl)) {
- if (uidl.getBooleanAttribute("modal") != getWidgetForPaintable().vaadinModality) {
- getWidgetForPaintable().setVaadinModality(
- !getWidgetForPaintable().vaadinModality);
+ if (uidl.getBooleanAttribute("modal") != getWidget().vaadinModality) {
+ getWidget().setVaadinModality(
+ !getWidget().vaadinModality);
}
- if (!getWidgetForPaintable().isAttached()) {
- getWidgetForPaintable().setVisible(false); // hide until
+ if (!getWidget().isAttached()) {
+ getWidget().setVisible(false); // hide until
// possible centering
- getWidgetForPaintable().show();
+ getWidget().show();
}
- if (uidl.getBooleanAttribute("resizable") != getWidgetForPaintable().resizable) {
- getWidgetForPaintable().setResizable(
- !getWidgetForPaintable().resizable);
+ if (uidl.getBooleanAttribute("resizable") != getWidget().resizable) {
+ getWidget().setResizable(
+ !getWidget().resizable);
}
- getWidgetForPaintable().resizeLazy = uidl
+ getWidget().resizeLazy = uidl
.hasAttribute(VView.RESIZE_LAZY);
- getWidgetForPaintable().setDraggable(
+ 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.
- getWidgetForPaintable()
+ getWidget()
.setCaption(
getState().getCaption(),
uidl.getStringAttribute(VAbstractPaintableWidget.ATTRIBUTE_ICON));
}
- getWidgetForPaintable().visibilityChangesDisabled = true;
+ getWidget().visibilityChangesDisabled = true;
super.updateFromUIDL(uidl, client);
if (!isRealUpdate(uidl)) {
return;
}
- getWidgetForPaintable().visibilityChangesDisabled = false;
+ getWidget().visibilityChangesDisabled = false;
clickEventHandler.handleEventHandlerRegistration(client);
- getWidgetForPaintable().immediate = getState().isImmediate();
+ getWidget().immediate = getState().isImmediate();
- getWidgetForPaintable().setClosable(!getState().isReadOnly());
+ getWidget().setClosable(!getState().isReadOnly());
// Initialize the position form UIDL
int positionx = uidl.getIntVariable("positionx");
if (positiony < 0) {
positiony = 0;
}
- getWidgetForPaintable().setPopupPosition(positionx, positiony);
+ getWidget().setPopupPosition(positionx, positiony);
}
boolean showingUrl = false;
DOM.setStyleAttribute(frame.getElement(), "height", "100%");
DOM.setStyleAttribute(frame.getElement(), "border", "0px");
frame.setUrl(parsedUri);
- getWidgetForPaintable().contentPanel.setWidget(frame);
+ getWidget().contentPanel.setWidget(frame);
showingUrl = true;
} else {
final String target = childUidl.getStringAttribute("name");
}
final VPaintableWidget lo = client.getPaintable(childUidl);
- if (getWidgetForPaintable().layout != null) {
- if (getWidgetForPaintable().layout != lo) {
+ if (getWidget().layout != null) {
+ if (getWidget().layout != lo) {
// remove old
- client.unregisterPaintable(getWidgetForPaintable().layout);
- getWidgetForPaintable().contentPanel
- .remove(getWidgetForPaintable().layout
- .getWidgetForPaintable());
+ client.unregisterPaintable(getWidget().layout);
+ getWidget().contentPanel
+ .remove(getWidget().layout
+ .getWidget());
// add new
if (!showingUrl) {
- getWidgetForPaintable().contentPanel.setWidget(lo
- .getWidgetForPaintable());
+ getWidget().contentPanel.setWidget(lo
+ .getWidget());
}
- getWidgetForPaintable().layout = lo;
+ getWidget().layout = lo;
}
} else if (!showingUrl) {
- getWidgetForPaintable().contentPanel.setWidget(lo
- .getWidgetForPaintable());
- getWidgetForPaintable().layout = lo;
+ getWidget().contentPanel.setWidget(lo
+ .getWidget());
+ getWidget().layout = lo;
}
- getWidgetForPaintable().dynamicWidth = getState().isUndefinedWidth();
- getWidgetForPaintable().dynamicHeight = getState().isUndefinedHeight();
+ getWidget().dynamicWidth = getState().isUndefinedWidth();
+ getWidget().dynamicHeight = getState().isUndefinedHeight();
- getWidgetForPaintable().layoutRelativeWidth = uidl
+ getWidget().layoutRelativeWidth = uidl
.hasAttribute("layoutRelativeWidth");
- getWidgetForPaintable().layoutRelativeHeight = uidl
+ getWidget().layoutRelativeHeight = uidl
.hasAttribute("layoutRelativeHeight");
- if (getWidgetForPaintable().dynamicWidth
- && getWidgetForPaintable().layoutRelativeWidth) {
+ if (getWidget().dynamicWidth
+ && getWidget().layoutRelativeWidth) {
/*
* Relative layout width, fix window width before rendering (width
* according to caption)
*/
- getWidgetForPaintable().setNaturalWidth();
+ getWidget().setNaturalWidth();
}
- getWidgetForPaintable().layout.updateFromUIDL(childUidl, client);
- if (!getWidgetForPaintable().dynamicHeight
- && getWidgetForPaintable().layoutRelativeWidth) {
+ 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(getWidgetForPaintable());
+ 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 (getWidgetForPaintable().dynamicWidth
- && !getWidgetForPaintable().layoutRelativeWidth) {
- getWidgetForPaintable().setNaturalWidth();
+ if (getWidget().dynamicWidth
+ && !getWidget().layoutRelativeWidth) {
+ getWidget().setNaturalWidth();
}
- if (getWidgetForPaintable().dynamicHeight
- && getWidgetForPaintable().layoutRelativeHeight) {
+ if (getWidget().dynamicHeight
+ && getWidget().layoutRelativeHeight) {
// Prevent resizing until height has been fixed
- getWidgetForPaintable().resizable = false;
+ getWidget().resizable = false;
}
// we may have actions and notifications
for (int i = 1; i < cnt; i++) {
childUidl = uidl.getChildUIDL(i);
if (childUidl.getTag().equals("actions")) {
- if (getWidgetForPaintable().shortcutHandler == null) {
- getWidgetForPaintable().shortcutHandler = new ShortcutActionHandler(
+ if (getWidget().shortcutHandler == null) {
+ getWidget().shortcutHandler = new ShortcutActionHandler(
getId(), client);
}
- getWidgetForPaintable().shortcutHandler
+ getWidget().shortcutHandler
.updateActionMap(childUidl);
}
}
}
// setting scrollposition must happen after children is rendered
- getWidgetForPaintable().contentPanel.setScrollPosition(uidl
+ getWidget().contentPanel.setScrollPosition(uidl
.getIntVariable("scrollTop"));
- getWidgetForPaintable().contentPanel.setHorizontalScrollPosition(uidl
+ getWidget().contentPanel.setHorizontalScrollPosition(uidl
.getIntVariable("scrollLeft"));
// Center this window on screen if requested
// everything is painted into the window
if (uidl.getBooleanAttribute("center")) {
// mark as centered - this is unset on move/resize
- getWidgetForPaintable().centered = true;
- getWidgetForPaintable().center();
+ getWidget().centered = true;
+ getWidget().center();
} else {
// don't try to center the window anymore
- getWidgetForPaintable().centered = false;
+ getWidget().centered = false;
}
- getWidgetForPaintable().updateShadowSizeAndPosition();
- getWidgetForPaintable().setVisible(true);
+ getWidget().updateShadowSizeAndPosition();
+ getWidget().setVisible(true);
boolean sizeReduced = false;
// ensure window is not larger than browser window
- if (getWidgetForPaintable().getOffsetWidth() > Window.getClientWidth()) {
- getWidgetForPaintable().setWidth(Window.getClientWidth() + "px");
+ if (getWidget().getOffsetWidth() > Window.getClientWidth()) {
+ getWidget().setWidth(Window.getClientWidth() + "px");
sizeReduced = true;
}
- if (getWidgetForPaintable().getOffsetHeight() > Window
+ if (getWidget().getOffsetHeight() > Window
.getClientHeight()) {
- getWidgetForPaintable().setHeight(Window.getClientHeight() + "px");
+ getWidget().setHeight(Window.getClientHeight() + "px");
sizeReduced = true;
}
- if (getWidgetForPaintable().dynamicHeight
- && getWidgetForPaintable().layoutRelativeHeight) {
+ 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
* this.
*/
- int h = getWidgetForPaintable().contents.getOffsetHeight()
- + getWidgetForPaintable().getExtraHeight();
- int w = getWidgetForPaintable().getElement().getOffsetWidth();
+ 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(getWidgetForPaintable());
+ client.runDescendentsLayout(getWidget());
}
- Util.runWebkitOverflowAutoFix(getWidgetForPaintable().contentPanel
+ Util.runWebkitOverflowAutoFix(getWidget().contentPanel
.getElement());
- client.getView().getWidgetForPaintable().scrollIntoView(uidl);
+ client.getView().getWidget().scrollIntoView(uidl);
if (uidl.hasAttribute("bringToFront")) {
/*
* ApplicationConnection if another component was focused by the
* server side.
*/
- getWidgetForPaintable().contentPanel.focus();
- getWidgetForPaintable().bringToFrontSequence = uidl
+ getWidget().contentPanel.focus();
+ getWidget().bringToFrontSequence = uidl
.getIntAttribute("bringToFront");
VWindow.deferOrdering();
}
}
@Override
- public VWindow getWidgetForPaintable() {
- return (VWindow) super.getWidgetForPaintable();
+ public VWindow getWidget() {
+ return (VWindow) super.getWidget();
}
@Override
}
public void layout() {
- getWidgetForPaintable().requestLayout();
+ getWidget().requestLayout();
}
public void postLayout() {
- VWindow window = getWidgetForPaintable();
+ VWindow window = getWidget();
if (window.centered) {
window.center();
window.updateShadowSizeAndPosition();
private void addActiveDragSourceStyleName() {
VPaintableWidget dragSource = currentDrag.getTransferable()
.getDragSource();
- dragSource.getWidgetForPaintable().addStyleName(
+ dragSource.getWidget().addStyleName(
ACTIVE_DRAG_SOURCE_STYLENAME);
}
};
}
private void removeActiveDragSourceStyleName(VPaintableWidget dragSource) {
- dragSource.getWidgetForPaintable().removeStyleName(
+ dragSource.getWidget().removeStyleName(
ACTIVE_DRAG_SOURCE_STYLENAME);
}
@Override
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
super.updateFromUIDL(uidl, client);
- getWidgetForPaintable().setConnection(client);
+ getWidget().setConnection(client);
if (!isRealUpdate(uidl)) {
return;
}
final String mode = uidl.getStringAttribute("mode");
if (mode == null || "text".equals(mode)) {
- getWidgetForPaintable().setText(uidl.getChildString(0));
+ 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
- getWidgetForPaintable().setHTML("");
+ getWidget().setHTML("");
// add preformatted text to dom
- getWidgetForPaintable().getElement().appendChild(preElement);
+ getWidget().getElement().appendChild(preElement);
} else if ("uidl".equals(mode)) {
- getWidgetForPaintable().setHTML(uidl.getChildrenAsXML());
+ getWidget().setHTML(uidl.getChildrenAsXML());
} else if ("xhtml".equals(mode)) {
UIDL content = uidl.getChildUIDL(0).getChildUIDL(0);
if (content.getChildCount() > 0) {
- getWidgetForPaintable().setHTML(content.getChildString(0));
+ getWidget().setHTML(content.getChildString(0));
} else {
- getWidgetForPaintable().setHTML("");
+ getWidget().setHTML("");
}
sinkOnloads = true;
} else if ("xml".equals(mode)) {
- getWidgetForPaintable().setHTML(
+ getWidget().setHTML(
uidl.getChildUIDL(0).getChildString(0));
} else if ("raw".equals(mode)) {
- getWidgetForPaintable().setHTML(
+ getWidget().setHTML(
uidl.getChildUIDL(0).getChildString(0));
sinkOnloads = true;
} else {
- getWidgetForPaintable().setText("");
+ getWidget().setText("");
}
if (sinkOnloads) {
- Util.sinkOnloadForImages(getWidgetForPaintable().getElement());
+ Util.sinkOnloadForImages(getWidget().getElement());
}
}
}
@Override
- public VLabel getWidgetForPaintable() {
- return (VLabel) super.getWidgetForPaintable();
+ public VLabel getWidget() {
+ return (VLabel) super.getWidget();
}
}
private LayoutManager layoutManager;
public VPaintableLayoutSlot(String baseClassName, VPaintableWidget paintable) {
- super(baseClassName, paintable.getWidgetForPaintable());
+ super(baseClassName, paintable.getWidget());
this.paintable = paintable;
layoutManager = paintable.getLayoutManager();
}
@Override
public int getWidgetHeight() {
- return layoutManager.getOuterHeight(paintable.getWidgetForPaintable()
+ return layoutManager.getOuterHeight(paintable.getWidget()
.getElement());
}
@Override
public int getWidgetWidth() {
- return layoutManager.getOuterWidth(paintable.getWidgetForPaintable()
+ return layoutManager.getOuterWidth(paintable.getWidget()
.getElement());
}
@Override
public void updateFromUIDL(final UIDL uidl, ApplicationConnection client) {
- getWidgetForPaintable().client = client;
- getWidgetForPaintable().id = uidl.getId();
+ getWidget().client = client;
+ getWidget().id = uidl.getId();
if (uidl.hasVariable("text")) {
- getWidgetForPaintable().currentValue = uidl
+ getWidget().currentValue = uidl
.getStringVariable("text");
- if (getWidgetForPaintable().rta.isAttached()) {
- getWidgetForPaintable().rta
- .setHTML(getWidgetForPaintable().currentValue);
+ if (getWidget().rta.isAttached()) {
+ getWidget().rta
+ .setHTML(getWidget().currentValue);
} else {
- getWidgetForPaintable().html
- .setHTML(getWidgetForPaintable().currentValue);
+ getWidget().html
+ .setHTML(getWidget().currentValue);
}
}
if (isRealUpdate(uidl)) {
- getWidgetForPaintable().setEnabled(!getState().isDisabled());
+ getWidget().setEnabled(!getState().isDisabled());
}
super.updateFromUIDL(uidl, client);
return;
}
- getWidgetForPaintable().setReadOnly(getState().isReadOnly());
- getWidgetForPaintable().immediate = getState().isImmediate();
+ getWidget().setReadOnly(getState().isReadOnly());
+ getWidget().immediate = getState().isImmediate();
int newMaxLength = uidl.hasAttribute("maxLength") ? uidl
.getIntAttribute("maxLength") : -1;
if (newMaxLength >= 0) {
- if (getWidgetForPaintable().maxLength == -1) {
- getWidgetForPaintable().keyPressHandler = getWidgetForPaintable().rta
- .addKeyPressHandler(getWidgetForPaintable());
+ if (getWidget().maxLength == -1) {
+ getWidget().keyPressHandler = getWidget().rta
+ .addKeyPressHandler(getWidget());
}
- getWidgetForPaintable().maxLength = newMaxLength;
- } else if (getWidgetForPaintable().maxLength != -1) {
- getWidgetForPaintable().getElement().setAttribute("maxlength", "");
- getWidgetForPaintable().maxLength = -1;
- getWidgetForPaintable().keyPressHandler.removeHandler();
+ getWidget().maxLength = newMaxLength;
+ } else if (getWidget().maxLength != -1) {
+ getWidget().getElement().setAttribute("maxlength", "");
+ getWidget().maxLength = -1;
+ getWidget().keyPressHandler.removeHandler();
}
if (uidl.hasAttribute("selectAll")) {
- getWidgetForPaintable().selectAll();
+ getWidget().selectAll();
}
}
public void onBeforeShortcutAction(Event e) {
- getWidgetForPaintable().synchronizeContentToServer();
+ getWidget().synchronizeContentToServer();
}
@Override
- public VRichTextArea getWidgetForPaintable() {
- return (VRichTextArea) super.getWidgetForPaintable();
+ public VRichTextArea getWidget() {
+ return (VRichTextArea) super.getWidget();
};
@Override
if (!isRealUpdate(uidl)) {
return;
}
- getWidgetForPaintable().client = client;
+ getWidget().client = client;
}
@Override
- public VMyDropTarget getWidgetForPaintable() {
- return (VMyDropTarget) super.getWidgetForPaintable();
+ public VMyDropTarget getWidget() {
+ return (VMyDropTarget) super.getWidget();
}
@Override
projects / vaadin-framework.git / commitdiff