/*

 * This file is part of libbluray

 * Copyright (C) 2012-2014  libbluray

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library. If not, see

 * <http://www.gnu.org/licenses/>.

 */

package java.awt;

import java.lang.reflect.Field;

import java.text.AttributedCharacterIterator;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashSet;

import java.awt.image.AreaAveragingScaleFilter;

import java.awt.image.BufferedImage;

import java.awt.image.ImageConsumer;

import java.awt.image.ImageObserver;

import org.dvb.ui.DVBBufferedImage;

import org.dvb.ui.DVBAlphaComposite;

import org.dvb.ui.DVBGraphics;

import org.dvb.ui.UnsupportedDrawingOperationException;

import sun.awt.ConstrainableGraphics;

import org.videolan.GUIManager;

import org.videolan.Logger;

abstract class BDGraphicsBase extends DVBGraphics implements ConstrainableGraphics {

    private static final Color DEFAULT_COLOR = Color.BLACK;

    private static final Font DEFAULT_FONT = new Font("Dialog", Font.PLAIN, 12);

    private int width;

    private int height;

    private int[] backBuffer;

    private Area dirty;

    private GraphicsConfiguration gc;

    private Color foreground;

    protected Color background;

    private Font font;

    private BDFontMetrics fontMetrics;

    private AlphaComposite composite;

    /** The current xor color. If null then we are in paint mode. */

    private Color xorColor;

    /** Translated X, Y offset from native offset. */

    private int originX;

    private int originY;

    /** The actual clip rectangle that is intersection of user clip and constrained rectangle. */

    private Rectangle actualClip;

    /** The current user clip rectangle or null if no clip has been set. This is stored in the

     native coordinate system and not the (possibly) translated Java coordinate system. */

    private Rectangle clip = null;

    /** The rectangle this graphics object has been constrained too. This is stored in the

     native coordinate system and not the (possibly) translated Java coordinate system.

     If it is null then this graphics has not been constrained. The constrained rectangle

     is another layer of clipping independant of the user clip. */

    private Rectangle constrainedRect = null;

    BDGraphicsBase(BDGraphicsBase g) {

        backBuffer = g.backBuffer;

        dirty = g.dirty;

        width = g.width;

        height = g.height;

        gc = g.gc;

        foreground = g.foreground;

        background = g.background;

        composite = g.composite;

        font = g.font;

        fontMetrics = g.fontMetrics;

        originX = g.originX;

        originY = g.originY;

        if (g.clip != null) {

            clip = new Rectangle(g.clip);

        }

        setupClip();

    }

    BDGraphicsBase(BDRootWindow window) {

        width = window.getWidth();

        height = window.getHeight();

        backBuffer = window.getBdBackBuffer();

        dirty = window.getDirtyArea();

        gc = window.getGraphicsConfiguration();

        foreground = window.getForeground();

        background = window.getBackground();

        font = window.getFont();

        postInit();

    }

    BDGraphicsBase(BDImage image) {

        width = image.getWidth();

        height = image.getHeight();

        backBuffer = image.getBdBackBuffer();

        dirty = image.getDirtyArea();

        gc = image.getGraphicsConfiguration();

        Component component = image.getComponent();

        if (component != null) {

            foreground = component.getForeground();

            background = component.getBackground();

            font = component.getFont();

        }

        if (background == null)

            background = new Color(0, 0, 0, 0);

        postInit();

    }

    private void postInit() {

        if (foreground == null)

            foreground = DEFAULT_COLOR;

        if (background == null)

            background = DEFAULT_COLOR;

        /* if font is not set, use AWT default font from BDJO */

        if (font == null) {

            font = GUIManager.getInstance().getDefaultFont();

            if (font == null) {

                font = DEFAULT_FONT;

            }

        }

        fontMetrics = null;

        composite = AlphaComposite.SrcOver;

        setupClip();

    }

    public Graphics create() {

        return new BDGraphics((BDGraphics)this);

    }

    /*

     * DVBGraphics methods

     */

    public int[] getAvailableCompositeRules()

