/**
 * Copyright (C) 1998-1999 by University of Maryland, College Park, MD 20742, USA
 * All rights reserved.
 */
package edu.umd.cs.piccolox.swt;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.Paint;
import java.awt.geom.*;
import java.util.*;

import org.eclipse.swt.graphics.FontMetrics;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Display;

import edu.umd.cs.piccolo.PNode;
import edu.umd.cs.piccolo.util.PPaintContext;

/**
 * <b>PSWTText</b> creates a visual component to support text. Multiple lines
 * can be entered, and basic editing is supported. A caret is drawn, and can be
 * repositioned with mouse clicks. The text object is positioned so that its
 * upper-left corner is at the origin, though this can be changed with the
 * translate methods.
 * <P>
 * <b>Warning:</b> Serialized and ZSerialized objects of this class will not be
 * compatible with future Jazz releases. The current serialization support is
 * appropriate for short term storage or RMI between applications running the
 * same version of Jazz. A future release of Jazz will provide support for long
 * term persistence.
 */
public class PSWTText extends PNode {

    /**
     * Below this magnification render text as 'greek'.
     */
    static protected final double DEFAULT_GREEK_THRESHOLD = 5.5;

    /**
     * Default color of text rendered as 'greek'.
     */
    static protected final Color DEFAULT_GREEK_COLOR = Color.gray;

    /**
     * Default font name of text.
     */
    static protected final String DEFAULT_FONT_NAME = "Helvetica";

    /**
     * Default font style for text.
     */
    static protected final int DEFAULT_FONT_STYLE = Font.PLAIN;

    /**
     * Default font size for text.
     */
    static protected final int DEFAULT_FONT_SIZE = 12;

    /**
     * Default font for text.
     */
    static protected final Font DEFAULT_FONT = new Font(DEFAULT_FONT_NAME, DEFAULT_FONT_STYLE, DEFAULT_FONT_SIZE);

    /**
     * Default color for text.
     */
    static protected final Color DEFAULT_PEN_COLOR = Color.black;

    /**
     * Default text when new text area is created.
     */
    static protected final String DEFAULT_TEXT = "";

    /**
     * Default padding
     */
    static protected final int DEFAULT_PADDING = 2;

    /**
     * Below this magnification text is rendered as greek.
     */
    protected double greekThreshold = DEFAULT_GREEK_THRESHOLD;

    /**
     * Color for greek text.
     */
    protected Color greekColor = DEFAULT_GREEK_COLOR;

    /**
     * Current pen color.
     */
    protected Color penColor = DEFAULT_PEN_COLOR;

    /**
     * Current text font.
     */
    protected Font font = DEFAULT_FONT;

    /**
     * The amount of padding on each side of the text
     */
    protected int padding = DEFAULT_PADDING;

    /**
     * Each vector element is one line of text.
     */
    protected ArrayList lines = new ArrayList();

    /**
     * Translation offset X.
     */
    protected double translateX = 0.0;

    /**
     * Translation offset Y.
     */
    protected double translateY = 0.0;

    /**
     * Default constructor for PSWTTest.
     */
    public PSWTText() {
        this("", DEFAULT_FONT);
    }

    /**
     * PSWTTest constructor with initial text.
     * 
     * @param str The initial text.
     */
    public PSWTText(String str) {
        this(str, DEFAULT_FONT);
    }

    /**
     * PSWTTest constructor with initial text and font.
     * 
     * @param str The initial text.
     * @param font The font for this PSWTText component.
     */
    public PSWTText(String str, Font font) {
        setText(str);
        this.font = font;

        recomputeBounds();
    }

    //**************************************************************************
    // **
    //
    // Get/Set and pairs
    //
    //**************************************************************************
    // *

    /**
     * Returns the current pen color.
     */
    public Color getPenColor() {
        return penColor;
    }

    /**
     * Sets the current pen color.
     * 
     * @param color use this color.
     */
    public void setPenColor(Color color) {
        penColor = color;
        repaint();
    }

    /**
     * Returns the current pen paint.
     */
    public Paint getPenPaint() {
        return penColor;
    }

    /**
     * Sets the current pen paint.
     * 
     * @param aPaint use this paint.
     */
    public void setPenPaint(Paint aPaint) {
        penColor = (Color) aPaint;
    }

    /**
     * Returns the current background color.
     */
    public Color getBackgroundColor() {
        return (Color) getPaint();
    }

