Example usage for com.google.gwt.event.logical.shared HasValueChangeHandlers addValueChangeHandler

List of usage examples for com.google.gwt.event.logical.shared HasValueChangeHandlers addValueChangeHandler

  1. HOME
  2. Java
  3. com.google.gwt
  4. com.google.gwt.event.logical.shared.*
  5. HasValueChangeHandlers
  6. addValueChangeHandler

Introduction

In this page you can find the example usage for com.google.gwt.event.logical.shared HasValueChangeHandlers addValueChangeHandler.

Prototype

HandlerRegistration addValueChangeHandler(ValueChangeHandler<T> handler);

Source Link

Document

Adds a ValueChangeEvent handler.

Usage

From source file:com.qualogy.qafe.gwt.client.component.CellRendererHelper.java

License:Apache License

private static CellRenderer<DataContainerGVO, String> createDefaultRenderer(final DataGridColumnGVO column,
        final String uuid, final String parent, final HasDataGridMethods parentWidget,
        final ComponentGVO component) {
    CellRenderer<DataContainerGVO, String> cellRenderer;
    cellRenderer = new CellRenderer<DataContainerGVO, String>() {
        public void renderRowValue(final DataContainerGVO rowValue,
                final ColumnDefinition<DataContainerGVO, String> columnDef,
                AbstractCellView<DataContainerGVO> view) {
            if (rowValue.isMap()) {
                String generatedId = generateIdBasedOnIndex(column, view.getRowIndex());
                component.setId(generatedId);
                component.setEvents(column.getEvents());
                if (component instanceof EditableComponentGVO) {
                    EditableComponentGVO editableComponent = (EditableComponentGVO) component;
                    editableComponent.setEditable(column.getEditable());
                }//  w ww  .  j  av  a 2 s  .  co  m
                final UIObject uiObject = getOrCreateRenderedComponent(column, component, generatedId, uuid,
                        parent);

                // Get key for handler based on component uuid
                String key4Handler = getKey4Handler(column, view.getRowIndex(), parent);

                // HasSelectionHandlers is added for handling suggest text fields
                if (uiObject instanceof HasSelectionHandlers) {
                    HasSelectionHandlers hasSelectionHandlers = (HasSelectionHandlers) uiObject;

                    // Remove existing handler containing old rowValue
                    removeExistingHandler(key4Handler, selectionHandlers4Default);

                    HandlerRegistration handler = hasSelectionHandlers
                            .addSelectionHandler(new SelectionHandler<String>() {
                                public void onSelection(SelectionEvent<String> event) {
                                    if (column.getEditable()) {
                                        handleSetModifiedForSelectionEvent(parentWidget, rowValue, columnDef,
                                                uiObject, event);
                                    }
                                }
                            });
                    selectionHandlers4Default.put(key4Handler, handler);
                } else if (uiObject instanceof HasDataChangeHandlers) {
                    HasDataChangeHandlers hasDataChangeHandlers = (HasDataChangeHandlers) uiObject;

                    // Remove existing handler containing old rowValue
                    DataChangeHandler dataChangeHandler = dataChangeHandlers4Default.get(key4Handler);
                    hasDataChangeHandlers.removeDataChangeHandler(dataChangeHandler);

                    dataChangeHandler = new DataChangeHandler() {
                        public void onDataChange(UIObject uiObject, Object oldValue, Object newValue) {
                            if (column.getEditable()) {
                                handleSetModified(parentWidget, rowValue, columnDef, uiObject, newValue);
                            }
                        }
                    };
                    hasDataChangeHandlers.addDataChangeHandler(dataChangeHandler);
                    dataChangeHandlers4Default.put(key4Handler, dataChangeHandler);
                } else if (uiObject instanceof HasValueChangeHandlers) {
                    HasValueChangeHandlers hasValueChangeHandlers = (HasValueChangeHandlers) uiObject;

                    // Remove existing handler containing old rowValue
                    removeExistingHandler(key4Handler, valueChangeHandlers4Default);

                    HandlerRegistration handler = hasValueChangeHandlers
                            .addValueChangeHandler(new ValueChangeHandler() {
                                public void onValueChange(ValueChangeEvent event) {
                                    if (column.getEditable()) {
                                        handleSetModifiedForValueChangeEvent(parentWidget, rowValue, columnDef,
                                                uiObject, event);
                                    }
                                }
                            });
                    valueChangeHandlers4Default.put(key4Handler, handler);
                } else if (uiObject instanceof HasChangeHandlers) {
                    HasChangeHandlers hasChangeHandlers = (HasChangeHandlers) uiObject;

                    // Remove existing handler containing old rowValue
                    removeExistingHandler(key4Handler, changeHandlers4Default);

                    HandlerRegistration handler = hasChangeHandlers.addChangeHandler(new ChangeHandler() {
                        public void onChange(ChangeEvent event) {
                            if (column.getEditable()) {
                                handleSetModifiedForChangeEvent(parentWidget, rowValue, columnDef, uiObject,
                                        event);
                            }
                        }
                    });
                    changeHandlers4Default.put(key4Handler, handler);
                }
                if (uiObject instanceof HasKeyUpHandlers) {
                    // Handle value changed when typing
                    HasKeyUpHandlers hasKeyUpHandlers = (HasKeyUpHandlers) uiObject;

                    // Remove existing handler containing old rowValue
                    removeExistingHandler(key4Handler, keyUpHandlers4Default);

                    HandlerRegistration handler = hasKeyUpHandlers.addKeyUpHandler(new KeyUpHandler() {
                        public void onKeyUp(KeyUpEvent event) {
                            if (column.getEditable()
                                    && KeyBoardHelper.isValidKeyInput(event.getNativeEvent())) {
                                handleSetModifiedForValueChangeEvent(parentWidget, rowValue, columnDef,
                                        uiObject, event);
                            }
                        }
                    });
                    keyUpHandlers4Default.put(key4Handler, handler);
                }

                SetValueGVO setValueGVO = new SetValueGVO();
                DataContainerGVO valueDTC = new DataContainerGVO(
                        simpleObjectToText(columnDef.getCellValue(rowValue)));
                if (uiObject instanceof Widget) {
                    if (uiObject instanceof QDatePicker) {
                        valueDTC = ((QColumnDefinition) columnDef).getDataContainerGVO(rowValue);
                    } else if (uiObject instanceof ListBox) {
                        // Inner component is a drop down and hence is first filled with the stored value and the selected index is managed later with the column value.
                        QPagingScrollTable qPagingScrollTable = ((QPagingScrollTable) view
                                .getSourceTableDefinition());
                        if (qPagingScrollTable.getDropDownColumnAndValues() != null && qPagingScrollTable
                                .getDropDownColumnAndValues().containsKey(column.getId())) {
                            SetValueGVO setValueGVOForInitialising = qPagingScrollTable
                                    .getDropDownColumnAndValues().get(column.getId());
                            // Do the set operation for the drop down - it can be a set with action set/add
                            SetValueExecute.processValue(uiObject,
                                    setValueGVOForInitialising.getDataContainer(), setValueGVOForInitialising,
                                    setValueGVOForInitialising.getDataContainer());
                        }
                    }
                    // Now set the value to the column
                    SetValueExecute.processValue(uiObject, simpleObjectToText(columnDef.getCellValue(rowValue)),
                            setValueGVO, valueDTC);
                    view.setWidget((Widget) uiObject);
                }
            }
        }
    };
    return cellRenderer;
}