    {

        /*

        int[] rules = { DVBAlphaComposite.CLEAR, DVBAlphaComposite.SRC,

                        DVBAlphaComposite.SRC_OVER, DVBAlphaComposite.DST_OVER,

                        DVBAlphaComposite.SRC_IN, DVBAlphaComposite.DST_IN,

                        DVBAlphaComposite.SRC_OUT, DVBAlphaComposite.DST_OUT };

        */

        int[] rules = {

            DVBAlphaComposite.CLEAR,

            DVBAlphaComposite.SRC,

            DVBAlphaComposite.SRC_OVER };

        return rules;

    }

    public DVBAlphaComposite getDVBComposite()

    {

        Composite comp = getComposite();

        if (!(comp instanceof AlphaComposite))

            return null;

        return DVBAlphaComposite.getInstance(

                                             ((AlphaComposite)comp).getRule(),

                                             ((AlphaComposite)comp).getAlpha());

    }

    public void setDVBComposite(DVBAlphaComposite comp)

                    throws UnsupportedDrawingOperationException

    {

        if ((comp.getRule() < DVBAlphaComposite.CLEAR) ||

            (comp.getRule() > DVBAlphaComposite.SRC_OVER)) {

            logger.error("setDVBComposite() FAILED: unsupported rule " + comp.getRule());

            throw new UnsupportedDrawingOperationException("Unsupported composition rule: " + comp.getRule());

        }

        setComposite(AlphaComposite.getInstance(comp.getRule(), comp.getAlpha()));

    }

    /*

     *

     */

    public void translate(int x, int y) {

        originX += x;

        originY += y;

    }

    public void setFont(Font font) {

        if (font != null && !font.equals(this.font)) {

            this.font = font;

            fontMetrics = null;

        }

    }

    public Font getFont() {

        if (font == null)

            return DEFAULT_FONT;

        return font;

    }

    public FontMetrics getFontMetrics() {

        if (font != null && fontMetrics == null) {

            fontMetrics = BDFontMetrics.getFontMetrics(font);

        }

        if (fontMetrics == null) {

            logger.error("getFontMetrics() failed");

        }

        return fontMetrics;

    }

    public FontMetrics getFontMetrics(Font font) {

        if (font != null) {

            return BDFontMetrics.getFontMetrics(font);

        }

        logger.error("getFontMetrics(null) from " + Logger.dumpStack());

        return null;

    }

    public void setColor(Color c) {

        if ((c != null) && (c != foreground))

            foreground = c;

    }

    public Color getColor() {

        return foreground;

    }

    public Composite getComposite() {

        return composite;

    }

    public GraphicsConfiguration getDeviceConfiguration() {

        if (gc == null)

            logger.error("getDeviceConfiguration() failed");

        return gc;

    }

    public void setComposite(Composite comp) {

        if ((comp != null) && (comp != composite)) {

            if (!(comp instanceof AlphaComposite)) {

                logger.error("Composite is not AlphaComposite");

                throw new IllegalArgumentException("Only AlphaComposite is supported");

            }

            composite = (AlphaComposite) comp;

        }

    }

    public void setPaintMode() {

        xorColor = null;

        composite = AlphaComposite.SrcOver;

    }

    public void setXORMode(Color color) {

        xorColor = color;

    }

    /** Gets the current clipping area. */

    public Rectangle getClipBounds() {

        if (clip != null)

            return new Rectangle (clip.x - originX, clip.y - originY, clip.width, clip.height);

        return null;

    }

    public void constrain(int x, int y, int w, int h) {

        Rectangle rect;

        if (constrainedRect != null)

            rect = constrainedRect;

        else

            rect = new Rectangle(0, 0, width, height);

        constrainedRect = rect.intersection(new Rectangle(rect.x + x, rect.y + y, w, h));

        originX = constrainedRect.x;

        originY = constrainedRect.y;

        setupClip();

    }

    /** Returns a Shape object representing the clip. */

    public Shape getClip() {

        return getClipBounds();

    }

    /** Crops the clipping rectangle. */

    public void clipRect(int x, int y, int w, int h) {

        Rectangle rect = new Rectangle(x + originX, y + originY, w, h);

        if (clip != null)

            clip = clip.intersection(rect);

        else

            clip = rect;

        setupClip();

    }

    /** Sets the clipping rectangle. */

    public void setClip(int x, int y, int w, int h) {

        clip = new Rectangle (x + originX, y + originY, w, h);

        setupClip();

    }

