/* class SyncThread
*
* Copyright (C) 2001 R M Pitman
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package charva.awt;
import charva.awt.event.AWTEvent;
import charva.awt.event.GarbageCollectionEvent;
import charva.awt.event.SyncEvent;
/**
* The purpose of this class it to speed up redrawing of the screen
* after the closing (or opening) of a window and the subsequent opening
* of a new window, by delaying the calling of Toolkit.sync() until
* the new window has had a chance to be drawn.<p>
*
* Note that it is not _guaranteed_ that the new window will be drawn in
* time, but it probably will be.<p>
*
* This thread loops forever, reading SyncEvents off the SyncQueue
* (a SyncEvent is generated whenever a window closes and the underlying
* windows have been redrawn).
* After reading the event off the queue, this thread sleeps for 50 msec
* and then puts the event onto the EventQueue, from which it will be
* picked up by the active window. If there are more events on the SyncQueue
* when the thread awakes, the SyncQueue is drained.<p>
*
* This thread also processes GarbageCollectionEvents; when it receives
* a GarbageCollectionEvent, it calls System.gc() (after waiting 50 msec
* to give the AWT event-handler time to complete).
*/
class SyncThread
extends Thread
{
SyncThread(SyncQueue syncQueue_, EventQueue eventQueue_) {
_syncQueue = syncQueue_;
_eventQueue = eventQueue_;
}
public void run() {
for (;;) {
AWTEvent evt = _syncQueue.getNextEvent();
// Sync thread exit point
if(evt == null) break;
try {
sleep(50);
}
catch (InterruptedException e) {
System.err.println("SyncThread: sleep interrupted!");
}
if (evt instanceof SyncEvent) {
_eventQueue.postEvent(evt);
/* If there any more SyncEvents on the queue, drain the queue;
* there is no point in putting more than one SyncEvent on the
* EventQueue.
*/
while (_syncQueue.isEmpty() == false) {
if (_syncQueue.getNextEvent() instanceof GarbageCollectionEvent) {
System.gc();
break;
}
}
} /* //LS
else
System.gc(); // it was a GarbageCollectionEvent
*/
}
}
private SyncQueue _syncQueue;
private EventQueue _eventQueue;
}