/*

 * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 *   - Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 *

 *   - Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in the

 *     documentation and/or other materials provided with the distribution.

 *

 *   - Neither the name of Oracle nor the names of its

 *     contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS

 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

/*

 * This source code is provided to illustrate the usage of a given feature

 * or technique and has been deliberately simplified. Additional steps

 * required for a production-quality application, such as security checks,

 * input validation and proper error handling, might not be present in

 * this sample code.

 */

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Cursor;

import java.awt.Dimension;

import java.awt.Font;

import java.awt.FontMetrics;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.GraphicsConfiguration;

import java.awt.GraphicsEnvironment;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.RenderingHints;

import java.awt.Toolkit;

import java.awt.event.AdjustmentEvent;

import java.awt.event.AdjustmentListener;

import java.awt.event.ComponentAdapter;

import java.awt.event.ComponentEvent;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import java.awt.event.MouseMotionListener;

import java.awt.font.FontRenderContext;

import java.awt.font.GlyphVector;

import java.awt.font.LineBreakMeasurer;

import java.awt.font.TextLayout;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.awt.print.PageFormat;

import java.awt.print.Printable;

import java.awt.print.PrinterJob;

import java.io.BufferedOutputStream;

import java.io.FileOutputStream;

import java.text.AttributedString;

import java.util.EnumSet;

import java.util.Vector;

import javax.imageio.*;

import javax.swing.*;

import static java.awt.RenderingHints.*;

/**

 * FontPanel.java

 *

 * @author Shinsuke Fukuda

 * @author Ankit Patel [Conversion to Swing - 01/07/30]

 */

/// This panel is combination of the text drawing area of Font2DTest

/// and the custom controlled scroll bar

public final class FontPanel extends JPanel implements AdjustmentListener {

    /// Drawing Option Constants

    private final String STYLES[] =

      { "plain", "bold", "italic", "bold italic" };

    private final int NONE = 0;

    private final int SCALE = 1;

    private final int SHEAR = 2;

    private final int ROTATE = 3;

    private final String TRANSFORMS[] =

      { "with no transforms", "with scaling", "with Shearing", "with rotation" };

    private final int DRAW_STRING = 0;

    private final int DRAW_CHARS = 1;

    private final int DRAW_BYTES = 2;

    private final int DRAW_GLYPHV = 3;

    private final int TL_DRAW = 4;

    private final int GV_OUTLINE = 5;

    private final int TL_OUTLINE = 6;

    private final String METHODS[] = {

        "drawString", "drawChars", "drawBytes", "drawGlyphVector",

        "TextLayout.draw", "GlyphVector.getOutline", "TextLayout.getOutline" };

    public final int RANGE_TEXT = 0;

    public final int ALL_GLYPHS = 1;

    public final int USER_TEXT = 2;

    public final int FILE_TEXT = 3;

    private final String MS_OPENING[] =

      { " Unicode ", " Glyph Code ", " lines ", " lines " };

    private final String MS_CLOSING[] =

      { "", "", " of User Text ", " of LineBreakMeasurer-reformatted Text " };

    /// General Graphics Variable

    private final JScrollBar verticalBar;

    private final FontCanvas fc;

    private boolean updateBackBuffer = true;

    private boolean updateFontMetrics = true;

    private boolean updateFont = true;

    private boolean force16Cols = false;

    public boolean showingError = false;

    private int g2Transform = NONE; /// ABP

    /// Printing constants and variables

    public final int ONE_PAGE = 0;

    public final int CUR_RANGE = 1;

    public final int ALL_TEXT = 2;

    private int printMode = ONE_PAGE;

    private PageFormat page = null;

    private PrinterJob printer = null;

    /// Text drawing variables

    private String fontName = "Dialog";

    private float fontSize = 12;

    private int fontStyle = Font.PLAIN;

    private int fontTransform = NONE;

    private Font testFont = null;

    private Object antiAliasType = VALUE_TEXT_ANTIALIAS_DEFAULT;

    private Object fractionalMetricsType = VALUE_FRACTIONALMETRICS_DEFAULT;