    /** Sets the clip to a Shape (only Rectangle allowed). */

    public void setClip(Shape clip) {

        if (clip == null) {

            this.clip = null;

            setupClip();

        } else if (clip instanceof Rectangle) {

            Rectangle rect = (Rectangle) clip;

            setClip(rect.x, rect.y, rect.width, rect.height);

        } else {

            logger.error("Shape is not Rectangle: " + clip.getClass().getName());

            throw new IllegalArgumentException("setClip(Shape) only supports Rectangle objects");

        }

    }

    private void setupClip() {

        Rectangle rect;

        if (constrainedRect != null)

            rect = constrainedRect;

        else

            rect = new Rectangle(0, 0, width, height);

        if (clip != null)

            actualClip = clip.intersection(rect);

        else

            actualClip = rect;

    }

    private int alphaBlend(int dest, int src) {

        int As = src >>> 24;

        if (As == 0)

            return dest;

        if (As == 255)

            return src;

        int Ad = (dest >>> 24);

        if (Ad == 0)

            return src;

        int R, G, B;

        R = ((src >>> 16) & 255) * As * 255;

        G = ((src >>> 8) & 255) * As * 255;

        B = (src & 255) * As * 255;

        Ad = Ad * (255 - As);

        As = As * 255 + Ad;

        R = (R + ((dest >>> 16) & 255) * Ad) / As;

        G = (G + ((dest >>> 8) & 255) * Ad) / As;

        B = (B + (dest & 255) * Ad) / As;

        R = Math.min(255, R);

        G = Math.min(255, G);

        B = Math.min(255, B);

        Ad = As / 255;

        Ad = Math.min(255, Ad);

        return (Ad << 24) | (R << 16) | (G << 8) | B;

    }

    private int applyComposite(int rgb) {

        return ((int)((rgb >>> 24) * composite.getAlpha()) << 24) | (rgb & 0x00FFFFFF);

    }

    private void drawSpanN(int x, int y, int length, int rgb) {

        Rectangle rect = new Rectangle(x, y, length, 1);

        rect = actualClip.intersection(rect);

        if (rect.width <= 0 || rect.height <= 0 || rect.x < 0 || rect.y < 0 || backBuffer == null) {

            return;

        }

        x      = rect.x;

        length = rect.width;

        if (xorColor != null) {

            for (int i = 0; i < length; i++) {

                backBuffer[y * width + x + i] ^= xorColor.getRGB() ^ rgb;

            }

            dirty.add(rect);

            return;

        }

        switch (composite.getRule()) {

            case AlphaComposite.CLEAR:

                for (int i = 0; i < length; i++) {

                    backBuffer[y * width + x + i] = 0;

                }

                break;

            case AlphaComposite.SRC:

                rgb = applyComposite(rgb);

                for (int i = 0; i < length; i++) {

                    backBuffer[y * width + x + i] = rgb;

                }

                break;

            case AlphaComposite.SRC_OVER:

                rgb = applyComposite(rgb);

                for (int i = 0; i < length; i++) {

                    backBuffer[y * width + x + i] = alphaBlend(backBuffer[y * width + x + i], rgb);

                }

                break;

        }

        dirty.add(rect);

    }

