componentevt.java

linux下建立JAVA虚拟机的源码KAFFE

package java.awt;

import java.awt.event.ComponentEvent;

class ComponentEvt
  extends ComponentEvent
{
	int x;
	int y;
	int width;
	int height;
	static ComponentEvt cache;

ComponentEvt ( Component c, int id ){
	super( c, id);
	
	x = c.x;
	y = c.y;
	width = c.width;
	height = c.height;
}

protected void dispatch () {
	Component src = (Component) source;

	if ( (src.parent == null) && ((id == COMPONENT_MOVED) || (id == COMPONENT_RESIZED)) ) {
		// Check for toplevel resizes and moves BEFORE processing this event. Each resize
		// has to cause a validation. This has been moved out of the getEvent() (which is
		// native called and therefore Toolkit synchronized), to avoid deadlock problems with
		// treelock synchronized methods (e.g. invalidate, validate, which might be called by
		// non-dispatcher threads, too)
	
		if ( (width != src.width) || (height != src.height) ) {
			src.invalidate();

			src.width = width;
			src.height = height;
		}

		src.x = x;
		src.y = y;

		if ( (src.flags & Component.IS_VALID) == 0 ){
			// if source is already visible, we wait for the subsequent
			// expose (fake repaint by temp changing visibility)
			if ( (src.flags & Component.IS_VISIBLE) != 0 ) {
				// The 'parentShowing' jitter is a waz to prevent superfluous
				// redraws and resident Graphics updates. Note that the final
				// propagateParentShowing has to be called with a "false" parameter
				// (to make sure it forces the required updates)
				src.flags &= ~Component.IS_PARENT_SHOWING;
				src.propagateParentShowing( true);

				src.validate();

				src.flags |= Component.IS_PARENT_SHOWING;
				src.propagateParentShowing( false);
			}
			else {
				src.validate();
			}
		}
	}

	src.process( this);

	if ( (Defaults.RecycleEvents & AWTEvent.COMPONENT_EVENT_MASK) != 0 )	recycle();
}

static synchronized ComponentEvt getEvent ( Component source, int id ){
	ComponentEvt e;

	if ( cache == null ){
		e = new ComponentEvt( source, id);
	}
	else {
		e = cache;
		cache = (ComponentEvt)e.next;
		e.next = null;
		
		e.source = source;
		e.id = id;
		
		e.x = source.x;
		e.y = source.y;
		e.width = source.width;
		e.height = source.height;
	}

	return e;
}

static synchronized ComponentEvt getEvent ( int srcIdx, int id, int x, int y, int width, int height ){
	// This is exclusively called by the native event emitter, be aware of the fact that
	// it therefore is Toolkit synchronized.

	ComponentEvt   e;
	Component      source = sources[srcIdx];

	if ( (Toolkit.flags & Toolkit.EXTERNAL_DECO) != 0 ) {
		// revert deco fake (the native side may not know about it)
		Rectangle      d = source.deco;
		x -= d.x;
		y -= d.y;
		width  += d.width;
		height += d.height;
	}
	
	if ( cache == null ){
		e = new ComponentEvt( source, id);
	}
	else {
		e = cache;
		cache = (ComponentEvt)e.next;
		e.next = null;

		e.source = source;
		e.id = id;
	}

  // store new coordinates for subsequent update / validation in dispatch()
	// (not here anymore because of deadlock problems for non-Toolkit treelocks)
	// !! Don't do any other native called (e.g. getEvent triggered) processing
	// !! (except of generating/queueing events) because we are now inconsistent
	// !! with the native layer until dispatch() is called
	e.x = x;
	e.y = y;
	e.width = width;
	e.height = height;


	if ( (Toolkit.flags & Toolkit.NATIVE_DISPATCHER_LOOP) != 0 ) {
		// this is not used as a direct return value for EventQueue.getNextEvent(), 
		// it has to be Java-queued by the native layer
		Toolkit.eventQueue.postEvent( e);
	}

	return e;
}

protected void recycle () {
	synchronized ( ComponentEvt.class ) {
		source = null;

		next = cache;	
		cache = this;
	}
}
}