    /**
     * Sets the current background color.
     * 
     * @param color use this color.
     */
    public void setBackgroundColor(Color color) {
        super.setPaint(color);
    }

    /**
     * Returns the current greek threshold. Below this magnification text is
     * rendered as 'greek'.
     */
    public double getGreekThreshold() {
        return greekThreshold;
    }

    /**
     * Sets the current greek threshold. Below this magnification text is
     * rendered as 'greek'.
     * 
     * @param threshold compared to renderContext magnification.
     */
    public void setGreekThreshold(double threshold) {
        greekThreshold = threshold;
        repaint();
    }

    /**
     * Returns the current font.
     */
    public Font getFont() {
        return font;
    }

    /**
     * Return the text within this text component. Multline text is returned as
     * a single string where each line is separated by a newline character.
     * Single line text does not have any newline characters.
     */
    public String getText() {
        String line;
        String result = new String();
        int lineNum = 0;

        for (Iterator i = lines.iterator(); i.hasNext();) {
            if (lineNum > 0) {
                result += '\n';
            }
            line = (String) i.next();
            result += line;
            lineNum++;
        }

        return result;
    }

    /**
     * Sets the font for the text.
     * <p>
     * <b>Warning:</b> Java has a serious bug in that it does not support very
     * small fonts. In particular, fonts that are less than about a pixel high
     * just don't work. Since in Jazz, it is common to create objects of
     * arbitrary sizes, and then scale them, an application can easily create a
     * text object with a very small font by accident. The workaround for this
     * bug is to create a larger font for the text object, and then scale the
     * node down correspondingly.
     * 
     * @param aFont use this font.
     */
    public void setFont(Font aFont) {
        font = aFont;

        recomputeBounds();
    }

    /**
     * Sets the text of this visual component to str. Multiple lines of text are
     * separated by a newline character.
     * 
     * @param str use this string.
     */
    public void setText(String str) {
        int pos = 0;
        int index;
        boolean done = false;
        lines = new ArrayList();
        do {
            index = str.indexOf('\n', pos);
            if (index == -1) {
                lines.add(str);
                done = true;
            }
            else {
                lines.add(str.substring(0, index));
                str = str.substring(index + 1);
            }
        } while (!done);

        recomputeBounds();
    }

    /**
     * Set text translation offset X.
     * 
     * @param x the X translation.
     */
    public void setTranslateX(double x) {
        setTranslation(x, translateY);
    }

    /**
     * Get the X offset translation.
     * 
     * @return the X translation.
     */
    public double getTranslateX() {
        return translateX;
    }

    /**
     * Set text translation offset Y.
     * 
     * @param y the Y translation.
     */
    public void setTranslateY(double y) {
        setTranslation(translateX, y);
    }

    /**
     * Get the Y offset translation.
     * 
     * @return the Y translation.
     */
    public double getTranslateY() {
        return translateY;
    }

    /**
     * Set the text translation offset to the specified position.
     * 
     * @param x the X-coord of translation
     * @param y the Y-coord of translation
     */
    public void setTranslation(double x, double y) {
        translateX = x;
        translateY = y;

        recomputeBounds();
    }

    /**
     * Set the text translation offset to point p.
     * 
     * @param p The translation offset.
     */
    public void setTranslation(Point2D p) {
        setTranslation(p.getX(), p.getY());
    }

    /**
     * Get the text translation offset.
     * 
     * @return The translation offset.
     */
    public Point2D getTranslation() {
        Point2D p = new Point2D.Double(translateX, translateY);
        return p;
    }

    /**
     * Renders the text object.
     * <p>
     * The transform, clip, and composite will be set appropriately when this
     * object is rendered. It is up to this object to restore the transform,
     * clip, and composite of the Graphics2D if this node changes any of them.
     * However, the color, font, and stroke are unspecified by Jazz. This object
     * should set those things if they are used, but they do not need to be
     * restored.
     * 
     * @param ppc Contains information about current render.
     */
    public void paint(PPaintContext ppc) {
        Graphics2D g2 = ppc.getGraphics();
        AffineTransform at = null;
        boolean translated = false;
        if (!lines.isEmpty()) {

            if ((translateX != 0.0) || (translateY != 0.0)) {
                at = g2.getTransform(); // save transform
                g2.translate(translateX, translateY);
                translated = true;
            }

            // If font too small and not antialiased, then greek
            double renderedFontSize = font.getSize() * ppc.getScale();
            // BBB: HACK ALERT - July 30, 1999
            // This is a workaround for a bug in Sun JDK 1.2.2 where
            // fonts that are rendered at very small magnifications show up big!
            // So, we render as greek if requested (that's normal)
            // OR if the font is very small (that's the workaround)
            if ((renderedFontSize < 0.5) || (renderedFontSize < greekThreshold)) {
                paintAsGreek(ppc);
            }
            else {
                paintAsText(ppc);
            }
            if (translated) {
                g2.setTransform(at); // restore transform
            }
        }
    }

