| /* |
| * 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.junit.client.GWTTestCase; |
| |
| /** |
| * Tests keyboard events in the {@link DelegatingKeyboardListenerCollection} |
| * class. |
| */ |
| public class DelegatingKeyboardListenerCollectionTest extends GWTTestCase |
| implements KeyboardListener { |
| |
| /** |
| * A {@link Widget} that uses the {@link DelegatingKeyboardListenerCollection} |
| * to save its list of keyboard events. |
| */ |
| public static class DelegatingWidget extends Widget { |
| // The delegating collection of keyboard listeners |
| private DelegatingKeyboardListenerCollection keyboardListeners; |
| |
| // The owner of all events |
| private Widget eventOwner; |
| |
| /** |
| * Adds a listener interface to receive keyboard events. |
| * |
| * @param listener the listener interface to add |
| */ |
| public void addKeyboardListener(KeyboardListener listener) { |
| if (keyboardListeners == null) { |
| this.eventOwner = new Widget(); |
| keyboardListeners = new DelegatingKeyboardListenerCollection( |
| this.eventOwner, new TextBox()); |
| } |
| keyboardListeners.add(listener); |
| } |
| |
| /** |
| * Get the event owner. |
| * |
| * @return the event owner |
| */ |
| public Widget getEventOwner() { |
| return this.eventOwner; |
| } |
| |
| /** |
| * Get the keyboardListener. |
| * |
| * @return the keyboardListener |
| */ |
| public DelegatingKeyboardListenerCollection getKeyboardListeners() { |
| return this.keyboardListeners; |
| } |
| |
| /** |
| * Removes a previously added listener interface. |
| * |
| * @param listener the listener interface to remove |
| */ |
| public void removeKeyboardListener(KeyboardListener listener) { |
| /* |
| * This method is not used in the test or in the |
| * DelegatingKeyboardListenerCollection constructor |
| */ |
| } |
| } |
| |
| // The owner of the events |
| private DelegatingWidget delegatingWidget; |
| |
| // A bit used to verify that some event handler was called |
| private boolean eventHandled; |
| |
| // The name of the last event fired |
| private String lastEventName; |
| |
| public String getModuleName() { |
| return "com.google.gwt.user.User"; |
| } |
| |
| /** |
| * Handle the key down event from the ownerOfEvents. |
| * |
| * @param sender the widget sending the event. |
| * @param keyCode the key to send with the event. |
| * @param modifiers the modifier keys pressed at when the event occurred. This |
| * value is a combination of the bits defined by |
| * {@link KeyboardListener#MODIFIER_SHIFT}, |
| * {@link KeyboardListener#MODIFIER_CTRL}, and |
| * {@link KeyboardListener#MODIFIER_ALT}. |
| */ |
| public void onKeyDown(Widget sender, char keyCode, int modifiers) { |
| this.handleKeyEvent(sender, "onKeyDown"); |
| } |
| |
| /** |
| * Handle the key press event from the ownerOfEvents. |
| * |
| * @param sender the widget sending the event. |
| * @param keyCode the key to send with the event. |
| * @param modifiers the modifier keys pressed at when the event occurred. This |
| * value is a combination of the bits defined by |
| * {@link KeyboardListener#MODIFIER_SHIFT}, |
| * {@link KeyboardListener#MODIFIER_CTRL}, and |
| * {@link KeyboardListener#MODIFIER_ALT}. |
| */ |
| public void onKeyPress(Widget sender, char keyCode, int modifiers) { |
| this.handleKeyEvent(sender, "onKeyPress"); |
| } |
| |
| /** |
| * Handle the key up event from the ownerOfEvents. |
| * |
| * @param sender the widget sending the event. |
| * @param keyCode the key to send with the event. |
| * @param modifiers the modifier keys pressed at when the event occurred. This |
| * value is a combination of the bits defined by |
| * {@link KeyboardListener#MODIFIER_SHIFT}, |
| * {@link KeyboardListener#MODIFIER_CTRL}, and |
| * {@link KeyboardListener#MODIFIER_ALT}. |
| */ |
| public void onKeyUp(Widget sender, char keyCode, int modifiers) { |
| this.handleKeyEvent(sender, "onKeyUp"); |
| } |
| |
| /** |
| * Tests that the key event handlers re-fire the correct key events to the |
| * correct owner. The owner of the events is a {@link TextBox}, which |
| * implements {@link SourcesKeyboardEvents} and allows us to check that the |
| * owner is correctly re-firing the events. |
| */ |
| public void testKeyEvents() { |
| // Create a keyboard event listener with a DeletagingWidgetknown owner |
| this.delegatingWidget = new DelegatingWidget(); |
| this.delegatingWidget.addKeyboardListener(this); |
| |
| // Fire events from through delegate, which should set the correct owner |
| this.fireKeyEvent("onKeyDown"); |
| this.fireKeyEvent("onKeyUp"); |
| this.fireKeyEvent("onKeyPress"); |
| } |
| |
| /** |
| * This helper method simulates the firing of an event by the delegating |
| * widget, with a generic Widget as the source. |
| * |
| * @param eventName the name of the event to fire |
| */ |
| private void fireKeyEvent(String eventName) { |
| this.lastEventName = eventName; // Set the name of this event |
| this.eventHandled = false; // Mark that we haven't handled it yet |
| |
| // Fire the actual event through the delegate |
| if (eventName.compareTo("onKeyDown") == 0) { |
| this.delegatingWidget.getKeyboardListeners().onKeyDown(new Widget(), 'a', |
| 0); |
| } else if (eventName.compareTo("onKeyUp") == 0) { |
| this.delegatingWidget.getKeyboardListeners().onKeyUp(new Widget(), 'a', 0); |
| } else if (eventName.compareTo("onKeyPress") == 0) { |
| this.delegatingWidget.getKeyboardListeners().onKeyPress(new Widget(), |
| 'a', 0); |
| } else { |
| fail("The event " + eventName + " is not supported"); |
| } |
| |
| // Verify that the event was handled |
| assertTrue(this.eventHandled); |
| } |
| |
| /** |
| * Handle an event from the ownerOfEvents by verifying the the event the the |
| * source are correct. |
| * |
| * @param sender the Widget that fired the event |
| * @param eventName the name of the event |
| */ |
| private void handleKeyEvent(Widget sender, String eventName) { |
| assertEquals(this.delegatingWidget.getEventOwner(), sender); |
| assertEquals(this.lastEventName, eventName); |
| this.eventHandled = true; |
| } |
| } |