    private Object lcdContrast = getDefaultLCDContrast();

    private int drawMethod = DRAW_STRING;

    private int textToUse = RANGE_TEXT;

    private String userText[] = null;

    private String fileText[] = null;

    private int drawRange[] = { 0x0000, 0x007f };

    private String fontInfos[] = new String[2];

    private boolean showGrid = true;

    /// Parent Font2DTest panel

    private final Font2DTest f2dt;

    private final JFrame parent;

    public FontPanel( Font2DTest demo, JFrame f ) {

        f2dt = demo;

        parent = f;

        verticalBar = new JScrollBar ( JScrollBar.VERTICAL );

        fc = new FontCanvas();

        this.setLayout( new BorderLayout() );

        this.add( "Center", fc );

        this.add( "East", verticalBar );

        verticalBar.addAdjustmentListener( this );

        this.addComponentListener( new ComponentAdapter() {

            public void componentResized( ComponentEvent e ) {

                updateBackBuffer = true;

                updateFontMetrics = true;

            }

        });

        /// Initialize font and its infos

        testFont = new Font(fontName, fontStyle, (int)fontSize);

        if ((float)((int)fontSize) != fontSize) {

            testFont = testFont.deriveFont(fontSize);

        }

        updateFontInfo();

    }

    public Dimension getPreferredSize() {

        return new Dimension(600, 200);

    }

    /// Functions called by the main programs to set the various parameters

    public void setTransformG2( int transform ) {

        g2Transform = transform;

        updateBackBuffer = true;

        updateFontMetrics = true;

        fc.repaint();

    }

    /// convenience fcn to create AffineTransform of appropriate type

    private AffineTransform getAffineTransform( int transform ) {

            /// ABP

            AffineTransform at = new AffineTransform();

            switch ( transform )

            {

            case SCALE:

              at.setToScale( 1.5f, 1.5f ); break;

            case ROTATE:

              at.setToRotation( Math.PI / 6 ); break;

            case SHEAR:

              at.setToShear( 0.4f, 0 ); break;

            case NONE:

              break;

            default:

              //System.err.println( "Illegal G2 Transform Arg: " + transform);

              break;

            }

            return at;

    }

    public void setFontParams(Object obj, float size,

                              int style, int transform) {

        setFontParams( (String)obj, size, style, transform );

    }

    public void setFontParams(String name, float size,

                              int style, int transform) {

        boolean fontModified = false;

        if ( !name.equals( fontName ) || style != fontStyle )

          fontModified = true;

        fontName = name;

        fontSize = size;

        fontStyle = style;

        fontTransform = transform;

        /// Recreate the font as specified

        testFont = new Font(fontName, fontStyle, (int)fontSize);

        if ((float)((int)fontSize) != fontSize) {

            testFont = testFont.deriveFont(fontSize);

        }

        if ( fontTransform != NONE ) {

            AffineTransform at = getAffineTransform( fontTransform );

            testFont = testFont.deriveFont( at );

        }

        updateBackBuffer = true;

        updateFontMetrics = true;

        fc.repaint();

        if ( fontModified ) {

            /// Tell main panel to update the font info

            updateFontInfo();

            f2dt.fireUpdateFontInfo();

        }

    }

    public void setRenderingHints( Object aa, Object fm, Object contrast) {

        antiAliasType = ((AAValues)aa).getHint();

        fractionalMetricsType = ((FMValues)fm).getHint();

        lcdContrast = contrast;

        updateBackBuffer = true;

        updateFontMetrics = true;

        fc.repaint();

    }

    public void setDrawMethod( int i ) {

        drawMethod = i;

        updateBackBuffer = true;

        fc.repaint();

    }

    public void setTextToDraw( int i, int range[],

                               String textSet[], String fileData[] ) {

        textToUse = i;

        if ( textToUse == RANGE_TEXT )

          drawRange = range;

        else if ( textToUse == ALL_GLYPHS )

          drawMethod = DRAW_GLYPHV;

        else if ( textToUse == USER_TEXT )

          userText = textSet;

        else if ( textToUse == FILE_TEXT ) {

            fileText = fileData;

            drawMethod = TL_DRAW;

        }

        updateBackBuffer = true;

        updateFontMetrics = true;

        fc.repaint();

        updateFontInfo();

    }