    /**
     * Paints this object as greek.
     * 
     * @param ppc The graphics context to paint into.
     */
    public void paintAsGreek(PPaintContext ppc) {
        Graphics2D g2 = ppc.getGraphics();

        if (greekColor != null) {
            g2.setBackground(greekColor);
            ((SWTGraphics2D) g2).fillRect(0, 0, getWidth(), getHeight());
        }
    }

    /**
     * Paints this object normally (show it's text). Note that the entire text
     * gets rendered so that it's upper left corner appears at the origin of
     * this local object.
     * 
     * @param ppc The graphics context to paint into.
     */
    public void paintAsText(PPaintContext ppc) {
        SWTGraphics2D sg2 = (SWTGraphics2D) ppc.getGraphics();

        if (getPaint() != null) {
            sg2.setBackground((Color) getPaint());
            Rectangle2D rect = new Rectangle2D.Double(0.0, 0.0, getWidth(), getHeight());
            sg2.fillRect(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight());
        }

        sg2.translate(padding, padding);

        double scale = Math.min(sg2.getTransform().getScaleX(), sg2.getTransform().getScaleY());
        double dSize = scale * font.getSize();
        double fixupScale = Math.floor(dSize) / dSize;

        // This moves the text size down to the next closest integer size - to
        // help it stay in
        // it's alloted bounds. This is because SWT only supports integer font
        // metrics
        sg2.scale(fixupScale, fixupScale);

        // Render each line of text
        // Note that the entire text gets rendered so that it's upper left
        // corner
        // appears at the origin of this local object.
        sg2.setColor(penColor);
        sg2.setFont(font);

        int lineNum = 0;
        String line;
        double y;

        FontMetrics metrics = sg2.getSWTFontMetrics();

        for (Iterator i = lines.iterator(); i.hasNext();) {
            line = (String) i.next();

            // ADDED BY LEG ON 2/25/03 - BUG CAUSING PROBLEMS AT CERTAIN
            // SCALES WHEN LINE WAS EMPTY
            line = (line.equals("")) ? " " : line;

            y = (lineNum * metrics.getHeight());

            sg2.drawString(line, (double) 0, (double) y);

            lineNum++;
        }

        sg2.scale(1 / fixupScale, 1 / fixupScale);

        sg2.translate(-padding, -padding);
    }

    /**
     * Notifies this object that it has changed and that it should update its
     * notion of its bounding box.
     */
    protected void recomputeBounds() {
        Point bds;
        double lineWidth;
        double maxWidth = 0.0;
        double height;

        height = 0.0;

        boolean hasText = true;
        if ((lines.size() == 1) && (((String) lines.get(0)).equals(""))) {
            hasText = false;
        }

        GC gc = new GC(Display.getDefault());
        SWTGraphics2D g2 = new SWTGraphics2D(gc, Display.getDefault());
        g2.setFont(font);
        FontMetrics fm = g2.getSWTFontMetrics();

        if (!lines.isEmpty() && hasText) {
            String line;
            int lineNum = 0;
            for (Iterator i = lines.iterator(); i.hasNext();) {
                line = (String) i.next();

                // Find the longest line in the text
                bds = gc.stringExtent(line);
                lineWidth = bds.x;

                if (lineWidth > maxWidth) {
                    maxWidth = lineWidth;
                }
                // Find the heighest line in the text
                if (lineNum == 0) {
                    height += fm.getAscent() + fm.getDescent() + fm.getLeading();
                }
                else {
                    height += fm.getHeight();
                }

                lineNum++;
            }
        }
        else {
            // If no text, then we want to have the bounds of a space character,
            // so get those bounds here
            bds = gc.stringExtent(" ");
            maxWidth = bds.x;
            height = bds.y;
        }

        gc.dispose();

        // Finally, set the bounds of this text
        setBounds(translateX, translateY, maxWidth + 2 * DEFAULT_PADDING, height + 2 * DEFAULT_PADDING);
    }

    protected void internalUpdateBounds(double x, double y, double width, double height) {
        recomputeBounds();
    }

}