From source file:com.qualogy.qafe.gwt.client.component.QChoiceHelper.java

License:Apache License

public void registerItemValueChangeHandler(final Widget item) {
    if (item instanceof HasValueChangeHandlers) {
        HasValueChangeHandlers<Boolean> hasValueChangeHandlers = (HasValueChangeHandlers<Boolean>) item;
        hasValueChangeHandlers.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
            public void onValueChange(ValueChangeEvent<Boolean> event) {
                doItemValueChange(event);
            }//from   w  ww .j a va 2s.co m
        });
    }
}

From source file:com.qualogy.qafe.gwt.client.ui.renderer.PagingDataGridRenderer.java

License:Apache License

private void registerOverflowItemDataChange(final DataGridGVO datagridGVO, final UIObject datagrid) {
    String overflowGroup = datagridGVO.getOverflowGroup();
    String key4OverflowGroup = generateId(overflowGroup, datagrid);
    List<UIObject> overflowItems = RendererHelper.getGroupedComponent(key4OverflowGroup);
    if (overflowItems == null) {
        return;/*from   w  w w  .ja  v  a2  s  . c o m*/
    }
    for (UIObject overflowItem : overflowItems) {
        if (overflowItem instanceof HasDataChangeHandlers) {
            HasDataChangeHandlers hasDataChangeHandlers = (HasDataChangeHandlers) overflowItem;
            hasDataChangeHandlers.addDataChangeHandler(new DataChangeHandler() {
                @Override
                public void onDataChange(UIObject uiObject, Object oldValue, Object newValue) {
                    handleOverflowItemDataChange(datagridGVO, datagrid, uiObject, newValue);
                }
            });
        } else if (overflowItem instanceof HasValueChangeHandlers) {
            HasValueChangeHandlers hasValueChangeHandlers = (HasValueChangeHandlers) overflowItem;
            hasValueChangeHandlers.addValueChangeHandler(new ValueChangeHandler<Object>() {
                @Override
                public void onValueChange(ValueChangeEvent<Object> event) {
                    UIObject source = (UIObject) event.getSource();
                    handleOverflowItemDataChange(datagridGVO, datagrid, source);
                }
            });
        } else if (overflowItem instanceof HasChangeHandlers) {
            HasChangeHandlers hasChangeHandlers = (HasChangeHandlers) overflowItem;
            hasChangeHandlers.addChangeHandler(new ChangeHandler() {
                @Override
                public void onChange(ChangeEvent event) {
                    UIObject source = (UIObject) event.getSource();
                    handleOverflowItemDataChange(datagridGVO, datagrid, source);
                }
            });
        } else if (overflowItem instanceof SourcesChangeEvents) {
            // LEGACY CODE
            SourcesChangeEvents sourcesChangeEvents = (SourcesChangeEvents) overflowItem;
            sourcesChangeEvents.addChangeListener(new ChangeListener() {
                @Override
                public void onChange(Widget sender) {
                    handleOverflowItemDataChange(datagridGVO, datagrid, sender);
                }
            });
        }
    }
}

