/*
 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code 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 General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package sun.java2d.xr;

import java.awt.geom.*;
import java.util.*;

import sun.font.*;
import sun.java2d.jules.*;
import sun.java2d.pipe.*;

import static sun.java2d.xr.XRUtils.XDoubleToFixed;

/**
 * Native implementation of XRBackend.
 * Almost direct 1:1 binding to libX11.
 *
 * @author Clemens Eisserer
 */

public class XRBackendNative implements XRBackend {

    static {
        initIDs();
    }

    private static long FMTPTR_A8;
    private static long FMTPTR_ARGB32;
    private static long MASK_XIMG;

    private static native void initIDs();

    public native long createGC(int drawable);

    public native void freeGC(long gc);

    public native int createPixmap(int drawable, int depth,
                                   int width, int height);

    private native int createPictureNative(int drawable, long formatID);

    public native void freePicture(int picture);

    public native void freePixmap(int pixmap);

    public native void setGCExposures(long gc, boolean exposure);

    public native void setGCForeground(long gc, int pixel);

    public native void setPictureRepeat(int picture, int repeat);

    public native void copyArea(int src, int dst, long gc,
                                int srcx, int srcy, int width, int height,
                                 int dstx, int dsty);

    public native void setGCMode(long gc, boolean copy);

    private static native void GCRectanglesNative(int drawable, long gc,
                                                  int[] rectArray, int rectCnt);

    public native void renderComposite(byte op, int src, int mask,
                                       int dst, int srcX, int srcY,
                                       int maskX, int maskY, int dstX, int dstY,
                                       int width, int height);

    private native void renderRectangle(int dst, byte op,
                                        short red, short green,
                                        short blue, short alpha,
                                        int x, int y, int width, int height);

    private static native void
         XRenderRectanglesNative(int dst, byte op,
                                 short red, short green,
                                 short blue, short alpha,
                                 int[] rects, int rectCnt);

    private native void XRSetTransformNative(int pic,
                                             int m00, int m01, int m02,
                                             int m10, int m11, int m12);

    private static native int
        XRCreateLinearGradientPaintNative(float[] fractionsArray,
                                          short[] pixelsArray,
                                          int x1, int y1, int x2, int y2,
                                          int numStops, int repeat);

    private static native int
        XRCreateRadialGradientPaintNative(float[] fractionsArray,
                                          short[] pixelsArray, int numStops,
                                          int centerX, int centerY,
                                          int innerRadius, int outerRadius,
                                          int repeat);

    public native void setFilter(int picture, int filter);

    private static native void XRSetClipNative(long dst,
                                               int x1, int y1, int x2, int y2,
                                               Region clip, boolean isGC);

    public void GCRectangles(int drawable, long gc, GrowableRectArray rects) {
        GCRectanglesNative(drawable, gc, rects.getArray(), rects.getSize());
    }

    public int createPicture(int drawable, int formatID) {
        return createPictureNative(drawable, getFormatPtr(formatID));
    }

    public void setPictureTransform(int picture, AffineTransform transform) {
        XRSetTransformNative(picture,
                             XDoubleToFixed(transform.getScaleX()),
                             XDoubleToFixed(transform.getShearX()),
                             XDoubleToFixed(transform.getTranslateX()),
                             XDoubleToFixed(transform.getShearY()),
                             XDoubleToFixed(transform.getScaleY()),
                             XDoubleToFixed(transform.getTranslateY()));
    }

    public void renderRectangle(int dst, byte op, XRColor color,
                                int x, int y, int width, int height) {
        renderRectangle(dst, op, (short)color.red, (short)color.green,
                       (short)color.blue, (short)color.alpha,
                        x, y, width, height);
    }

    private short[] getRenderColors(int[] pixels) {
        short[] renderColors = new short[pixels.length * 4];

        XRColor c = new XRColor();
        for (int i = 0; i < pixels.length; i++) {
            c.setColorValues(pixels[i], true);
            renderColors[i * 4 + 0] = (short) c.alpha;
            renderColors[i * 4 + 1] = (short) c.red;
            renderColors[i * 4 + 2] = (short) c.green;
            renderColors[i * 4 + 3] = (short) c.blue;
        }

        return renderColors;
    }

    private static long getFormatPtr(int formatID) {
        switch (formatID) {
        case XRUtils.PictStandardA8:
            return FMTPTR_A8;
        case XRUtils.PictStandardARGB32:
            return FMTPTR_ARGB32;
        }

        return 0L;
    }

    public int createLinearGradient(Point2D p1, Point2D p2, float[] fractions,
                              int[] pixels,  int repeat) {

        short[] colorValues = getRenderColors(pixels);
        int gradient =
           XRCreateLinearGradientPaintNative(fractions, colorValues,
                XDoubleToFixed(p1.getX()), XDoubleToFixed(p1.getY()),
                XDoubleToFixed(p2.getX()), XDoubleToFixed(p2.getY()),
                fractions.length, repeat);
        return gradient;
    }

    public int createRadialGradient(float centerX, float centerY,
                                   float innerRadius, float outerRadius,
                                   float[] fractions, int[] pixels, int repeat) {

        short[] colorValues = getRenderColors(pixels);
        return XRCreateRadialGradientPaintNative
             (fractions, colorValues, fractions.length,
              XDoubleToFixed(centerX),
              XDoubleToFixed(centerY),
              XDoubleToFixed(innerRadius),
              XDoubleToFixed(outerRadius),
              repeat);
    }

