/*

 * Copyright 1999-2007 Sun Microsystems, Inc.  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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package sun.java2d.x11;

import java.awt.GraphicsDevice;

import java.awt.GraphicsEnvironment;

import java.awt.Color;

import java.awt.Composite;

import java.awt.Rectangle;

import java.awt.GraphicsConfiguration;

import java.awt.Image;

import java.awt.color.ColorSpace;

import java.awt.Transparency;

import java.awt.image.BufferedImage;

import java.awt.image.ColorModel;

import java.awt.image.ComponentColorModel;

import java.awt.image.DirectColorModel;

import java.awt.image.IndexColorModel;

import java.awt.image.Raster;

import java.awt.peer.ComponentPeer;

import sun.awt.SunHints;

import sun.awt.SunToolkit;

import sun.awt.X11ComponentPeer;

import sun.awt.X11GraphicsConfig;

import sun.awt.image.PixelConverter;

import sun.font.X11TextRenderer;

import sun.java2d.InvalidPipeException;

import sun.java2d.SunGraphics2D;

import sun.java2d.SunGraphicsEnvironment;

import sun.java2d.SurfaceData;

import sun.java2d.SurfaceDataProxy;

import sun.java2d.loops.SurfaceType;

import sun.java2d.loops.CompositeType;

import sun.java2d.loops.RenderLoops;

import sun.java2d.loops.GraphicsPrimitive;

import sun.java2d.loops.XORComposite;

import sun.java2d.loops.Blit;

import sun.java2d.pipe.ValidatePipe;

import sun.java2d.pipe.PixelToShapeConverter;

import sun.java2d.pipe.TextPipe;

import sun.java2d.pipe.Region;

    X11ComponentPeer peer;

    X11GraphicsConfig graphicsConfig;

    private RenderLoops solidloops;

    protected int depth;

    private static native void initIDs(Class xorComp, boolean tryDGA);

    protected native void initSurface(int depth, int width, int height,

                                      long drawable);

    public static final String

        DESC_INT_BGR_X11        = "Integer BGR Pixmap";

    public static final String

        DESC_INT_RGB_X11        = "Integer RGB Pixmap";

    public static final String

        DESC_4BYTE_ABGR_PRE_X11 = "4 byte ABGR Pixmap with pre-multplied alpha";

    public static final String

        DESC_INT_ARGB_PRE_X11   = "Integer ARGB Pixmap with pre-multiplied " +

                                  "alpha";

    public static final String

        DESC_BYTE_IND_OPQ_X11   = "Byte Indexed Opaque Pixmap";

    public static final String

        DESC_INT_BGR_X11_BM     = "Integer BGR Pixmap with 1-bit transp";

    public static final String

        DESC_INT_RGB_X11_BM     = "Integer RGB Pixmap with 1-bit transp";

    public static final String

        DESC_BYTE_IND_X11_BM    = "Byte Indexed Pixmap with 1-bit transp";

    public static final String

        DESC_BYTE_GRAY_X11      = "Byte Gray Opaque Pixmap";

    public static final String

        DESC_INDEX8_GRAY_X11    = "Index8 Gray Opaque Pixmap";

    public static final String

        DESC_BYTE_GRAY_X11_BM   = "Byte Gray Opaque Pixmap with 1-bit transp";

    public static final String

        DESC_INDEX8_GRAY_X11_BM = "Index8 Gray Opaque Pixmap with 1-bit transp";

    public static final String

        DESC_3BYTE_RGB_X11      = "3 Byte RGB Pixmap";

    public static final String

        DESC_3BYTE_BGR_X11      = "3 Byte BGR Pixmap";

    public static final String

        DESC_3BYTE_RGB_X11_BM   = "3 Byte RGB Pixmap with 1-bit transp";

    public static final String

        DESC_3BYTE_BGR_X11_BM   = "3 Byte BGR Pixmap with 1-bit transp";

    public static final String

        DESC_USHORT_555_RGB_X11 = "Ushort 555 RGB Pixmap";

    public static final String

        DESC_USHORT_565_RGB_X11 = "Ushort 565 RGB Pixmap";

    public static final String

        DESC_USHORT_555_RGB_X11_BM

                                = "Ushort 555 RGB Pixmap with 1-bit transp";

    public static final String

        DESC_USHORT_565_RGB_X11_BM

                                = "Ushort 565 RGB Pixmap with 1-bit transp";

    public static final String

        DESC_USHORT_INDEXED_X11 = "Ushort Indexed Pixmap";

    public static final String

        DESC_USHORT_INDEXED_X11_BM = "Ushort Indexed Pixmap with 1-bit transp";

    public static final SurfaceType IntBgrX11 =

        SurfaceType.IntBgr.deriveSubType(DESC_INT_BGR_X11);

    public static final SurfaceType IntRgbX11 =

        SurfaceType.IntRgb.deriveSubType(DESC_INT_RGB_X11);

    public static final SurfaceType FourByteAbgrPreX11 =

        SurfaceType.FourByteAbgrPre.deriveSubType(DESC_4BYTE_ABGR_PRE_X11);

    public static final SurfaceType IntArgbPreX11 =

        SurfaceType.IntArgbPre.deriveSubType(DESC_INT_ARGB_PRE_X11);

    public static final SurfaceType ThreeByteRgbX11 =

        SurfaceType.ThreeByteRgb.deriveSubType(DESC_3BYTE_RGB_X11);

    public static final SurfaceType ThreeByteBgrX11 =

        SurfaceType.ThreeByteBgr.deriveSubType(DESC_3BYTE_BGR_X11);

    public static final SurfaceType UShort555RgbX11 =

        SurfaceType.Ushort555Rgb.deriveSubType(DESC_USHORT_555_RGB_X11);

    public static final SurfaceType UShort565RgbX11 =

        SurfaceType.Ushort565Rgb.deriveSubType(DESC_USHORT_565_RGB_X11);

    public static final SurfaceType UShortIndexedX11 =

        SurfaceType.UshortIndexed.deriveSubType(DESC_USHORT_INDEXED_X11);

    public static final SurfaceType ByteIndexedOpaqueX11 =

        SurfaceType.ByteIndexedOpaque.deriveSubType(DESC_BYTE_IND_OPQ_X11);

    public static final SurfaceType ByteGrayX11 =

        SurfaceType.ByteGray.deriveSubType(DESC_BYTE_GRAY_X11);

    public static final SurfaceType Index8GrayX11 =

        SurfaceType.Index8Gray.deriveSubType(DESC_INDEX8_GRAY_X11);

    // Bitmap surface types

    public static final SurfaceType IntBgrX11_BM =

        SurfaceType.Custom.deriveSubType(DESC_INT_BGR_X11_BM,

                                         PixelConverter.Xbgr.instance);

    public static final SurfaceType IntRgbX11_BM =

        SurfaceType.Custom.deriveSubType(DESC_INT_RGB_X11_BM,

                                         PixelConverter.Xrgb.instance);

    public static final SurfaceType ThreeByteRgbX11_BM =

        SurfaceType.Custom.deriveSubType(DESC_3BYTE_RGB_X11_BM,

                                         PixelConverter.Xbgr.instance);

    public static final SurfaceType ThreeByteBgrX11_BM =

        SurfaceType.Custom.deriveSubType(DESC_3BYTE_BGR_X11_BM,

                                         PixelConverter.Xrgb.instance);

    public static final SurfaceType UShort555RgbX11_BM =

        SurfaceType.Custom.deriveSubType(DESC_USHORT_555_RGB_X11_BM,

                                         PixelConverter.Ushort555Rgb.instance);

    public static final SurfaceType UShort565RgbX11_BM =

        SurfaceType.Custom.deriveSubType(DESC_USHORT_565_RGB_X11_BM,

                                         PixelConverter.Ushort565Rgb.instance);

    public static final SurfaceType UShortIndexedX11_BM =

        SurfaceType.Custom.deriveSubType(DESC_USHORT_INDEXED_X11_BM);

    public static final SurfaceType ByteIndexedX11_BM =

        SurfaceType.Custom.deriveSubType(DESC_BYTE_IND_X11_BM);

    public static final SurfaceType ByteGrayX11_BM =

        SurfaceType.Custom.deriveSubType(DESC_BYTE_GRAY_X11_BM);

    public static final SurfaceType Index8GrayX11_BM =

        SurfaceType.Custom.deriveSubType(DESC_INDEX8_GRAY_X11_BM);

    private static Boolean accelerationEnabled = null;

    public Raster getRaster(int x, int y, int w, int h) {

        throw new InternalError("not implemented yet");

    }

    protected X11Renderer x11pipe;

    protected PixelToShapeConverter x11txpipe;

    protected static TextPipe x11textpipe;

    protected static boolean dgaAvailable;

    static {

            // If a screen magnifier is present, don't attempt to use DGA

            String magPresent = (String) java.security.AccessController.doPrivileged

                (new sun.security.action.GetPropertyAction("javax.accessibility.screen_magnifier_present"));

            boolean tryDGA = magPresent == null || !"true".equals(magPresent);

            initIDs(XORComposite.class, tryDGA);

            String xtextpipe = (String) java.security.AccessController.doPrivileged

                (new sun.security.action.GetPropertyAction("sun.java2d.xtextpipe"));

            if (xtextpipe == null || "true".startsWith(xtextpipe)) {

                if ("true".equals(xtextpipe)) {

                    // Only verbose if they use the full string "true"

                    System.out.println("using X11 text renderer");

                }

                x11textpipe = new X11TextRenderer();

                if (GraphicsPrimitive.tracingEnabled()) {

                    x11textpipe = ((X11TextRenderer) x11textpipe).traceWrap();

                }

            } else {

                if ("false".equals(xtextpipe)) {

                    // Only verbose if they use the full string "false"

                    System.out.println("using DGA text renderer");

                }

                x11textpipe = solidTextRenderer;

            }

            dgaAvailable = isDgaAvailable();

            if (isAccelerationEnabled()) {

                X11PMBlitLoops.register();

                X11PMBlitBgLoops.register();

            }

    }

    /**

     * Returns true if we can use DGA on any of the screens

     */

    public static native boolean isDgaAvailable();

    /**

     * Returns true if shared memory pixmaps are available

     */

    private static native boolean isShmPMAvailable();

    public static boolean isAccelerationEnabled() {

        if (accelerationEnabled == null) {

            if (GraphicsEnvironment.isHeadless()) {

                accelerationEnabled = Boolean.FALSE;

            } else {

                String prop =

                    (String) java.security.AccessController.doPrivileged(

                        new sun.security.action.GetPropertyAction("sun.java2d.pmoffscreen"));

                if (prop != null) {

                    // true iff prop==true, false otherwise

                    accelerationEnabled = Boolean.valueOf(prop);

                } else {

                    boolean isDisplayLocal = false;

                    GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();

                    if (ge instanceof SunGraphicsEnvironment) {

                        isDisplayLocal = ((SunGraphicsEnvironment) ge).isDisplayLocal();

                     }

                    // EXA based drivers tend to place pixmaps in VRAM, slowing down readbacks.

                    // Don't use pixmaps if dga is available,

                    // or we are local and shared memory Pixmaps are not available.

                    accelerationEnabled =

                        !(isDgaAvailable() || (isDisplayLocal && !isShmPMAvailable()));

                }

            }

        }

        return accelerationEnabled.booleanValue();

    }

    @Override

    public SurfaceDataProxy makeProxyFor(SurfaceData srcData) {

        return X11SurfaceDataProxy.createProxy(srcData, graphicsConfig);

    }

    public void validatePipe(SunGraphics2D sg2d) {

        if (sg2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON &&

            sg2d.paintState <= sg2d.PAINT_ALPHACOLOR &&

            (sg2d.compositeState <= sg2d.COMP_ISCOPY ||

             sg2d.compositeState == sg2d.COMP_XOR))

        {

            if (x11txpipe == null) {

                /*

                 * Note: this is thread-safe since x11txpipe is the

                 * second of the two pipes constructed in makePipes().

                 * In the rare case we are racing against another

                 * thread making new pipes, setting lazypipe is a

                 * safe alternative to waiting for the other thread.

                 */

                sg2d.drawpipe = lazypipe;

                sg2d.fillpipe = lazypipe;

                sg2d.shapepipe = lazypipe;

                sg2d.imagepipe = lazypipe;

                sg2d.textpipe = lazypipe;

                return;

            }

            if (sg2d.clipState == sg2d.CLIP_SHAPE) {

                // Do this to init textpipe correctly; we will override the

                // other non-text pipes below

                // REMIND: we should clean this up eventually instead of

                // having this work duplicated.

                super.validatePipe(sg2d);

            } else {

                switch (sg2d.textAntialiasHint) {

                case SunHints.INTVAL_TEXT_ANTIALIAS_DEFAULT:

                    /* equating to OFF which it is for us */

                case SunHints.INTVAL_TEXT_ANTIALIAS_OFF:

                    // Use X11 pipe even if DGA is available since DGA

                    // text slows everything down when mixed with X11 calls

                    if (sg2d.compositeState == sg2d.COMP_ISCOPY) {

                        sg2d.textpipe = x11textpipe;

                    } else {

                        sg2d.textpipe = solidTextRenderer;

                    }

                    break;

                case SunHints.INTVAL_TEXT_ANTIALIAS_ON:

                    // Remind: may use Xrender for these when composite is

                    // copy as above, or if remote X11.

                    sg2d.textpipe = aaTextRenderer;

                    break;

                default:

                    switch (sg2d.getFontInfo().aaHint) {

                    case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_HRGB:

                    case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_VRGB:

                        sg2d.textpipe = lcdTextRenderer;

                        break;

                    case SunHints.INTVAL_TEXT_ANTIALIAS_OFF:

                    // Use X11 pipe even if DGA is available since DGA

                    // text slows everything down when mixed with X11 calls

                    if (sg2d.compositeState == sg2d.COMP_ISCOPY) {

                        sg2d.textpipe = x11textpipe;

                    } else {

                        sg2d.textpipe = solidTextRenderer;

                    }

                    break;

                    case SunHints.INTVAL_TEXT_ANTIALIAS_ON:

                        sg2d.textpipe = aaTextRenderer;

                        break;

                    default:

                        sg2d.textpipe = solidTextRenderer;

                    }

                }

            }

            if (sg2d.transformState >= sg2d.TRANSFORM_TRANSLATESCALE) {

                sg2d.drawpipe = x11txpipe;

                sg2d.fillpipe = x11txpipe;

            } else if (sg2d.strokeState != sg2d.STROKE_THIN){

                sg2d.drawpipe = x11txpipe;

                sg2d.fillpipe = x11pipe;

            } else {

                sg2d.drawpipe = x11pipe;

                sg2d.fillpipe = x11pipe;

            }

            sg2d.shapepipe = x11pipe;

            sg2d.imagepipe = imagepipe;

            // This is needed for AA text.

            // Note that even an X11TextRenderer can dispatch AA text

            // if a GlyphVector overrides the AA setting.

            // We use getRenderLoops() rather than setting solidloops

            // directly so that we get the appropriate loops in XOR mode.

            if (sg2d.loops == null) {

                // assert(some pipe will always be a LoopBasedPipe)

                sg2d.loops = getRenderLoops(sg2d);

            }

        } else {

            super.validatePipe(sg2d);

        }

    }

    public RenderLoops getRenderLoops(SunGraphics2D sg2d) {

        if (sg2d.paintState <= sg2d.PAINT_ALPHACOLOR &&

            sg2d.compositeState <= sg2d.COMP_ISCOPY)

        {

            return solidloops;

        }

        return super.getRenderLoops(sg2d);

    }

    public GraphicsConfiguration getDeviceConfiguration() {

        return graphicsConfig;

    }

    /**

     * Method for instantiating a Window SurfaceData

     */

    public static X11WindowSurfaceData createData(X11ComponentPeer peer) {

       X11GraphicsConfig gc = getGC(peer);

       return new X11WindowSurfaceData(peer, gc, gc.getSurfaceType());

    }

    /**

     * Method for instantiating a Pixmap SurfaceData (offscreen)

     */

    public static X11PixmapSurfaceData createData(X11GraphicsConfig gc,

                                                  int width, int height,

                                                  ColorModel cm, Image image,

                                                  long drawable,

                                                  int transparency)

    {

        return new X11PixmapSurfaceData(gc, width, height, image,

                                        getSurfaceType(gc, transparency, true),

                                        cm, drawable, transparency);

    }

    protected X11SurfaceData(X11ComponentPeer peer,

                             X11GraphicsConfig gc,

                             SurfaceType sType,

                             ColorModel cm) {

        super(sType, cm);

        this.peer = peer;

        this.graphicsConfig = gc;

        this.solidloops = graphicsConfig.getSolidLoops(sType);

        this.depth = cm.getPixelSize();

        initOps(peer, graphicsConfig, depth);

        if (isAccelerationEnabled()) {

            setBlitProxyKey(gc.getProxyKey());

        }

    }

    public static X11GraphicsConfig getGC(X11ComponentPeer peer) {

        if (peer != null) {

            return (X11GraphicsConfig) peer.getGraphicsConfiguration();

        } else {

            GraphicsEnvironment env =

                GraphicsEnvironment.getLocalGraphicsEnvironment();

            GraphicsDevice gd = env.getDefaultScreenDevice();

            return (X11GraphicsConfig)gd.getDefaultConfiguration();

        }

    }

    /**

     * Returns a boolean indicating whether or not a copyArea from

     * the given rectangle source coordinates might be incomplete

     * and result in X11 GraphicsExposure events being generated

     * from XCopyArea.

     * This method allows the SurfaceData copyArea method to determine

     * if it needs to set the GraphicsExposures attribute of the X11 GC

     * to True or False to receive or avoid the events.

     * @return true if there is any chance that an XCopyArea from the

     *              given source coordinates could produce any X11

     *              Exposure events.

     */

    public abstract boolean canSourceSendExposures(int x, int y, int w, int h);

    public boolean copyArea(SunGraphics2D sg2d,

                            int x, int y, int w, int h, int dx, int dy)

    {

        if (x11pipe == null) {

            if (!isDrawableValid()) {

                return true;

            }

            makePipes();

        }

        CompositeType comptype = sg2d.imageComp;

        if (sg2d.transformState < sg2d.TRANSFORM_TRANSLATESCALE &&

            (CompositeType.SrcOverNoEa.equals(comptype) ||

             CompositeType.SrcNoEa.equals(comptype)))

        {

            x += sg2d.transX;

            y += sg2d.transY;

            SunToolkit.awtLock();

            try {

                boolean needExposures = canSourceSendExposures(x, y, w, h);

                long xgc = getBlitGC(sg2d.getCompClip(), needExposures);

                x11pipe.devCopyArea(getNativeOps(), xgc,

                                    x, y,

                                    x + dx, y + dy,

                                    w, h);

            } finally {

                SunToolkit.awtUnlock();

            }

            return true;

        }

        return false;

    }

    public static SurfaceType getSurfaceType(X11GraphicsConfig gc,

                                             int transparency)

    {

        return getSurfaceType(gc, transparency, false);

    }

    public static SurfaceType getSurfaceType(X11GraphicsConfig gc,

                                             int transparency,

                                             boolean pixmapSurface)

    {

        boolean transparent = (transparency == Transparency.BITMASK);