source: trunk/src/org/expeditee/gui/MessageBay.java@ 674

package org.expeditee.gui;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsEnvironment;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.geom.Area;
import java.awt.image.VolatileImage;
import java.util.LinkedList;
import java.util.List;

import org.expeditee.actions.Misc;
import org.expeditee.items.Item;
import org.expeditee.items.Text;

/**
 * The bay at the bottom of the expeditee browser which displays messages. TODO
 * make it thread safe!
 * 
 */
public final class MessageBay {


        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;

        public static final Color ERROR_COLOR = Color.red;

        public static final String MESSAGES_FRAMESET_NAME = "Messages";

        // messages shown in the message window
        private static Text[] _messages = new Text[3];
        private static Text _status = null;

        // buffer of the message window
        private static VolatileImage _messageBuffer = null;

        // creator for creating the message frames
        private static FrameCreator _creator = 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;

        // if true, error messages are not shown to the user
        private static boolean _supressMessages = false;

        // The link to the message frameset
        private static Item _messageLink = new Text(-2, "@"
                        + MESSAGES_FRAMESET_NAME, Color.black, Color.white);

        private static List<Rectangle> _dirtyAreas = new LinkedList<Rectangle>();

        private static String _lastMessage = null;

        private MessageBay() {
        }

        /**
         * Syncs messsage bay size according to FrameGraphics max size.
         * 
         */
        static void updateSize() {

                _messageBuffer = null;

                for (int i = 0; i < _messages.length; i++) {
                        if (_messages[i] != null) {
                                _messages[i].setOffset(0,
                                                -FrameGraphics.getMaxFrameSize().height);
                                // _messages[i].setMaxWidth(FrameGraphics.getMaxFrameSize().width);
                        }
                }

                _messageLink.setOffset(0, -FrameGraphics.getMaxFrameSize().height);
                // _messageLink.setMaxWidth(FrameGraphics.getMaxFrameSize().width);
                // _messageLink.setPosition(FrameGraphics.getMaxFrameSize().width
                // - MESSAGE_LINK_Y_OFFSET, MESSAGE_LINK_X);
                updateLink();
                initBuffer();
        }

        /**
         * @param i
         * @return True if i is an item in the message bay
         */
        public static boolean isMessageItem(Item i) {
                if (_messages != null) {
                        for (Text txt : _messages) {
                                if (txt == i)
                                        return true;
                        }
                }

                return i == _messageLink;
        }

        public synchronized static void addDirtyArea(Rectangle r) {
                _dirtyAreas.add(r);
        }

        static synchronized int getMessageBufferHeight() {
                if (_messageBuffer != null)
                        return _messageBuffer.getHeight();
                return 0;
        }

        public synchronized static Item getMessageLink() {
                return _messageLink;
        }

        public synchronized static Text[] getMessages() {
                return _messages;
        }

        public synchronized static boolean isDirty() {
                return !_dirtyAreas.isEmpty();
        }

        public synchronized static void invalidateFullBay() {
                if (_messageBuffer != null) {
                        _dirtyAreas.clear();
                        addDirtyArea(new Rectangle(0,
                                        FrameGraphics.getMaxFrameSize().height, _messageBuffer
                                                        .getWidth(), _messageBuffer.getHeight()));
                }
        }

        private synchronized static boolean initBuffer() {
                if (_messageBuffer == null) {
                        if (FrameGraphics.isAudienceMode()
                                        || FrameGraphics.getMaxSize().width <= 0)
                                return false;

                        GraphicsEnvironment ge = GraphicsEnvironment
                                        .getLocalGraphicsEnvironment();
                        _messageBuffer = ge.getDefaultScreenDevice()
                                        .getDefaultConfiguration().createCompatibleVolatileImage(
                                                        FrameGraphics.getMaxSize().width,
                                                        MESSAGE_BUFFER_HEIGHT);
                }
                return true;
        }

        private static boolean isLinkInitialized = false;