    public void setGCClipRectangles(long gc, Region clip) {
        XRSetClipNative(gc, clip.getLoX(), clip.getLoY(),
                        clip.getHiX(), clip.getHiY(),
                        clip.isRectangular() ? null : clip, true);
    }

    public void setClipRectangles(int picture, Region clip) {
        if (clip != null) {
            XRSetClipNative(picture, clip.getLoX(), clip.getLoY(),
                            clip.getHiX(), clip.getHiY(),
                            clip.isRectangular() ? null : clip, false);
        } else {
            XRSetClipNative(picture, 0, 0, 32767, 32767, null, false);
        }
    }

    public void renderRectangles(int dst, byte op, XRColor color,
                                 GrowableRectArray rects) {
        XRenderRectanglesNative(dst, op,
                                (short) color.red, (short) color.green,
                                (short) color.blue, (short) color.alpha,
                                rects.getArray(), rects
                .getSize());
    }

    private static long[] getGlyphInfoPtrs(List<XRGlyphCacheEntry> cacheEntries) {
        long[] glyphInfoPtrs = new long[cacheEntries.size()];
        for (int i = 0; i < cacheEntries.size(); i++) {
            glyphInfoPtrs[i] = cacheEntries.get(i).getGlyphInfoPtr();
        }
        return glyphInfoPtrs;
    }

    public void XRenderAddGlyphs(int glyphSet, GlyphList gl,
                                 List<XRGlyphCacheEntry> cacheEntries,
                                 byte[] pixelData) {
        long[] glyphInfoPtrs = getGlyphInfoPtrs(cacheEntries);
        XRAddGlyphsNative(glyphSet, glyphInfoPtrs,
                          glyphInfoPtrs.length, pixelData, pixelData.length);
    }

    public void XRenderFreeGlyphs(int glyphSet, int[] gids) {
        XRFreeGlyphsNative(glyphSet, gids, gids.length);
    }

    private static native void XRAddGlyphsNative(int glyphSet,
                                                 long[] glyphInfoPtrs,
                                                 int glyphCnt,
                                                 byte[] pixelData,
                                                 int pixelDataLength);

    private static native void XRFreeGlyphsNative(int glyphSet,
                                                  int[] gids, int idCnt);

    private static native void
        XRenderCompositeTextNative(int op, int src, int dst,
                                   int srcX, int srcY, long maskFormat,
                                   int[] eltArray, int[] glyphIDs, int eltCnt,
                                   int glyphCnt);

    public int XRenderCreateGlyphSet(int formatID) {
        return XRenderCreateGlyphSetNative(getFormatPtr(formatID));
    }

    private static native int XRenderCreateGlyphSetNative(long format);

    public void XRenderCompositeText(byte op, int src, int dst,
                                     int maskFormatID,
                                     int sx, int sy, int dx, int dy,
                                     int glyphset, GrowableEltArray elts) {

        GrowableIntArray glyphs = elts.getGlyphs();
        XRenderCompositeTextNative(op, src, dst, sx, sy, 0, elts.getArray(),
                                   glyphs.getArray(), elts.getSize(),
                                   glyphs.getSize());
    }

    public void putMaskImage(int drawable, long gc, byte[] imageData,
                             int sx, int sy, int dx, int dy,
                             int width, int height, int maskOff,
                             int maskScan, float ea) {
        putMaskNative(drawable, gc, imageData, sx, sy, dx, dy,
                      width, height, maskOff, maskScan, ea, MASK_XIMG);
    }

    private static native void putMaskNative(int drawable, long gc,
                                             byte[] imageData,
                                             int sx, int sy, int dx, int dy,
                                             int width, int height,
                                             int maskOff, int maskScan,
                                             float ea, long xImg);

    public void padBlit(byte op, int srcPict, int maskPict, int dstPict,
                        AffineTransform maskTrx, int maskWidth, int maskHeight,
                        int lastMaskWidth, int lastMaskHeight,
                        int sx, int sy, int dx, int dy, int w, int h) {

        padBlitNative(op, srcPict, maskPict, dstPict,
                      XDoubleToFixed(maskTrx.getScaleX()),
                      XDoubleToFixed(maskTrx.getShearX()),
                      XDoubleToFixed(maskTrx.getTranslateX()),
                      XDoubleToFixed(maskTrx.getShearY()),
                      XDoubleToFixed(maskTrx.getScaleY()),
                      XDoubleToFixed(maskTrx.getTranslateY()),
                      maskWidth, maskHeight, lastMaskWidth, lastMaskHeight,
                      sx, sy, dx, dy, w, h);
    }

    private static native void padBlitNative(byte op, int srcPict,
                                             int maskPict, int dstPict,
                                             int m00, int m01, int m02,
                                             int m10, int m11, int m12,
                                             int maskWidth, int maskHeight,
                                             int lastMaskWidth,
                                             int lastMaskHeight,
                                             int sx, int sy, int dx, int dy,
                                             int w, int h);

    public void renderCompositeTrapezoids(byte op, int src, int maskFormat,
                                          int dst, int srcX, int srcY,
                                          TrapezoidList trapList) {
        renderCompositeTrapezoidsNative(op, src, getFormatPtr(maskFormat),
                                        dst, srcX, srcY,
                                        trapList.getTrapArray());
    }

    private static native void
        renderCompositeTrapezoidsNative(byte op, int src, long maskFormat,
                                        int dst, int srcX, int srcY,
                                        int[] trapezoids);
}