/*
 * @(#)SystemEventQueueUtilities.java	1.44 10/03/23
 *
 * Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
package javax.swing;

import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;

import java.util.*;

import sun.awt.SunToolkit;
import sun.awt.AppContext;

/**
 * Swing internal utilities for dealing with the AWT system event
 * queue.  Four methods are exported, see the individual method javadoc
 * for more information: addRunnableCanvas(), removeRunnableCanvas(),
 * postRunnable(), queueComponentWorkRequest().
 *
 * Note: most of the code in this class is no longer needed since
 * we're no longer supporting Swing in 1.1.x VM's and in 1.2 we're
 * guaranteed access to the AWT event queue.  However all of the entry 
 * points, save postRunnable(), are still used.
 * 
 * @see RepaintManager
 * @see JRootPane
 */
class SystemEventQueueUtilities
{
    private static final Object classLock = new Object();


    private static final Object rootTableKey = new Object(); // SystemEventQueueUtilties.rootTableKey

    private static Map getRootTable() {
        return getRootTable(AppContext.getAppContext());
    }

    private static Map getRootTable(AppContext appContext) {
	Map rt = (Map)appContext.get(rootTableKey);
	if (rt == null) {
	    synchronized (rootTableKey) {
		rt = (Map)appContext.get(rootTableKey);
		if (rt == null) {
		    rt = Collections.synchronizedMap(new WeakHashMap(4));
		    appContext.put(rootTableKey, rt);
		}
	    }
	}
	return rt;
    }


    /**
     * SystemEventQueue class.  This private class just exists to 
     * encapsulate the details of getting at the System Event queue 
     * in the Java 2 platform.  The rest of the SystemEventQueueUtilities 
     * class just uses SystemEventQueue.get() to access the event queue.
     */

    private static class SystemEventQueue 
    {
	// If the AWT system event queue is accessible then return it.
	// otherwise return null.  

	static EventQueue get() {
	    EventQueue retValue;
	    try {
	        retValue = Toolkit.getDefaultToolkit().getSystemEventQueue();
            }
	    catch (SecurityException se) {
	        // Should never happen.
                retValue = null;
            }
            return retValue;
	}

	// If the AWT system event queue is accessible then return it.
	// otherwise return null.  
	static EventQueue get(JRootPane rootPane) {
	    return get();
	}
    }

    /**
     * A Runnable with a component.  If we need to post this
     * runnable to the AWT system event queue, we'll find it's
     * JRootPane ancestor and use that as the key to the table
     * of RunnableCanvas's.
     *
     * @see SystemEventQueueUtilities.RunnableCanvas
     */
    private static class ComponentWorkRequest implements Runnable
    {
	boolean isPending;
 	Component component;
  
 	ComponentWorkRequest(Component c) {
 	    /* As of 1.2, the component field is no longer used.  It was 
 	     * used by the RunnableCanvas class to find the JRootPane 
 	     * associated with a ComponentWorkRequest for JDK1.1.x.
 	     */
 	    // component = c;
  	}
	public void run() {
	    RepaintManager rm = RepaintManager.currentManager(component);

	    synchronized (this) {
		isPending = false;
	    }
            // First pass, flush any heavy paint events into real paint
            // events.  If there are pending heavy weight requests this will
            // result in q'ing this request up one more time.  As
            // long as no other requests come in between now and the time
            // the second one is processed nothing will happen.  This is not
            // ideal, but the logic needed to suppress the second request is
            // more headache than it's worth.
            rm.scheduleHeavyWeightPaints();
            // Do the actual validation and painting.
	    rm.validateInvalidComponents();
	    rm.seqPaintDirtyRegions();
	}
    }


    /**
     * This method is used by RepaintManager to queue a ComponentWorkRequest
     * with invokeLater().  It assumes that the root argument is either
     * and Applet or a Window, the root passed in obtained in a
     * slightly different manner than see SwingUtilities.getRoot(). If this
     * called with the root obtained in a different way than RepaintManager
     * currently uses, be sure to also tweak removeRunnableCanvas.
     */
    static void queueComponentWorkRequest(Component root) {
        queueComponentWorkRequest(root, AppContext.getAppContext());
    }

