| /* |
| * Copyright 2008 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| |
| package com.google.gwt.user.client.ui; |
| |
| import com.google.gwt.dom.client.Element; |
| import com.google.gwt.event.dom.client.BlurEvent; |
| import com.google.gwt.event.dom.client.BlurHandler; |
| import com.google.gwt.event.dom.client.ChangeEvent; |
| import com.google.gwt.event.dom.client.ChangeHandler; |
| import com.google.gwt.event.dom.client.ClickEvent; |
| import com.google.gwt.event.dom.client.ClickHandler; |
| import com.google.gwt.event.dom.client.ErrorEvent; |
| import com.google.gwt.event.dom.client.ErrorHandler; |
| import com.google.gwt.event.dom.client.FocusEvent; |
| import com.google.gwt.event.dom.client.FocusHandler; |
| import com.google.gwt.event.dom.client.HandlesAllFocusEvents; |
| import com.google.gwt.event.dom.client.HandlesAllKeyEvents; |
| import com.google.gwt.event.dom.client.HasAllFocusHandlers; |
| import com.google.gwt.event.dom.client.HasAllKeyHandlers; |
| import com.google.gwt.event.dom.client.HasChangeHandlers; |
| import com.google.gwt.event.dom.client.HasClickHandlers; |
| import com.google.gwt.event.dom.client.HasErrorHandlers; |
| import com.google.gwt.event.dom.client.HasLoadHandlers; |
| import com.google.gwt.event.dom.client.HasMouseDownHandlers; |
| import com.google.gwt.event.dom.client.HasMouseMoveHandlers; |
| import com.google.gwt.event.dom.client.HasMouseOutHandlers; |
| import com.google.gwt.event.dom.client.HasMouseOverHandlers; |
| import com.google.gwt.event.dom.client.HasMouseUpHandlers; |
| import com.google.gwt.event.dom.client.HasMouseWheelHandlers; |
| import com.google.gwt.event.dom.client.HasScrollHandlers; |
| import com.google.gwt.event.dom.client.KeyDownEvent; |
| import com.google.gwt.event.dom.client.KeyDownHandler; |
| import com.google.gwt.event.dom.client.KeyPressEvent; |
| import com.google.gwt.event.dom.client.KeyPressHandler; |
| import com.google.gwt.event.dom.client.KeyUpEvent; |
| import com.google.gwt.event.dom.client.KeyUpHandler; |
| import com.google.gwt.event.dom.client.LoadEvent; |
| import com.google.gwt.event.dom.client.LoadHandler; |
| import com.google.gwt.event.dom.client.MouseDownEvent; |
| import com.google.gwt.event.dom.client.MouseDownHandler; |
| import com.google.gwt.event.dom.client.MouseMoveEvent; |
| import com.google.gwt.event.dom.client.MouseMoveHandler; |
| import com.google.gwt.event.dom.client.MouseOutEvent; |
| import com.google.gwt.event.dom.client.MouseOutHandler; |
| import com.google.gwt.event.dom.client.MouseOverEvent; |
| import com.google.gwt.event.dom.client.MouseOverHandler; |
| import com.google.gwt.event.dom.client.MouseUpEvent; |
| import com.google.gwt.event.dom.client.MouseUpHandler; |
| import com.google.gwt.event.dom.client.MouseWheelEvent; |
| import com.google.gwt.event.dom.client.MouseWheelHandler; |
| import com.google.gwt.event.dom.client.ScrollEvent; |
| import com.google.gwt.event.dom.client.ScrollHandler; |
| import com.google.gwt.event.logical.shared.BeforeSelectionEvent; |
| import com.google.gwt.event.logical.shared.BeforeSelectionHandler; |
| import com.google.gwt.event.logical.shared.CloseEvent; |
| import com.google.gwt.event.logical.shared.CloseHandler; |
| import com.google.gwt.event.logical.shared.HasCloseHandlers; |
| import com.google.gwt.event.logical.shared.HasValueChangeHandlers; |
| import com.google.gwt.event.logical.shared.OpenEvent; |
| import com.google.gwt.event.logical.shared.OpenHandler; |
| import com.google.gwt.event.logical.shared.SelectionEvent; |
| import com.google.gwt.event.logical.shared.SelectionHandler; |
| import com.google.gwt.event.logical.shared.ValueChangeEvent; |
| import com.google.gwt.event.logical.shared.ValueChangeHandler; |
| import com.google.gwt.event.shared.EventHandler; |
| import com.google.gwt.event.shared.HandlerManager; |
| import com.google.gwt.event.shared.GwtEvent.Type; |
| import com.google.gwt.user.client.BaseListenerWrapper; |
| import com.google.gwt.user.client.Event; |
| |
| import java.util.EventListener; |
| |
| /** |
| * Legacy listener support hierarchy for |
| * <code>com.google.gwt.user.client.ui</code>. Gathers the bulk of the legacy |
| * glue code in one place, for easy deletion when Listener methods are deleted. |
| * |
| * |
| * @param <T> listener type |
| * @deprecated will be removed in GWT 2.0 with the handler listeners themselves |
| */ |
| @Deprecated |
| public abstract class ListenerWrapper<T> extends BaseListenerWrapper<T> { |
| |
| /** |
| * Wrapper for a {@link LoadListener}. |
| */ |
| public static class WrappedLoadListener extends ListenerWrapper<LoadListener> |
| implements LoadHandler, ErrorHandler { |
| |
| /** |
| * Adds the wrapped listener. |
| * |
| * @param <S> the source of the events |
| * |
| * @param source the event source |
| * @param listener the listener |
| * @return the wrapped listener |
| * |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static <S extends HasLoadHandlers & HasErrorHandlers> WrappedLoadListener add( |
| S source, LoadListener listener) { |
| WrappedLoadListener l = new WrappedLoadListener(listener); |
| source.addLoadHandler(l); |
| source.addErrorHandler(l); |
| return l; |
| } |
| |
| /** |
| * Removes the wrapped listener. |
| * |
| * @param eventSource the event source from which to remove the wrapped |
| * listener |
| * @param listener the listener to remove |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static void remove(Widget eventSource, LoadListener listener) { |
| baseRemove(eventSource, listener, LoadEvent.getType(), |
| ErrorEvent.getType()); |
| } |
| |
| private WrappedLoadListener(LoadListener listener) { |
| super(listener); |
| } |
| |
| public void onError(ErrorEvent event) { |
| getListener().onError(getSource(event)); |
| } |
| |
| public void onLoad(LoadEvent event) { |
| getListener().onLoad(getSource(event)); |
| } |
| } |
| /** |
| * Wrapper for a {@link ChangeListener}. |
| * |
| * @deprecated will be removed in GWT 2.0 along with the listeners being |
| * wrapped |
| */ |
| @Deprecated |
| public static class WrappedChangeListener extends |
| ListenerWrapper<ChangeListener> implements ChangeHandler { |
| |
| /** |
| * Adds the wrapped listener. |
| * |
| * @param source the event source |
| * @param listener the listener |
| * @return the wrapped listener |
| * |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static WrappedChangeListener add(HasChangeHandlers source, |
| ChangeListener listener) { |
| WrappedChangeListener rtn = new WrappedChangeListener(listener); |
| source.addChangeHandler(rtn); |
| return rtn; |
| } |
| |
| /** |
| * Removes the wrapped listener. |
| * |
| * @param eventSource the event source from which to remove the wrapped |
| * listener |
| * @param listener the listener to remove |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static void remove(Widget eventSource, ChangeListener listener) { |
| baseRemove(eventSource, listener, ChangeEvent.getType()); |
| } |
| |
| WrappedChangeListener(ChangeListener listener) { |
| super(listener); |
| } |
| |
| public void onChange(ChangeEvent event) { |
| getListener().onChange(getSource(event)); |
| } |
| } |
| |
| /** |
| * Wrapper for a {@link ClickListener}. |
| * |
| * @deprecated will be removed in GWT 2.0 along with the listeners being |
| * wrapped |
| */ |
| @Deprecated |
| public static class WrappedClickListener extends |
| ListenerWrapper<ClickListener> implements ClickHandler { |
| |
| /** |
| * Adds the wrapped listener. |
| * |
| * @param source the event source |
| * @param listener the listener |
| * @return the wrapped listener |
| * |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static WrappedClickListener add(HasClickHandlers source, |
| ClickListener listener) { |
| WrappedClickListener rtn = new WrappedClickListener(listener); |
| source.addClickHandler(rtn); |
| return rtn; |
| } |
| |
| /** |
| * Removes the wrapped listener. |
| * |
| * @param eventSource the event source from which to remove the wrapped |
| * listener |
| * @param listener the listener to remove |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static void remove(Widget eventSource, ClickListener listener) { |
| baseRemove(eventSource, listener, ClickEvent.getType()); |
| } |
| |
| private WrappedClickListener(ClickListener listener) { |
| super(listener); |
| } |
| |
| public void onClick(ClickEvent event) { |
| getListener().onClick(getSource(event)); |
| } |
| } |
| /** |
| * Wrapper for a {@link FocusListener}. |
| */ |
| public static class WrappedFocusListener extends |
| ListenerWrapper<FocusListener> implements FocusHandler, BlurHandler { |
| |
| /** |
| * Adds the wrapped listener. |
| * |
| * @param eventSource the event source |
| * @param listener the listener |
| * |
| * @return the wrapped listener |
| * |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static WrappedFocusListener add(HasAllFocusHandlers eventSource, |
| FocusListener listener) { |
| WrappedFocusListener rtn = new WrappedFocusListener(listener); |
| HandlesAllFocusEvents.handle(eventSource, rtn); |
| return rtn; |
| } |
| |
| /** |
| * Removes the wrapped listener. |
| * |
| * @param eventSource the event source from which to remove the wrapped |
| * listener |
| * @param listener the listener to remove |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static void remove(Widget eventSource, FocusListener listener) { |
| baseRemove(eventSource, listener, LoadEvent.getType(), |
| ErrorEvent.getType()); |
| } |
| |
| private WrappedFocusListener(FocusListener listener) { |
| super(listener); |
| } |
| |
| public void onBlur(BlurEvent event) { |
| getListener().onLostFocus(getSource(event)); |
| } |
| |
| public void onFocus(FocusEvent event) { |
| getListener().onFocus(getSource(event)); |
| } |
| } |
| |
| /** |
| * Wrapper for a {@link KeyboardListener}. |
| */ |
| public static class WrappedKeyboardListener extends |
| ListenerWrapper<KeyboardListener> implements KeyDownHandler, |
| KeyUpHandler, KeyPressHandler { |
| |
| /** |
| * Adds the wrapped listener. |
| * |
| * @param source the event source |
| * @param listener the listener |
| * @return the wrapped listener |
| * |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static WrappedKeyboardListener add(HasAllKeyHandlers source, |
| KeyboardListener listener) { |
| WrappedKeyboardListener b = new WrappedKeyboardListener(listener); |
| HandlesAllKeyEvents.addHandlers(source, b); |
| return b; |
| } |
| |
| /** |
| * Removes the wrapped listener. |
| * |
| * @param eventSource the event source from which to remove the wrapped |
| * listener |
| * @param listener the listener to remove |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static void remove(Widget eventSource, KeyboardListener listener) { |
| ListenerWrapper.baseRemove(eventSource, listener, KeyDownEvent.getType(), |
| KeyUpEvent.getType(), KeyPressEvent.getType()); |
| } |
| |
| private WrappedKeyboardListener(KeyboardListener listener) { |
| super(listener); |
| } |
| |
| public void onKeyDown(KeyDownEvent event) { |
| getListener().onKeyDown( |
| getSource(event), |
| (char) event.getNativeKeyCode(), |
| KeyboardListenerCollection.getKeyboardModifiers(Event.as(event.getNativeEvent()))); |
| } |
| |
| public void onKeyPress(KeyPressEvent event) { |
| getListener().onKeyPress( |
| getSource(event), |
| (char) event.getNativeEvent().getKeyCode(), |
| KeyboardListenerCollection.getKeyboardModifiers(Event.as(event.getNativeEvent()))); |
| } |
| |
| public void onKeyUp(KeyUpEvent event) { |
| getSource(event); |
| getListener().onKeyUp( |
| getSource(event), |
| (char) event.getNativeKeyCode(), |
| KeyboardListenerCollection.getKeyboardModifiers(Event.as(event.getNativeEvent()))); |
| } |
| } |
| |
| /** |
| * Wrapper for a {@link ChangeListener} being converted to a logical |
| * {@link ValueChangeHandler}. |
| * |
| * @param <V> the type of the value changed |
| * |
| * @deprecated will be removed in GWT 2.0 along with the listeners being |
| * wrapped |
| */ |
| @Deprecated |
| public static class WrappedLogicalChangeListener<V> extends |
| ListenerWrapper<ChangeListener> implements ValueChangeHandler<V> { |
| |
| /** |
| * Adds the wrapped listener. |
| * |
| * @param <V> the type of value changed |
| * |
| * @param source the event source |
| * @param listener the listener |
| * @return the wrapped listener |
| * |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static <V> WrappedLogicalChangeListener<V> add( |
| HasValueChangeHandlers<V> source, ChangeListener listener) { |
| WrappedLogicalChangeListener<V> rtn = new WrappedLogicalChangeListener<V>( |
| listener); |
| source.addValueChangeHandler(rtn); |
| return rtn; |
| } |
| |
| /** |
| * Removes the wrapped listener. |
| * |
| * @param eventSource the event source from which to remove the wrapped |
| * listener |
| * @param listener the listener to remove |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static void remove(Widget eventSource, ChangeListener listener) { |
| baseRemove(eventSource, listener, ValueChangeEvent.getType()); |
| } |
| |
| private WrappedLogicalChangeListener(ChangeListener listener) { |
| super(listener); |
| } |
| |
| public void onValueChange(ValueChangeEvent<V> event) { |
| getListener().onChange(getSource(event)); |
| } |
| } |
| /** |
| * Wrapper for a {@link MouseListener}. |
| */ |
| public static class WrappedMouseListener extends |
| ListenerWrapper<MouseListener> implements MouseDownHandler, |
| MouseUpHandler, MouseOutHandler, MouseOverHandler, MouseMoveHandler { |
| /** |
| * Adds the wrapped listener. |
| * |
| * @param source the event source |
| * @param listener the listener |
| * @return the wrapped listener |
| * @param <E> source of the handlers |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static <E extends HasMouseDownHandlers & HasMouseUpHandlers & HasMouseOutHandlers & HasMouseOverHandlers & HasMouseMoveHandlers> WrappedMouseListener add( |
| E source, MouseListener listener) { |
| WrappedMouseListener handlers = new WrappedMouseListener(listener); |
| source.addMouseDownHandler(handlers); |
| source.addMouseUpHandler(handlers); |
| source.addMouseOutHandler(handlers); |
| source.addMouseOverHandler(handlers); |
| source.addMouseMoveHandler(handlers); |
| return handlers; |
| } |
| |
| /** |
| * Removes the wrapped listener. |
| * |
| * @param eventSource the event source from which to remove the wrapped |
| * listener |
| * @param listener the listener to remove |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static void remove(Widget eventSource, MouseListener listener) { |
| baseRemove(eventSource, listener, MouseDownEvent.getType(), |
| MouseUpEvent.getType(), MouseOverEvent.getType(), |
| MouseOutEvent.getType()); |
| } |
| |
| private WrappedMouseListener(MouseListener listener) { |
| super(listener); |
| } |
| |
| public void onMouseDown(MouseDownEvent event) { |
| Widget source = getSource(event); |
| getListener().onMouseDown(source, event.getX(), event.getY()); |
| } |
| |
| public void onMouseMove(MouseMoveEvent event) { |
| Widget source = getSource(event); |
| getListener().onMouseMove(source, event.getX(), event.getY()); |
| } |
| |
| public void onMouseOut(MouseOutEvent event) { |
| getListener().onMouseLeave(getSource(event)); |
| } |
| |
| public void onMouseOver(MouseOverEvent event) { |
| getListener().onMouseEnter(getSource(event)); |
| } |
| |
| public void onMouseUp(MouseUpEvent event) { |
| Widget source = getSource(event); |
| getListener().onMouseUp(source, event.getX(), event.getY()); |
| } |
| } |
| /** |
| * Wrapper for a {@link MouseWheelListener}. |
| */ |
| public static class WrappedMouseWheelListener extends |
| ListenerWrapper<MouseWheelListener> implements MouseWheelHandler { |
| /** |
| * Adds the wrapped listener. |
| * |
| * @param source the event source |
| * @param listener the listener |
| * @return the wrapped listener |
| * |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static WrappedMouseWheelListener add(HasMouseWheelHandlers source, |
| MouseWheelListener listener) { |
| WrappedMouseWheelListener wrap = new WrappedMouseWheelListener(listener); |
| source.addMouseWheelHandler(new WrappedMouseWheelListener(listener)); |
| return wrap; |
| } |
| |
| /** |
| * Removes the wrapped listener. |
| * |
| * @param eventSource the event source from which to remove the wrapped |
| * listener |
| * @param listener the listener to remove |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static void remove(Widget eventSource, MouseWheelListener listener) { |
| baseRemove(eventSource, listener, MouseWheelEvent.getType()); |
| } |
| |
| private WrappedMouseWheelListener(MouseWheelListener listener) { |
| super(listener); |
| } |
| |
| public void onMouseWheel(MouseWheelEvent event) { |
| getListener().onMouseWheel(getSource(event), |
| new MouseWheelVelocity(Event.as(event.getNativeEvent()))); |
| } |
| } |
| /** |
| * Wrapper for a {@link ScrollListener}. |
| */ |
| public static class WrappedScrollListener extends |
| ListenerWrapper<ScrollListener> implements ScrollHandler { |
| |
| /** |
| * Adds the wrapped listener. |
| * |
| * @param source the event source |
| * @param listener the listener |
| * @return the wrapped listener |
| * |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static WrappedScrollListener add(HasScrollHandlers source, |
| ScrollListener listener) { |
| WrappedScrollListener s = new WrappedScrollListener(listener); |
| source.addScrollHandler(s); |
| return s; |
| } |
| |
| /** |
| * Removes the wrapped listener. |
| * |
| * @param eventSource the event source from which to remove the wrapped |
| * listener |
| * @param listener the listener to remove |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static void remove(Widget eventSource, ScrollListener listener) { |
| baseRemove(eventSource, listener, ScrollEvent.getType(), |
| ErrorEvent.getType()); |
| } |
| |
| private WrappedScrollListener(ScrollListener listener) { |
| super(listener); |
| } |
| |
| public void onScroll(ScrollEvent event) { |
| Widget source = getSource(event); |
| Element elem = source.getElement(); |
| getListener().onScroll(getSource(event), elem.getScrollLeft(), |
| elem.getScrollTop()); |
| } |
| } |
| static class WrappedOldDisclosureHandler extends |
| ListenerWrapper<DisclosureHandler> implements |
| CloseHandler<DisclosurePanel>, OpenHandler<DisclosurePanel> { |
| |
| public static void add(DisclosurePanel source, DisclosureHandler listener) { |
| WrappedOldDisclosureHandler handlers = new WrappedOldDisclosureHandler( |
| listener); |
| source.addOpenHandler(handlers); |
| source.addCloseHandler(handlers); |
| } |
| |
| public static void remove(Widget eventSource, DisclosureHandler listener) { |
| baseRemove(eventSource, listener, CloseEvent.getType(), |
| OpenEvent.getType()); |
| } |
| |
| private WrappedOldDisclosureHandler(DisclosureHandler listener) { |
| super(listener); |
| } |
| |
| public void onClose(CloseEvent<DisclosurePanel> event) { |
| getListener().onClose( |
| new DisclosureEvent((DisclosurePanel) event.getSource())); |
| } |
| |
| public void onOpen(OpenEvent<DisclosurePanel> event) { |
| getListener().onOpen( |
| new DisclosureEvent((DisclosurePanel) event.getSource())); |
| } |
| } |
| |
| static class WrappedOldFormHandler extends ListenerWrapper<FormHandler> |
| implements FormPanel.SubmitHandler, FormPanel.SubmitCompleteHandler { |
| |
| public static void add(FormPanel source, FormHandler listener) { |
| WrappedOldFormHandler handlers = new WrappedOldFormHandler(listener); |
| source.addSubmitHandler(handlers); |
| source.addSubmitCompleteHandler(handlers); |
| } |
| |
| public static void remove(Widget eventSource, FormHandler listener) { |
| baseRemove(eventSource, listener, FormPanel.SubmitEvent.getType(), |
| FormPanel.SubmitCompleteEvent.getType()); |
| } |
| |
| private WrappedOldFormHandler(FormHandler listener) { |
| super(listener); |
| } |
| |
| public void onSubmit(FormPanel.SubmitEvent event) { |
| FormSubmitEvent fse = new FormSubmitEvent((FormPanel) event.getSource()); |
| getListener().onSubmit(fse); |
| if (fse.isSetCancelledCalled()) { |
| event.setCanceled(fse.isCancelled()); |
| } |
| } |
| |
| public void onSubmitComplete(FormPanel.SubmitCompleteEvent event) { |
| getListener().onSubmitComplete( |
| new FormSubmitCompleteEvent((FormPanel) event.getSource(), |
| event.getResults())); |
| } |
| } |
| |
| static class WrappedOldSuggestionHandler extends |
| ListenerWrapper<SuggestionHandler> implements |
| SelectionHandler<SuggestOracle.Suggestion> { |
| /** |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static void add(SuggestBox source, SuggestionHandler listener) { |
| source.addSelectionHandler(new WrappedOldSuggestionHandler(listener)); |
| } |
| |
| public static void remove(Widget eventSource, SuggestionHandler listener) { |
| baseRemove(eventSource, listener, SelectionEvent.getType()); |
| } |
| |
| private WrappedOldSuggestionHandler(SuggestionHandler listener) { |
| super(listener); |
| } |
| |
| public void onSelection(SelectionEvent<SuggestOracle.Suggestion> event) { |
| getListener().onSuggestionSelected( |
| new SuggestionEvent((SuggestBox) event.getSource(), |
| event.getSelectedItem())); |
| } |
| } |
| |
| static class WrappedPopupListener extends ListenerWrapper<PopupListener> |
| implements CloseHandler<PopupPanel> { |
| |
| public static void add(HasCloseHandlers<PopupPanel> source, |
| PopupListener listener) { |
| source.addCloseHandler(new WrappedPopupListener(listener)); |
| } |
| |
| public static void remove(Widget eventSource, PopupListener listener) { |
| baseRemove(eventSource, listener, CloseEvent.getType()); |
| } |
| |
| private WrappedPopupListener(PopupListener listener) { |
| super(listener); |
| } |
| |
| public void onClose(CloseEvent<PopupPanel> event) { |
| getListener().onPopupClosed((PopupPanel) event.getSource(), |
| event.isAutoClosed()); |
| } |
| } |
| |
| static class WrappedTableListener extends ListenerWrapper<TableListener> |
| implements ClickHandler { |
| /** |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static void add(HasClickHandlers source, TableListener listener) { |
| source.addClickHandler(new WrappedTableListener(listener)); |
| } |
| |
| public static void remove(Widget eventSource, TableListener listener) { |
| baseRemove(eventSource, listener, ClickEvent.getType()); |
| } |
| |
| private WrappedTableListener(TableListener listener) { |
| super(listener); |
| } |
| |
| public void onClick(ClickEvent event) { |
| HTMLTable table = (HTMLTable) event.getSource(); |
| HTMLTable.Cell cell = table.getCellForEvent(event); |
| if (cell != null) { |
| getListener().onCellClicked(table, cell.getRowIndex(), |
| cell.getCellIndex()); |
| } |
| } |
| } |
| |
| static class WrappedTabListener extends ListenerWrapper<TabListener> |
| implements SelectionHandler<Integer>, BeforeSelectionHandler<Integer> { |
| /** |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static void add(TabBar source, TabListener listener) { |
| WrappedTabListener t = new WrappedTabListener(listener); |
| source.addBeforeSelectionHandler(t); |
| source.addSelectionHandler(t); |
| } |
| |
| public static void add(TabPanel source, TabListener listener) { |
| WrappedTabListener t = new WrappedTabListener(listener); |
| source.addBeforeSelectionHandler(t); |
| source.addSelectionHandler(t); |
| } |
| |
| public static void remove(Widget eventSource, TabListener listener) { |
| baseRemove(eventSource, listener, SelectionEvent.getType(), |
| BeforeSelectionEvent.getType()); |
| } |
| |
| private WrappedTabListener(TabListener listener) { |
| super(listener); |
| } |
| |
| public void onBeforeSelection(BeforeSelectionEvent<Integer> event) { |
| if (!getListener().onBeforeTabSelected( |
| (SourcesTabEvents) event.getSource(), event.getItem().intValue())) { |
| event.cancel(); |
| } |
| } |
| |
| public void onSelection(SelectionEvent<Integer> event) { |
| getListener().onTabSelected((SourcesTabEvents) event.getSource(), |
| event.getSelectedItem().intValue()); |
| } |
| } |
| |
| static class WrappedTreeListener extends ListenerWrapper<TreeListener> |
| implements SelectionHandler<TreeItem>, CloseHandler<TreeItem>, |
| OpenHandler<TreeItem> { |
| /** |
| * @deprecated will be removed in GWT 2.0 along with the listener classes |
| */ |
| @Deprecated |
| public static void add(com.google.gwt.user.client.ui.Tree tree, |
| TreeListener listener) { |
| WrappedTreeListener t = new WrappedTreeListener(listener); |
| tree.addSelectionHandler(t); |
| tree.addCloseHandler(t); |
| tree.addOpenHandler(t); |
| } |
| |
| public static void remove(Widget eventSource, TreeListener listener) { |
| baseRemove(eventSource, listener, ValueChangeEvent.getType()); |
| } |
| |
| private WrappedTreeListener(TreeListener listener) { |
| super(listener); |
| } |
| |
| public void onClose(CloseEvent<TreeItem> event) { |
| getListener().onTreeItemStateChanged(event.getTarget()); |
| } |
| |
| public void onOpen(OpenEvent<TreeItem> event) { |
| getListener().onTreeItemStateChanged(event.getTarget()); |
| } |
| |
| public void onSelection(SelectionEvent<TreeItem> event) { |
| getListener().onTreeItemSelected(event.getSelectedItem()); |
| } |
| } |
| |
| /** |
| * Convenience method to remove wrapped handlers from a widget. |
| * |
| * @param <H> event handler type |
| * @param eventSource the event source |
| * @param listener the listener to remove |
| * @param types the event types to remove it from |
| */ |
| // This is an internal helper method with the current formulation, we have |
| // lost the info needed to make it safe by this point. |
| @SuppressWarnings("unchecked") |
| protected static <H extends EventHandler> void baseRemove(Widget eventSource, |
| EventListener listener, Type... types) { |
| HandlerManager manager = eventSource.getHandlerManager(); |
| if (manager != null) { |
| baseRemove(manager, listener, types); |
| } |
| } |
| |
| protected ListenerWrapper(T listener) { |
| super(listener); |
| } |
| |
| } |