    public void setGridDisplay( boolean b ) {

        showGrid = b;

        updateBackBuffer = true;

        fc.repaint();

    }

    public void setForce16Columns( boolean b ) {

        force16Cols = b;

        updateBackBuffer = true;

        updateFontMetrics = true;

        fc.repaint();

    }

    /// Prints out the text display area

    public void doPrint( int i ) {

        if ( printer == null ) {

            printer = PrinterJob.getPrinterJob();

            page = printer.defaultPage();

        }

        printMode = i;

        printer.setPrintable( fc, page );

        if ( printer.printDialog() ) {

            try {

                printer.print();

            }

            catch ( Exception e ) {

                f2dt.fireChangeStatus( "ERROR: Printing Failed; See Stack Trace", true );

            }

        }

    }

    /// Displays the page setup dialog and updates PageFormat info

    public void doPageSetup() {

        if ( printer == null ) {

            printer = PrinterJob.getPrinterJob();

            page = printer.defaultPage();

        }

        page = printer.pageDialog( page );

    }

    /// Obtains the information about selected font

    private void updateFontInfo() {

        int numGlyphs = 0, numCharsInRange = drawRange[1] - drawRange[0] + 1;

        fontInfos[0] = "Font Face Name: " + testFont.getFontName();

        fontInfos[1] = "Glyphs in This Range: ";

        if ( textToUse == RANGE_TEXT ) {

            for ( int i = drawRange[0]; i < drawRange[1]; i++ )

              if ( testFont.canDisplay( i ))

                numGlyphs++;

            fontInfos[1] = fontInfos[1] + numGlyphs + " / " + numCharsInRange;

        }

        else

          fontInfos[1] = null;

    }

    /// Accessor for the font information

    public String[] getFontInfo() {

        return fontInfos;

    }

    /// Collects the currectly set options and returns them as string

    public String getCurrentOptions() {

        /// Create a new String to store the options

        /// The array will contain all 8 setting (font name, size...) and

        /// character range or user text data used (no file text data)

        int userTextSize = 0;

        String options;

        options = ( fontName + "\n" + fontSize  + "\n" + fontStyle + "\n" +

                    fontTransform + "\n"  + g2Transform + "\n"+

                    textToUse + "\n" + drawMethod + "\n" +

                    AAValues.getHintVal(antiAliasType) + "\n" +

                    FMValues.getHintVal(fractionalMetricsType) + "\n" +

                    lcdContrast + "\n");

        if ( textToUse == USER_TEXT )

          for ( int i = 0; i < userText.length; i++ )

            options += ( userText[i] + "\n" );

        return options;

    }

    /// Reload all options and refreshes the canvas

    public void loadOptions( boolean grid, boolean force16, int start, int end,

                             String name, float size, int style,

                             int transform, int g2transform,

                             int text, int method, int aa, int fm,

                             int contrast, String user[] ) {

        int range[] = { start, end };

        /// Since repaint call has a low priority, these functions will finish

        /// before the actual repainting is done

        setGridDisplay( grid );

        setForce16Columns( force16 );

        // previous call to readTextFile has already set the text to draw

        if (textToUse != FILE_TEXT) {

          setTextToDraw( text, range, user, null );

        }

        setFontParams( name, size, style, transform );

        setTransformG2( g2transform ); // ABP

        setDrawMethod( method );

        setRenderingHints(AAValues.getValue(aa), FMValues.getValue(fm),

                          new Integer(contrast));

    }

    /// Writes the current screen to PNG file

    public void doSavePNG( String fileName ) {

        fc.writePNG( fileName );

    }

    /// When scrolled using the scroll bar, update the backbuffer

    public void adjustmentValueChanged( AdjustmentEvent e ) {

        updateBackBuffer = true;

        fc.repaint();

    }