        private static void updateLink() {

                if (!isLinkInitialized && FrameGraphics.getMaxSize().width > 0) {
                        // set up 'Messages' link on the right hand side
                        _messageLink.setPosition(FrameGraphics.getMaxSize().width
                                        - MESSAGE_LINK_Y_OFFSET, MESSAGE_LINK_X);
                        _messageLink.setOffset(0, -FrameGraphics.getMaxFrameSize().height);
                        isLinkInitialized = true;

                } else {
                        _messageLink.setPosition(FrameGraphics.getMaxSize().width
                                        - MESSAGE_LINK_Y_OFFSET, MESSAGE_LINK_X);
                }
        }

        /**
         * Repaints the message bay. Updates the message bay buffer and draws to
         * given graphics.
         * 
         * @param useInvalidation
         *            Set to true of repinting dirty areas only. Otherwise false for
         *            full-repaint.
         * 
         * @param g
         * 
         * @param background
         *            The color of the message background
         */
        public static synchronized void refresh(boolean useInvalidation,
                        Graphics g, Color background) {

                if (FrameGraphics.getMaxSize().width <= 0)
                        return;

                Area clip = null;

                if (useInvalidation) { // build clip

                        if (!_dirtyAreas.isEmpty()) {

                                for (Rectangle r : _dirtyAreas) {
                                        r.y = (r.y < 0) ? 0 : r.y;
                                        r.x = (r.x < 0) ? 0 : r.x;
                                        if (clip == null)
                                                clip = new Area(r);
                                        else
                                                clip.add(new Area(r));
                                }
                        } else
                                return; // nothing to render
                }

                _dirtyAreas.clear();

                // Update the buffer
                updateBuffer(background, clip);

                // Now repaint to screen
                if (!FrameGraphics.isAudienceMode()) {

                        // Translate clip to messagebox coords
                        // clip.transform(t) // TODO
                        // g.setClip(clip);

                        g.drawImage(_messageBuffer, 0,
                                        FrameGraphics.getMaxFrameSize().height, null);
                }

        }

        private static void updateBuffer(Color background, Area clip) {
                if (!initBuffer())
                        return;

                Graphics2D g = _messageBuffer.createGraphics();

                g.setClip(clip);

                g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
                                RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
                g.setColor(background);
                g.fillRect(0, 0, FrameGraphics.getMaxSize().width,
                                MESSAGE_BUFFER_HEIGHT);
                g.setFont(_messageFont);
                g.setColor(Color.BLACK);
                g.drawLine(0, 0, FrameGraphics.getMaxSize().width, 0);

                for (Item t : _messages) {
                        if (t == null)
                                continue;
                        if (clip == null || t.isInDrawingArea(clip))
                                FrameGraphics.PaintItem(g, t);
                }
                if(_status != null)
                        FrameGraphics.PaintItem(g, _status);

                if (// _messageLink.getLink() != null
                // &&
                (clip == null || _messageLink.isInDrawingArea(clip))) {
                        FrameGraphics.PaintItem(g, _messageLink);
                }
                g.dispose();

        }

        private static Text displayMessage(String message, String link,
                        List<String> actions, Color color) {
                return displayMessage(message, link, actions, color, true);
        }

        public synchronized static Text displayMessage(String message, String link, Color color,
                        boolean displayAlways, String action) {
                List<String> actions = new LinkedList<String>();
                if (action != null)
                        actions.add(action);
                return displayMessage(message, link, actions, color, displayAlways);
        }

        public synchronized static Text displayMessage(String message, String link,
                        List<String> actions, Color color, boolean displayAlways) {

                System.out.println(message);
                assert (message != null);

                // Invalidate whole area
                invalidateFullBay();

                if (_supressMessages)
                        return null;

                if (!displayAlways && message.equals(_lastMessage)) {
                        Misc.beep();
                        return null;
                }
                _lastMessage = message;

                if (_creator == null) {
                        _creator = new FrameCreator(MESSAGES_FRAMESET_NAME,
                                        FrameIO.MESSAGES_PATH, MESSAGES_FRAMESET_NAME, true, false);
                }

                // set up 'Messages' link on the right hand side
                updateLink();

                // 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,
                                                        -FrameGraphics.getMaxFrameSize().height);
                                        // _messages[i].setMaxWidth(FrameGraphics.getMaxFrameSize().width);
                                        _messages[i].setColor(color);
                                        _messages[i].setLink(link);
                                        _messages[i].setActions(actions);
                                        _messages[i].setFont(_messageFont);
                                        _creator.addItem(_messages[i].copy(), true);
                                        _messageLink.setLink(_creator.getCurrent());

