/*
 * [Proofreader.java]
 *
 * Summary: Display a sample of proofreader font.
 *
 * Copyright: (c) 1998-2017 Roedy Green, Canadian Mind Products, http://mindprod.com
 *
 * Licence: This software may be copied and used freely for any purpose but military.
 *          http://mindprod.com/contact/nonmil.html
 *
 * Requires: JDK 1.8+
 *
 * Created with: JetBrains IntelliJ IDEA IDE http://www.jetbrains.com/idea/
 *
 * Version History:
 *  1.0 1998-07-08 original.
 */
package com.mindprod.proofreader;

import java.awt.Graphics;
import java.awt.Rectangle;

/**
 * Display a sample of proofreader font.
 *
 * @author Roedy Green, Canadian Mind Products
 * @version 1.0 1998-07-08 original.
 * @since 1998-07-08
 */
public class Proofreader
    {
    Graphics gr;

    /* current point, in grid units*/
    int wherex;

    int wherey;

    /* origin of string we are writing in pixels, also origin of current char*/
    int originX;

    int originY;

    /**
     * pixels per grid unit used to define the characters
     */
    int xscale;

    /**
     * pixels per grid unit used to define the characters
     */
    int yscale;

    public Proofreader( Graphics gr, int scale )
        {
        this.gr = gr;
        this.xscale = scale;
        this.yscale = scale;
        }

    /* move to absolute point in current cell. */
    void a( int x, int y )
        {
        wherex = x;
        wherey = y;
        }

    void drawA()
        {
        l( 0, 1 );
        l( 2, 4 );
        l( 2, -4 );
        l( 0, -1 );
        a( 5, 0 );
        }

    void drawB()
        {
        a( 2, 2 );
        e( 2, 2, 'O' );
        a( 0, 6 );
        l( 0, -6 );
        a( 5, 0 );
        }

    void drawBackSlash()
        {
        a( 0, 4 );
        l( 4, -4 );
        a( 5, 0 );
        }

    void drawBang()
        {
        l( 1, 0 );
        l( 0, 1 );
        l( -1, 0 );
        l( 0, -1 );
        a( 0, 2 );
        l( 1, 0 );
        l( 0, 4 );
        l( -1, 0 );
        l( 0, -4 );
        a( 2, 0 );
        }

    void drawC()
        {
        a( 2, 2 );
        e( 2, 2, 'C' );
        a( 3, 4 );
        l( -1, 0 );
        a( 3, 0 );
        l( -1, 0 );
        a( 4, 0 );
        }

    void drawColon()
        {
        l( 0, 1 );
        l( 1, 0 );
        l( 0, -1 );
        l( -1, 0 );
        a( 0, 4 );
        l( 0, 1 );
        l( 1, 0 );
        l( 0, -1 );
        l( -1, 0 );
        a( 3, 0 );
        }

    void drawComma()
        {
        l( 0, 1 );
        l( 1, 0 );
        l( 0, -1 );
        l( -1, 0 );
        a( 1, 0 );
        l( 0, -1 );
        l( -1, -1 );
        a( 3, 0 );
        }

    void drawD()
        {
        a( 2, 2 );
        e( 2, 2, 'O' );
        a( 4, 6 );
        l( 0, -6 );
        a( 6, 0 );
        }

    void drawDoubleQuot()
        {
        a( 0, 6 );
        l( 1, 0 );
        l( 0, -1 );
        l( -1, 0 );
        l( 0, 1 );
        a( 3, 6 );
        l( 1, 0 );
        l( 0, -1 );
        l( -1, 0 );
        l( 0, 1 );
        a( 0, 6 );
        l( 4, 0 );
        a( 5, 0 );
        }

    void drawE()
        {
        a( 2, 2 );
        e( 2, 3, 'C' );
        a( 3, 5 );
        l( -1, 0 );
        a( 3, -1 );
        l( -1, 0 );
        a( 2, 2 );
        l( -2, 0 );
        a( 4, 0 );
        }

    void drawEight()
        {
        /* backward N */
        a( 0, 4 );
        l( 0, -4 );
        l( 4, 4 );
        l( 0, -4 );
        a( 6, 0 );
        }

    void drawF()
        {
        a( 1, 2 );
        e( 2, 3, 'D' );
        a( 0, 5 );
        l( 1, 0 );
        a( 1, 2 );
        l( 3, 0 );
        a( 0, -1 );
        l( 1, 0 );
        a( 6, 0 );
        }

    void drawFive()
        {     /* backward 4 */
        g( 0, -2 );
        l( 0, 5 );
        g( 0, -2 );
        l( 3, 0 );
        l( 0, 3 );
        a( 5, 0 );
        }

    void drawFour()
        {
        /* 4 */
        a( 0, 4 );
        l( 0, -3 );
        l( 3, 0 );
        g( 0, 2 );
        l( 0, -5 );
        a( 5, 0 );
        }

    void drawG()
        {
        a( 2, 2 );
        e( 2, 2, 'o' );
        a( 4, -2 );
        l( 0, 8 );
        a( 6, 0 );
        }

    void drawGrave()
        {
        a( 0, 6 );
        l( 3, -2 );
        l( 1, 0 );
        a( 5, 0 );
        }

    void drawH()
        {
        l( 0, 4 );
        a( 0, 2 );
        l( 4, 0 );
        g( 0, 2 );
        l( 0, -4 );
        a( 6, 0 );
        }

    void drawI()
        {
        a( 3, 0 );
        l( 0, 4 );
        l( -3, 0 );
        a( 4, 0 );
        }

    void drawJ()
        {
        a( 0, -1 );
        l( 3, 1 );
        l( 0, 4 );
        a( 4, 0 );
        }

    void drawK()
        {
        a( 1, 2 );
        e( 2, 2, 'D' );
        a( 0, 4 );
        l( 1, 0 );
        a( 0, 0 );
        l( 1, 0 );
        a( 5, 0 );
        }

    void drawL()
        {
        a( 0, 4 );
        l( 0, -4 );
        l( 3, 0 );
        a( 4, 0 );
        }

    void drawLeftBrace()
        {
        a( 2, -2 );
        l( -1, 0 );
        l( 0, 3 );
        l( -1, 1 );
        l( 1, 1 );
        l( 0, 3 );
        l( 1, 0 );
        a( 3, 0 );
        }

    void drawLeftDoubleQuot()
        {
        a( 0, 4 );
        l( 1, 0 );
        l( 0, -1 );
        l( -1, 0 );
        l( 0, 1 );
        a( 3, 4 );
        l( 1, 0 );
        l( 0, -1 );
        l( -1, 0 );
        l( 0, 1 );
        a( 0, 3 );
        l( 4, 0 );
        a( 0, 4 );
        l( 0, 1 );
        l( 1, 1 );
        a( 3, 4 );
        l( 0, 1 );
        l( 1, 1 );
        a( 5, 0 );
        }

    void drawLeftParen()
        {
        a( 2, 2 );
        e( 2, 3, 'C' );
        a( 4, 0 );
        }

    void drawLeftSingleQuot()
        {
        a( 0, 4 );
        l( 1, 0 );
        l( 0, -1 );
        l( -1, 0 );
        l( 0, 1 );
        a( 0, 4 );
        l( 0, 1 );
        l( 1, 1 );
        a( 2, 0 );
        }

    void drawM()
        {
        a( 1, 0 );
        l( 0, 4 );
        l( 4, 0 );
        l( 0, -4 );
        a( 3, 5 );
        l( 0, -2 );
        a( 7, 0 );
        }

    void drawN()
        {
        l( 0, 2 );
        a( 2, 2 );
        e( 2, 2, 'n' );
        a( 4, 0 );
        l( 0, 2 );
        a( 5, 0 );
        }

    void drawNine()
        {
        /* N */
        l( 0, 4 );
        l( 4, -4 );
        l( 0, 4 );
        a( 6, 0 );
        }

    void drawO()
        {
        a( 2, 2 );
        e( 2, 2, 'O' );
        a( 5, 0 );
        }

    void drawOne()
        {
        /* one with left top tab */
        l( 4, 0 );
        g( -2, 0 );
        l( 0, 4 );
        l( -2, 0 );
        a( 5, 0 );
        }

    void drawP()
        {
        a( 2, 2 );
        e( 2, 2, 'o' );
        a( 0, -2 );
        l( 0, 6 );
        a( 5, 0 );
        }

    void drawPeriod()
        {
        l( 0, 1 );
        l( 1, 0 );
        l( 0, -1 );
        l( -1, 0 );
        a( 3, 0 );
        }

    void drawQ()
        {
        a( 2, 2 );
        e( 2, 2, 'o' );
        a( 4, -2 );
        l( 0, 6 );
        a( 5, 0 );
        }

    void drawR()
        {
        l( 0, 4 );
        l( 3, 1 );
        a( 4, 0 );
        }

    void drawRightBrace()
        {
        a( 0, -2 );
        l( 1, 0 );
        l( 0, 3 );
        l( 1, 1 );
        l( -1, 1 );
        l( 0, 3 );
        l( -1, 0 );
        a( 3, 0 );
        }

    void drawRightBracket()
        {
        a( 0, -1 );
        l( 1, 0 );
        l( 0, 6 );
        l( -1, 0 );
        a( 2, 0 );
        }

    void drawRightDoubleQuot()
        {
        a( 0, 6 );
        l( 1, 0 );
        l( 0, -1 );
        l( -1, 0 );
        l( 0, 1 );
        a( 3, 6 );
        l( 1, 0 );
        l( 0, -1 );
        l( -1, 0 );
        l( 0, 1 );
        a( 0, 6 );
        l( 4, 0 );
        a( 1, 5 );
        l( 0, -1 );
        l( -1, -1 );
        a( 4, 5 );
        l( 0, -1 );
        l( -1, -1 );
        a( 5, 0 );
        }

    void drawRightParen()
        {
        a( 0, 2 );
        e( 2, 3, 'D' );
        a( 4, 0 );
        }

    void drawRightSingleQuot()
        {
        a( 0, 6 );
        l( 1, 0 );
        l( 0, -1 );
        l( -1, 0 );
        l( 0, 1 );
        a( 1, 5 );
        l( 0, -1 );
        l( -1, -1 );
        a( 2, 0 );
        }

    void drawS()
        {
        a( 0, -2 );
        l( 4, 2 );
        l( -4, 4 );
        l( 4, 2 );
        a( 5, 0 );
        }

    void drawSemicolon()
        {
        l( 0, 1 );
        l( 1, 0 );
        l( 0, -1 );
        l( -1, 0 );
        a( 1, 0 );
        l( 0, -1 );
        l( -1, -1 );
        a( 0, 4 );
        l( 0, 1 );
        l( 1, 0 );
        l( 0, -1 );
        l( -1, 0 );
        a( 3, 0 );
        }

    void drawSeven()
        { /* backward h */
        a( 2, 2 );
        e( 2, 2, 'n' );
        a( 0, 0 );
        l( 0, 2 );
        a( 4, 0 );
        l( 0, 6 );
        a( 6, 0 );
        }

    void drawSingleQuot()
        {
        a( 0, 6 );
        l( 1, 0 );
        l( 0, -1 );
        l( -1, 0 );
        l( 0, 1 );
        a( 2, 0 );
        }

    void drawSix()
        {
        /* h=hex */
        a( 2, 2 );
        e( 2, 2, 'n' );
        a( 0, 0 );
        l( 0, 6 );
        a( 4, 0 );
        l( 0, 2 );
        a( 6, 0 );
        }

    void drawSlash()
        {
        l( 4, 4 );
        a( 5, 0 );
        }

    void drawSpace()
        {
        a( 3, 0 );
        }

    /* draw a string in proofreader font at given pixel location */
    void drawString( String s, int originX, int originY )
        {
        this.originX = originX;
        this.originY = originY;
        wherex = wherey = 0;
        for ( int i = 0; i < s.length(); i++ )
            {
            char c = s.charAt( i );
            switch ( c )
                {
                case '/':
                    drawSlash();
                    break;
                case '\\':
                    drawBackSlash();
                    break;
                case '|':
                    drawVert();
                    break;
                case '!':
                    drawBang();
                    break;
                case '{':
                    drawLeftBrace();
                    break;
                case '}':
                    drawRightBrace();
                    break;
                case '(':
                    drawLeftParen();
                    break;
                case ')':
                    drawRightParen();
                    break;
                case '[':
                    drawleftBracket();
                    break;
                case ']':
                    drawRightBracket();
                    break;
                case ' ':
                    drawSpace();
                    break;
                case '.':
                    drawPeriod();
                    break;
                case ',':
                    drawComma();
                    break;
                case ';':
                    drawSemicolon();
                    break;
                case ':':
                    drawColon();
                    break;
                case '\'':
                    drawSingleQuot();
                    break;
                case '\"':
                    drawDoubleQuot();
                    break;
                case '\u2018':
                    drawLeftSingleQuot();
                    break;
                case '\u2019':
                    drawRightSingleQuot();
                    break;
                case '\u201c':
                    drawLeftDoubleQuot();
                    break;
                case '\u201d':
                    drawRightDoubleQuot();
                    break;
                case '`':
                    drawGrave();
                    break;
                case 'a':
                    drawA();
                    break;
                case 'A':
                    a( 0, 7 );
                    l( 4, 0 );
                    a( 0, 0 );
                    drawA();
                    break;
                case 'b':
                    drawB();
                    break;
                case 'B':
                    a( 0, 7 );
                    l( 4, 0 );
                    a( 0, 0 );
                    drawB();
                    break;
                case 'c':
                    drawC();
                    break;
                case 'C':
                    a( 0, 7 );
                    l( 3, 0 );
                    a( 0, 0 );
                    drawC();
                    break;
                case 'd':
                    drawD();
                    break;
                case 'D':
                    a( 0, 7 );
                    l( 5, 0 );
                    a( 0, 0 );
                    drawD();
                    break;
                case 'e':
                    drawE();
                    break;
                case 'E':
                    a( 0, 7 );
                    l( 3, 0 );
                    a( 0, 0 );
                    drawE();
                    break;
                case 'f':
                    drawF();
                    break;
                case 'F':
                    a( 0, 7 );
                    l( 4, 0 );
                    a( 0, 0 );
                    drawF();
                    break;
                case 'g':
                    drawG();
                    break;
                case 'G':
                    a( 0, 7 );
                    l( 5, 0 );
                    a( 0, 0 );
                    drawG();
                    break;
                case 'h':
                    drawH();
                    break;
                case 'H':
                    a( 0, 7 );
                    l( 5, 0 );
                    a( 0, 0 );
                    drawH();
                    break;
                case 'i':
                    drawI();
                    break;
                case 'I':
                    a( 0, 7 );
                    l( 3, 0 );
                    a( 0, 0 );
                    drawI();
                    break;
                case 'j':
                    drawJ();
                    break;
                case 'J':
                    a( 0, 7 );
                    l( 3, 0 );
                    a( 0, 0 );
                    drawJ();
                    break;
                case 'k':
                    drawK();
                    break;
                case 'K':
                    a( 0, 7 );
                    l( 4, 0 );
                    a( 0, 0 );
                    drawK();
                    break;
                case 'l':
                    drawL();
                    break;
                case 'L':
                    a( 0, 7 );
                    l( 3, 0 );
                    a( 0, 0 );
                    drawL();
                    break;
                case 'm':
                    drawM();
                    break;
                case 'M':
                    a( 0, 7 );
                    l( 4, 0 );
                    a( 0, 0 );
                    drawM();
                    break;
                case 'n':
                    drawN();
                    break;
                case 'N':
                    a( 0, 7 );
                    l( 4, 0 );
                    a( 0, 0 );
                    drawN();
                    break;
                case 'o':
                    drawO();
                    break;
                case 'O':
                    a( 0, 7 );
                    l( 4, 0 );
                    a( 0, 0 );
                    drawO();
                    break;
                case 'p':
                    drawP();
                    break;
                case 'P':
                    a( 0, 7 );
                    l( 4, 0 );
                    a( 0, 0 );
                    drawP();
                    break;
                case 'q':
                    drawQ();
                    break;
                case 'Q':
                    a( 0, 7 );
                    l( 4, 0 );
                    a( 0, 0 );
                    drawQ();
                    break;
                case 'r':
                    drawR();
                    break;
                case 'R':
                    a( 0, 7 );
                    l( 3, 0 );
                    a( 0, 0 );
                    drawR();
                    break;
                case 's':
                    drawS();
                    break;
                case 'S':
                    a( 0, 7 );
                    l( 4, 0 );
                    a( 0, 0 );
                    drawS();
                    break;
                case 't':
                    drawT();
                    break;
                case 'T':
                    a( 0, 7 );
                    l( 4, 0 );
                    a( 0, 0 );
                    drawT();
                    break;
                case 'u':
                    drawU();
                    break;
                case 'U':
                    a( 0, 7 );
                    l( 4, 0 );
                    a( 0, 0 );
                    drawU();
                    break;
                case 'v':
                    drawV();
                    break;
                case 'V':
                    a( 0, 7 );
                    l( 4, 0 );
                    a( 0, 0 );
                    drawV();
                    break;
                case 'w':
                    drawW();
                    break;
                case 'W':
                    a( 0, 7 );
                    l( 4, 0 );
                    a( 0, 0 );
                    drawW();
                    break;
                case 'x':
                    drawX();
                    break;
                case 'X':
                    a( 0, 7 );
                    l( 4, 0 );
                    a( 0, 0 );
                    drawX();
                    break;
                case 'y':
                    drawY();
                    break;
                case 'Y':
                    a( 0, 7 );
                    l( 4, 0 );
                    a( 0, 0 );
                    drawY();
                    break;
                case 'z':
                    drawZ();
                    break;
                case 'Z':
                    a( 0, 7 );
                    l( 4, 0 );
                    a( 0, 0 );
                    drawZ();
                    break;
                case '0':
                    drawZero();
                    break;
                case '1':
                    drawOne();
                    break;
                case '2':
                    drawTwo();
                    break;
                case '3':
                    drawThree();
                    break;
                case '4':
                    drawFour();
                    break;
                case '5':
                    drawFive();
                    break;
                case '6':
                    drawSix();
                    break;
                case '7':
                    drawSeven();
                    break;
                case '8':
                    drawEight();
                    break;
                case '9':
                    drawNine();
                    break;
                default:
                    drawPeriod();
                    break;
                }
            // set origin for next character.
            this.originX = toXPixel( wherex ) + 1;
            this.originY = toYPixel( wherey );
            this.wherex = 0;
            this.wherey = 0;
            } // end for
        }

    void drawT()
        {
        a( 2, 0 );
        l( 0, 6 );
        g( -2, -2 );
        l( 4, 0 );
        a( 5, 0 );
        }

    void drawThree()
        {
        /* upside down T */
        l( 4, 0 );
        g( -2, 0 );
        l( 0, 4 );
        a( 5, 0 );
        }

    void drawTwo()
        {
        /* one with right top tab */
        l( 4, 0 );
        g( -2, 0 );
        l( 0, 4 );
        l( 2, 0 );
        a( 5, 0 );
        }

    void drawU()
        {
        a( 2, 2 );
        e( 2, 2, 'u' );
        a( 0, 2 );
        l( 0, 2 );
        a( 4, 2 );
        l( 0, 2 );
        a( 5, 0 );
        }

    void drawV()
        {
        a( 0, 5 );
        l( 0, -1 );
        l( 2, -4 );
        l( 2, 4 );
        l( 0, 1 );
        a( 5, 0 );
        }

    void drawVert()
        {
        g( 0, -2 );
        l( 0, 8 );
        a( 1, 0 );
        }

    void drawW()
        {
        a( 1, 4 );
        l( 0, -4 );
        l( 4, 0 );
        l( 0, 4 );
        a( 3, 2 );
        l( 0, -2 );
        a( 7, 0 );
        }

    void drawX()
        {
        l( 4, 4 );
        a( 0, 4 );
        l( 4, -4 );
        a( 5, 0 );
        }

    void drawY()
        {
        a( 0, 4 );
        l( 2, -2 );
        l( 2, 2 );
        a( 2, 2 );
        l( 0, -2 );
        a( 0, 4 );
        l( 0, 1 );
        a( 4, 4 );
        l( 0, 1 );
        a( 5, 0 );
        }

    void drawZ()
        {
        a( 0, 6 );
        l( 4, -2 );
        l( -4, -4 );
        l( 4, -2 );
        a( 5, 0 );
        }

    void drawZero()
        {
        /* square O */
        l( 4, 0 );
        l( 0, 4 );
        l( -4, 0 );
        l( 0, -4 );
        a( 5, 0 );
        }

    void drawleftBracket()
        {
        a( 1, -1 );
        l( -1, 0 );
        l( 0, 6 );
        l( 1, 0 );
        a( 2, 0 );
        }

    /**
     * elipse centred on current point, size x, y
     *
     * @param x     radius in x direction
     * @param y     radius in y direction
     * @param shape letter C U D n O to indicate which half ellipse wanted.
     */
    void e( int x, int y, char shape )
        {
        switch ( shape )
            {
            case 'C':
            case 'c':
                gr.setClip( new Rectangle(/* upper left */ toXPixel( wherex - x ), toYPixel( wherey + y ), x * xscale + 1, 2 * y * yscale + 1 ) );
                break;
            case 'D':
                gr.setClip( new Rectangle(/* upper left */ toXPixel( wherex ), toYPixel( wherey + y ), x * xscale + 1, 2 * y * yscale + 1 ) );
                break;
            case 'U':
            case 'u':
                gr.setClip( new Rectangle(/* upper left */ toXPixel( wherex - x ), toYPixel( wherey ), x * xscale * 2 + 1, y * yscale + 1 ) );
                break;
            case 'n':
                gr.setClip( new Rectangle(/* upper left */ toXPixel( wherex - x ), toYPixel( wherey + y ), x * xscale * 2 + 1, y * yscale + 1 ) );
                break;
            case 'O':
            case 'o':
            default:
                /* draw full oval */
                gr.setClip( null );
                break;
            }
        // drawOval wants upper left corner, not center.
        gr.drawOval( toXPixel( wherex - x ), toYPixel( wherey + y ), x * xscale * 2, y * yscale * 2 );
        gr.setClip( null );
        }

    /* move relative to current point by x: case  y */
    void g( int x, int y )
        {
        wherex += x;
        wherey += y;
        }

    /**
     * draw line.
     * Starts at current point. Moves current point to end of line
     *
     * @param x relative length in x direction
     * @param y relative length in y direction
     */
    void l( int x, int y )
        {
        gr.drawLine( toXPixel( wherex ), toYPixel( wherey ), toXPixel( wherex + x ), toYPixel( wherey + y ) );
        wherex += x;
        wherey += y;
        }

    /* rectangle centred on current point, size x, y,
     * current point unchanged
     */
    void r( int x, int y )
        {
        g( -x, -y );
        l( 0, y * 2 );
        l( x * 2, 0 );
        l( 0, -y * 2 );
        l( -x * 2, 0 );
        g( x, y );
        }

    /**
     * convert from char gen co-ordinates to pixels
     *
     * @param x x in char gen co-ordinates
     *
     * @return x in pixels
     */
    int toXPixel( int x )
        {
        return x * xscale + originX;
        }

    /**
     * Convert from char gen co-ordinates to pixels
     *
     * @param y y in chargen co-ordinates
     *
     * @return y in pixels
     */
    int toYPixel( int y )
        {
        return originY - y * yscale;
        }
    } // end class ProofreaderFont