From source file:com.qualogy.qafe.gwt.client.ui.renderer.RendererHelper.java

License:Apache License

private static void addChangeListenerForWindowModified(final ComponentGVO vo, UIObject ui, final String uuid) {
    if (ui != null) {
        if (ui instanceof HasValueChangeHandlers) {
            HasValueChangeHandlers hasValueChangeHandlers = (HasValueChangeHandlers) ui;
            hasValueChangeHandlers.addValueChangeHandler(new ValueChangeHandler() {

                public void onValueChange(ValueChangeEvent event) {
                    WindowPanel window = ClientApplicationContext.getInstance().getWindow(vo.getWindow(), uuid);
                    if (window != null && window instanceof QWindowPanel) {
                        ((QWindowPanel) window).setModified(true);
                    }//from www. j av a2 s . c  o m
                }
            });
        }
    }

}

From source file:com.qualogy.qafe.gwt.client.ui.renderer.RendererHelper.java

License:Apache License

public static void handleRequiredAttribute(ComponentGVO gvo, UIObject uiObject) {

    if (gvo instanceof HasRequired) {
        HasRequired hasRequiredPropertyI = (HasRequired) gvo;
        final ComponentGVO finalGvo = gvo;
        if (hasRequiredPropertyI.getRequired() != null) {
            DOM.setElementAttribute(getElement(uiObject), "required",
                    hasRequiredPropertyI.getRequired().toString());

            handleRequiredStyle(gvo, uiObject);

            if (uiObject instanceof HasValueChangeHandlers) {
                HasValueChangeHandlers<String> hasValueChangeHandlers = (HasValueChangeHandlers<String>) uiObject;
                hasValueChangeHandlers.addValueChangeHandler(new ValueChangeHandler<String>() {

                    public void onValueChange(ValueChangeEvent<String> event) {
                        if (event.getSource() instanceof UIObject) {
                            handleRequiredStyle(finalGvo, (UIObject) event.getSource());
                        }/*  ww  w .j a  v a  2 s  .  c o  m*/
                    }
                });

            }
            if (uiObject instanceof HasChangeHandlers) {
                HasChangeHandlers hasChangeHandlers = (HasChangeHandlers) uiObject;
                hasChangeHandlers.addChangeHandler(new ChangeHandler() {

                    public void onChange(ChangeEvent event) {
                        if (event.getSource() instanceof ListBox) {
                            handleRequiredStyle(finalGvo, (UIObject) event.getSource());
                        }
                    }
                });
            }
        }
    }
}

