/*
 * Copyright 2000-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 sun.awt.SunToolkit;
import sun.java2d.loops.GraphicsPrimitive;
import sun.java2d.loops.GraphicsPrimitiveMgr;
import sun.java2d.loops.GraphicsPrimitiveProxy;
import sun.java2d.loops.CompositeType;
import sun.java2d.loops.SurfaceType;
import sun.java2d.loops.Blit;
import sun.java2d.loops.MaskBlit;
import sun.java2d.pipe.Region;
import sun.java2d.SurfaceData;
import java.awt.Composite;
import java.awt.image.IndexColorModel;

/**
 * X11PMBlitLoops
 *
 * This class accelerates Blits between two surfaces of types *PM.  Since
 * the onscreen surface is of that type and some of the offscreen surfaces
 * may be of that type (if they were created via X11OffScreenImage), then
 * this type of Blit will accelerated double-buffer copies between those
 * two surfaces.
*/
public class X11PMBlitLoops extends Blit {

    public static void register()
    {
        GraphicsPrimitive[] primitives = {
            new X11PMBlitLoops(X11SurfaceData.IntBgrX11,
                               X11SurfaceData.IntBgrX11, false),
            new X11PMBlitLoops(X11SurfaceData.IntRgbX11,
                               X11SurfaceData.IntRgbX11, false),
            new X11PMBlitLoops(X11SurfaceData.ThreeByteBgrX11,
                               X11SurfaceData.ThreeByteBgrX11, false),
            new X11PMBlitLoops(X11SurfaceData.ThreeByteRgbX11,
                               X11SurfaceData.ThreeByteRgbX11, false),
            new X11PMBlitLoops(X11SurfaceData.ByteIndexedOpaqueX11,
                               X11SurfaceData.ByteIndexedOpaqueX11, false),
            new X11PMBlitLoops(X11SurfaceData.ByteGrayX11,
                               X11SurfaceData.ByteGrayX11, false),
            new X11PMBlitLoops(X11SurfaceData.Index8GrayX11,
                               X11SurfaceData.Index8GrayX11, false),
            new X11PMBlitLoops(X11SurfaceData.UShort555RgbX11,
                               X11SurfaceData.UShort555RgbX11, false),
            new X11PMBlitLoops(X11SurfaceData.UShort565RgbX11,
                               X11SurfaceData.UShort565RgbX11, false),
            new X11PMBlitLoops(X11SurfaceData.UShortIndexedX11,
                               X11SurfaceData.UShortIndexedX11, false),

            // 1-bit transparent to opaque loops
            new X11PMBlitLoops(X11SurfaceData.IntBgrX11_BM,
                               X11SurfaceData.IntBgrX11, true),
            new X11PMBlitLoops(X11SurfaceData.IntRgbX11_BM,
                               X11SurfaceData.IntRgbX11, true),
            new X11PMBlitLoops(X11SurfaceData.ThreeByteBgrX11_BM,
                               X11SurfaceData.ThreeByteBgrX11, true),
            new X11PMBlitLoops(X11SurfaceData.ThreeByteRgbX11_BM,
                               X11SurfaceData.ThreeByteRgbX11, true),
            new X11PMBlitLoops(X11SurfaceData.ByteIndexedX11_BM,
                               X11SurfaceData.ByteIndexedOpaqueX11, true),
            new X11PMBlitLoops(X11SurfaceData.ByteGrayX11_BM,
                               X11SurfaceData.ByteGrayX11, true),
            new X11PMBlitLoops(X11SurfaceData.Index8GrayX11_BM,
                               X11SurfaceData.Index8GrayX11, true),
            new X11PMBlitLoops(X11SurfaceData.UShort555RgbX11_BM,
                               X11SurfaceData.UShort555RgbX11, true),
            new X11PMBlitLoops(X11SurfaceData.UShort565RgbX11_BM,
                               X11SurfaceData.UShort565RgbX11, true),
            new X11PMBlitLoops(X11SurfaceData.UShortIndexedX11_BM,
                               X11SurfaceData.UShortIndexedX11, true),

            // delegate loops
            new DelegateBlitLoop(X11SurfaceData.IntBgrX11_BM,
                                 X11SurfaceData.IntBgrX11),
            new DelegateBlitLoop(X11SurfaceData.IntRgbX11_BM,
                                 X11SurfaceData.IntRgbX11),
            new DelegateBlitLoop(X11SurfaceData.ThreeByteBgrX11_BM,
                                 X11SurfaceData.ThreeByteBgrX11),
            new DelegateBlitLoop(X11SurfaceData.ThreeByteRgbX11_BM,
                                 X11SurfaceData.ThreeByteRgbX11),
            new DelegateBlitLoop(X11SurfaceData.ByteIndexedX11_BM,
                                 X11SurfaceData.ByteIndexedOpaqueX11),
            new DelegateBlitLoop(X11SurfaceData.ByteGrayX11_BM,
                                 X11SurfaceData.ByteGrayX11),
            new DelegateBlitLoop(X11SurfaceData.Index8GrayX11_BM,
                                 X11SurfaceData.Index8GrayX11),
            new DelegateBlitLoop(X11SurfaceData.UShort555RgbX11_BM,
                                 X11SurfaceData.UShort555RgbX11),
            new DelegateBlitLoop(X11SurfaceData.UShort565RgbX11_BM,
                                 X11SurfaceData.UShort565RgbX11),
            new DelegateBlitLoop(X11SurfaceData.UShortIndexedX11_BM,
                                 X11SurfaceData.UShortIndexedX11),

        };
        GraphicsPrimitiveMgr.register(primitives);
    }