    private void drawSpanN(int x, int y, int length, int src[], int srcOffset, boolean flipX) {

        /* avoid overreading source */

        if (srcOffset + length > src.length) {

            length -= srcOffset + length - src.length;

        }

        /* avoid underreading source */

        if (srcOffset < 0) {

            length += srcOffset;

            x -= srcOffset;

            srcOffset = 0;

        }

        if (length <= 0) {

            return;

        }

        Rectangle rect = new Rectangle(x, y, length, 1);

        rect = actualClip.intersection(rect);

        if (rect.width <= 0 || rect.height <= 0 || rect.x < 0 || rect.y < 0 || backBuffer == null) {

            return;

        }

        int dstOffset;

        srcOffset += rect.x - x;

        x          = rect.x;

        length     = rect.width;

        dstOffset  = y * width + x;

        if (xorColor != null) {

            if (flipX) {

                for (int i = 0; i < length; i++) {

                    backBuffer[dstOffset + length -1 - i] ^= xorColor.getRGB() ^ src[srcOffset + i];

                }

            } else {

                for (int i = 0; i < length; i++) {

                    backBuffer[dstOffset + i] ^= xorColor.getRGB() ^ src[srcOffset + i];

                }

            }

            dirty.add(rect);

            return;

        }

        switch (composite.getRule()) {

            case AlphaComposite.CLEAR:

                for (int i = 0; i < length; i++) {

                    backBuffer[dstOffset + i] = 0;

                }

                break;

            case AlphaComposite.SRC:

                if (flipX) {

                    for (int i = 0; i < length; i++) {

                        backBuffer[dstOffset + length -1 - i] = applyComposite(src[srcOffset + i]);

                    }

                } else {

                    for (int i = 0; i < length; i++) {

                        backBuffer[dstOffset + i] = applyComposite(src[srcOffset + i]);

                    }

                }

                break;

            case AlphaComposite.SRC_OVER:

                if (flipX) {

                    for (int i = 0; i < length; i++) {

                        backBuffer[dstOffset + length -1 - i] = alphaBlend(backBuffer[dstOffset + length -1 - i], applyComposite(src[srcOffset + i]));

                    }

                } else {

                    for (int i = 0; i < length; i++) {

                        backBuffer[dstOffset + i] = alphaBlend(backBuffer[dstOffset + i], applyComposite(src[srcOffset + i]));

                    }

                }

                break;

        }

        dirty.add(rect);

    }

    private void drawSpan(int x, int y, int length, int rgb) {

        x += originX;

        y += originY;

        drawSpanN(x, y, length, rgb);

    }

    private void drawSpan(int x, int y, int length, int src[], int srcOffset, boolean flipX) {

        x += originX;

        y += originY;

        drawSpanN(x, y, length, src, srcOffset, flipX);

    }

    private void drawPointN(int x, int y, int rgb) {

        drawSpanN(x, y, 1, rgb);

    }

    private void drawGlyph(int[] rgbArray, int x0, int y0, int w, int h) {

        for (int y = 0; y < h; y++)

            for (int x = 0; x < w; x++)

                drawPoint(x + x0, y + y0, rgbArray[y * w + x]);

    }

    private void drawPoint(int x, int y, int rgb) {

        x += originX;

        y += originY;

        if (actualClip.contains(x, y))

            drawPointN(x, y, rgb);

    }

    public void clearRect(int x, int y, int w, int h) {

        x += originX;

        y += originY;

        Rectangle rect = new Rectangle(x, y, w, h);

        rect = actualClip.intersection(rect);

        if (rect.isEmpty() || backBuffer == null) {

            return;

        }

        x = rect.x;

        y = rect.y;

        w = rect.width;

        h = rect.height;

        int rgb = background.getRGB();

        for (int i = 0; i < h; i++)

            Arrays.fill(backBuffer, (y + i) * width + x, (y + i) * width + x + w, rgb);

        dirty.add(rect);

    }

    public void fillRect(int x, int y, int w, int h) {

        x += originX;

        y += originY;

        Rectangle rect = new Rectangle(x, y, w, h);

        rect = actualClip.intersection(rect);

        x = rect.x;

        y = rect.y;

        w = rect.width;

        h = rect.height;

        int rgb = foreground.getRGB();

        for (int Y = y; Y < (y + h); Y++)

            drawSpanN(x, Y, w, rgb);

    }

    public void drawRect(int x, int y, int w, int h) {

        x += originX;

        y += originY;

        drawLineN(x, y, x + w, y);

        drawLineN(x, y + h, x + w, y + h);

        drawLineN(x, y, x, y + h);

        drawLineN(x + w, y, x + w, y + h);

    }