From source file:com.qualogy.qafe.gwt.client.ui.renderer.RendererHelper.java

License:Apache License

public static void processEvents(ComponentGVO vo, UIObject ui, EventListenerGVO event,
        List<com.qualogy.qafe.gwt.client.vo.ui.event.InputVariableGVO> inputVariables, String appId) {
    if (ui != null) {
        String nonHandledEventName = null;
        String nonHandledEventMessage = null;
        if (event instanceof OnEnterEventListenerGVO) {
            if (ui instanceof HasAllKeyHandlers) {
                HasAllKeyHandlers hasAllKeyHandlers = (HasAllKeyHandlers) ui;
                hasAllKeyHandlers.addKeyDownHandler(EventFactory.createOnEnterListener(event, inputVariables));
            } else {
                nonHandledEventName = QAMLConstants.EVENT_ONENTER;
            }//from ww  w.  j  a  v  a  2s.  co  m
        }
        if (event instanceof OnFocusEventListenerGVO) {
            if (ui instanceof HasFocusHandlers) {
                HasFocusHandlers hasFocusHandlers = (HasFocusHandlers) ui;
                hasFocusHandlers.addFocusHandler(EventFactory.createFocusListener(event, inputVariables));
            } else {
                nonHandledEventName = QAMLConstants.EVENT_ONFOCUS;
            }
        }
        if (event instanceof OnExitEventListenerGVO) {
            if (ui instanceof HasBlurHandlers) {
                HasBlurHandlers hasBlurHandlers = (HasBlurHandlers) ui;
                hasBlurHandlers.addBlurHandler(EventFactory.createOnExitListener(event, inputVariables));
            } else {
                nonHandledEventName = QAMLConstants.EVENT_ONEXIT;
            }
        }
        if (event instanceof ClickEventListenerGVO) {
            if (ui instanceof HasClickHandlers) {
                ui.addStyleName("qafe_hand");
                HasClickHandlers hasClickHandlers = (HasClickHandlers) ui;
                hasClickHandlers.addClickHandler(EventFactory.createClickListener(event, inputVariables));
            } else if (ui instanceof MenuItem) {
                MenuItem menuItem = (MenuItem) ui;
                menuItem.setCommand(EventFactory.createCommandListener(menuItem, event, inputVariables));
                ui.addStyleName("qafe_hand");
            } else if (ui instanceof AreaWidget) {
                AreaWidget area = (AreaWidget) ui;
                area.setCommand(EventFactory.createCommandListener(area, event, inputVariables));
                ui.addStyleName("qafe_hand");
            } else if (ui instanceof TabPanel) {
                TabPanel tabPanel = (TabPanel) ui;
                String eventComponentId = event.getEventComponentId();
                String[] components = eventComponentId.split("\\.");
                if (components.length == 1) {
                    tabPanel.addSelectionHandler(
                            EventFactory.createTabPanelListener(tabPanel, event, inputVariables));
                    ui.addStyleName("qafe_hand");
                }
            } else {
                nonHandledEventName = QAMLConstants.EVENT_ONCLICK;
            }
        }
        if (event instanceof DoubleClickEventListenerGVO) {
            if (ui instanceof HasDoubleClickHandlers) {
                //ui.addStyleName("qafe_hand");
                HasDoubleClickHandlers hasDoubleClickHandlers = (HasDoubleClickHandlers) ui;
                hasDoubleClickHandlers
                        .addDoubleClickHandler(EventFactory.createDoubleClickListener(event, inputVariables));
            } else {
                nonHandledEventName = QAMLConstants.EVENT_ONDBLCLICK;
            }
        }
        if (event instanceof OnChangeEventListenerGVO) {
            if (ui instanceof QSuggestBox) {
                QSuggestBox suggestionBox = (QSuggestBox) ui;
                suggestionBox.addKeyUpHandler(
                        EventFactory.createSuggestionOnKeyUpHandler(suggestionBox, event, inputVariables));
            } else if (ui instanceof QDatePicker && ui instanceof HasValueChangeHandlers) {
                HasValueChangeHandlers hasValueChangeHandlers = (HasValueChangeHandlers) ui;
                hasValueChangeHandlers.addValueChangeHandler(
                        (EventFactory.createOnValueChangeHandler(event, inputVariables)));
            } else if (ui instanceof HasDataChangeHandlers) {
                HasDataChangeHandlers hasDataChangeHandlers = (HasDataChangeHandlers) ui;
                hasDataChangeHandlers
                        .addDataChangeHandler((EventFactory.createOnDataChangeHandler(event, inputVariables)));
            } else if (ui instanceof HasChangeHandlers) {
                HasChangeHandlers hasChangeHandlers = (HasChangeHandlers) ui;
                hasChangeHandlers
                        .addChangeHandler((EventFactory.createOnChangeListener(event, inputVariables)));
            } else if (ui instanceof SourcesChangeEvents) {
                SourcesChangeEvents sourcesChangeEvents = (SourcesChangeEvents) ui;
                sourcesChangeEvents
                        .addChangeListener(EventFactory.createLegacyOnChangeListener(event, inputVariables));
            } else {
                nonHandledEventName = QAMLConstants.EVENT_ONCHANGE;
            }
        }
        if (event instanceof OnMouseEnterEventListenerGVO) {
            if (ui instanceof HasAllMouseHandlers) {
                HasAllMouseHandlers hasAllMouseHandlers = (HasAllMouseHandlers) ui;
                hasAllMouseHandlers
                        .addMouseOverHandler(EventFactory.createOnMouseEnterListener(event, inputVariables));
            } else {
                nonHandledEventName = QAMLConstants.EVENT_ONMOUSE_ENTER;
            }
        }
        if (event instanceof OnMouseExitEventListenerGVO) {
            if (ui instanceof HasAllMouseHandlers) {
                HasAllMouseHandlers hasAllMouseHandlers = (HasAllMouseHandlers) ui;
                hasAllMouseHandlers
                        .addMouseOutHandler(EventFactory.createOnMouseExitListener(event, inputVariables));
            } else {
                nonHandledEventName = QAMLConstants.EVENT_ONMOUSE_EXIT;
            }
        }
        if (event instanceof OnMouseMoveEventListenerGVO) {
            if (ui instanceof HasAllMouseHandlers) {
                HasAllMouseHandlers hasAllMouseHandlers = (HasAllMouseHandlers) ui;
                hasAllMouseHandlers
                        .addMouseMoveHandler(EventFactory.createOnMouseMoveListener(event, inputVariables));
            } else {
                nonHandledEventName = QAMLConstants.EVENT_ONMOUSE_MOVE;
            }
        }
        if (event instanceof OnMouseUpEventListenerGVO) {
            if (ui instanceof HasAllMouseHandlers) {
                HasAllMouseHandlers hasAllMouseHandlers = (HasAllMouseHandlers) ui;
                hasAllMouseHandlers
                        .addMouseUpHandler(EventFactory.createOnMouseUpListener(event, inputVariables));
            } else {
                nonHandledEventName = QAMLConstants.EVENT_ONMOUSE_UP;
            }
        }
        if (event instanceof OnMouseDownEventListenerGVO) {
            if (ui instanceof HasAllMouseHandlers) {
                HasAllMouseHandlers hasAllMouseHandlers = (HasAllMouseHandlers) ui;
                hasAllMouseHandlers
                        .addMouseDownHandler(EventFactory.createOnMouseDownListener(event, inputVariables));
            } else {
                nonHandledEventName = QAMLConstants.EVENT_ONMOUSE_DOWN;
            }
        }
        if (event instanceof OnKeyPressEventListenerGVO) {
            if (ui instanceof HasAllKeyHandlers) {
                HasAllKeyHandlers hasAllKeyHandlers = (HasAllKeyHandlers) ui;
                hasAllKeyHandlers
                        .addKeyPressHandler(EventFactory.createOnKeyPressListener(event, inputVariables));
            } else {
                nonHandledEventName = QAMLConstants.EVENT_ONKEYPRESS;
            }
        }
        if (event instanceof OnKeyDownEventListenerGVO) {
            if (ui instanceof HasAllKeyHandlers) {
                HasAllKeyHandlers hasAllKeyHandlers = (HasAllKeyHandlers) ui;
                hasAllKeyHandlers
                        .addKeyDownHandler(EventFactory.createOnKeyDownListener(event, inputVariables));
            } else if (ui instanceof HasNativeKeyHandlers) {
                HasNativeKeyHandlers hasNativeKeyHandlers = (HasNativeKeyHandlers) ui;
                hasNativeKeyHandlers.addNativeKeyDownHandler(
                        EventFactory.createOnNativeKeyDownListener(event, inputVariables));
            } else {
                nonHandledEventName = QAMLConstants.EVENT_ONKEYDOWN;
            }
        }
        if (event instanceof OnKeyUpEventListenerGVO) {
            if (ui instanceof HasAllKeyHandlers) {
                HasAllKeyHandlers hasAllKeyHandlers = (HasAllKeyHandlers) ui;
                hasAllKeyHandlers.addKeyUpHandler(EventFactory.createOnKeyUpListener(event, inputVariables));
            } else if (ui instanceof HasNativeKeyHandlers) {
                HasNativeKeyHandlers hasNativeKeyHandlers = (HasNativeKeyHandlers) ui;
                hasNativeKeyHandlers
                        .addNativeKeyUpHandler(EventFactory.createOnNativeKeyUpListener(event, inputVariables));
            } else {
                nonHandledEventName = QAMLConstants.EVENT_ONKEYUP;
            }
        }
        if (event instanceof OnLoadEventListenerGVO) {
            if (!(vo instanceof WindowGVO)) {
                nonHandledEventName = QAMLConstants.EVENT_ONLOAD;
                nonHandledEventMessage = "Support on Window only.";
            }
        }
        if (event instanceof OnUnLoadEventListenerGVO) {
            if (!(vo instanceof WindowGVO)) {
                nonHandledEventName = QAMLConstants.EVENT_ONUNLOAD;
                nonHandledEventMessage = "Support on Window only.";
            }
        }
        if (event instanceof OnFinishEventListenerGVO) {
            if (ui instanceof FormPanel) {
                FormPanel formPanel = (FormPanel) ui;
                formPanel.addSubmitCompleteHandler(
                        EventFactory.createSubmitCompleteHandler(ui, event, inputVariables));
            } else {
                nonHandledEventName = QAMLConstants.EVENT_ONFINISH;
            }
        }
        if (event instanceof OnTimerEventListenerGVO) {
            //check a timer is already scheduled for this event- this happens when there are multiple component reference mentioned in that event
            if (!ClientApplicationContext.getInstance().isTimerScheduledForEvent(appId, vo.getWindow(),
                    event.getEventId())) {
                OnTimerHandler timerHandler = new OnTimerHandler();
                timerHandler.processOnTimer(ui, vo, appId, event, inputVariables);
            } else {
                nonHandledEventName = QAMLConstants.EVENT_ONTIMER;
                nonHandledEventMessage = "Timer is already scheduled.";
            }
        }
        if (nonHandledEventName != null) {
            if (nonHandledEventMessage == null) {
                nonHandledEventMessage = "";
            }
            ClientApplicationContext.getInstance()
                    .log("The component [" + DOM.getElementAttribute(ui.getElement(), "id") + "] for event ["
                            + event.getEventId() + "] does not support " + nonHandledEventName + " listener. "
                            + nonHandledEventMessage, null);
        }
    }
}

