Changeset 121 for trunk/src/org/expeditee/gui/FrameGraphics.java

Timestamp:

07/03/08 16:48:09 (16 years ago)

Author:

bjn8

Message:

Added invalidation for graphics... biiiig commit. LOts of effeciency improvements - now can animate

File:

• trunk/src/org/expeditee/gui/FrameGraphics.java (modified) (28 diffs)

trunk/src/org/expeditee/gui/FrameGraphics.java

@@ -5 +5 @@
 import java.awt.Container;
 import java.awt.Dimension;
-import java.awt.Font;
+import java.awt.EventQueue;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
@@ -11 +11 @@
 import java.awt.Image;
 import java.awt.Point;
+import java.awt.Rectangle;
 import java.awt.RenderingHints;
+import java.awt.geom.Area;
 import java.awt.image.BufferedImage;
-import java.awt.image.VolatileImage;
 import java.util.Collection;
 import java.util.Collections;
@@ -21 +22 @@
 import java.util.List;
 
+import javax.swing.JComponent;
 import javax.swing.JPopupMenu;
 import javax.swing.SwingUtilities;
 
-import org.expeditee.actions.Misc;
 import org.expeditee.items.Circle;
 import org.expeditee.items.InteractiveWidget;
@@ -30 +31 @@
 import org.expeditee.items.ItemUtils;
 import org.expeditee.items.Line;