    private void drawLineN(int x1, int y1, int x2, int y2) {

        int rgb = foreground.getRGB();

        int dy = y2 - y1;

        int dx = x2 - x1;

        int stepx, stepy;

        int fraction;

        if (dy < 0) {

            dy = -dy;

            stepy = -1;

        } else {

            stepy = 1;

        }

        if (dx < 0) {

            dx = -dx;

            stepx = -1;

        } else {

            stepx = 1;

        }

        dy <<= 1;

        dx <<= 1;

        drawPointN(x1, y1, rgb);

        if (dx > dy) {

            fraction = dy - (dx >> 1);

            while (x1 != x2) {

                if (fraction >= 0) {

                    y1 += stepy;

                    fraction -= dx;

                }

                x1 += stepx;

                fraction += dy;

                drawPointN(x1, y1, rgb);

            }

        } else {

            fraction = dx - (dy >> 1);

            while (y1 != y2) {

                if (fraction >= 0) {

                    x1 += stepx;

                    fraction -= dy;

                }

                y1 += stepy;

                fraction += dx;

                drawPointN(x1, y1, rgb);

            }

        }

    }

    public void drawLine(int x1, int y1, int x2, int y2) {

        x1 += originX;

        y1 += originY;

        x2 += originX;

        y2 += originY;

        drawLineN(x1, y1, x2, y2);

    }

    /**

     * Copies an area of the canvas that this graphics context paints to.

     * @param X the x-coordinate of the source.

     * @param Y the y-coordinate of the source.

     * @param W the width.

     * @param H the height.

     * @param dx the horizontal distance to copy the pixels.

     * @param dy the vertical distance to copy the pixels.

     */

    public void copyArea(int x, int y, int w, int h, int dx, int dy) {

        x += originX;

        y += originY;

        Rectangle rect = new Rectangle(x, y, w, h);

        rect = actualClip.intersection(rect);

        if (rect.width <= 0 || rect.height <= 0 || backBuffer == null) {

            return;

        }

        x = rect.x;

        y = rect.y;

        w = rect.width;

        h = rect.height;

        int subImage[] = new int[w * h];

        // copy back buffer

        for (int i = 0; i < h; i++) {

            System.arraycopy(backBuffer, ((y + i) * width) + x, subImage, w * i, w);

        }

        // draw sub image

        for (int i = 0; i < h; i++) {

            drawSpanN(x + dx, y + i + dy, w, subImage, w * i, false);

        }

    }

    /** Draws lines defined by an array of x points and y points */

    public void drawPolyline(int xPoints[], int yPoints[], int nPoints) {

        if (nPoints == 1) {

            drawPoint(xPoints[0], yPoints[0], foreground.getRGB());

        } else {

            for (int i = 0; i < (nPoints - 1); i++)

                drawLine(xPoints[i], xPoints[i], xPoints[i + 1], xPoints[i + 1]);

        }

    }

    /** Draws a polygon defined by an array of x points and y points */

    public void drawPolygon(int xPoints[], int yPoints[], int nPoints) {

        if (nPoints == 1) {

            drawPoint(xPoints[0], yPoints[0], foreground.getRGB());

        } else {

            for (int i = 0; i < (nPoints - 1); i++)

                drawLine(xPoints[i], xPoints[i], xPoints[i + 1], xPoints[i + 1]);

            if (nPoints > 2)

                drawLine(xPoints[0], xPoints[0], xPoints[nPoints - 1], xPoints[nPoints - 1]);

        }

    }

    /** Fills a polygon with the current fill mask */

    public void fillPolygon(int xPoints[], int yPoints[], int nPoints) {

        int minY = Integer.MAX_VALUE;

        int maxY = Integer.MIN_VALUE;

        int colour = foreground.getRGB();

        if (nPoints < 3) {

            return;

        }

        for (int i = 0; i < nPoints; i++) {

            if (yPoints[i] > maxY) {

                maxY = yPoints[i];

            }

            if (yPoints[i] < minY) {

                minY = yPoints[i];

            }

        }

        // check the last point to see if its the same as the first

        if (xPoints[0] == xPoints[nPoints - 1] && yPoints[0] == yPoints[nPoints - 1]) {

            nPoints--;

        }

        PolyEdge[] polyEdges = new PolyEdge[nPoints];

        for (int i = 0; i < nPoints - 1; i++) {

            polyEdges[i] = new PolyEdge(xPoints[i], yPoints[i], xPoints[i + 1], yPoints[i + 1]);

        }

        // add the last one

        polyEdges[nPoints - 1] = new PolyEdge(xPoints[nPoints - 1], yPoints[nPoints - 1], xPoints[0], yPoints[0]);

        ArrayList xList = new ArrayList();

        for (int i = minY; i <= maxY; i++) {

            for (int j = 0; j < nPoints; j++) {

                if (polyEdges[j].intersects(i)) {

                    int x = polyEdges[j].intersectionX(i);

                    xList.add(new Integer(x));

                }

            }

            // probably a better way of doing this (removing duplicates);

            HashSet hs = new HashSet();

            hs.addAll(xList);

            xList.clear();

            xList.addAll(hs);

            if (xList.size() % 2 > 0) {

                xList.clear();

                continue;                       // this should be impossible unless the poly is open somewhere

            }

            Collections.sort(xList);

            for (int j = 0; j < xList.size(); j +=2 ) {

                int x1 = ((Integer)xList.get(j)).intValue();

                int x2 = ((Integer)xList.get(j + 1)).intValue();

                drawSpan(x1, i, x2 - x1, colour);

            }

            xList.clear();

        }

    }

