/*
* 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 Pavel Dolgov
* @version $Revision$
*/
package java.awt;
import java.awt.event.ActionEvent;
import java.awt.event.InputEvent;
import java.awt.event.InputMethodEvent;
import java.awt.event.InvocationEvent;
import java.awt.event.MouseEvent;
import java.util.LinkedList;
import org.apache.harmony.awt.internal.nls.Messages;
/**
* The events storage for EventQueue
*/
final class EventQueueCore {
private final LinkedList<EventQueue> queueStack = new LinkedList<EventQueue>();
private final LinkedList<AWTEvent> events = new LinkedList<AWTEvent>();
private Toolkit toolkit;
private EventQueue activeQueue;
private Thread dispatchThread;
AWTEvent currentEvent;
long mostRecentEventTime = System.currentTimeMillis();
EventQueueCore(EventQueue eq) {
synchronized (this) {
queueStack.addLast(eq);
activeQueue = eq;
}
}
EventQueueCore(EventQueue eq, Toolkit t) {
synchronized (this) {
queueStack.addLast(eq);
activeQueue = eq;
setToolkit(t);
}
}
synchronized long getMostRecentEventTime() {
return mostRecentEventTime;
}
synchronized AWTEvent getCurrentEvent() {
return currentEvent;
}
synchronized boolean isSystemEventQueue() {
return toolkit != null;
}
private void setToolkit(Toolkit t) {
toolkit = t;
if (toolkit != null) {
toolkit.setSystemEventQueueCore(this);
dispatchThread = toolkit.dispatchThread;
}
}
synchronized void postEvent(AWTEvent event) {
//???AWT
/*
events.addLast(event);
if ((toolkit == null) && (dispatchThread == null)) {
dispatchThread = new EventQueueThread(this);
dispatchThread.start();
}
// TODO: add event coalescing
if (toolkit != null) {
toolkit.shutdownWatchdog.setAwtQueueEmpty(false);
if (!GraphicsEnvironment.getLocalGraphicsEnvironment().isHeadlessInstance()) {
notifyEventMonitor(toolkit);
}
}
notifyAll();
*/
}
void notifyEventMonitor(Toolkit t) {
Object em = t.getNativeEventQueue().getEventMonitor();
synchronized (em) {
em.notifyAll();
}
}
synchronized AWTEvent getNextEvent() throws InterruptedException {
while (events.isEmpty()) {
wait();
}
AWTEvent event = events.removeFirst();
// TODO: add event coalescing
return event;
}
synchronized AWTEvent peekEvent() {
return events.isEmpty() ? null : events.getFirst();
}
synchronized AWTEvent peekEvent(int id) {
for (AWTEvent event : events) {
if (event.getID() == id) {
return event;
}
}
return null;
}
synchronized void dispatchEvent(AWTEvent event) {
updateCurrentEventAndTime(event);
try {
activeQueue.dispatchEvent(event);
} finally {
currentEvent = null;
}
}
void dispatchEventImpl(AWTEvent event) {
if (event instanceof ActiveEvent) {
updateCurrentEventAndTime(event);
try {
((ActiveEvent) event).dispatch();
} finally {
currentEvent = null;
}
return;
}
Object src = event.getSource();
if (src instanceof Component) {
if (preprocessComponentEvent(event)) {
((Component) src).dispatchEvent(event);
}
} else {
if (toolkit != null) {
toolkit.dispatchAWTEvent(event);
}
if (src instanceof MenuComponent) {
((MenuComponent) src).dispatchEvent(event);
}
}
}
private final boolean preprocessComponentEvent(AWTEvent event) {
if (event instanceof MouseEvent) {
return preprocessMouseEvent((MouseEvent)event);
}
return true;
}
private final boolean preprocessMouseEvent(MouseEvent event) {
//???AWT
/*
if (toolkit != null && toolkit.mouseEventPreprocessor != null) {
toolkit.lockAWT();
try {
return toolkit.mouseEventPreprocessor.preprocess(event);
} finally {
toolkit.unlockAWT();
}
}
return true;
*/
return true;
}
private void updateCurrentEventAndTime(AWTEvent event) {
currentEvent = event;
long when = 0;
if (event instanceof ActionEvent) {
when = ((ActionEvent) event).getWhen();
} else if (event instanceof InputEvent) {
when = ((InputEvent) event).getWhen();
} else if (event instanceof InputMethodEvent) {
when = ((InputMethodEvent) event).getWhen();
} else if (event instanceof InvocationEvent) {
when = ((InvocationEvent) event).getWhen();
}
if (when != 0) {
mostRecentEventTime = when;
}
}
synchronized void push(EventQueue newEventQueue) {
// TODO: handle incorrect situations
if (queueStack.isEmpty()) {
// awt.6B=Queue stack is empty
throw new IllegalStateException(Messages.getString("awt.6B")); //$NON-NLS-1$
}
queueStack.addLast(newEventQueue);
activeQueue = newEventQueue;
activeQueue.setCore(this);
}
synchronized void pop() {
EventQueue removed = queueStack.removeLast();
if (removed != activeQueue) {
// awt.6C=Event queue stack is broken
throw new IllegalStateException(Messages.getString("awt.6C")); //$NON-NLS-1$
}
activeQueue = queueStack.getLast();
removed.setCore(null);
}
synchronized AWTEvent getNextEventNoWait() {
try {
return events.isEmpty() ? null : activeQueue.getNextEvent();
} catch (InterruptedException e) {
return null;
}
}
synchronized boolean isEmpty() {
return (currentEvent == null) && events.isEmpty();
}
synchronized boolean isEmpty(long timeout) {
if (!isEmpty()) {
return false;
}
try {
wait(timeout);
} catch (InterruptedException e) {}
return isEmpty();
}
synchronized EventQueue getActiveEventQueue() {
return activeQueue;
}
}