source: trunk/src/org/expeditee/gio/GraphicsManager.java@ 1545

package org.expeditee.gio;

import java.net.URL;
import java.util.LinkedList;
import java.util.List;

import org.expeditee.core.Clip;
import org.expeditee.core.Colour;
import org.expeditee.core.Cursor;
import org.expeditee.core.Dimension;
import org.expeditee.core.EnforcedClipStack.EnforcedClipKey;
import org.expeditee.core.Fill;
import org.expeditee.core.Font;
import org.expeditee.core.Image;
import org.expeditee.core.Line;
import org.expeditee.core.Point;
import org.expeditee.core.Stroke;
import org.expeditee.core.TextLayout;
import org.expeditee.core.bounds.AxisAlignedBoxBounds;
import org.expeditee.core.bounds.EllipticalBounds;
import org.expeditee.core.bounds.PolygonBounds;
import org.expeditee.items.widgets.Widget;

/** TODO: Comment. cts16 */
public abstract class GraphicsManager {

        /** TODO: Comment. cts16 */
        protected static String _windowIcon = "";
        
        protected GraphicsManager()
        {
                _widgets = new LinkedList<Widget>();
        }

        /*
         * 
         * Screen and window methods.
         * 
         */
        
        /** Gets the width and height of the display screen in pixels. */
        public abstract Dimension getScreenSize();
        
        /**
         * Gets the pixel location of the top-left corner of the window drawing area
         * in screen-relative coordinates.
         */
        public abstract Point getWindowLocation();
        
        /**
         * Sets the pixel location of the top-left corner of the window drawing area
         * in screen-relative coordinates.
         */
        public abstract void setWindowLocation(Point p);

        /** Gets the dimensions of window drawing area. */
        public abstract Dimension getWindowSize();
        
        /** Sets the dimensions of window drawing area. */
        public abstract void setWindowSize(Dimension d);
        
        /** Tries to focus the window. */
        public abstract void requestFocus();
        
        /** Tells the GraphicsManager which icon to use for the window. */
        public static final void setWindowIcon(String filename)
        {
                if (_windowIcon == "") {
                        _windowIcon = filename;
                }
        }
        
        /** Should be called by the platform-specific graphics manager to set the window's icon. */
        protected void setWindowIcon()
        {
                // set up the image used for the icon
            try
        {
          URL iconURL = ClassLoader.getSystemResource(_windowIcon);
          if (iconURL != null)
          {
            Image localImage = Image.getImage(iconURL);
            setWindowIcon(localImage);
          }
        }
        catch (Exception e)
        {
          e.printStackTrace();
        }
        }
        
        /** Sets the window's icon to the given image. */
        protected abstract void setWindowIcon(Image image);
        
        /** Sets the title text for the window. */
        public abstract void setWindowTitle(String title);
        
        /** Returns whether or not the window is capable of going fullscreen. */
        public abstract boolean canGoFullscreen();
        
        /** Returns whether or not the window is currently in fullscreen mode. */
        public abstract boolean isFullscreen();
        
        /** Tells the window to enter fullscreen mode. */
        public abstract void goFullscreen();
        
        /** Tells the window to leave fullscreen mode. */
        public abstract void exitFullscreen();
        
        /*
         * 
         * Drawing-surface methods.
         * 
         */
        
        /** Gets the platform-specific sub-typed surface stack. */
        protected abstract GraphicsSurfaceStack<?> getGraphicsSurfaceStack();
        
        /** Puts the given image on top of the drawing stack, making it the current rendering surface. */
        public void pushDrawingSurface(Image image)
        {
                getGraphicsSurfaceStack().push(image);
        }
        
        /** Removes a rendering surface from the drawing stack. */
        public Image popDrawingSurface()
        {
                return getGraphicsSurfaceStack().pop();
        }
        
        /** Pushes a new clip onto the stack, ensuring that it is a sub-area of the top of the stack. */
        public EnforcedClipKey pushClip(Clip clip)
        {
                return getGraphicsSurfaceStack().pushClip(clip);
        }
        
        /** Pops the top of the current clip-stack if there given key corresponds to it. */
        public Clip popClip(EnforcedClipKey key)
        {
                return getGraphicsSurfaceStack().popClip(key);
        }
        
        /** Returns a copy of the top of the current clip-stack. */
        public Clip peekClip()
        {
                return getGraphicsSurfaceStack().peekClip();
        }
        
        /** Gets the size of the current drawing surface. */
        public abstract Dimension getCurrentDrawingSurfaceSize();
        
        /** Sets the global compositing alpha value for the current rendering surface. */
        public abstract void setCompositeAlpha(float alpha);
        
        /** Sets whether antialiased rendering should be used on the current surface. */
        public abstract void setAntialiasing(boolean on);
        
        public abstract void setTransientAntialiasingOn();
        public abstract void setTransientAntialiasingOff();
        
        /** Sets the default font for the current rendering surface. */
        public abstract void setFont(Font font);
        