    static void queueComponentWorkRequest(Component root,
                                          AppContext appContext) {
	ComponentWorkRequest req = (ComponentWorkRequest)
                 getRootTable(appContext).get(root);
	boolean newWorkRequest = (req == null);
	if (newWorkRequest) {
	    req = new ComponentWorkRequest(root);
	}

	/* At this point the ComponentWorkRequest may be accessible from
	 * an event dispatching thread so before updating it further
	 * we synchronize access to it.
	 */
        boolean schedule = false;
	synchronized(req) {
	    if (newWorkRequest) {
		getRootTable(appContext).put(root, req);
	    }
	    if (!req.isPending) {
		req.isPending = true;
                schedule = true;
	    }
	}
        if (schedule) {
            SunToolkit.getSystemEventQueueImplPP(appContext).
                postEvent(new InvocationEvent(Toolkit.getDefaultToolkit(),
                                              req));
        }
    }


    /**
     * Associate a RunnableCanvas and a JRootPane to enable queuing
     * events for the root pane's parent window's event dispatching thread.
     * Adds a 1x1 RunnableCanvas to the root pane's layered pane.
     * <p>
     * Called by JRootPane.addNotify() to set up the RunnableCanvas.
     *
     * @see RunnableCanvas
     * @see JRootPane#addNotify
     */
    static void addRunnableCanvas(JRootPane rootPane)
    {
	synchronized (classLock) {
	    /* If we have access to the system event queue, we don't bother
	     * with a RunnableCanvas
	     */
	    if (SystemEventQueue.get(rootPane) != null) {
		return;
	    }

	    JLayeredPane layeredPane = rootPane.getLayeredPane();
	    if (layeredPane != null) {
		RunnableCanvas rc = new RunnableCanvas(rootPane);
		layeredPane.add(rc);
	    }
	}
    }


    /**
     * Remove the RunnableCanvas from the JRootPane and clear the
     * internal bookeeping associated with it.
     * <p>
     * Called by JRootPane.removeNotify()
     *
     * @see RunnableCanvas
     */
    static void removeRunnableCanvas(JRootPane rootPane) {
	synchronized (classLock) {
	    // We don't use SwingUtilities.getRoot, as it has different
	    // behavior then the RepaintManager call to add the initial root.
	    Component root = null;
	    for (Component c = rootPane; c != null; c = c.getParent()) {
		if ((c instanceof Window) ||
		    (c instanceof  java.applet.Applet)) {
		    root = c;
		    break;
		}
	    }
	    if (root != null) {
		getRootTable().remove(root);
	    }
	    RunnableCanvas.remove(rootPane);
	}
    }


    /**
     * Post an event to the AWT System event queue that, when dispatched,
     * will invoke the specified Runnable.  If lock is non-null this call
     * blocks (by waiting on the lock) until the doRun() method returns,
     * otherwise we return as soon as the event has been enqueued.  An
     * exception is only returned if lock is non-null, i.e. if we're
     * being called from invokeAndWait().
     * <p>
     * This method is only intended to support SwingUtilities.invokeLater()
     * and SwingUtilities.invokeAndWait().
     */
    static Exception postRunnable(Runnable doRun, Object lock)
    {
	EventQueue systemEventQueue = SystemEventQueue.get();

	RunnableEvent event = new RunnableEvent(doRun, lock);
	if (systemEventQueue != null) {
	    systemEventQueue.postEvent(event);
	}
	else {
	    postRunnableCanvasEvent(event);
	}
	return event.exception;
    }


    /**
     * Adds a RunnableEvent to all the remaining RunnableCanvases to restart
     * the TimerQueues thread.
     *
     * @see RunnableCanvas#postRunnableEventToAll
     */
    static void restartTimerQueueThread() {
	synchronized (classLock) {
	    if (SystemEventQueue.get() == null) {
		Runnable restarter = new TimerQueueRestart();
		RunnableEvent event = new RunnableEvent(restarter, null);
		RunnableCanvas.postRunnableEventToAll(event);
	    }
	}
    }


    /**
     * Runnable that will message the shared instance of the Timer Queue
     * to restart.
     *
     * @see SystemEventQueueUtilities#restartTimerQueueThread
     */
    private static class TimerQueueRestart implements Runnable {
	boolean attemptedStart;

	public synchronized void run() {
	    // Only try and restart the q once.
	    if(!attemptedStart) {
		TimerQueue q = TimerQueue.sharedInstance();

		synchronized(q) {
		    if(!q.running)
			q.start();
		}
		attemptedStart = true;
	    }
	}
    }

    /**
     * Event type used for dispatching runnable objects for
     * SwingUtilities.invokeLater() and SwingUtilities.invokeAndWait().
     *
     * @see SystemEventQueueUtilities#postRunnable
     */
    private static class RunnableEvent extends AWTEvent {
        static final int EVENT_ID = AWTEvent.RESERVED_ID_MAX + 1000;
	static final Component target = new RunnableTarget();
	final Runnable doRun;
	final Object lock;
	Exception exception;

