internal/awt/AndroidGraphics2D.java

/*
 * Copyright 2007, The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.internal.awt;

import com.android.internal.awt.AndroidGraphicsConfiguration;
import com.android.internal.graphics.NativeUtils;

import java.awt.AlphaComposite;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Composite;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.Image;
import java.awt.Polygon;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.Stroke;
import java.awt.font.FontRenderContext;
import java.awt.font.GlyphVector;
import java.awt.geom.AffineTransform;
import java.awt.geom.Area;
import java.awt.geom.GeneralPath;
import java.awt.geom.NoninvertibleTransformException;
import java.awt.geom.PathIterator;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.awt.image.BufferedImageOp;
import java.awt.image.DataBuffer;
import java.awt.image.DirectColorModel;
import java.awt.image.ImageObserver;
import java.awt.image.Raster;
import java.awt.image.RenderedImage;
import java.awt.image.SinglePixelPackedSampleModel;
import java.awt.image.WritableRaster;
import java.awt.image.renderable.RenderableImage;
import java.text.AttributedCharacterIterator;
import java.util.Map;

import org.apache.harmony.awt.gl.ImageSurface;
import org.apache.harmony.awt.gl.MultiRectArea;
import org.apache.harmony.awt.gl.Surface;
import org.apache.harmony.awt.gl.font.AndroidGlyphVector;
import org.apache.harmony.awt.gl.font.FontMetricsImpl;
import org.apache.harmony.awt.gl.image.OffscreenImage;

import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.Path;

import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.Region;
import android.graphics.Typeface;
import android.graphics.PixelXorXfermode;
import android.view.Display;
import android.view.WindowManager;
import android.content.Context;

public class AndroidGraphics2D extends Graphics2D {

    private int displayWidth, displayHeight;

    protected Surface dstSurf = null;
    protected MultiRectArea clip = null;

    protected Composite composite = AlphaComposite.SrcOver;
    protected AffineTransform transform = new AffineTransform();

    private static AndroidGraphics2D mAg;
    private static Canvas mC;

    // Android Paint
    public static Paint mP;

    private static java.awt.Font mFnt;

    // Cached Matrix
    public static Matrix mM;
    private static FontMetrics mFm;
    private static RenderingHints mRh;
    private static Color mBc;

    private Area mCurrClip;

    public final static double RAD_360 = Math.PI / 180 * 360;

    // Image drawing
    private AndroidJavaBlitter blitter;
    private DirectColorModel cm;
    private SinglePixelPackedSampleModel sm;
    private WritableRaster wr;


    public static AndroidGraphics2D getInstance() {
        if (mAg == null) {
            throw new RuntimeException("AndroidGraphics2D not instantiated!");
        }
        return mAg;
    }

    public static AndroidGraphics2D getInstance(Context ctx, Canvas c, Paint p) {
        if (c == null || ctx == null) {
            throw new RuntimeException(
                    "Illegal argument, Canvas cannot be null!");
        }
        mAg = new AndroidGraphics2D(ctx, c, p);
        return mAg;
    }

    private AndroidGraphics2D(Context ctx, Canvas c, Paint p) {
        super();
        mC = c;
        mP = p;
        mM = new Matrix();
        mM.reset();
        mM = mC.getMatrix();
        Rect r = mC.getClipBounds();
        int cl[] = {-1, r.top, r.left, -2, r.top, r.right, -2, r.bottom, r.right, -2, r.bottom, r.left};
        mCurrClip = new Area(createShape(cl));
        if(ctx != null) {
            WindowManager wm = (WindowManager)ctx.getSystemService(Context.WINDOW_SERVICE);
            Display d = wm.getDefaultDisplay();
            displayWidth = d.getWidth();
            displayHeight = d.getHeight();
        }
        blitter = new AndroidJavaBlitter(c);
        cm = new DirectColorModel(32, 0xff0000, 0xff00, 0xff, 0xff000000);
        sm = new SinglePixelPackedSampleModel(
                DataBuffer.TYPE_INT, displayWidth, displayHeight, cm.getMasks());
        wr = Raster.createWritableRaster(sm, null);
        dstSurf = new ImageSurface(cm, wr);
    }

    @Override
    public void addRenderingHints(Map<?, ?> hints) {
        if (mRh == null) {
            mRh = (RenderingHints) hints;
        }
        mRh.add((RenderingHints) hints);
    }

    public float[] getMatrix() {
        float[] f = new float[9];
        mC.getMatrix().getValues(f);
        return f;
    }

    /**
     *
     * @return a Matrix in Android format
     */
    public float[] getInverseMatrix() {
        AffineTransform af = new AffineTransform(createAWTMatrix(getMatrix()));
        try {
            af = af.createInverse();
        } catch (NoninvertibleTransformException e) {
        }
        return createMatrix(af);
    }

    private Path getPath(Shape s) {
        Path path = new Path();
        PathIterator pi = s.getPathIterator(null);
        while (pi.isDone() == false) {
            getCurrentSegment(pi, path);
            pi.next();
        }
        return path;
    }

    private void getCurrentSegment(PathIterator pi, Path path) {
        float[] coordinates = new float[6];
        int type = pi.currentSegment(coordinates);
        switch (type) {
        case PathIterator.SEG_MOVETO:
            path.moveTo(coordinates[0], coordinates[1]);
            break;
        case PathIterator.SEG_LINETO:
            path.lineTo(coordinates[0], coordinates[1]);
            break;
        case PathIterator.SEG_QUADTO:
            path.quadTo(coordinates[0], coordinates[1], coordinates[2],
                    coordinates[3]);
            break;
        case PathIterator.SEG_CUBICTO:
            path.cubicTo(coordinates[0], coordinates[1], coordinates[2],
                    coordinates[3], coordinates[4], coordinates[5]);
            break;
        case PathIterator.SEG_CLOSE:
            path.close();
            break;
        default:
            break;
        }
    }

    private Shape createShape(int[] arr) {
        Shape s = new GeneralPath();
        for(int i = 0; i < arr.length; i++) {
            int type = arr[i];
            switch (type) {
            case -1:
                //MOVETO
                ((GeneralPath)s).moveTo(arr[++i], arr[++i]);
                break;
            case -2:
                //LINETO
                ((GeneralPath)s).lineTo(arr[++i], arr[++i]);
                break;
            case -3:
                //QUADTO
                ((GeneralPath)s).quadTo(arr[++i], arr[++i], arr[++i],
                        arr[++i]);
                break;
            case -4:
                //CUBICTO
                ((GeneralPath)s).curveTo(arr[++i], arr[++i], arr[++i],
                        arr[++i], arr[++i], arr[++i]);
                break;
            case -5:
                //CLOSE
                return s;
            default:
                break;
            }
        }
        return s;
    }
    /*
    public int[] getPixels() {
        return mC.getPixels();
    }*/

    public static float getRadian(float degree) {
        return (float) ((Math.PI / 180) * degree);
    }

    private Shape getShape() {
        return null;
    }

    public static float getDegree(float radian) {
        return (float) ((180 / Math.PI) * radian);
    }

    /*
     * Degree in radian
     */
    public static float getEllipsisX(float degree, float princAxis) {
        return (float) Math.cos(degree) * princAxis;
    }

    public static float getEllipsisY(float degree, float conAxis) {
        return (float) Math.sin(degree) * conAxis;
    }

    @Override
    public void clip(Shape s) {
        mC.clipPath(getPath(s));
    }

    public void setCanvas(Canvas c) {
        mC = c;
    }

    @Override
    public void draw(Shape s) {
        if (mP == null) {
            mP = new Paint();
        }
        Paint.Style tmp = mP.getStyle();
        mP.setStyle(Paint.Style.STROKE);
        mC.drawPath(getPath(s), mP);
        mP.setStyle(tmp);
    }
