723 lines
25 KiB
Java
723 lines
25 KiB
Java
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership.
|
|
* The ASF licenses this file to You 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.
|
|
*/
|
|
/**
|
|
* @author Michael Danilov, Dmitry A. Durnev
|
|
* @version $Revision$
|
|
*/
|
|
package java.awt;
|
|
|
|
import java.awt.event.ComponentEvent;
|
|
import java.awt.event.FocusEvent;
|
|
import java.awt.event.InputEvent;
|
|
import java.awt.event.KeyEvent;
|
|
import java.awt.event.MouseEvent;
|
|
import java.awt.event.PaintEvent;
|
|
import java.awt.event.WindowEvent;
|
|
|
|
import org.apache.harmony.awt.internal.nls.Messages;
|
|
import org.apache.harmony.awt.wtk.NativeEvent;
|
|
import org.apache.harmony.awt.wtk.NativeWindow;
|
|
|
|
|
|
/**
|
|
* Helper package-private class for managing lightweight components &
|
|
* dispatching events from heavyweight source
|
|
*/
|
|
class Dispatcher {
|
|
|
|
//???AWT: final PopupDispatcher popupDispatcher = new PopupDispatcher();
|
|
|
|
//???AWT: final FocusDispatcher focusDispatcher;
|
|
|
|
final MouseGrabManager mouseGrabManager = new MouseGrabManager();
|
|
|
|
final MouseDispatcher mouseDispatcher;
|
|
|
|
private final ComponentDispatcher componentDispatcher = new ComponentDispatcher();
|
|
|
|
private final KeyDispatcher keyDispatcher = new KeyDispatcher();
|
|
|
|
private final Toolkit toolkit;
|
|
|
|
int clickInterval = 250;
|
|
|
|
/**
|
|
* @param toolkit - AWT toolkit
|
|
*/
|
|
Dispatcher(Toolkit toolkit) {
|
|
this.toolkit = toolkit;
|
|
|
|
//???AWT: focusDispatcher = new FocusDispatcher(toolkit);
|
|
mouseDispatcher = new MouseDispatcher(mouseGrabManager, toolkit);
|
|
}
|
|
|
|
/**
|
|
* Dispatch native event: produce appropriate AWT events,
|
|
* update component's fields when needed
|
|
* @param event - native event to dispatch
|
|
* @return - true means default processing by OS is not needed
|
|
*/
|
|
public boolean onEvent(NativeEvent event) {
|
|
int eventId = event.getEventId();
|
|
|
|
if (eventId == NativeEvent.ID_CREATED) {
|
|
return toolkit.onWindowCreated(event.getWindowId());
|
|
} else if (eventId == NativeEvent.ID_MOUSE_GRAB_CANCELED) {
|
|
return mouseGrabManager.onGrabCanceled();
|
|
//???AWT
|
|
// } else if (popupDispatcher.onEvent(event)) {
|
|
// return false;
|
|
} else {
|
|
Component src = toolkit.getComponentById(event.getWindowId());
|
|
|
|
if (src != null) {
|
|
if (((eventId >= ComponentEvent.COMPONENT_FIRST) && (eventId <= ComponentEvent.COMPONENT_LAST))
|
|
|| ((eventId >= WindowEvent.WINDOW_FIRST) && (eventId <= WindowEvent.WINDOW_LAST))
|
|
|| (eventId == NativeEvent.ID_INSETS_CHANGED)
|
|
|| (eventId == NativeEvent.ID_BOUNDS_CHANGED)
|
|
|| (eventId == NativeEvent.ID_THEME_CHANGED)) {
|
|
return componentDispatcher.dispatch(src, event);
|
|
} else if ((eventId >= MouseEvent.MOUSE_FIRST)
|
|
&& (eventId <= MouseEvent.MOUSE_LAST)) {
|
|
return mouseDispatcher.dispatch(src, event);
|
|
} else if (eventId == PaintEvent.PAINT) {
|
|
//???AWT: src.redrawManager.addPaintRegion(src, event.getClipRects());
|
|
return true;
|
|
}
|
|
}
|
|
if ((eventId >= FocusEvent.FOCUS_FIRST)
|
|
&& (eventId <= FocusEvent.FOCUS_LAST)) {
|
|
|
|
//???AWT: return focusDispatcher.dispatch(src, event);
|
|
return false;
|
|
} else if ((eventId >= KeyEvent.KEY_FIRST)
|
|
&& (eventId <= KeyEvent.KEY_LAST)) {
|
|
return keyDispatcher.dispatch(src, event);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* The dispatcher of native events that affect
|
|
* component's state or bounds
|
|
*/
|
|
final class ComponentDispatcher {
|
|
|
|
/**
|
|
* Handle native event that affects component's state or bounds
|
|
* @param src - the component updated by the event
|
|
* @param event - the native event
|
|
* @return - as in Dispatcher.onEvent()
|
|
* @see Dispatcher#onEvent(NativeEvent)
|
|
*/
|
|
boolean dispatch(Component src, NativeEvent event) {
|
|
int id = event.getEventId();
|
|
|
|
if ((id == NativeEvent.ID_INSETS_CHANGED)
|
|
|| (id == NativeEvent.ID_THEME_CHANGED)) {
|
|
return dispatchInsets(event, src);
|
|
} else if ((id >= WindowEvent.WINDOW_FIRST)
|
|
&& (id <= WindowEvent.WINDOW_LAST)) {
|
|
return dispatchWindow(event, src);
|
|
} else {
|
|
return dispatchPureComponent(event, src);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Handle the change of top-level window's native decorations
|
|
* @param event - the native event
|
|
* @param src - the component updated by the event
|
|
* @return - as in Dispatcher.onEvent()
|
|
* @see Dispatcher#onEvent(NativeEvent)
|
|
*/
|
|
boolean dispatchInsets(NativeEvent event, Component src) {
|
|
//???AWT
|
|
/*
|
|
if (src instanceof Window) {
|
|
((Window) src).setNativeInsets(event.getInsets());
|
|
}
|
|
*/
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Handle the change of top-level window's state
|
|
* @param event - the native event
|
|
* @param src - the component updated by the event
|
|
* @return - as in Dispatcher.onEvent()
|
|
* @see Dispatcher#onEvent(NativeEvent)
|
|
*/
|
|
boolean dispatchWindow(NativeEvent event, Component src) {
|
|
//???AWT
|
|
/*
|
|
Window window = (Window) src;
|
|
int id = event.getEventId();
|
|
|
|
if (id == WindowEvent.WINDOW_CLOSING) {
|
|
toolkit.getSystemEventQueueImpl().postEvent(
|
|
new WindowEvent(window, WindowEvent.WINDOW_CLOSING));
|
|
|
|
return true;
|
|
} else if (id == WindowEvent.WINDOW_STATE_CHANGED) {
|
|
if (window instanceof Frame) {
|
|
((Frame) window)
|
|
.updateExtendedState(event.getWindowState());
|
|
}
|
|
}
|
|
*/
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Handle the change of component's size and/or position
|
|
* @param event - the native event
|
|
* @param src - the component updated by the event
|
|
* @return - as in Dispatcher.onEvent()
|
|
* @see Dispatcher#onEvent(NativeEvent)
|
|
*/
|
|
private boolean dispatchPureComponent(NativeEvent event, Component src) {
|
|
Rectangle rect = event.getWindowRect();
|
|
Point loc = rect.getLocation();
|
|
int mask;
|
|
|
|
switch (event.getEventId()) {
|
|
case NativeEvent.ID_BOUNDS_CHANGED:
|
|
mask = 0;
|
|
break;
|
|
case ComponentEvent.COMPONENT_MOVED:
|
|
mask = NativeWindow.BOUNDS_NOSIZE;
|
|
break;
|
|
case ComponentEvent.COMPONENT_RESIZED:
|
|
mask = NativeWindow.BOUNDS_NOMOVE;
|
|
break;
|
|
default:
|
|
// awt.12E=Unknown component event id.
|
|
throw new RuntimeException(Messages.getString("awt.12E")); //$NON-NLS-1$
|
|
}
|
|
|
|
//???AWT
|
|
/*
|
|
if (!(src instanceof Window)) {
|
|
Component compTo = src.getParent();
|
|
Component compFrom = src.getHWAncestor();
|
|
|
|
if ((compTo != null) && (compFrom != null)) {
|
|
loc = MouseDispatcher.convertPoint(compFrom, loc, compTo);
|
|
}
|
|
} else {
|
|
int windowState = event.getWindowState();
|
|
|
|
if ((windowState >= 0) && (src instanceof Frame)) {
|
|
((Frame) src).updateExtendedState(windowState);
|
|
}
|
|
}
|
|
src.setBounds(loc.x, loc.y, rect.width, rect.height, mask, false);
|
|
*/
|
|
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* The dispatcher of the keyboard events
|
|
*/
|
|
final class KeyDispatcher {
|
|
|
|
/**
|
|
* Handle the keyboard event using the KeyboardFocusManager
|
|
* @param src - the component receiving the event
|
|
* @param event - the native event
|
|
* @return - as in Dispatcher.onEvent()
|
|
* @see Dispatcher#onEvent(NativeEvent)
|
|
*/
|
|
boolean dispatch(Component src, NativeEvent event) {
|
|
int id = event.getEventId();
|
|
int modifiers = event.getInputModifiers();
|
|
int location = event.getKeyLocation();
|
|
int code = event.getVKey();
|
|
StringBuffer chars = event.getKeyChars();
|
|
int charsLength = chars.length();
|
|
long time = event.getTime();
|
|
char keyChar = event.getLastChar();
|
|
|
|
//???AWT
|
|
/*
|
|
if (src == null) {
|
|
//retarget focus proxy key events to focusOwner:
|
|
Window focusProxyOwner = toolkit.getFocusProxyOwnerById(event
|
|
.getWindowId());
|
|
if (focusProxyOwner == null) {
|
|
return false;
|
|
}
|
|
src = KeyboardFocusManager.actualFocusOwner;
|
|
}
|
|
*/
|
|
|
|
EventQueue eventQueue = toolkit.getSystemEventQueueImpl();
|
|
|
|
if (src != null) {
|
|
eventQueue.postEvent(new KeyEvent(src, id, time, modifiers,
|
|
code, keyChar, location));
|
|
// KEY_TYPED goes after KEY_PRESSED
|
|
if (id == KeyEvent.KEY_PRESSED) {
|
|
for (int i = 0; i < charsLength; i++) {
|
|
keyChar = chars.charAt(i);
|
|
if (keyChar != KeyEvent.CHAR_UNDEFINED) {
|
|
eventQueue.postEvent(new KeyEvent(src,
|
|
KeyEvent.KEY_TYPED, time, modifiers,
|
|
KeyEvent.VK_UNDEFINED, keyChar,
|
|
KeyEvent.KEY_LOCATION_UNKNOWN));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Retargets the mouse events to the grab owner when mouse is grabbed,
|
|
* grab and ungrab mouse when mouse buttons are pressed and released
|
|
*/
|
|
|
|
static final class MouseGrabManager {
|
|
|
|
/**
|
|
* The top-level window holding the mouse grab
|
|
* that was explicitly started by startGrab() method
|
|
*/
|
|
//???AWT: private Window nativeGrabOwner = null;
|
|
/**
|
|
* The component that owns the synthetic
|
|
* mouse grab while at least one of the
|
|
* mouse buttons is pressed
|
|
*/
|
|
private Component syntheticGrabOwner = null;
|
|
|
|
/**
|
|
* Previous value of syntheticGrabOwner
|
|
*/
|
|
private Component lastSyntheticGrabOwner = null;
|
|
|
|
/**
|
|
* Number of mouse buttons currently pressed
|
|
*/
|
|
private int syntheticGrabDepth = 0;
|
|
|
|
/**
|
|
* The callback to be called when the explicit mouse grab ends
|
|
*/
|
|
private Runnable whenCanceled;
|
|
|
|
/**
|
|
* Explicitly start the mouse grab
|
|
* @param grabWindow - the window that will own the grab
|
|
* @param whenCanceled - the callback to call when the grab ends.
|
|
* This parameter can be null
|
|
*/
|
|
//???AWT
|
|
/*
|
|
void startGrab(Window grabWindow, Runnable whenCanceled) {
|
|
|
|
if (nativeGrabOwner != null) {
|
|
// awt.12F=Attempt to start nested mouse grab
|
|
throw new RuntimeException(Messages.getString("awt.12F")); //$NON-NLS-1$
|
|
}
|
|
|
|
NativeWindow win = grabWindow.getNativeWindow();
|
|
if (win == null) {
|
|
// awt.130=Attempt to grab mouse in not displayable window
|
|
throw new RuntimeException(Messages.getString("awt.130")); //$NON-NLS-1$
|
|
}
|
|
|
|
nativeGrabOwner = grabWindow;
|
|
this.whenCanceled = whenCanceled;
|
|
win.grabMouse();
|
|
}
|
|
*/
|
|
|
|
/**
|
|
* Ends the explicit mouse grab. If the non-null callback was provided
|
|
* in the startGrab() method, this callback is called
|
|
*/
|
|
void endGrab() {
|
|
//???AWT
|
|
/*
|
|
if (nativeGrabOwner == null) {
|
|
return;
|
|
}
|
|
|
|
Window grabWindow = nativeGrabOwner;
|
|
nativeGrabOwner = null;
|
|
NativeWindow win = grabWindow.getNativeWindow();
|
|
|
|
if (win != null) {
|
|
win.ungrabMouse();
|
|
if (whenCanceled != null) {
|
|
whenCanceled.run();
|
|
whenCanceled = null;
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
|
|
/**
|
|
* Ends both explicit and synthetic grans
|
|
* @return - always returns false
|
|
*/
|
|
boolean onGrabCanceled() {
|
|
endGrab();
|
|
resetSyntheticGrab();
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Starts the synthetic mouse grab, increases the counter
|
|
* of currently pressed mouse buttons
|
|
* @param source - the component where mouse press event occured
|
|
* @return - the component that owns the synthetic grab
|
|
*/
|
|
Component onMousePressed(Component source) {
|
|
if (syntheticGrabDepth == 0) {
|
|
syntheticGrabOwner = source;
|
|
lastSyntheticGrabOwner = source;
|
|
}
|
|
syntheticGrabDepth++;
|
|
|
|
return syntheticGrabOwner;
|
|
}
|
|
|
|
/**
|
|
* Decreases the counter of currently pressed mouse buttons,
|
|
* ends the synthetic mouse grab, when this counter becomes zero
|
|
* @param source - the component where mouse press event occured
|
|
* @return - the component that owns the synthetic grab,
|
|
* or source parameter if mouse grab was released
|
|
*/
|
|
Component onMouseReleased(Component source) {
|
|
Component ret = source;
|
|
|
|
//???AWT
|
|
/*
|
|
if (syntheticGrabOwner != null && nativeGrabOwner == null) {
|
|
ret = syntheticGrabOwner;
|
|
}
|
|
*/
|
|
syntheticGrabDepth--;
|
|
if (syntheticGrabDepth <= 0) {
|
|
resetSyntheticGrab();
|
|
lastSyntheticGrabOwner = null;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Update the state of synthetic ouse gram
|
|
* when the mouse is moved/dragged
|
|
* @param event - the native event
|
|
*/
|
|
void preprocessEvent(NativeEvent event) {
|
|
int id = event.getEventId();
|
|
switch (id) {
|
|
case MouseEvent.MOUSE_MOVED:
|
|
if (syntheticGrabOwner != null) {
|
|
syntheticGrabOwner = null;
|
|
syntheticGrabDepth = 0;
|
|
}
|
|
if (lastSyntheticGrabOwner != null) {
|
|
lastSyntheticGrabOwner = null;
|
|
}
|
|
case MouseEvent.MOUSE_DRAGGED:
|
|
if (syntheticGrabOwner == null
|
|
&& lastSyntheticGrabOwner != null) {
|
|
syntheticGrabOwner = lastSyntheticGrabOwner;
|
|
syntheticGrabDepth = 0;
|
|
int mask = event.getInputModifiers();
|
|
syntheticGrabDepth += (mask & InputEvent.BUTTON1_DOWN_MASK) != 0 ? 1
|
|
: 0;
|
|
syntheticGrabDepth += (mask & InputEvent.BUTTON2_DOWN_MASK) != 0 ? 1
|
|
: 0;
|
|
syntheticGrabDepth += (mask & InputEvent.BUTTON3_DOWN_MASK) != 0 ? 1
|
|
: 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return the component that currently owns the synthetic grab
|
|
*/
|
|
Component getSyntheticGrabOwner() {
|
|
return syntheticGrabOwner;
|
|
}
|
|
|
|
/**
|
|
* ends synthetic grab
|
|
*/
|
|
private void resetSyntheticGrab() {
|
|
syntheticGrabOwner = null;
|
|
syntheticGrabDepth = 0;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Dispatches native events related to the pop-up boxes
|
|
* (the non-component windows such as menus and drop lists)
|
|
*/
|
|
// final class PopupDispatcher {
|
|
//
|
|
// private PopupBox activePopup;
|
|
//
|
|
// private PopupBox underCursor;
|
|
//
|
|
// private final MouseGrab grab = new MouseGrab();
|
|
//
|
|
// /**
|
|
// * Handles the mouse grab for pop-up boxes
|
|
// */
|
|
// private final class MouseGrab {
|
|
// private int depth;
|
|
//
|
|
// private PopupBox owner;
|
|
//
|
|
// private final Point start = new Point();
|
|
//
|
|
// /**
|
|
// * Starts the grab when mouse is pressed
|
|
// * @param src - the pop-up box where mouse event has occured
|
|
// * @param where - the mouse pointer location
|
|
// * @return - the grab owner
|
|
// */
|
|
// PopupBox mousePressed(PopupBox src, Point where) {
|
|
// if (depth == 0) {
|
|
// owner = src;
|
|
// start.setLocation(where);
|
|
// }
|
|
// depth++;
|
|
// return owner;
|
|
// }
|
|
//
|
|
// /**
|
|
// * Ends the grab when all mousebuttons are released
|
|
// * @param src - the pop-up box where mouse event has occured
|
|
// * @param where - the mouse pointer location
|
|
// * @return - the grab owner, or src parameter if the grab has ended
|
|
// */
|
|
// PopupBox mouseReleased(PopupBox src, Point where) {
|
|
// PopupBox ret = (owner != null) ? owner : src;
|
|
// if (depth == 0) {
|
|
// return ret;
|
|
// }
|
|
// depth--;
|
|
// if (depth == 0) {
|
|
// PopupBox tgt = owner;
|
|
// owner = null;
|
|
// if (tgt != null && src == null) {
|
|
// Point a = new Point(start);
|
|
// Point b = new Point(where);
|
|
// Point pos = tgt.getScreenLocation();
|
|
// a.translate(-pos.x, -pos.y);
|
|
// b.translate(-pos.x, -pos.y);
|
|
// if (tgt.closeOnUngrab(a, b)) {
|
|
// return null;
|
|
// }
|
|
// }
|
|
// }
|
|
// return ret;
|
|
// }
|
|
//
|
|
// /**
|
|
// * Set the grab owner to null
|
|
// */
|
|
// void reset() {
|
|
// depth = 0;
|
|
// owner = null;
|
|
// start.setLocation(0, 0);
|
|
// }
|
|
//
|
|
// /**
|
|
// * @return - the pop-up box currently owning the grab
|
|
// */
|
|
// public PopupBox getOwner() {
|
|
// return owner;
|
|
// }
|
|
// }
|
|
//
|
|
// /**
|
|
// * Call the mouse event handler of the pop-up box
|
|
// * @param src - the pop-up box where the mouse event occured
|
|
// * @param eventId - the event ID, one of MouseEvent.MOUSE_* constants
|
|
// * @param where - the mouse pointer location
|
|
// * @param event - native event
|
|
// */
|
|
// private void mouseEvent(PopupBox src, int eventId, Point where,
|
|
// NativeEvent event) {
|
|
// Point pos = src.getScreenLocation();
|
|
// pos.setLocation(where.x - pos.x, where.y - pos.y);
|
|
//
|
|
// src.onMouseEvent(eventId, pos, event.getMouseButton(), event
|
|
// .getTime(), event.getInputModifiers(), event
|
|
// .getWheelRotation());
|
|
// }
|
|
//
|
|
// /**
|
|
// * Handle the native event targeted by a pop-up box. This could be
|
|
// * paint event, mouse or keyboard event.
|
|
// * @param event - the native event
|
|
// * @return - false if the event was handled and doesn't
|
|
// * need the further processing; true when the further
|
|
// * processing is needed
|
|
// */
|
|
// boolean onEvent(NativeEvent event) {
|
|
// PopupBox src = toolkit.getPopupBoxById(event.getWindowId());
|
|
// int id = event.getEventId();
|
|
//
|
|
// if ((id == PaintEvent.PAINT)) {
|
|
// if (src != null) {
|
|
// src.paint(event.getClipRects());
|
|
// return true;
|
|
// }
|
|
// Component c = toolkit.getComponentById(event.getWindowId());
|
|
// if ((c != null) && (c instanceof Frame)) {
|
|
// ((Frame) c).paintMenuBar(event.getClipRects());
|
|
// }
|
|
// return false;
|
|
// }
|
|
//
|
|
// if ((id >= MouseEvent.MOUSE_FIRST) && (id <= MouseEvent.MOUSE_LAST)) {
|
|
// Point where = event.getScreenPos();
|
|
//
|
|
// if (src != underCursor) {
|
|
// if (underCursor != null) {
|
|
// mouseEvent(underCursor, MouseEvent.MOUSE_EXITED, where,
|
|
// event);
|
|
// }
|
|
// underCursor = src;
|
|
// if (underCursor != null) {
|
|
// mouseEvent(underCursor, MouseEvent.MOUSE_ENTERED,
|
|
// where, event);
|
|
// underCursor.setDefaultCursor();
|
|
// }
|
|
// }
|
|
// if (id == MouseEvent.MOUSE_EXITED) {
|
|
// underCursor = null;
|
|
// }
|
|
//
|
|
// if ((activePopup == null) && (src == null || !src.isMenuBar())) {
|
|
// return false;
|
|
// }
|
|
//
|
|
// if (id == MouseEvent.MOUSE_PRESSED) {
|
|
// src = grab.mousePressed(src, where);
|
|
// } else if (id == MouseEvent.MOUSE_RELEASED) {
|
|
// src = grab.mouseReleased(src, where);
|
|
// } else if (src == null) {
|
|
// src = grab.getOwner();
|
|
// }
|
|
//
|
|
// PopupBox wasActive = activePopup;
|
|
//
|
|
// if (src != null) {
|
|
// mouseEvent(src, id, where, event);
|
|
// return src.isMenu() || src.contains(where);
|
|
// }
|
|
//
|
|
// if (wasActive != null && activePopup == null) {
|
|
// return wasActive.isMenu();
|
|
// }
|
|
//
|
|
// if ((id == MouseEvent.MOUSE_PRESSED)
|
|
// || (id == MouseEvent.MOUSE_RELEASED)) {
|
|
// boolean isMenu = activePopup.isMenu();
|
|
// deactivateAll();
|
|
// return !isMenu;
|
|
// }
|
|
// return true;
|
|
// }
|
|
//
|
|
// if (activePopup == null) {
|
|
// return false;
|
|
// }
|
|
//
|
|
// if ((id >= KeyEvent.KEY_FIRST) && (id <= KeyEvent.KEY_LAST)) {
|
|
// boolean isMenu = activePopup.isMenu();
|
|
// activePopup.dispatchKeyEvent(id, event.getVKey(), event
|
|
// .getTime(), event.getInputModifiers());
|
|
//
|
|
// return isMenu;
|
|
// }
|
|
//
|
|
// return false;
|
|
// }
|
|
//
|
|
// /**
|
|
// * Remember the pop-up as active and grab the mouse on it
|
|
// * @param popup - the pop-up box to activate
|
|
// */
|
|
// void activate(final PopupBox popup) {
|
|
// if (activePopup == null) {
|
|
//
|
|
// activePopup = popup;
|
|
// mouseGrabManager.startGrab(popup.getOwner(), new Runnable() {
|
|
// public void run() {
|
|
// deactivate(popup);
|
|
// }
|
|
// });
|
|
// }
|
|
// }
|
|
//
|
|
// /**
|
|
// * Deactivate the currently active pop-up box
|
|
// */
|
|
// void deactivateAll() {
|
|
// deactivate(activePopup);
|
|
// }
|
|
//
|
|
// /**
|
|
// * Deactivate the pop-up box, end the mouse grab
|
|
// */
|
|
// void deactivate(PopupBox popup) {
|
|
// grab.reset();
|
|
//
|
|
// if (activePopup != null && activePopup == popup) {
|
|
// activePopup = null;
|
|
// mouseGrabManager.endGrab();
|
|
// popup.hide();
|
|
// underCursor = null;
|
|
// }
|
|
// }
|
|
//
|
|
// /**
|
|
// * Check that the pop-up box is currently active
|
|
// * @param popup - the pop-up box to check
|
|
// * @return - true if active
|
|
// */
|
|
// boolean isActive(PopupBox popup) {
|
|
// return (popup == activePopup) && (popup != null);
|
|
// }
|
|
// }
|
|
|
|
} |