        RunnableEvent(Runnable doRun, Object lock) {
            super(target, EVENT_ID);
	    this.doRun = doRun;
	    this.lock = lock;
        }
    }


    /**
     * Calls RunnableEvent.doRun.run().  If RunnableEvent.lock is non
     * null then we synchronize the run() call and save the exception
     * (if any) in the RunnableEvent.exception field.
     */
    private static void processRunnableEvent(RunnableEvent runnableEvent)
    {
	Object lock = runnableEvent.lock;
	if (lock == null) {
	    runnableEvent.doRun.run();
	}
	else {
	    synchronized(lock) {
		try {
		    runnableEvent.doRun.run();
		}
		catch (Exception e) {
		    runnableEvent.exception = e;
		}
		finally {
		    if (runnableEvent.lock != null) {
			runnableEvent.lock.notify();
		    }
		}
	    }
	}
    }


    /**
     * A dummy Component subclass that (only) handles RunnableEvents.  If the
     * AWT System event queue is accessible (i.e. we're running as
     * an application or as trusted code), RunnableEvents are dispatched
     * to this component.
     *
     * @see SystemEventQueueUtilities#processRunnableEvent
     */
    private static class RunnableTarget extends Component
    {
        RunnableTarget() {
            super();
            enableEvents(RunnableEvent.EVENT_ID);
        }

        protected void processEvent(AWTEvent event) {
	    if (event instanceof RunnableEvent) {
		processRunnableEvent((RunnableEvent)event);
	    }
        }
    }


    /**
     * Synchronized entry point to the applet support for AWT System
     * event queue access.  This method adds the event to the appropriate
     * runnable canvas's queue and then has the canvas repaint().  Note
     * that by the time the event dispatching thread gets to handling
     * the repaint() (by calling runnableCanvas.update()), many runnable
     * events may have been queued up.
     *
     * @see RunnableCanvas#addRunnableEvent
     * @see RunnableCanvas#update
     */
    private static void postRunnableCanvasEvent(RunnableEvent e) {
	synchronized (classLock) {
	    RunnableCanvas runnableCanvas = RunnableCanvas.lookup(e);

	    if (runnableCanvas == null) {

		/* If this is a ComponentWorkRequest and we were unable to
		 * queue it, then clear the pending flag.
		 */
		if (e.doRun instanceof ComponentWorkRequest) {
		    ComponentWorkRequest req = (ComponentWorkRequest)e.doRun;
		    synchronized(req) {
			req.isPending = false;
		    }
		}

		/* If this is a Timer event let it know that it didn't fire.
		 */
		if(e.doRun instanceof Timer.DoPostEvent) {
		    ((Timer.DoPostEvent)e.doRun).getTimer().cancelEvent();
		}

		/* We are unable to queue this event on a system event queue.  Make
		 * sure that any code that's waiting for the runnable to finish
		 * doesn't hang.
		 */
		if (e.lock != null) {
		    e.lock.notify();
		}
		return;
	    }

	    runnableCanvas.addRunnableEvent(e);
	    runnableCanvas.repaint();
	}
    }

    
    /**
     * Return the current threads ThreadGroup, even on IE4.0.
     * IE4.0 throws a SecurityException if you apply getThreadGroup()
     * to the event dispatching thread.  However a child of the
     * event dispatching thread (same thread group) is OK.  
     */
    private static ThreadGroup getThreadGroupSafely() {
	return new Thread().getThreadGroup();
    }


    /**
     * Applets don't have direct access to the AWT SystemEvent queue.  To
     * work around this we call RunnableCanvas.repaint() on a per applet
     * instance of this class.  The AWT deals with this by queuing a
     * java.awt.PaintEvent for the event dispatching thread which
     * is dispatched (Component.dispatchEvent()) the usual way.
     * Component.dispatchEvent() handles PaintEvents by calling our update()
     * method (on the event dispatching thread) which processes
     * the RunnableEvents stashed in the runnableEvents vector.
     */
     private static class RunnableCanvas extends Canvas
     {
	 private static final Graphics nullGraphics = new RunnableCanvasGraphics();
	 private static Hashtable runnableCanvasTable = new Hashtable(1);
	 private Vector runnableEvents = new Vector(2);
	 private boolean isRegistered = false;