    /** Draws an oval to fit in the given rectangle */

    public void drawOval(int x, int y, int w, int h) {

        int     startX;

        int     endX;

        int     offset;

        int[]   xList;

        int[]   yList;

        int     numPoints;

        int     count;

        float   as;

        float   bs;

        if (w <= 0 || h <=0 ) {

            return;

        }

        count = 0;

        numPoints = ((h/2) + (h/2) + 1) * 2;

        numPoints += 1; // to close

        xList = new int[numPoints];

        yList = new int[numPoints];

        as = (w/2.0f) * (w/2.0f);

        bs = (h/2.0f) * (h/2.0f);

        for (int i = -h/2; i <= h/2; i++) {

            offset = (int) Math.sqrt( (1.0 - ((i*i)/bs)) * as );

            startX  = x - offset + w/2;

            xList[count] = startX;

            yList[count] = y + i + h/2;

            count++;

        }

        for (int i = h/2; i >= -h/2; i--) {

            offset = (int) Math.sqrt( (1.0 - ((i*i)/bs)) * as );

            endX    = x + offset + w/2;

            xList[count] = endX;

            yList[count] = y + i + h/2;

            count++;

        }

        xList[count] = xList[0];        // close the loop

        yList[count] = yList[0];        // close the loop

        drawPolyline(xList, yList, numPoints);

    }

    /** Fills an oval to fit in the given rectangle */

    public void fillOval(int x, int y, int w, int h) {

        int     startX;

        int     endX;

        int     offset;

        int     colour;

        float   as;

        float   bs;

        if (w <= 0 || h <= 0) {

            return;

        }

        as = (w/2.0f) * (w/2.0f);

        bs = (h/2.0f) * (h/2.0f);

        colour = foreground.getRGB();

        for(int i=-h/2; i<=h/2; i++) {

            offset  = (int) Math.sqrt( (1.0 - ((i*i)/bs)) * as );

            startX  = x - offset + w/2;

            endX    = x + offset + w/2;

            drawSpan(startX, y + i + h/2, endX - startX + 1, colour);

        }

    }

    private int getAngle(int centreX, int centreY, int pointX, int pointY) {

        float  vStartX;

        float  vStartY;

        float  vEndX;

        float  vEndY;

        float  length;

        double angle;

        vStartX = 1;    // vector pointing right (this is where angle starts for arcs)

        vStartY = 0;

        vEndX = pointX - centreX;

        vEndY = pointY - centreY;

        length = (float) Math.sqrt(vEndX*vEndX + vEndY*vEndY);

        vEndX /= length;

        vEndY /= length;

        angle = Math.acos(vStartX*vEndX + vStartY*vEndY);

        angle = angle * 180.0 / Math.PI;

        if (vEndY > 0) {

            angle = 360 - angle;

        }

        return (int)(angle + 0.5);

    }

    private void drawArcI(boolean fill, int x, int y, int width, int height, int startAngle, int arcAngle) {

        int     endAngle;

        int     startX;

        int     endX;

        int     offset;

        int[]   xList;

        int[]   yList;

        int     count;

        int     numPoints;

        int     tempX;

        int     tempY;

        int     angle;

        int     widthDiv2;

        int     heightDiv2;

        float   as;

        float   bs;

        boolean addedZero;

        boolean circle;

        // sanity checks

        if (width <= 0 || height <= 0 || arcAngle == 0) {

            return;