    public void paintComponent( Graphics g ) {

        // Windows does not repaint correctly, after

        // a zoom. Thus, we need to force the canvas

        // to repaint, but only once. After the first repaint,

        // everything stabilizes. [ABP]

        fc.repaint();

    }

    /// Inner class definition...

    /// Inner panel that holds the actual drawing area and its routines

    private class FontCanvas extends JPanel implements MouseListener, MouseMotionListener, Printable {

        /// Number of characters that will fit across and down this canvas

        private int numCharAcross, numCharDown;

        /// First and last character/line that will be drawn

        /// Limit is the end of range/text where no more draw will be done

        private int drawStart, drawEnd, drawLimit;

        /// FontMetrics variables

        /// Here, gridWidth is equivalent to maxAdvance (slightly bigger though)

        /// and gridHeight is equivalent to lineHeight

        private int maxAscent, maxDescent, gridWidth = 0, gridHeight = 0;

        /// Offset from the top left edge of the canvas where the draw will start

        private int canvasInset_X = 5, canvasInset_Y = 5;

        /// Offscreen buffer of this canvas

        private BufferedImage backBuffer = null;

        /// LineBreak'ed TextLayout vector

        private Vector lineBreakTLs = null;

        /// Whether the current draw command requested is for printing

        private boolean isPrinting = false;

        /// Other printing infos

        private int lastPage, printPageNumber, currentlyShownChar = 0;

        private final int PR_OFFSET = 10;

        private final int PR_TITLE_LINEHEIGHT = 30;

        /// Information about zooming (used with range text draw)

        private final JWindow zoomWindow;

        private BufferedImage zoomImage = null;

        private int mouseOverCharX = -1, mouseOverCharY = -1;

        private int currMouseOverChar = -1, prevZoomChar = -1;

        private float ZOOM = 2.0f;

        private boolean nowZooming = false;

        private boolean firstTime = true;

// ABP

        /// Status bar message backup

        private String backupStatusString = null;

        /// Error constants

        private final String ERRORS[] = {

            "ERROR: drawBytes cannot handle characters beyond 0x00FF. Select different range or draw methods.",

            "ERROR: Cannot fit text with the current font size. Resize the window or use smaller font size.",

            "ERROR: Cannot print with the current font size. Use smaller font size.",

        };

        private final int DRAW_BYTES_ERROR = 0;

        private final int CANT_FIT_DRAW = 1;

        private final int CANT_FIT_PRINT = 2;

        /// Other variables

        private final Cursor blankCursor;

        public FontCanvas() {

            this.addMouseListener( this );

            this.addMouseMotionListener( this );

            this.setForeground( Color.black );

            this.setBackground( Color.white );

            /// Creates an invisble pointer by giving it bogus image

            /// Possibly find a workaround for this...

            Toolkit tk = Toolkit.getDefaultToolkit();

            byte bogus[] = { (byte) 0 };

            blankCursor =

              tk.createCustomCursor( tk.createImage( bogus ), new Point(0, 0), "" );

            zoomWindow = new JWindow( parent ) {

                public void paint( Graphics g ) {

                    g.drawImage( zoomImage, 0, 0, zoomWindow );

                }

            };

            zoomWindow.setCursor( blankCursor );

            zoomWindow.pack();

        }

        public boolean firstTime() { return firstTime; }

        public void refresh() {

            firstTime = false;

            updateBackBuffer = true;

            repaint();

        }

        /// Sets the font, hints, according to the set parameters

        private void setParams( Graphics2D g2 ) {

            g2.setFont( testFont );

            g2.setRenderingHint(KEY_TEXT_ANTIALIASING, antiAliasType);

            g2.setRenderingHint(KEY_FRACTIONALMETRICS, fractionalMetricsType);

            g2.setRenderingHint(KEY_TEXT_LCD_CONTRAST, lcdContrast);

            /* I am preserving a somewhat dubious behaviour of this program.

             * Outline text would be drawn anti-aliased by setting the

             * graphics anti-aliasing hint if the text anti-aliasing hint

             * was set. The dubious element here is that people simply

             * using this program may think this is built-in behaviour

             * but its not - at least not when the app explicitly draws