        /*
         * 
         * Image-drawing methods.
         * 
         */
        
        /** Draws the given image at its natural size at the given location. */
        public void drawImage(Image image, Point topLeft)
        {
                drawImage(image, topLeft, null);
        }
        
        /** Draws the given image at the given size. */
        public void drawImage(Image image, Point topLeft, Dimension size)
        {
                drawImage(image, topLeft, size, 0.0f);
        }
        
        /** Draws the given image rotated about its top-left corner by the given angle. */
        public void drawImage(Image image, Point topLeft, Dimension size, double angle)
        {
                drawImage(image, topLeft, size, angle, null, null);
        }
        
        /** Draws the given cropped area of the given image. */
        public abstract void drawImage(Image image, Point topLeft, Dimension size, double angle, Point cropTopLeft, Dimension cropSize);
        
        /*
         * 
         * Shape-drawing methods.
         * 
         */
        
        /** Completely fills the current surface with the specified colour. */
        public void clear(Colour colour)
        {
                // Can't clear to no colour
                if (colour == null) {
                        return;
                }
                
                Dimension fullSurface = getCurrentDrawingSurfaceSize();
                Fill fill = new Fill(colour);
                
                drawRectangle(new Point(0, 0), fullSurface, 0.0, fill, null, null, null);
        }
        
        /** Draws the given rectangle. */
        public void drawRectangle(AxisAlignedBoxBounds rect, double angle, Fill fill, Colour borderColour, Stroke borderStroke, Dimension cornerRadius)
        {
                if (rect == null) {
                        return;
                }
                
                drawRectangle(rect.getTopLeft(), rect.getSize(), angle, fill, borderColour, borderStroke, cornerRadius);
        }
        
        /** Draws a rectangle specified by the given top-left corner and dimensions. */
        public abstract void drawRectangle(Point topLeft, Dimension size, double angle, Fill fill, Colour borderColour, Stroke borderStroke, Dimension cornerRadius);
        
        /** Draws the given ellipse. */
        public void drawOval(EllipticalBounds oval, double angle, Fill fill, Colour borderColour, Stroke borderStroke)
        {
                if (oval == null) {
                        return;
                }
                
                drawOval(oval.getCentre(), oval.getDiameters(), angle, fill, borderColour, borderStroke);
        }
        
        /** Draws an oval defined by the given centre-point and diameters. */
        public abstract void drawOval(Point centre, Dimension diameters, double angle, Fill fill, Colour borderColour, Stroke borderStroke);
        
        /** Draws a polygon. Fills the closed area but strokes the open line. */
        public abstract void drawPolygon(PolygonBounds points, Point offset, Dimension scale, double angle, Fill fill, Colour borderColour, Stroke borderStroke);
        
        /** Draws the given line. */
        public void drawLine(Line line, Colour colour, Stroke stroke)
        {
                if (line == null) {
                        return;
                }
                
                drawLine(line.getFirstEnd(), line.getSecondEnd(), colour, stroke);
        }
        
        /** Draws a line defined by two end points. */
        public void drawLine(Point p1, Point p2, Colour colour, Stroke stroke)
        {
                if (p1 == null || p2 == null) {
                        return;
                }
                
                drawLine(p1.getX(), p1.getY(), p2.getX(), p2.getY(), colour, stroke);
        }
        
        /** Draws a line defined by two end points. */
        public abstract void drawLine(int x1, int y1, int x2, int y2, Colour colour, Stroke stroke);
        
        /*
         * 
         * Text-drawing methods.
         * 
         */
        
        /** Draws the given string. */
        public abstract void drawString(String string, Point position, Font font, Colour colour);
        
        /** Draws the text in the given text-layout. */
        public void drawTextLayout(TextLayout layout, Point position, Colour colour)
        {
                drawString(layout.getLine(), position, layout.getFont(), colour);
        }
        
        /*
         * 
         * Cursor-graphics methods.
         * 
         */

        /** TODO: Comment. cts16 */
        public abstract void setCursor(Cursor cursor);

        /** TODO: Comment. cts16 */
        public abstract Dimension getBestCursorSize(Dimension desiredSize);
        
        /*
         * 
         * Dialog box methods.
         * 
         */

        /** TODO: Comment. cts16 */
        public abstract boolean showDialog(String title, String message);
        
        /*
         * 
         * Widget methods.
         * 
         */
        
        /** TODO: Comment. cts16 */
        protected List<Widget> _widgets;
        
        /** TODO: Comment. cts16 */
        public boolean addInteractiveWidget(Widget iw)
        {
                if (iw == null) {
                        return false;
                }
                
                return _widgets.add(iw);
        }
        
        /** TODO: Comment. cts16 */
        public boolean removeInteractiveWidget(Widget iw)
        {
                if (iw == null) {
                        return false;
                }
                
                return _widgets.remove(iw);
        }

        /**
         * Acquire the height of text produced using this font.
         * @param font
         * @return
         */
        public abstract int getFontHeight(final Font font);
}