/*
    private ArrayList getSegments(Shape s) {
        ArrayList arr = new ArrayList();
        PathIterator pi = s.getPathIterator(null);
        while (pi.isDone() == false) {
            getCurrentSegment(pi, arr);
            pi.next();
        }
        return arr;
    }

    private void getCurrentSegment(PathIterator pi, ArrayList arr) {
        float[] coordinates = new float[6];
        int type = pi.currentSegment(coordinates);
        switch (type) {
        case PathIterator.SEG_MOVETO:
            arr.add(new Integer(-1));
            break;
        case PathIterator.SEG_LINETO:
            arr.add(new Integer(-2));
            break;
        case PathIterator.SEG_QUADTO:
            arr.add(new Integer(-3));
            break;
        case PathIterator.SEG_CUBICTO:
            arr.add(new Integer(-4));
            break;
        case PathIterator.SEG_CLOSE:
            arr.add(new Integer(-5));
            break;
        default:
            break;
        }
    }
*/
    /*
     * Convenience method, not standard AWT
     */
    public void draw(Path s) {
        if (mP == null) {
            mP = new Paint();
        }
        Paint.Style tmp = mP.getStyle();
        mP.setStyle(Paint.Style.STROKE);
        s.transform(mM);
        mC.drawPath(s, mP);
        mP.setStyle(tmp);
    }

    @Override
    public void drawGlyphVector(GlyphVector g, float x, float y) {
        // TODO draw at x, y
        // draw(g.getOutline());
        /*
        Matrix matrix = new Matrix();
        matrix.setTranslate(x, y);
        Path pth = getPath(g.getOutline());
        pth.transform(matrix);
        draw(pth);
        */
        Path path = new Path();
        char[] c = ((AndroidGlyphVector)g).getGlyphs();
        mP.getTextPath(c, 0, c.length, x, y, path);
        mC.drawPath(path, mP);
    }

    @Override
    public void drawRenderableImage(RenderableImage img, AffineTransform xform) {
        throw new RuntimeException("Not implemented!");
    }

    @Override
    public void drawRenderedImage(RenderedImage img, AffineTransform xform) {
        throw new RuntimeException("Not implemented!");
    }

    @Override
    public void drawString(AttributedCharacterIterator iterator, float x,
            float y) {
        throw new RuntimeException("AttributedCharacterIterator not supported!");

    }

    @Override
    public void drawString(AttributedCharacterIterator iterator, int x, int y) {
        throw new RuntimeException("AttributedCharacterIterator not supported!");

    }

    @Override
    public void drawString(String s, float x, float y) {
            if (mP == null) {
                mP = new Paint();
            }
            Paint.Style tmp = mP.getStyle();

            mP.setStyle(Paint.Style.FILL);
            Path pth = new Path();
            mP.getTextPath(s, 0, s.length(), x, y, pth);
            mC.drawPath(pth, mP);
            mP.setStyle(tmp);
    }

    @Override
    public void drawString(String str, int x, int y) {
            if (mP == null) {
                mP = new Paint();
            }
            Paint.Style tmp = mP.getStyle();
            mP.setStrokeWidth(0);

            mC.drawText(str.toCharArray(), 0, str.toCharArray().length, x, y,
                    mP);
            mP.setStyle(tmp);
    }

    @Override
    public void fill(Shape s) {
            if (mP == null) {
                mP = new Paint();
            }
            Paint.Style tmp = mP.getStyle();
            mP.setStyle(Paint.Style.FILL);
            mC.drawPath(getPath(s), mP);
            mP.setStyle(tmp);
    }

    @Override
    public Color getBackground() {
        return mBc;
    }

    @Override
    public Composite getComposite() {
        throw new RuntimeException("Composite not implemented!");
    }

    @Override
    public GraphicsConfiguration getDeviceConfiguration() {
        return new AndroidGraphicsConfiguration();
    }

    @Override
    public FontRenderContext getFontRenderContext() {
        return new FontRenderContext(getTransform(), mP.isAntiAlias(), true);
    }

    @Override
    public java.awt.Paint getPaint() {
        throw new RuntimeException("AWT Paint not implemented in Android!");
    }

    public static Canvas getAndroidCanvas() {
        return mC;
    }

    public static Paint getAndroidPaint() {
        return mP;
    }

    @Override
    public RenderingHints getRenderingHints() {
        return mRh;
    }

    @Override
    public Stroke getStroke() {
        if (mP != null) {
            return new BasicStroke(mP.getStrokeWidth(), mP.getStrokeCap()
                    .ordinal(), mP.getStrokeJoin().ordinal());
        }
        return null;
    }

    @Override
    public AffineTransform getTransform() {
        return new AffineTransform(createAWTMatrix(getMatrix()));
    }

    @Override
    public boolean hit(Rectangle rect, Shape s, boolean onStroke) {
        // ???AWT TODO check if on stroke
        return s.intersects(rect.getX(), rect.getY(), rect.getWidth(), rect
                .getHeight());
    }

    @Override
    public void rotate(double theta) {
        mM.preRotate((float) AndroidGraphics2D
                .getDegree((float) (RAD_360 - theta)));
        mC.concat(mM);
    }

    @Override
    public void rotate(double theta, double x, double y) {
        mM.preRotate((float) AndroidGraphics2D.getDegree((float) theta),
                (float) x, (float) y);
        mC.concat(mM);
    }

    @Override
    public void scale(double sx, double sy) {
        mM.setScale((float) sx, (float) sy);
        mC.concat(mM);
    }

    @Override
    public void setBackground(Color color) {
        mBc = color;
        mC.clipRect(new Rect(0, 0, mC.getWidth(), mC.getHeight()));
        // TODO don't limit to current clip
        mC.drawARGB(color.getAlpha(), color.getRed(), color.getGreen(), color
                .getBlue());
    }

    @Override
    public void setComposite(Composite comp) {
        throw new RuntimeException("Composite not implemented!");
    }

    public void setSpaint(Paint paint) {
        mP = paint;
    }

    @Override
    public void setPaint(java.awt.Paint paint) {
        setColor((Color)paint);
    }

    @Override
    public Object getRenderingHint(RenderingHints.Key key) {
        if (mRh == null) {
            return null;
        }
        return mRh.get(key);
    }

    @Override
    public void setRenderingHint(RenderingHints.Key hintKey, Object hintValue) {
        if (mRh == null) {
            mRh = new RenderingHints(hintKey, hintValue);
        } else {
            mRh.put(hintKey, hintValue);
        }
        applyHints();
    }

    @Override
    public void setRenderingHints(Map<?, ?> hints) {
        mRh = (RenderingHints) hints;
        applyHints();
    }

    private void applyHints() {
        Object o;

        // TODO do something like this:
        /*
         * Set s = mRh.keySet(); Iterator it = s.iterator(); while(it.hasNext()) {
         * o = it.next(); }
         */

        // /////////////////////////////////////////////////////////////////////
        // not supported in skia
        /*
         * o = mRh.get(RenderingHints.KEY_ALPHA_INTERPOLATION); if
         * (o.equals(RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT)) { } else
         * if (o.equals(RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY)) { }
         * else if (o.equals(RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED)) { }
         *
         * o = mRh.get(RenderingHints.KEY_COLOR_RENDERING); if
         * (o.equals(RenderingHints.VALUE_COLOR_RENDER_DEFAULT)) { } else if
         * (o.equals(RenderingHints.VALUE_COLOR_RENDER_QUALITY)) { } else if
         * (o.equals(RenderingHints.VALUE_COLOR_RENDER_SPEED)) { }
         *
         * o = mRh.get(RenderingHints.KEY_DITHERING); if
         * (o.equals(RenderingHints.VALUE_DITHER_DEFAULT)) { } else if
         * (o.equals(RenderingHints.VALUE_DITHER_DISABLE)) { } else if
         * (o.equals(RenderingHints.VALUE_DITHER_ENABLE)) { }
         *
         * o = mRh.get(RenderingHints.KEY_FRACTIONALMETRICS); if
         * (o.equals(RenderingHints.VALUE_FRACTIONALMETRICS_DEFAULT)) { } else
         * if (o.equals(RenderingHints.VALUE_FRACTIONALMETRICS_OFF)) { } else if
         * (o.equals(RenderingHints.VALUE_FRACTIONALMETRICS_ON)) { }
         *
         * o = mRh.get(RenderingHints.KEY_INTERPOLATION); if
         * (o.equals(RenderingHints.VALUE_INTERPOLATION_BICUBIC)) { } else if
         * (o.equals(RenderingHints.VALUE_INTERPOLATION_BILINEAR)) { } else if
         * (o .equals(RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR)) { }
         *
         * o = mRh.get(RenderingHints.KEY_RENDERING); if
         * (o.equals(RenderingHints.VALUE_RENDER_DEFAULT)) { } else if
         * (o.equals(RenderingHints.VALUE_RENDER_QUALITY)) { } else if
         * (o.equals(RenderingHints.VALUE_RENDER_SPEED)) { }
         *
         * o = mRh.get(RenderingHints.KEY_STROKE_CONTROL); if
         * (o.equals(RenderingHints.VALUE_STROKE_DEFAULT)) { } else if
         * (o.equals(RenderingHints.VALUE_STROKE_NORMALIZE)) { } else if
         * (o.equals(RenderingHints.VALUE_STROKE_PURE)) { }
         */

        o = mRh.get(RenderingHints.KEY_ANTIALIASING);
        if (o != null) {
            if (o.equals(RenderingHints.VALUE_ANTIALIAS_DEFAULT)) {
                mP.setAntiAlias(false);
            } else if (o.equals(RenderingHints.VALUE_ANTIALIAS_OFF)) {
                mP.setAntiAlias(false);
            } else if (o.equals(RenderingHints.VALUE_ANTIALIAS_ON)) {
                mP.setAntiAlias(true);
            }
        }

        o = mRh.get(RenderingHints.KEY_TEXT_ANTIALIASING);
        if (o != null) {
            if (o.equals(RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT)) {
                mP.setAntiAlias(false);
            } else if (o.equals(RenderingHints.VALUE_TEXT_ANTIALIAS_OFF)) {
                mP.setAntiAlias(false);
            } else if (o.equals(RenderingHints.VALUE_TEXT_ANTIALIAS_ON)) {
                mP.setAntiAlias(true);
            }
        }
    }

    @Override
    public void setStroke(Stroke s) {
        if (mP == null) {
            mP = new Paint();
        }
        BasicStroke bs = (BasicStroke) s;
        mP.setStyle(Paint.Style.STROKE);
        mP.setStrokeWidth(bs.getLineWidth());

        int cap = bs.getEndCap();
        if (cap == 0) {
            mP.setStrokeCap(Paint.Cap.BUTT);
        } else if (cap == 1) {
            mP.setStrokeCap(Paint.Cap.ROUND);
        } else if (cap == 2) {
            mP.setStrokeCap(Paint.Cap.SQUARE);
        }

        int join = bs.getLineJoin();
        if (join == 0) {
            mP.setStrokeJoin(Paint.Join.MITER);
        } else if (join == 1) {
            mP.setStrokeJoin(Paint.Join.ROUND);
        } else if (join == 2) {
            mP.setStrokeJoin(Paint.Join.BEVEL);
        }
    }

    public static float[] createMatrix(AffineTransform Tx) {
        double[] at = new double[9];
        Tx.getMatrix(at);
        float[] f = new float[at.length];
        f[0] = (float) at[0];
        f[1] = (float) at[2];
        f[2] = (float) at[4];
        f[3] = (float) at[1];
        f[4] = (float) at[3];
        f[5] = (float) at[5];
        f[6] = 0;
        f[7] = 0;
        f[8] = 1;
        return f;
    }

    private float[] createAWTMatrix(float[] matrix) {
        float[] at = new float[9];
        at[0] = matrix[0];
        at[1] = matrix[3];
        at[2] = matrix[1];
        at[3] = matrix[4];
        at[4] = matrix[2];
        at[5] = matrix[5];
        at[6] = 0;
        at[7] = 0;
        at[8] = 1;
        return at;
    }

    public static Matrix createMatrixObj(AffineTransform Tx) {
        Matrix m = new Matrix();
        m.reset();
        m.setValues(createMatrix(Tx));
        return m;
    }

    @Override
    public void setTransform(AffineTransform Tx) {
        mM.reset();
        /*
         * if(Tx.isIdentity()) { mM = new Matrix(); }
         */
        mM.setValues(createMatrix(Tx));
        Matrix m = new Matrix();
        m.setValues(getInverseMatrix());
        mC.concat(m);
        mC.concat(mM);
    }

    @Override
    public void shear(double shx, double shy) {
        mM.setSkew((float) shx, (float) shy);
        mC.concat(mM);
    }

    @Override
    public void transform(AffineTransform Tx) {
        Matrix m = new Matrix();
        m.setValues(createMatrix(Tx));
        mC.concat(m);
    }

    @Override
    public void translate(double tx, double ty) {
        mM.setTranslate((float) tx, (float) ty);
        mC.concat(mM);
    }

    @Override
    public void translate(int x, int y) {
        mM.setTranslate((float) x, (float) y);
        mC.concat(mM);
    }

    @Override
    public void clearRect(int x, int y, int width, int height) {
        mC.clipRect(x, y, x + width, y + height);
        if (mBc != null) {
            mC.drawARGB(mBc.getAlpha(), mBc.getBlue(), mBc.getGreen(), mBc
                    .getRed());
        } else {
            mC.drawARGB(0xff, 0xff, 0xff, 0xff);
        }
    }

    @Override
    public void clipRect(int x, int y, int width, int height) {
        int cl[] = {-1, x, y, -2, x, y + width, -2, x + height, y + width, -2, x + height, y};
        Shape shp = createShape(cl);
        mCurrClip.intersect(new Area(shp));
        mC.clipRect(new Rect(x, y, x + width, y + height), Region.Op.INTERSECT);
    }

    @Override
    public void copyArea(int sx, int sy, int width, int height, int dx, int dy) {
        copyArea(mC, sx, sy, width + dx, height + dy, dx, dy);
    }

    @Override
    public Graphics create() {
        return this;
    }

    @Override
    public void dispose() {
            mC = null;
            mP = null;
    }

    @Override
    public void drawArc(int x, int y, int width, int height, int sa, int ea) {
            if (mP == null) {
                mP = new Paint();
            }
            mP.setStrokeWidth(0);
            mC.drawArc(new RectF(x, y, x + width, y + height), 360 - (ea + sa),
                       ea, true, mP);
    }


    // ???AWT: only used for debuging, delete in final version
    public void drawBitmap(Bitmap bm, float x, float y, Paint p) {
        mC.drawBitmap(bm, x, y, null);
    }

    @Override
    public boolean drawImage(Image image, int x, int y, Color bgcolor,
            ImageObserver imageObserver) {

        if(image == null) {
            return true;
        }

        boolean done = false;
        boolean somebits = false;
        Surface srcSurf = null;
        if(image instanceof OffscreenImage){
            OffscreenImage oi = (OffscreenImage) image;
            if((oi.getState() & ImageObserver.ERROR) != 0) {
                return false;
            }
            done = oi.prepareImage(imageObserver);
            somebits = (oi.getState() & ImageObserver.SOMEBITS) != 0;
            srcSurf = oi.getImageSurface();
        }else{
            done = true;
            srcSurf = Surface.getImageSurface(image);
        }

        if(done || somebits) {
            int w = srcSurf.getWidth();
            int h = srcSurf.getHeight();

            blitter.blit(0, 0, srcSurf, x, y, dstSurf, w, h, (AffineTransform) transform.clone(),
                    composite, bgcolor, clip);
        }
        return done;
    }

    @Override
    public boolean drawImage(Image image, int x, int y, ImageObserver imageObserver) {
        return drawImage(image, x, y, null, imageObserver);
    }

    @Override
    public boolean drawImage(Image image, int x, int y, int width, int height,
            Color bgcolor, ImageObserver imageObserver) {

        if(image == null) {
            return true;
        }
        if(width == 0 || height == 0) {
            return true;
        }

        boolean done = false;
        boolean somebits = false;
        Surface srcSurf = null;

        if(image instanceof OffscreenImage){
            OffscreenImage oi = (OffscreenImage) image;
            if((oi.getState() & ImageObserver.ERROR) != 0) {
                return false;
            }
            done = oi.prepareImage(imageObserver);
            somebits = (oi.getState() & ImageObserver.SOMEBITS) != 0;
            srcSurf = oi.getImageSurface();
        }else{
            done = true;
            srcSurf = Surface.getImageSurface(image);
        }

        if(done || somebits) {
            int w = srcSurf.getWidth();
            int h = srcSurf.getHeight();
            if(w == width && h == height){
                blitter.blit(0, 0, srcSurf, x, y, dstSurf, w, h,
                        (AffineTransform) transform.clone(),
                        composite, bgcolor, clip);
            }else{
                AffineTransform xform = new AffineTransform();
                xform.setToScale((float)width / w, (float)height / h);
                blitter.blit(0, 0, srcSurf, x, y, dstSurf, w, h,
                        (AffineTransform) transform.clone(),
                        xform, composite, bgcolor, clip);
            }
        }
        return done;
    }

    @Override
    public boolean drawImage(Image image, int x, int y, int width, int height,
            ImageObserver imageObserver) {
        return drawImage(image, x, y, width, height, null, imageObserver);
    }

    @Override
    public boolean drawImage(Image image, int dx1, int dy1, int dx2, int dy2,
            int sx1, int sy1, int sx2, int sy2, Color bgcolor,
            ImageObserver imageObserver) {

        if(image == null) {
            return true;
        }
        if(dx1 == dx2 || dy1 == dy2 || sx1 == sx2 || sy1 == sy2) {
            return true;
        }

        boolean done = false;
        boolean somebits = false;
        Surface srcSurf = null;
        if(image instanceof OffscreenImage){
            OffscreenImage oi = (OffscreenImage) image;
            if((oi.getState() & ImageObserver.ERROR) != 0) {
                return false;
            }
            done = oi.prepareImage(imageObserver);
            somebits = (oi.getState() & ImageObserver.SOMEBITS) != 0;
            srcSurf = oi.getImageSurface();
        }else{
            done = true;
            srcSurf = Surface.getImageSurface(image);
        }

        if(done || somebits) {

            int dstX = dx1;
            int dstY = dy1;
            int srcX = sx1;
            int srcY = sy1;

            int dstW = dx2 - dx1;
            int dstH = dy2 - dy1;
            int srcW = sx2 - sx1;
            int srcH = sy2 - sy1;

            if(srcW == dstW && srcH == dstH){
                blitter.blit(srcX, srcY, srcSurf, dstX, dstY, dstSurf, srcW, srcH,
                        (AffineTransform) transform.clone(),
                        composite, bgcolor, clip);
            }else{
                AffineTransform xform = new AffineTransform();
                xform.setToScale((float)dstW / srcW, (float)dstH / srcH);
                blitter.blit(srcX, srcY, srcSurf, dstX, dstY, dstSurf, srcW, srcH,
                        (AffineTransform) transform.clone(),
                        xform, composite, bgcolor, clip);
            }
        }
        return done;
    }

    @Override
    public boolean drawImage(Image image, int dx1, int dy1, int dx2, int dy2,
            int sx1, int sy1, int sx2, int sy2, ImageObserver imageObserver) {

        return drawImage(image, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, null,
                imageObserver);
     }

    @Override
    public void drawImage(BufferedImage bufImage, BufferedImageOp op,
            int x, int y) {

        if(bufImage == null) {
            return;
        }

        if(op == null) {
            drawImage(bufImage, x, y, null);
        } else if(op instanceof AffineTransformOp){
            AffineTransformOp atop = (AffineTransformOp) op;
            AffineTransform xform = atop.getTransform();
            Surface srcSurf = Surface.getImageSurface(bufImage);
            int w = srcSurf.getWidth();
            int h = srcSurf.getHeight();
            blitter.blit(0, 0, srcSurf, x, y, dstSurf, w, h,
                    (AffineTransform) transform.clone(), xform,
                    composite, null, clip);
        } else {
            bufImage = op.filter(bufImage, null);
            Surface srcSurf = Surface.getImageSurface(bufImage);
            int w = srcSurf.getWidth();
            int h = srcSurf.getHeight();
            blitter.blit(0, 0, srcSurf, x, y, dstSurf, w, h,
                    (AffineTransform) transform.clone(),
                    composite, null, clip);
        }
    }

    @Override
    public boolean drawImage(Image image, AffineTransform trans,
            ImageObserver imageObserver) {

        if(image == null) {
            return true;
        }
        if(trans == null || trans.isIdentity()) {
            return drawImage(image, 0, 0, imageObserver);
        }

        boolean done = false;
        boolean somebits = false;
        Surface srcSurf = null;
        if(image instanceof OffscreenImage){
            OffscreenImage oi = (OffscreenImage) image;
            if((oi.getState() & ImageObserver.ERROR) != 0) {
                return false;
            }
            done = oi.prepareImage(imageObserver);
            somebits = (oi.getState() & ImageObserver.SOMEBITS) != 0;
            srcSurf = oi.getImageSurface();
        }else{
            done = true;
            srcSurf = Surface.getImageSurface(image);
        }

        if(done || somebits) {
            int w = srcSurf.getWidth();
            int h = srcSurf.getHeight();
            AffineTransform xform = (AffineTransform) transform.clone();
            xform.concatenate(trans);
            blitter.blit(0, 0, srcSurf, 0, 0, dstSurf, w, h, xform, composite,
                    null, clip);
        }
        return done;
    }

    @Override
    public void drawLine(int x1, int y1, int x2, int y2) {
        if (mP == null) {
            mP = new Paint();
        }
            mC.drawLine(x1, y1, x2, y2, mP);
    }

    @Override
    public void drawOval(int x, int y, int width, int height) {
            if (mP == null) {
                mP = new Paint();
            }
            mP.setStyle(Paint.Style.STROKE);
            mC.drawOval(new RectF(x, y, x + width, y + height), mP);
    }

    @Override
    public void drawPolygon(int[] xpoints, int[] ypoints, int npoints) {
            if (mP == null) {
                mP = new Paint();
            }
            mC.drawLine(xpoints[npoints - 1], ypoints[npoints - 1], xpoints[0],
                    ypoints[0], mP);
            for (int i = 0; i < npoints - 1; i++) {
                mC.drawLine(xpoints[i], ypoints[i], xpoints[i + 1],
                        ypoints[i + 1], mP);
            }
    }

    @Override
    public void drawPolyline(int[] xpoints, int[] ypoints, int npoints) {
        for (int i = 0; i < npoints - 1; i++) {
            drawLine(xpoints[i], ypoints[i], xpoints[i + 1], ypoints[i + 1]);
        }

    }

    @Override
    public void drawRoundRect(int x, int y, int width, int height,
            int arcWidth, int arcHeight) {
            if (mP == null) {
                mP = new Paint();
            }
            mC.drawRoundRect(new RectF(x, y, width, height), arcWidth,
                    arcHeight, mP);
    }

    @Override
    public void fillArc(int x, int y, int width, int height, int sa, int ea) {
            if (mP == null) {
                mP = new Paint();
            }

            Paint.Style tmp = mP.getStyle();
            mP.setStyle(Paint.Style.FILL_AND_STROKE);
            mC.drawArc(new RectF(x, y, x + width, y + height), 360 - (sa + ea),
                    ea, true, mP);

            mP.setStyle(tmp);
    }

    @Override
    public void fillOval(int x, int y, int width, int height) {
            if (mP == null) {
                mP = new Paint();
            }
            Paint.Style tmp = mP.getStyle();
            mP.setStyle(Paint.Style.FILL);
            mC.drawOval(new RectF(x, y, x + width, y + height), mP);
            mP.setStyle(tmp);
    }

    @Override
    public void fillPolygon(int[] xpoints, int[] ypoints, int npoints) {
            if (mP == null) {
                mP = new Paint();
            }
            Paint.Style tmp = mP.getStyle();
            mC.save(Canvas.CLIP_SAVE_FLAG);

            mP.setStyle(Paint.Style.FILL);

            GeneralPath filledPolygon = new GeneralPath(
                    GeneralPath.WIND_EVEN_ODD, npoints);
            filledPolygon.moveTo(xpoints[0], ypoints[0]);
            for (int index = 1; index < xpoints.length; index++) {
                filledPolygon.lineTo(xpoints[index], ypoints[index]);
            }
            filledPolygon.closePath();
            Path path = getPath(filledPolygon);
            mC.clipPath(path);
            mC.drawPath(path, mP);

            mP.setStyle(tmp);
            mC.restore();
    }

    @Override
    public void fillRect(int x, int y, int width, int height) {
            if (mP == null) {
                mP = new Paint();
            }
            Paint.Style tmp = mP.getStyle();
            mP.setStyle(Paint.Style.FILL);
            mC.drawRect(new Rect(x, y, x + width, y + height), mP);
            mP.setStyle(tmp);
    }

    @Override
    public void drawRect(int x, int y, int width, int height) {
        int[] xpoints = { x, x, x + width, x + width };
        int[] ypoints = { y, y + height, y + height, y };
        drawPolygon(xpoints, ypoints, 4);
    }

    @Override
    public void fillRoundRect(int x, int y, int width, int height,
            int arcWidth, int arcHeight) {
            if (mP == null) {
                mP = new Paint();
            }
            mP.setStyle(Paint.Style.FILL);
            mC.drawRoundRect(new RectF(x, y, x + width, y + height), arcWidth,
                    arcHeight, mP);
    }

    @Override
    public Shape getClip() {
        return mCurrClip;
    }

    @Override
    public Rectangle getClipBounds() {
            Rect r = mC.getClipBounds();
            return new Rectangle(r.left, r.top, r.width(), r.height());
    }

    @Override
    public Color getColor() {
        if (mP != null) {
            return new Color(mP.getColor());
        }
        return null;
    }

    @Override
    public Font getFont() {
        return mFnt;
    }

    @Override
    public FontMetrics getFontMetrics(Font font) {
        mFm = new FontMetricsImpl(font);
        return mFm;
    }

    @Override
    public void setClip(int x, int y, int width, int height) {
        int cl[] = {-1, x, y, -2, x, y + width, -2, x + height, y + width, -2, x + height, y};
        mCurrClip = new Area(createShape(cl));
        mC.clipRect(x, y, x + width, y + height, Region.Op.REPLACE);

    }

    @Override
    public void setClip(Shape clip) {
        mCurrClip = new Area(clip);
        mC.clipPath(getPath(clip), Region.Op.REPLACE);
    }

    @Override
    public void setColor(Color c) {
        if (mP == null) {
            mP = new Paint();
        }
        mP.setColor(c.getRGB());
    }

    /**
     * Font mapping:
     *
     * Family:
     *
     * Android         AWT
     * -------------------------------------
     * serif           Serif / TimesRoman
     * sans-serif      SansSerif / Helvetica
     * monospace       Monospaced / Courier
     *
     * Style:
     *
     * Android            AWT
     * -------------------------------------
     * normal          Plain
     * bold            bold
     * italic          italic
     *
     */
    @Override
    public void setFont(Font font) {
        if (font == null) {
            return;
        }
        if (mP == null) {
            mP = new Paint();
        }

        mFnt = font;
        Typeface tf = null;
        int sty = font.getStyle();
        String nam = font.getName();
        String aF = "";
        if (nam != null) {
            if (nam.equalsIgnoreCase("Serif")
                    || nam.equalsIgnoreCase("TimesRoman")) {
                aF = "serif";
            } else if (nam.equalsIgnoreCase("SansSerif")
                    || nam.equalsIgnoreCase("Helvetica")) {
                aF = "sans-serif";
            } else if (nam.equalsIgnoreCase("Monospaced")
                    || nam.equalsIgnoreCase("Courier")) {
                aF = "monospace";
            }
        }

        switch (sty) {
        case Font.PLAIN:
            tf = Typeface.create(aF, Typeface.NORMAL);
            break;
        case Font.BOLD:
            tf = Typeface.create(aF, Typeface.BOLD);
            break;
        case Font.ITALIC:
            tf = Typeface.create(aF, Typeface.ITALIC);
            break;
        case Font.BOLD | Font.ITALIC:
            tf = Typeface.create(aF, Typeface.BOLD_ITALIC);
            break;
        default:
            tf = Typeface.DEFAULT;
        }

        mP.setTextSize(font.getSize());
        mP.setTypeface(tf);
    }

    @Override
    public void drawBytes(byte[] data, int offset, int length, int x, int y) {
        drawString(new String(data, offset, length), x, y);
    }

    @Override
    public void drawPolygon(Polygon p) {
        drawPolygon(p.xpoints, p.ypoints, p.npoints);
    }

    @Override
    public void fillPolygon(Polygon p) {
        fillPolygon(p.xpoints, p.ypoints, p.npoints);
    }

    @Override
    public Rectangle getClipBounds(Rectangle r) {
        Shape clip = getClip();
        if (clip != null) {
            Rectangle b = clip.getBounds();
            r.x = b.x;
            r.y = b.y;
            r.width = b.width;
            r.height = b.height;
        }
        return r;
    }

    @Override
    public boolean hitClip(int x, int y, int width, int height) {
        return getClipBounds().intersects(new Rectangle(x, y, width, height));
    }

    @Override
    public void drawChars(char[] data, int offset, int length, int x, int y) {
        mC.drawText(data, offset, length, x, y, mP);
    }

    @Override
    public void setPaintMode() {
        if (mP == null) {
            mP = new Paint();
        }
        mP.setXfermode(null);
    }

    @Override
    public void setXORMode(Color color) {
        if (mP == null) {
            mP = new Paint();
        }
        mP.setXfermode(new PixelXorXfermode(color.getRGB()));
    }

    @Override
    public void fill3DRect(int x, int y, int width, int height, boolean raised) {
        Color color = getColor();
        Color colorUp, colorDown;
        if (raised) {
            colorUp = color.brighter();
            colorDown = color.darker();
            setColor(color);
        } else {
            colorUp = color.darker();
            colorDown = color.brighter();
            setColor(colorUp);
        }

        width--;
        height--;
        fillRect(x+1, y+1, width-1, height-1);

        setColor(colorUp);
        fillRect(x, y, width, 1);
        fillRect(x, y+1, 1, height);

        setColor(colorDown);
        fillRect(x+width, y, 1, height);
        fillRect(x+1, y+height, width, 1);
    }

    @Override
    public void draw3DRect(int x, int y, int width, int height, boolean raised) {
        Color color = getColor();
        Color colorUp, colorDown;
        if (raised) {
            colorUp = color.brighter();
            colorDown = color.darker();
        } else {
            colorUp = color.darker();
            colorDown = color.brighter();
        }

        setColor(colorUp);
        fillRect(x, y, width, 1);
        fillRect(x, y+1, 1, height);

        setColor(colorDown);
        fillRect(x+width, y, 1, height);
        fillRect(x+1, y+height, width, 1);
    }

    public void copyArea(Canvas canvas, int sx, int sy, int width, int height, int dx, int dy) {
        sx += getTransform().getTranslateX();
        sy += getTransform().getTranslateY();

        NativeUtils.nativeScrollRect(canvas,
                new Rect(sx, sy, sx + width, sy + height),
                dx, dy);
    }
}