	 RunnableCanvas(JRootPane rootPane) {
	     super();
	     setBounds(0, 0, 1, 1);

	     /* Remember the mapping from the current thread (and the current
	      * thread group) to this RunnableCanvas.  Note that if a mapping
	      * has already been defined, e.g. this rootPane belongs to an
	      * existing applet, then leave the table alone.  We're assuming that
	      * an applets addNotify method will always run before the addNotify
	      * method in any subsidiary windows the applet creates can run.
	      */
	     if (runnableCanvasTable.get(Thread.currentThread()) == null) {
		 try {
		     runnableCanvasTable.put(Thread.currentThread(), this);
		     runnableCanvasTable.put(getThreadGroupSafely(), this);
		     if (SwingUtilities.isEventDispatchThread()) {
			 isRegistered = true;
		     }
		 }
		 catch(Exception e) {
		     System.err.println("Can't register RunnableCanvas");
		     e.printStackTrace();
		 }
	     }
	     runnableCanvasTable.put(rootPane, this);
	     maybeRegisterEventDispatchThread();
	 }


	 /**
	  * If called on an event dispatching thread that we haven't seen
	  * before then make two hashtable entries in the runnableCanvasTable:
	  * <pre>
	  *   current thread => this RunnableCanvas
	  *   current thread group => this RunnableCanvas
	  * </pre>
	  * @see #lookup
	  */
	 private void maybeRegisterEventDispatchThread() {
	     /* Avoid the cost of a synchronized block (or method) in the
	      * common case, since this method is called each time paint is called.
	      */
	     if (!isRegistered) {
		 synchronized(this) {
		     if (!isRegistered && SwingUtilities.isEventDispatchThread()) {
			 Thread currentThread = Thread.currentThread();

			 /* If this event dispatching thread is already mapped to
			  * a runnableCanvas then don't replace the mapping (which
			  * we expect to be generated by the applet).
			  */
			 if (runnableCanvasTable.get(currentThread) != null) {
			     isRegistered = true;
			 }
			 else {
			     runnableCanvasTable.put(currentThread, this);
			     runnableCanvasTable.put(getThreadGroupSafely(), this);
			     isRegistered = true;
			 }
		     }
		 }
	     }
	 }


	 /**
	  * If we're running on the event dispatching thread then lookup
	  * the canvas with the current thread itself, otherwise use the
	  * current threads thread group.  If there is no match for the 
	  * ThreadGroup, the first visible RunnableCanvas is returned.
	  */
	 static RunnableCanvas lookup(RunnableEvent e) 
	 {
	     /* If this is a ComponentWorkRequest, find the components
	      * JRootPane ancestor and use that as the index into the
	      * runnableCanvasTable.  This case occurs when any thread,
	      * other than the event dispatching thead, calls repaint
	      */
	     if (e.doRun instanceof ComponentWorkRequest) {
		 ComponentWorkRequest req = (ComponentWorkRequest)e.doRun;
		 synchronized(req) {
		     JRootPane rootPane = SwingUtilities.getRootPane(req.component);
		     if(rootPane != null) {
			 return (RunnableCanvas)(runnableCanvasTable.get(rootPane));
		     }
		     /* Failure.  There doesn't appear to be a RunnableCanvas to use
		      * so indicate that a new request will need to be queued, see
		      * RepaintManager.queueWorkRequest().
		      */
		     req.isPending = false;
		     return null;
		 }
	     }

	     /* If the current thread is in the runnableCanvasTable
	      * (e.g. we're on the event dispatching thread) we're done.
	      */
	     Object rv = runnableCanvasTable.get(Thread.currentThread());
	     if (rv != null) {
		 return (RunnableCanvas)rv;
	     }

	     /* At this point we're assuming that the calling thread isn't
	      * a system thread (like an image observer thread), so it's safe 
	      * to lookup via the current threads ThreadGroup.
	      */
	     Object threadGroup;
	     try {
		 threadGroup = Thread.currentThread().getThreadGroup();
	     }
	     catch (SecurityException exc) {
		 return null;
	     }
	     RunnableCanvas rc = (RunnableCanvas)runnableCanvasTable.get(threadGroup);
	     
	     /* There's no RunnableCanvas associated with this thread group
	      * (so punt).  Return the first visible RunnableCanvas.
	      */
	     if(rc == null) {
		 Enumeration keys = runnableCanvasTable.keys();
		 if(keys == null) {
		     return null;
		 }
		 while(keys.hasMoreElements()) {
		     Object key = keys.nextElement();
		     if ((key instanceof JRootPane) && ((JRootPane)key).isShowing()) {
			 return (RunnableCanvas)runnableCanvasTable.get(key);
		     }
		 }
	     }

	     return rc;
	 }