From source file:com.qualogy.qafe.mgwt.client.ui.renderer.RendererHelper.java

License:Apache License

private static void addChangeListenerForWindowModified(final ComponentGVO vo, UIObject ui, final String uuid) {
    if (ui != null) {
        if (ui instanceof HasValueChangeHandlers) {
            HasValueChangeHandlers hasValueChangeHandlers = (HasValueChangeHandlers) ui;
            hasValueChangeHandlers.addValueChangeHandler(new ValueChangeHandler() {

                public void onValueChange(ValueChangeEvent event) {
                    //                  WindowPanel window = ClientApplicationContext.getInstance().getWindow(vo.getWindow(), uuid);
                    //                  if (window != null && window instanceof QWindowPanel) {
                    //                     ((QWindowPanel) window).setModified(true);
                    //                  }
                }/*w w  w . ja  va 2 s  . c om*/
            });
        }
    }

}

From source file:de.csenk.gwt.commons.editor.client.AutoFlushInitializer.java

License:Apache License

/**
 * {@inheritDoc}/*  w w  w  .  j av  a  2 s  . c  o m*/
 */
@Override
public <Q> boolean visit(EditorContext<Q> ctx) {
    final HasValueChangeHandlers<Q> editor = asHasValueChangeHandlers(ctx.getEditor());
    if (editor != null) {
        handlerRegistrations.add(editor.addValueChangeHandler(createValueChangeHandler(ctx)));
    }

    return super.visit(ctx);
}

