Example usage for com.google.gwt.event.dom.client HasChangeHandlers addChangeHandler

List of usage examples for com.google.gwt.event.dom.client HasChangeHandlers addChangeHandler

Introduction

In this page you can find the example usage for com.google.gwt.event.dom.client HasChangeHandlers addChangeHandler.

Prototype

HandlerRegistration addChangeHandler(ChangeHandler handler);

Source Link

Document

Adds a ChangeEvent 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());
                }//from ww  w.j  a  v a2s  .c  o 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.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;/*  w  ww  .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

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());
                        }//from   w  w  w  .  j a  v  a 2 s.  co  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   w w w  .  j  a  v  a  2s  .c o 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:net.sf.mmm.client.ui.impl.gwt.widget.field.adapter.UiWidgetAdapterGwtField.java

License:Apache License

/**
 * {@inheritDoc}/*from  w ww. jav  a2s. c o  m*/
 */
@Override
protected void applyEventAdapterForChange(EventAdapterGwt adapter) {

    HasChangeHandlers widget = getWidgetAsHasChangeHandlers();
    if (widget != null) {
        HandlerRegistration registration = widget.addChangeHandler(adapter);
        addHandlerRegistration(registration);
    }
}

From source file:org.glom.web.client.activity.TableSelectionActivity.java

License:Open Source License

/**
 * Invoked by the ActivityManager to start a new Activity
 *//*from ww w . j  a  va 2 s.  c om*/
@Override
public void start(final AcceptsOneWidget containerWidget, final EventBus eventBus) {

    final TableSelectionView tableSelectionView = clientFactory.getTableSelectionView();
    tableSelectionView.setPresenter(this);

    // TODO: Check for authentication here?
    // Or just let it fail to retrieve the list of tables,
    // and let the other activity on the page ask for authentication.

    // For table changes with the tableSelector:
    final HasChangeHandlers tableSelector = tableSelectionView.getTableSelector();
    tableChangeHandlerRegistration = tableSelector.addChangeHandler(new ChangeHandler() {
        @Override
        public void onChange(final ChangeEvent event) {
            // Fire a table change event so that other views (e.g. the details view) know about the change and can
            // update themselves.
            eventBus.fireEvent(new TableChangeEvent(tableSelectionView.getSelectedTableName()));

            // Update the browser title because there's a place change and the setPlace() method will not be called.
            Window.setTitle(documentTitle + ": " + tableSelectionView.getSelectedTableTitle());
        }
    });

    // For quick find changes with the quick find box:
    final HasChangeHandlers quickFindBox = tableSelectionView.getQuickFindBox();
    quickFindChangeHandlerRegistration = quickFindBox.addChangeHandler(new ChangeHandler() {
        @Override
        public void onChange(final ChangeEvent event) {
            // Fire a quickfind change event so that other views (e.g. the details view) know about the change and
            // can
            // update themselves.
            eventBus.fireEvent(new QuickFindChangeEvent(tableSelectionView.getQuickFindText()));

            // Update the browser title because there's place change and the setPlace() method will not be called.
            // TODO? Window.setTitle(documentTitle + ": " + tableSelectionView.getSelectedTableTitle());
        }
    });

    // For locale changes with the localeSelector:
    final HasChangeHandlers localeSelector = tableSelectionView.getLocaleSelector();
    localeChangeHandlerRegistration = localeSelector.addChangeHandler(new ChangeHandler() {
        @Override
        public void onChange(final ChangeEvent event) {
            // Show the translated version of the document title and the table names:
            final String localeID = tableSelectionView.getSelectedLocale();
            fillView(tableSelectionView);

            final String newURL = Window.Location.createUrlBuilder()
                    .setParameter(LocaleInfo.getLocaleQueryParam(), localeID).buildString();
            Window.Location.assign(newURL);

            // Fire a locale change event so that other views (e.g. the details view) know about the change and can
            // update themselves.
            eventBus.fireEvent(new LocaleChangeEvent(localeID));
        }
    });

    // For report choices with the reportSelector:
    final HasChangeHandlers reportSelector = tableSelectionView.getReportSelector();
    reportChangeHandlerRegistration = reportSelector.addChangeHandler(new ChangeHandler() {
        @Override
        public void onChange(final ChangeEvent event) {
            final String reportName = tableSelectionView.getSelectedReport();
            if (StringUtils.isEmpty(reportName)) {
                // Interpret selecting no report as requesting the list view.
                goTo(new ListPlace(documentID, tableName, quickFind));
            } else {
                // Show the selected report:
                goTo(new ReportPlace(documentID, tableName, reportName, quickFind));
            }
        }
    });

    fillView(tableSelectionView);

    // we're done, set the widget
    containerWidget.setWidget(tableSelectionView.asWidget());
}