-import org.expeditee.items.Text;
 import org.expeditee.items.WidgetEdge;
 import org.expeditee.items.XRayable;
 
 public class FrameGraphics {
-        public static final int MESSAGE_BUFFER_HEIGHT = 100;
-
-        private static final int MESSAGE_LINK_Y_OFFSET = 100;
-
-        private static final int MESSAGE_LINK_X = 50;
 
         // the graphics used to paint with
@@ -47 +42 @@
         private static Dimension _MaxSize;
 
-        // messages shown in the message window
-        public static Text[] Messages = new Text[4];
-
-        // buffer of the message window
-        private static VolatileImage _MessageBuffer = null;
-
-        // font used for the messages
-        private static Font _MessageFont = Font.decode("Serif-Plain-16");
-
-        // the number of messages currently shown (used for scrolling up)
-        private static int _MessageCount = 0;
-
         // modes
         public static final int MODE_NORMAL = 0;
@@ -65 +48 @@
 
         public static final int MODE_XRAY = 2;
-
-        public static final Color ERROR_COLOR = Color.red;
 
         // Start in XRay mode so that errors arnt thrown when parsing the profile
         // frame if it has images on it
         private static int _Mode = MODE_XRAY;
-
-        // if true, error messages are not shown to the user
-        private static boolean _SupressMessages = false;
-
-        public static String MESSAGES_FRAMESET_NAME = "Messages";
-
-        // The link to the message frameset
-        public static Item MessageLink = new Text(-2, "@" + MESSAGES_FRAMESET_NAME,
-                        Color.black, Color.white);
-
-        // creator for creating the message frames
-        private static FrameCreator _creator;
+        
+        private FrameGraphics() {
+                // util constructor
+        }
 
         /**
@@ -104 +77 @@
                 FrameUtils.Parse(current);
                 DisplayIO.UpdateTitle();
-                setMaxSize(new Dimension(_MaxSize.width, _MessageBuffer.getHeight()
+                setMaxSize(new Dimension(_MaxSize.width, MessageBay.getMessageBufferHeight()
                                 + _MaxSize.height));
-                Repaint();
+                refresh(false);
         }
 
@@ -120 +93 @@
                 DisplayIO.UpdateTitle();
                 FrameMouseActions.getInstance().refreshHighlights();
-                Repaint();
+                refresh(false);
         }
 
@@ -151 +124 @@
                 // Hide the message buffer if in audience mode
                 int newMaxHeight = max.height
-                                - (isAudienceMode() ? 0 : MESSAGE_BUFFER_HEIGHT);
+                                - (isAudienceMode() ? 0 : MessageBay.MESSAGE_BUFFER_HEIGHT);
                 if (newMaxHeight > 0) {
                         _MaxSize.setSize(max.width, newMaxHeight);
@@ -161 +134 @@
                 }
 
-                if (newMaxHeight > 0) {
-                        _MessageBuffer = null;
-
-                        for (int i = 0; i < Messages.length; i++) {
-                                if (Messages[i] != null) {
-                                        Messages[i].setOffset(0, -_MaxSize.height);
-                                        Messages[i].setMaxSize(_MaxSize);
-                                }
-                        }
-
-                        MessageLink.setOffset(0, -_MaxSize.height);
-                        MessageLink.setMaxSize(_MaxSize);
-                        MessageLink.setPosition(_MaxSize.width - MESSAGE_LINK_Y_OFFSET,
-                                        MESSAGE_LINK_X);
-                }
-                // Repaint();
+                if (newMaxHeight > 0)
+                        MessageBay.updateSize();
         }
 
@@ -205 +164 @@
          * Displays the given Item on the screen
          */
-        private static void PaintItem(Graphics2D g, Item i) {
+        static void PaintItem(Graphics2D g, Item i) {
                 if (i == null || g == null)
                         return;
@@ -286 +245 @@
         }
 
-        private static Image Paint(Frame toPaint) {
-                return Paint(toPaint, true);
-        }
-
-        private static Image Paint(Frame toPaint, boolean isActualFrame) {
+        private static Image Paint(Frame toPaint, Area clip) {
+                return Paint(toPaint, clip, true);
+        }
+
+        /**
+         * 
+         * @param toPaint
+         * @param clip If null, then no clip applied.
+         * @param isActualFrame
+         * @return
+         */
+        private static Image Paint(Frame toPaint, Area clip, boolean isActualFrame) {
                 if (toPaint == null)
                         return null;
@@ -313 +279 @@
 
                         Graphics2D bg = (Graphics2D) buffer.getGraphics();
+                        bg.setClip(clip); 
+                        
+                        // TODO: Revise images and clip - VERY IMPORTANT
 
                         // Nicer looking lines, but may be too jerky while
@@ -331 +300 @@
                         }
 
+                        
                         bg.setColor(backgroundColor);
+                        // bg.setColor(Color.pink); // TODO: TEMP FOR DEBUGGING
+                        
                         bg.fillRect(0, 0, _MaxSize.width, _MaxSize.height);
 
-                        List<Item> paintItems = new LinkedList<Item>();
+                        List<Item> visibleItems = new LinkedList<Item>();
                         List<InteractiveWidget> paintWidgets;
 
@@ -340 +312 @@
                                 // Add all the items for this frame and any other from other
                                 // frames
-                                paintItems.addAll(toPaint.getAllItems());
-
+                                visibleItems.addAll(toPaint.getAllItems());
                                 paintWidgets = new LinkedList<InteractiveWidget>();
                                 AddAllOverlayWidgets(paintWidgets, toPaint,
                                                 new LinkedList<Frame>());
                         } else {
-                                paintItems.addAll(toPaint.getVisibleItems());
-                                paintItems.addAll(toPaint.getVectorItems());
+                                visibleItems.addAll(toPaint.getVisibleItems());
+                                visibleItems.addAll(toPaint.getVectorItems());
                                 paintWidgets = toPaint.getInteractiveWidgets();
                         }
 
                         // FIRST: Paint widgets swing gui (not expeditee gui) .
-                        // Note that these are the ancored widgets
+                        // Note that these are the anchored widgets
                         for (InteractiveWidget iw : paintWidgets) {
-                                iw.paint(bg);
-                        }
-
-                        PaintPictures(bg, paintItems);
-                        PaintLines(bg, paintItems);
-
+                                if (clip == null || clip.intersects(iw.getComponant().getBounds()))
+                                        iw.paint(bg);
+                        }
+                        
+                        // Filter out items that do not need to be painted
+                        List<Item> paintItems;
+                        HashSet<Item> fillOnlyItems = null; // only contains items that do not need drawing but fills might
+                        
+                        if (clip == null) {
+                                paintItems = visibleItems;
+                        } else {
+                                fillOnlyItems = new HashSet<Item>();
+                                paintItems = new LinkedList<Item>();
+                                for (Item i : visibleItems) {
+                                        if (i.isInDrawingArea(clip)) {
+                                                paintItems.add(i);
+                                        } else if (i.isEnclosed()) {
+                                                // just add all fill items despite possibility of fills not being in clip
+                                                // because it will be faster than having to test twice for fills that do need
+                                                // repainting.
+                                                fillOnlyItems.add(i);
+                                        }
+                                }
+                        }
+                        // Only paint files and lines once ... between anchored AND free items
+                        HashSet<Item> paintedFillsAndLines = new HashSet<Item> ();
+                        PaintPictures(bg, paintItems, fillOnlyItems, paintedFillsAndLines);
+                        PaintLines(bg, visibleItems);
+
+                        // Filter out free items that do not need to be painted
+                        // This is efficient in cases with animation while free items exist
+                        
+                        List<Item> freeItemsToPaint = new LinkedList<Item>();
+                        if (clip == null) {
+                                freeItemsToPaint = FreeItems.getInstance();
+                        } else {
+                                freeItemsToPaint = new LinkedList<Item>();
+                                fillOnlyItems.clear();
+                                for (Item i : FreeItems.getInstance()) {
+                                        if (i.isInDrawingArea(clip)) {
+                                                freeItemsToPaint.add(i);
+                                        } else if (i.isEnclosed()) {
+                                                fillOnlyItems.add(i);
+                                        }
+                                }
+                        }
+                        
                         if (isActualFrame /* && toPaint == DisplayIO.getCurrentFrame() */)
-                                PaintPictures(bg, Frame.FreeItems);
-                        // TODO if we can get transparency with FreeItems... then text can
+                                PaintPictures(bg, freeItemsToPaint, fillOnlyItems, paintedFillsAndLines);
+                        // TODO if we can get transparency with FreeItems.getInstance()... then text can
                         // be done before freeItems
                         PaintNonLinesNonPicture(bg, paintItems);
@@ -374 +386 @@
                         if (DisplayIO.isTwinFramesOn()) {
                                 List<Item> lines = new LinkedList<Item>();
-                                for (Item i : Frame.FreeItems) {
+                                for (Item i : freeItemsToPaint) {
                                         if (i instanceof Line) {
                                                 Line line = (Line) i;
@@ -411 +423 @@
                                 // Dont paint the
                                 if (isActualFrame)
-                                        PaintLines(bg, Frame.FreeItems);
+                                        PaintLines(bg, freeItemsToPaint);
                         }
 
                         if (isActualFrame /* && toPaint == DisplayIO.getCurrentFrame() */)
-                                PaintNonLinesNonPicture(bg, Frame.FreeItems);
+                                PaintNonLinesNonPicture(bg, freeItemsToPaint);
 
                         // BROOK: Ensure popups are repainted
@@ -465 +477 @@
         }
 
-        private static void Paint(Image left, Image right, Color background) {
-                if (_MessageBuffer == null) {
-                        GraphicsEnvironment ge = GraphicsEnvironment
-                                        .getLocalGraphicsEnvironment();
-                        _MessageBuffer = ge.getDefaultScreenDevice()
-                                        .getDefaultConfiguration().createCompatibleVolatileImage(
-                                                        _MaxSize.width,
-                                                        (isAudienceMode() ? 0 : MESSAGE_BUFFER_HEIGHT));
-                }
-
-                paintMessage(_MessageBuffer.createGraphics(), background);
-                Graphics g = _DisplayGraphics.create();
+        private static void Paint(Graphics g, Image left, Image right, Color background) {
 
                 // if TwinFrames mode is on, then clipping etc has to be set
@@ -503 +504 @@
                                 g.drawImage(right, 0, 0, Item.DEFAULT_BACKGROUND, null);
                 }
-                // Dont display the message area in audience mode
-                if (!isAudienceMode()) {
-                        // draw the message area
-                        g.drawImage(_MessageBuffer, 0, _MaxSize.height, null);
-                }
-                g.dispose();
-
-        }
-
-        /**
-         * Paints the message area
-         * 
-         * @param g
-         * @param background
-         */
-        private static void paintMessage(Graphics2D g, Color background) {
-                ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
-                                RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
-                g.setColor(background);
-                g.fillRect(0, 0, _MaxSize.width, MESSAGE_BUFFER_HEIGHT);
-                g.setFont(_MessageFont);
-                g.setColor(Color.BLACK);
-                g.drawLine(0, 0, _MaxSize.width, 0);
-                for (Item t : Messages)
-                        PaintItem(g, t);
-                if (MessageLink.getLink() != null)
-                        PaintItem(g, MessageLink);
-                g.dispose();
+
         }
 
@@ -539 +513 @@
                 g.dispose();
         }
-
-        /**
-         * Called to refresh the display screen.
-         * 
-         */
-        public static void Repaint() {
-                Runtime.getRuntime();
-                if (_DisplayGraphics == null)
-                        return;
-
-                if (UserSettings.Threading) {
-                        if (painter == null) {
-                                painter = new FrameGraphics().new Repainter();
-
-                                painter.setDaemon(true);
-                                painter.setPriority(Thread.MIN_PRIORITY);
-
-                                painter.start();
-                        } else
-                                painter.run();
-                } else {
-                        Frame[] toPaint = DisplayIO.getFrames();
-
-                        if (toPaint != null) {
-                                Image left = Paint(toPaint[0]);
-                                Image right = Paint(toPaint[1]);
-                                Paint(left, right, Item.DEFAULT_BACKGROUND);
-                        }
-                }
-        }
-
-        private static Repainter painter = null;
 
         private static void PaintNonLinesNonPicture(Graphics2D g, List<Item> toPaint) {
@@ -601 +543 @@
         }
 
+
         /**
          * Paint filled areas and their surrounding lines as well as pictures.
-         * 
+         * Note: floating widgets are painted as fills
          * @param g
          * @param toPaint
          */
-        private static void PaintPictures(Graphics2D g, List<Item> toPaint) {
-                // Use this set to keep track of the items that dont need to be
-                // repainted
-                Collection<Item> done = new HashSet<Item>();
+        private static void PaintPictures(Graphics2D g, List<Item> toPaint, 
+                        HashSet<Item> fillOnlyItems, HashSet<Item> done) {
+                
                 List<Item> toFill = new LinkedList<Item>();
                 for (Item i : toPaint) {
@@ -634 +576 @@
                         }
                 }
+                
+                if (fillOnlyItems != null) {
+                        for (Item i : fillOnlyItems) {
+                                if (done.contains(i)) continue;
+                                else if (!isAudienceMode() || !i.isConnectedToAnnotation()) {
+                                        toFill.add(i);
+                                }
+                                done.addAll(i.getAllConnected());
+                        }
+                }
+                
                 // Sort the items to fill
                 Collections.sort(toFill, new Comparator<Item>() {
@@ -639 +592 @@
                                 Double aArea = a.getEnclosedArea();
                                 Double bArea = b.getEnclosedArea();
-                                return aArea.compareTo(bArea) * -1;
+                                int cmp = aArea.compareTo(bArea);
+                                if (cmp == 0) {
+                                        return new Integer(a.getID()).compareTo(b.getID());
+                                }
+                                return cmp * -1;
                         }
                 });
@@ -715 +672 @@
                 // Mike: TODO comment on why the line below is used!!
                 // I forgot already!!Opps
-                boolean freeItem = Frame.FreeItems.contains(item);
+                boolean freeItem = FreeItems.getInstance().contains(item);
                 for (Item i : item.getAllConnected()) {
-                        if (/* freeItem || */!Frame.FreeItems.contains(i)) {
+                        if (/* freeItem || */!FreeItems.getInstance().contains(i)) {
                                 i.setHighlightMode(connectedNewMode);
                         }
@@ -723 +680 @@
                 if (!freeItem && newMode != connectedNewMode)
                         item.setHighlightMode(newMode);
-                Repaint();
-        }
-
-        public static void OverwriteMessage(String message) {
-                for (int ind = Messages.length - 1; ind >= 0; ind--) {
-                        if (Messages[ind] != null) {
-                                Messages[ind].setText(getMessagePrefix(false) + message);
-                                Repaint();
-                                return;
-                        }
-                }
-
-                // if we have not returned, then there are no messages yet
-                DisplayMessage(message, Color.darkGray);
-        }
-
-        /**
-         * Displays the given message in the message area of the Frame, any previous
-         * message is cleared from the screen.
-         * 
-         * @param message
-         *            The message to display to the user in the message area
-         */
-        public static void DisplayMessage(String message) {
-                DisplayMessageAlways(message);
-        }
-
-        public static void DisplayMessageOnce(String message) {
-                displayMessage(message, null, null, Color.BLACK, false);
-        }
-
-        public static void DisplayMessage(String message, Color textColor) {
-                displayMessage(message, null, null, textColor);
-                // Misc.Beep();
-        }
-
-        public static void DisplayMessage(Text message) {
-                displayMessage(message.getFirstLine(), message.getLink(), message
-                                .getAction(), message.getColor());
-                // Misc.Beep();
-        }
-
-        public static void DisplayMessageAlways(String message) {
-                displayMessage(message, null, null, Color.BLACK);
-                // Misc.Beep();
-        }
-
-        public static void WarningMessage(String message) {
-                displayMessage(message, null, null, Color.MAGENTA);
-                // Misc.Beep();
-        }
-
-        private static String _lastMessage = null;
-
-        private static void displayMessage(String message, String link,
-                        List<String> actions, Color color) {
-                displayMessage(message, link, actions, color, true);
-        }
-
-        private static void displayMessage(String message, String link,
-                        List<String> actions, Color color, boolean displayAlways) {
-
-                System.out.println(message);
-                assert (message != null);
-
-                if (_SupressMessages)
-                        return;
-
-                if (!displayAlways && message.equals(_lastMessage)) {
-                        Misc.Beep();
-                        return;
-                }
-                _lastMessage = message;
-
-                if (_creator == null) {
-                        _creator = new FrameCreator(MESSAGES_FRAMESET_NAME, true);
-
-                        // set up 'Messages' link on the right hand side
-                        MessageLink.setPosition(_MaxSize.width - MESSAGE_LINK_Y_OFFSET,
-                                        MESSAGE_LINK_X);
-                        MessageLink.setOffset(0, -_MaxSize.height);
-                }
-
-                // if the message slots have not all been used yet
-                if (_MessageCount <= Messages.length) {
-                        int pos = 15;
-                        // find the next empty slot, and create the new message
-                        for (int i = 0; i < Messages.length; i++) {
-                                if (Messages[i] == null) {
-                                        Messages[i] = new Text(getMessagePrefix(true) + message);
-                                        Messages[i].setPosition(20, pos);
-                                        Messages[i].setOffset(0, -_MaxSize.height);
-                                        Messages[i].setMaxSize(_MaxSize);
-                                        Messages[i].setColor(color);
-                                        Messages[i].setLink(link);
-                                        _creator.addItem(Messages[i].copy());
-                                        MessageLink.setLink(_creator.getCurrent());
-                                        Repaint();
-                                        return;
-                                }
-
-                                pos += 25;
-                        }
-                }
-
-                // if we have not returned then all message slots are used
-                for (int i = 0; i < Messages.length - 1; i++) {
-                        Messages[i].setText(Messages[i + 1].getFirstLine());
-                        Messages[i].setColor(Messages[i + 1].getColor());
-                        Messages[i].setLink(Messages[i + 1].getLink());
-                }
-
-                // show the new message
-                Text last = Messages[Messages.length - 1];
-                last.setColor(color);
-                // Make set the text for the new message
-                last.setText(getMessagePrefix(true) + message);
-                last.setLink(link);
-                last.setActions(actions);
-
-                _creator.addItem(last.copy());
-                // update the link to the latest message frame
-                MessageLink.setLink(_creator.getCurrent());
-                Repaint();
-        }
-
-        private static String getMessagePrefix(boolean incrementCounter) {
-                if (incrementCounter)
-                        _MessageCount++;
-                return "@" + _MessageCount + ": ";
-        }
-
-        /**
-         * Checks if the error message ends with a frame name after the
-         * frameNameSeparator symbol
-         * 
-         * @param message
-         *            the message to be displayed
-         */
-        public static void LinkedErrorMessage(String message) {
-                if (_SupressMessages)
-                        return;
-                Misc.Beep();
-                String[] tokens = message.split(Text.FRAME_NAME_SEPARATOR);
-                String link = null;
-                if (tokens.length > 1)
-                        link = tokens[tokens.length - 1];
-                displayMessage(message, link, null, ERROR_COLOR);
-        }
-
-        public static void ErrorMessage(String message) {
-                if (_SupressMessages)
-                        return;
-                Misc.Beep();
-                displayMessage(message, null, null, ERROR_COLOR);
-        }
-
-        private class Repainter extends Thread {
-                public boolean isPainting = false;
-
-                public void run() {
-                        // TODO see if there is any other way to deal with this
-                        if (_MaxSize.width <= 0 || _MaxSize.height <= 0) {
-                                return;
-                        }
-                        isPainting = true;
-
-                        Frame[] toPaint = DisplayIO.getFrames();
-
-                        if (toPaint != null) {
-                                Image left = Paint(toPaint[0]);
-                                Image right = Paint(toPaint[1]);
-                                Paint(left, right, Item.DEFAULT_BACKGROUND);
-                        }
-                        isPainting = false;
-                }
-        }
-
-        /**
-         * Invalidates the buffered image of the current Frame and forces it to be
-         * repainted on to the screen.
-         */
-        public static void ForceRepaint() {
-                Frame current = DisplayIO.getCurrentFrame();
-
-                if (current == null)
-                        return;
-
                 Repaint();
         }
@@ -925 +694 @@
                         return;
 
-                Image vi = Paint(toUpdate, paintOverlays);
+                Image vi = Paint(toUpdate, null, paintOverlays);
                 toUpdate.setBuffer(vi);
-        }
-
-        public static void SupressMessages(boolean val) {
-                _SupressMessages = val;
         }
 
@@ -939 +704 @@
                                                 Browser._theBrowser.getContentPane());
 
+                                c.setIgnoreRepaint(true);
+                                ((JComponent)c).setDoubleBuffered(false);
                                 g.translate(p.x, p.y);
                                 c.paint(g);
@@ -952 +719 @@
                 return _Mode;
         }