	 /**
	  * Adds the event to all the RunnableCanvases.
	  *
          * @see SystemEventQueueUtilities#restartTimerQueueThread
	  */
	 static void postRunnableEventToAll(RunnableEvent e) {
	     // Determine the RunnableCanvas for the current thread. It
	     // may be null.
	     RunnableCanvas currentThreadCanvas;
	     ThreadGroup tg;
	     try {
		 tg = new Thread().getThreadGroup();
	     }
	     catch (SecurityException se) {
		 tg = null;
	     }
	     if(tg != null) {
		 currentThreadCanvas = (RunnableCanvas)runnableCanvasTable.
		                        get(tg);
	     }
	     else
		 currentThreadCanvas = null;

	     // Add the event to all canvases, except the current one.
	     // Presumably the current one is no longer valid and will be
	     // going away shortly.
	     Enumeration keys = runnableCanvasTable.keys();
	     while(keys.hasMoreElements()) {
		 Object key = keys.nextElement();
		 if(key instanceof JRootPane) {
		     Object canvas = runnableCanvasTable.get(key);
		     if(canvas != currentThreadCanvas) {
			 RunnableCanvas rc = (RunnableCanvas)canvas;
			 rc.addRunnableEvent(e);
			 rc.repaint();
		     }
		 }
	     }
	 }


	 /**
	  * Remove the RunnableCanvas associated with this applet from the
	  * applets Layered pane and clear all of the runnableCanvasTable
	  * entries that point at it.
	  */
	 static void remove(JRootPane rootPane) {
	     RunnableCanvas rc = (RunnableCanvas)(runnableCanvasTable.get(rootPane));
	     if (rc != null) {
		 RunnableCanvas nextCanvas = null;
		 JLayeredPane layeredPane = rootPane.getLayeredPane();
		 layeredPane.remove((Component)rc);

		 Enumeration keys = runnableCanvasTable.keys();
		 while(keys.hasMoreElements()) {
		     Object key = keys.nextElement();
		     Object next = runnableCanvasTable.get(key);
		     if (rc == next) {
			 runnableCanvasTable.remove(key);
		     }
		     else if(nextCanvas == null) {
			 nextCanvas = (RunnableCanvas)next;
		     }
		 }

		 // If there are still events, either move them to another
		 // canvas, or mark the Timer type events as not having
		 // fired.
		 RunnableEvent[] events = rc.getRunnableCanvasEvents();
		 int numEvents = (events == null) ? 0 : events.length;
		 if(numEvents > 0) {
		     if(nextCanvas != null) {
			 for(int counter = 0; counter < numEvents; counter++) {
			     RunnableEvent e = events[counter];
			     if(e.doRun instanceof Timer.DoPostEvent)
				 nextCanvas.addRunnableEvent(e);
			 }
			 nextCanvas.repaint();
		     }
		     else {
			 // Mark all Timer type event as not having fired.
			 for(int counter = 0; counter < numEvents; counter++) {
			     RunnableEvent event = events[counter];
			     if(event.doRun instanceof Timer.DoPostEvent) {
				 ((Timer.DoPostEvent)event.doRun).getTimer().
				                     cancelEvent();
			     }
			 }
		     }
		 }
	     }
	 }


	 /**
	  * If there are events to be processed then we're showing.  Note
	  * that the AWT code that dispatches paint events short circuits
	  * (does nothing) if isShowing() returns false.
	  */
	 public boolean isShowing() {
	     return runnableEvents.size() > 0;
	 }


	 /**
	  * Reduce the cost of repainting (since we're not going to draw
	  * anything) by returning a constant no-op graphics object.
	  */
	 public Graphics getGraphics() {
	     return nullGraphics;
	 }


	 /**
	  * Testing purposes only.  This method shouldn't be called;
	  * the parent of this component should have a null layout
	  * manager.
	  */
	 public Dimension getPreferredSize() {
	     return new Dimension(1, 1);
	 }


	 /**
	  * Add a RunnableEvent to the queue that will be dispatched
	  * when this component is repainted.
	  * @see #update
	  */
	 synchronized void addRunnableEvent(RunnableEvent e) {
	     runnableEvents.addElement(e);
	 }