    public X11PMBlitLoops(SurfaceType srcType, SurfaceType dstType,
                          boolean over) {
        super(srcType,
              over ? CompositeType.SrcOverNoEa : CompositeType.SrcNoEa,
              dstType);
    }

    public void Blit(SurfaceData src, SurfaceData dst,
                     Composite comp, Region clip,
                     int sx, int sy,
                     int dx, int dy,
                     int w, int h)
    {
        SunToolkit.awtLock();
        try {
            X11SurfaceData x11sd = (X11SurfaceData)dst;
            // pass null clip region here since we clip manually in native code
            // also use false for needExposures since we clip to the pixmap
            long xgc = x11sd.getBlitGC(null, false);
            nativeBlit(src.getNativeOps(), dst.getNativeOps(), xgc, clip,
                       sx, sy, dx, dy, w, h);
        } finally {
            SunToolkit.awtUnlock();
        }
    }

    /**
     * Blit
     * This native method is where all of the work happens in the
     * accelerated Blit.
     */
    private native void nativeBlit(long srcData, long dstData,
                                   long xgc, Region clip,
                                   int sx, int sy, int dx, int dy,
                                   int w, int h);

    /**
     * This loop is used to render from a BITMASK Sw surface data
     * to the Hw cached copies managed by SurfaceDataProxies.
     * It first uses a delegate opaque Blit to perform the copy of
     * the pixel data and then updates the X11 clipping bitmask from
     * the transparent pixels in the source.
     */
    static class DelegateBlitLoop extends Blit {
        SurfaceType dstType;

        /**
         * @param realDstType SurfaceType for which the loop should be
         * registered
         * @param delegateDstType SurfaceType which will be used
         * for finding delegate loop
         */
        public DelegateBlitLoop(SurfaceType realDstType, SurfaceType delegateDstType) {
            super(SurfaceType.Any, CompositeType.SrcNoEa, realDstType);
            this.dstType = delegateDstType;
        }

        public void Blit(SurfaceData src, SurfaceData dst,
                         Composite comp, Region clip,
                         int sx, int sy, int dx, int dy, int w, int h)
        {
            Blit blit = Blit.getFromCache(src.getSurfaceType(),
                                          CompositeType.SrcNoEa,
                                          dstType);
            blit.Blit(src, dst, comp, clip, sx, sy, dx, dy, w, h);
            updateBitmask(src, dst,
                          src.getColorModel() instanceof IndexColorModel);
        }
    }

    private static native void updateBitmask(SurfaceData src,
                                             SurfaceData dst,
                                             boolean isICM);
}