From source file:de.knightsoftnet.validators.client.decorators.AbstractDecorator.java

License:Apache License

/**
 * add a change handler to clear error state on value change.
 *
 * @param pwidget widget to set the handler to
 *//* w  w w  . j  a va  2s.  c  o  m*/
protected void addValueChangeHandler(final HasValueChangeHandlers<T> pwidget) {
    pwidget.addValueChangeHandler(new ValueChangeHandler<T>() {
        @Override
        public void onValueChange(final ValueChangeEvent<T> event) {
            AbstractDecorator.this.clearErrors();
        }
    });
}

From source file:org.bonitasoft.forms.client.view.widget.ElementAttributeSupport.java

License:Open Source License

protected void addHtmlAttribute(Widget fieldWidget, final String htmlAttributeName,
        final String htmlAttributeValue) {
    //Working for bug 4991: the "Html Attributes" of date widget
    if (fieldWidget instanceof DateBox) {
        fieldWidget = ((DateBox) fieldWidget).getTextBox();
    }/*from w  w w .ja  v a2 s .c  o  m*/
    try {
        final SUPPORTED_EVENT event = SUPPORTED_EVENT.valueOf(htmlAttributeName.toLowerCase());
        switch (event) {
        case onclick:
            ((HasClickHandlers) fieldWidget).addClickHandler(new ClickHandler() {

                public void onClick(final ClickEvent event) {
                    DOMUtils.getInstance().javascriptEval(htmlAttributeValue);
                }
            });
            break;
        case ondbclick:
            ((HasDoubleClickHandlers) fieldWidget).addDoubleClickHandler(new DoubleClickHandler() {

                public void onDoubleClick(final DoubleClickEvent event) {
                    DOMUtils.getInstance().javascriptEval(htmlAttributeValue);
                }
            });
            break;
        case onblur:
            ((HasBlurHandlers) fieldWidget).addBlurHandler(new BlurHandler() {

                public void onBlur(final BlurEvent event) {
                    DOMUtils.getInstance().javascriptEval(htmlAttributeValue);
                }
            });
            break;
        case onchange:
            if (fieldWidget instanceof HasChangeHandlers) {
                ((HasChangeHandlers) fieldWidget).addChangeHandler(new ChangeHandler() {

                    public void onChange(final ChangeEvent event) {
                        DOMUtils.getInstance().javascriptEval(htmlAttributeValue);
                    }
                });
            } else if (fieldWidget instanceof HasValueChangeHandlers<?>) {
                final HasValueChangeHandlers<Serializable> widget = (HasValueChangeHandlers<Serializable>) fieldWidget;
                widget.addValueChangeHandler(new ValueChangeHandler<Serializable>() {

                    public void onValueChange(final ValueChangeEvent<Serializable> event) {
                        DOMUtils.getInstance().javascriptEval(htmlAttributeValue);
                    }
                });
            }
            break;
        case onfocus:
            ((HasFocusHandlers) fieldWidget).addFocusHandler(new FocusHandler() {

                public void onFocus(final FocusEvent event) {
                    DOMUtils.getInstance().javascriptEval(htmlAttributeValue);
                }
            });
            break;
        case onkeydown:
            ((HasKeyDownHandlers) fieldWidget).addKeyDownHandler(new KeyDownHandler() {

                public void onKeyDown(final KeyDownEvent event) {
                    DOMUtils.getInstance().javascriptEval(htmlAttributeValue);
                }
            });
            break;
        case onkeyup:
            ((HasKeyUpHandlers) fieldWidget).addKeyUpHandler(new KeyUpHandler() {

                public void onKeyUp(final KeyUpEvent event) {
                    DOMUtils.getInstance().javascriptEval(htmlAttributeValue);
                }
            });
            break;
        case onkeypress:
            ((HasKeyUpHandlers) fieldWidget).addKeyUpHandler(new KeyUpHandler() {

                public void onKeyUp(final KeyUpEvent event) {
                    DOMUtils.getInstance().javascriptEval(htmlAttributeValue);
                }
            });
            break;
        case onmousedown:
            ((HasMouseDownHandlers) fieldWidget).addMouseDownHandler(new MouseDownHandler() {

                public void onMouseDown(final MouseDownEvent event) {
                    DOMUtils.getInstance().javascriptEval(htmlAttributeValue);
                }
            });
            break;
        case onmouseup:
            ((HasMouseUpHandlers) fieldWidget).addMouseUpHandler(new MouseUpHandler() {

                public void onMouseUp(final MouseUpEvent event) {
                    DOMUtils.getInstance().javascriptEval(htmlAttributeValue);
                }
            });
            break;
        case onmouseover:
            ((HasMouseOverHandlers) fieldWidget).addMouseOverHandler(new MouseOverHandler() {

                public void onMouseOver(final MouseOverEvent event) {
                    DOMUtils.getInstance().javascriptEval(htmlAttributeValue);
                }
            });
            break;
        case onmouseout:
            ((HasMouseOutHandlers) fieldWidget).addMouseOutHandler(new MouseOutHandler() {

                public void onMouseOut(final MouseOutEvent event) {
                    DOMUtils.getInstance().javascriptEval(htmlAttributeValue);
                }
            });
            break;
        case onmousemove:
            ((HasMouseMoveHandlers) fieldWidget).addMouseMoveHandler(new MouseMoveHandler() {

                public void onMouseMove(final MouseMoveEvent event) {
                    DOMUtils.getInstance().javascriptEval(htmlAttributeValue);
                }
            });
            break;
        default:
            break;
        }
    } catch (final Exception e) {
        if (fieldWidget instanceof CheckBox || fieldWidget instanceof CheckboxGroupWidget
                || fieldWidget instanceof RadioButtonGroupWidget || fieldWidget instanceof FileUploadWidget
                || fieldWidget instanceof SuggestBox || fieldWidget instanceof AsyncSuggestBoxWidget
                || fieldWidget instanceof DateBox) {
            final NodeList<Element> inputs = fieldWidget.getElement().getElementsByTagName("input");
            if (inputs != null) {
                for (int i = 0; i < inputs.getLength(); i++) {
                    inputs.getItem(i).setAttribute(htmlAttributeName, htmlAttributeValue);
                }
            }
        } else if (fieldWidget instanceof DurationWidget) {
            final NodeList<Element> selects = fieldWidget.getElement().getElementsByTagName("select");
            if (selects != null) {
                for (int i = 0; i < selects.getLength(); i++) {
                    selects.getItem(i).setAttribute(htmlAttributeName, htmlAttributeValue);
                }
            }
        } else if (fieldWidget instanceof ImageWidget) {
            final NodeList<Element> images = fieldWidget.getElement().getElementsByTagName("img");
            if (images != null) {
                for (int i = 0; i < images.getLength(); i++) {
                    images.getItem(i).setAttribute(htmlAttributeName, htmlAttributeValue);
                }
            }
        } else if (fieldWidget instanceof FileDownloadWidget) {
            final NodeList<Element> links = fieldWidget.getElement().getElementsByTagName("a");
            if (links != null) {
                for (int i = 0; i < links.getLength(); i++) {
                    links.getItem(i).setAttribute(htmlAttributeName, htmlAttributeValue);
                }
            }
        } else if (fieldWidget instanceof TableWidget || fieldWidget instanceof EditableGridWidget) {
            final NodeList<Element> tables = fieldWidget.getElement().getElementsByTagName("table");
            if (tables != null) {
                for (int i = 0; i < tables.getLength(); i++) {
                    tables.getItem(i).setAttribute(htmlAttributeName, htmlAttributeValue);
                }
            }
        } else if (fieldWidget instanceof RichTextWidget) {
            final NodeList<Element> iframes = fieldWidget.getElement().getElementsByTagName("iframe");
            if (iframes != null) {
                for (int i = 0; i < iframes.getLength(); i++) {
                    iframes.getItem(i).setAttribute(htmlAttributeName, htmlAttributeValue);
                }
            }
        } else {
            fieldWidget.getElement().setAttribute(htmlAttributeName, htmlAttributeValue);
        }
    }
}