                                        Graphics g = FrameGraphics.createGraphics();
                                        if (g != null) {
                                                refresh(false, g, Item.DEFAULT_BACKGROUND);
                                        }
                                        return _messages[i];
                                }

                                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());
                        _messages[i].setActions(_messages[i + 1].getAction());
                }

                // show the new message
                Text last = _messages[_messages.length - 1];
                last.setColor(color);
                // Set the text for the new message
                last.setText(getMessagePrefix(true) + message);
                last.setLink(link);
                last.setActions(actions);

                _creator.addItem(last.copy(), true);
                // update the link to the latest message frame
                _messageLink.setLink(_creator.getCurrent());

                Graphics g = FrameGraphics.createGraphics();
                if (g != null) {
                    refresh(false, g, Item.DEFAULT_BACKGROUND);
                }

                return last;
        }

        public synchronized static void overwriteMessage(String message) {
                overwriteMessage(message, null);
        }

        public synchronized static void overwriteMessage(String message, Color color) {
                for (int ind = _messages.length - 1; ind >= 0; ind--) {
                        if (_messages[ind] != null) {
                                _messages[ind].setColor(color);
                                _messages[ind].setText(getMessagePrefix(false) + message);
                                refresh(false, FrameGraphics.createGraphics(),
                                                Item.DEFAULT_BACKGROUND);
                                return;
                        }
                }

                // if we have not returned, then there are no messages yet
                displayMessage(message, Color.darkGray);
        }

        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 synchronized static Text linkedErrorMessage(String message) {
                if (_supressMessages)
                        return null;
                Misc.beep();
                String[] tokens = message.split(Text.FRAME_NAME_SEPARATOR);
                String link = null;
                if (tokens.length > 1)
                        link = tokens[tokens.length - 1];
                return displayMessage(message, link, null, ERROR_COLOR);
        }

        public synchronized static Text errorMessage(String message) {
                if (_supressMessages)
                        return null;
                Misc.beep();
                return displayMessage(message, null, null, ERROR_COLOR, false);
        }

        /**
         * 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 synchronized static Text displayMessage(String message) {
                return displayMessageAlways(message);
        }

        public synchronized static Text displayMessageOnce(String message) {
                return displayMessage(message, null, null, Color.BLACK, false);
        }

        public synchronized static Text displayMessage(String message, Color textColor) {
                return displayMessage(message, null, null, textColor);
                // Misc.Beep();
        }

        public synchronized static Text displayMessage(Text message) {
                Text t = null;
                String link = message.getLink();
                List<String> action = message.getAction();
                Color color = message.getColor();
                for (String s : message.getTextList()) {
                        t = displayMessage(s, link, action, color);
                }
                return t;
                // Misc.Beep();
        }

        public synchronized static Text displayMessageAlways(String message) {
                return displayMessage(message, null, null, Color.BLACK);
                // Misc.Beep();
        }

        public synchronized static Text warningMessage(String message) {
                return displayMessage(message, null, null, Color.MAGENTA);
                // Misc.Beep();
        }

        public synchronized static void supressMessages(boolean val) {
                _supressMessages = val;
        }
        
        public synchronized static void setStatus(String status) {
                if (_status == null) {
                        _status = new Text(status);
                        _status.setPosition(0, 90);
                        _status.setOffset(0, FrameGraphics.getMaxFrameSize().height);
                        _status.setLink(null); // maybe link to a help frame?
                        _status.setFont(Font.decode(Text.MONOSPACED_FONT));
                } else {
                        _status.setText(status);
                }
                Graphics g = FrameGraphics.createGraphics();
                if (g != null) {
                        refresh(false, g, Item.DEFAULT_BACKGROUND);
                }
        }

}