	 /**
	  * Return an (array) copy of the runnableEvents vector or
	  * null if the vector is empty.  The update method processes
	  * a copy of the vector so that we don't have to hold
	  * the synchronized lock while calling processRunnableEvent().
	  * @see #update
	  */
	 private synchronized RunnableEvent[] getRunnableCanvasEvents() {
	     int n = runnableEvents.size();
	     if (n == 0) {
		 return null;
	     }
	     else {
		 RunnableEvent[] rv = new RunnableEvent[n];
		 for(int i = 0; i < n; i++) {
		     rv[i] = (RunnableEvent)(runnableEvents.elementAt(i));
		 }
		 runnableEvents.removeAllElements();
		 return rv;
	     }
	 }


	 public void paint(Graphics g) {
	     maybeRegisterEventDispatchThread();
	 }


	 /**
	  * Process all of the RunnableEvents that have accumulated
	  * since RunnableCanvas.repaint() was called.
	  */
	 public void update(Graphics g) {
	     RunnableEvent[] events = getRunnableCanvasEvents();
	     if (events != null) {
		 for(int i = 0; i < events.length; i++) {
		     processRunnableEvent(events[i]);
		 }
	     }
	 }
    }


    /**
     * A no-op Graphics object for the RunnableCanvas component.
     * Most AWT Component implementations handle update events
     * like this:
     * <pre>
     *      Graphics g = getGraphics();
     *      Rectangle r = ((PaintEvent)e).getUpdateRect();
     *      g.clipRect(r.x, r.y, r.width, r.height);
     *      update(g)
     *      g.dispose();
     * </pre>
     * Since the RunnableCanvas component isn't really going to do
     * any painting we don't bother with creating/disposing real
     * graphics objects, or setting any of the properties.
     *
     */
    private static class RunnableCanvasGraphics extends Graphics
    {
	public Graphics create() {
	    return this;
	}

	/* We don't expect any of the following methods to be called but
	 * we still return marginally valid values for the get methods
	 * just in case.
	 */

	public Rectangle getClipBounds() {
	    return new Rectangle(0, 0, Short.MAX_VALUE, Short.MAX_VALUE);
	}

	public Shape getClip() {
	    return (Shape)(getClipBounds());
	}

	public  void dispose() {}
	public void translate(int x, int y) {}
	public Color getColor() { return Color.black; }
	public void setColor(Color c) {}
	public void setPaintMode() {}
	public void setXORMode(Color c) {}
	public Font getFont() { return null; }
	public void setFont(Font font) {}
	public FontMetrics getFontMetrics(Font f) { return null; }
	public void clipRect(int x, int y, int width, int height) {}
	public void setClip(int x, int y, int width, int height) {}
	public void setClip(Shape clip) {}
	public void copyArea(int x, int y, int w, int h, int dx, int dy) {}
	public void drawLine(int x1, int y1, int x2, int y2) {}
	public void fillRect(int x, int y, int width, int height) {}
	public void clearRect(int x, int y, int width, int height) {}
	public void drawRoundRect(int x, int y, int w, int h, int aw, int ah) {}
	public void fillRoundRect(int x, int y, int w, int h, int aw, int ah) {}
	public void drawOval(int x, int y, int w, int h) {}
	public void fillOval(int x, int y, int w, int h) {}
	public void drawArc(int x, int y, int w, int h, int sa, int aa) {}
	public void fillArc(int x, int y, int w, int h, int sa, int aa) {}
	public void drawPolyline(int xPoints[], int yPoints[], int nPoints) {}
	public void drawPolygon(int xPoints[], int yPoints[], int nPoints) {}
	public void fillPolygon(int xPoints[], int yPoints[], int nPoints) {}
	public void drawString(String str, int x, int y) {}
        public void drawString(java.text.AttributedCharacterIterator iterator, int x, int y) {}
	public boolean drawImage(Image i, int x, int y, ImageObserver o) { return false; }
	public boolean drawImage(Image i, int x, int y, int w, int h, ImageObserver o) { return false; }
	public boolean drawImage(Image i, int x, int y, Color bgcolor, ImageObserver o) { return false; }
	public boolean drawImage(Image i, int x, int y, int w, int h, Color c, ImageObserver o) { return false; }
	public boolean drawImage(Image i,
            int dx1, int dy1, int dx2, int dy2,
	    int sx1, int sy1, int sx2, int sy2, ImageObserver o)
	    { return false; }
	public boolean drawImage(Image i,
            int dx1, int dy1, int dx2, int dy2,
	    int sx1, int sy1, int sx2, int sy2, Color c, ImageObserver o)
	    { return false; }
    }
}