+
+        // Damaged areas pending to render. Accessessed by multiple threads
+        private static HashSet<Rectangle> damagedAreas = new HashSet<Rectangle>();
+        
+        /**
+         * Checks that the item is visible (on current frame && overlays) - if visible
+         * then damaged area will be re-rendered on the next refresh.
+         * @param damagedItem
+         * @param toRepaint
+         */
+        public static void invalidateItem(Item damagedItem, Rectangle toRepaint) {
+                // Only add area to repaint if item is visible...
+                if (ItemUtils.isVisible(damagedItem)) {
+                        synchronized(damagedAreas) {
+                                damagedAreas.add(toRepaint);
+                        }
+                } else if(MessageBay.isMessageItem(damagedItem)) {
+                        MessageBay.addDirtyArea(toRepaint);
+                }
+        }
+        
+        /**
+         * The given area will be re-rendered in the next refresh. This is the quicker version
+         * and is more useful for re-rendering animated areas.
+         * @param toRepaint
+         */
+        public static void invalidateArea(Rectangle toRepaint) {
+                synchronized(damagedAreas) {
+                        damagedAreas.add(toRepaint);
+                }
+        }
+        
+        public static void clearInvalidAreas() {
+                synchronized(damagedAreas) {
+                        damagedAreas.clear();
+                }
+        }
+        
+        /**
+         * Invalidates the buffered image of the current Frame and forces it to be
+         * repainted on to the screen. Repaints all items. This is more expensive
+         * than refresh.
+         */
+        public static void ForceRepaint() {  // TODO: TEMP: Use refresh
+                Frame current = DisplayIO.getCurrentFrame();
+
+                if (current == null)
+                        return;
+                refresh(false);
+        }
+        
+        public static void Repaint() { // TODO: TEMP: Use refresh
+                refresh(true);
+        }
+
+        /**
+         * Called to refresh the display screen. Thread safe.
+         */
+        public static void refresh(boolean useInvalidation) {
+                
+                if (_DisplayGraphics == null) return;
+
+                Area clip = null;
+                if (useInvalidation) { // build clip
+                        
+                        synchronized(damagedAreas) {
+                                if (!damagedAreas.isEmpty()) {
+                                        
+                                        for (Rectangle r : damagedAreas) {
+                                                if (clip == null) clip = new Area(r);
+                                                clip.add(new Area(r));  
+                                        }
+                                        damagedAreas.clear();
+                                } else return; // nothing to render
+                        }
+                
+                } else {
+                        synchronized(damagedAreas) {
+                                damagedAreas.clear();
+                        }
+                        System.out.println("FULLSCREEN REFRESH"); // TODO: REMOVE
+                }
+
+                Frame[] toPaint = DisplayIO.getFrames();
+                Image left = Paint(toPaint[0], clip);
+                Image right = Paint(toPaint[1], clip); 
+                
+                Graphics dg = _DisplayGraphics.create();
+                
+                // Paint frame to window
+                Paint(dg, left, right, Item.DEFAULT_BACKGROUND);
+                
+                // Paint message bay
+                MessageBay.refresh(useInvalidation, dg, Item.DEFAULT_BACKGROUND);
+                
+                dg.dispose();
+        }
+        
+        /**
+         * If wanting to refresh from another thread - other than the main thread that
+         * handles the expeditee datamodel (modifying / accessing / rendering). Use
+         * this method for thread safety.
+         */
+        public static synchronized void requestRefresh(boolean useInvalidation) {
+                
+                _requestMarsheller._useInvalidation = useInvalidation;
+                
+                if (_requestMarsheller._isQueued) {
+                        return;
+                }
+                
+                _requestMarsheller._isQueued = true;
+                EventQueue.invokeLater(_requestMarsheller); // Render on AWT thread
+        }
+        
+        private static RenderRequestMarsheller _requestMarsheller = new FrameGraphics().new RenderRequestMarsheller();
+        
+        /**
+         * Used for marshelling render requests from foreign threads to the event dispatcher thread... (AWT)
+         * @author Brook Novak
+         */
+        private class RenderRequestMarsheller implements Runnable {
+
+                boolean _useInvalidation = true;
+                boolean _isQueued = false;
+                
+                public void run() {
+                        refresh(_useInvalidation);
+                        _isQueued = false;
+                        _useInvalidation = true;
+                }
+
+        }
+        
 }