/*

 * Copyright (c) 2008, 2010, 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.

 */

#include "math.h"

#include "GraphicsPrimitiveMgr.h"

#include "ParallelogramUtils.h"

#include "sun_java2d_loops_FillParallelogram.h"

/*

 * Class:     sun_java2d_loops_FillParallelogram

 * Method:    FillParallelogram

 * Signature: (Lsun/java2d/SunGraphics2D;Lsun/java2d/SurfaceData;DDDDDD)V

 */

JNIEXPORT void JNICALL

Java_sun_java2d_loops_FillParallelogram_FillParallelogram

    (JNIEnv *env, jobject self,

     jobject sg2d, jobject sData,

     jdouble x0, jdouble y0,

     jdouble dx1, jdouble dy1,

     jdouble dx2, jdouble dy2)

{

    SurfaceDataOps *sdOps;

    SurfaceDataRasInfo rasInfo;

    NativePrimitive *pPrim;

    CompositeInfo compInfo;

    jint pixel;

    jint ix1, iy1, ix2, iy2;

    if ((dy1 == 0 && dx1 == 0) || (dy2 == 0 && dx2 == 0)) {

        return;

    }

    /*

     * Sort parallelogram by y values, ensure that each delta vector

     * has a non-negative y delta.

     */

    SORT_PGRAM(x0, y0, dx1, dy1, dx2, dy2, );

    PGRAM_MIN_MAX(ix1, ix2, x0, dx1, dx2, JNI_FALSE);

    iy1 = (jint) floor(y0 + 0.5);

    iy2 = (jint) floor(y0 + dy1 + dy2 + 0.5);

    pPrim = GetNativePrim(env, self);

    if (pPrim == NULL) {

        return;

    }

    pixel = GrPrim_Sg2dGetPixel(env, sg2d);

    if (pPrim->pCompType->getCompInfo != NULL) {

        GrPrim_Sg2dGetCompInfo(env, sg2d, pPrim, &compInfo);

    }

    sdOps = SurfaceData_GetOps(env, sData);

    if (sdOps == NULL) {

        return;

    }

    GrPrim_Sg2dGetClip(env, sg2d, &rasInfo.bounds);

    SurfaceData_IntersectBoundsXYXY(&rasInfo.bounds, ix1, iy1, ix2, iy2);

    if (rasInfo.bounds.y2 <= rasInfo.bounds.y1 ||

        rasInfo.bounds.x2 <= rasInfo.bounds.x1)

    {

        return;

    }

    if (sdOps->Lock(env, sdOps, &rasInfo, pPrim->dstflags) != SD_SUCCESS) {

        return;

    }

    ix1 = rasInfo.bounds.x1;

    iy1 = rasInfo.bounds.y1;

    ix2 = rasInfo.bounds.x2;

    iy2 = rasInfo.bounds.y2;

    if (ix2 > ix1 && iy2 > iy1) {

        sdOps->GetRasInfo(env, sdOps, &rasInfo);

        if (rasInfo.rasBase) {

            jdouble lslope = (dy1 == 0) ? 0 : dx1 / dy1;

            jdouble rslope = (dy2 == 0) ? 0 : dx2 / dy2;

            jlong ldx = DblToLong(lslope);

            jlong rdx = DblToLong(rslope);

            jint cy1, cy2, loy, hiy;

            dx1 += x0;

            dy1 += y0;

            dx2 += x0;

            dy2 += y0;

            cy1 = (jint) floor(dy1 + 0.5);

            cy2 = (jint) floor(dy2 + 0.5);

            /* Top triangular portion. */

            loy = iy1;

            hiy = (cy1 < cy2) ? cy1 : cy2;

            if (hiy > iy2) hiy = iy2;

            if (loy < hiy) {

                jlong lx = PGRAM_INIT_X(loy, x0, y0, lslope);

                jlong rx = PGRAM_INIT_X(loy, x0, y0, rslope);

                (*pPrim->funcs.fillparallelogram)(&rasInfo,

                                                  ix1, loy, ix2, hiy,

                                                  lx, ldx, rx, rdx,

                                                  pixel, pPrim, &compInfo);

            }

            /* Middle parallelogram portion, which way does it slant? */

            if (cy1 < cy2) {

                /* Middle parallelogram portion, slanted to right. */

                /* left leg turned a corner at y0+dy1 */

                /* right leg continuing on its initial trajectory from y0 */

                loy = cy1;

                hiy = cy2;

                if (loy < iy1) loy = iy1;

                if (hiy > iy2) hiy = iy2;

                if (loy < hiy) {

                    jlong lx = PGRAM_INIT_X(loy, dx1, dy1, rslope);

                    jlong rx = PGRAM_INIT_X(loy,  x0,  y0, rslope);

                    (*pPrim->funcs.fillparallelogram)(&rasInfo,

                                                      ix1, loy, ix2, hiy,

                                                      lx, rdx, rx, rdx,

                                                      pixel, pPrim, &compInfo);

                }

            } else if (cy2 < cy1) {

                /* Middle parallelogram portion, slanted to left. */

                /* left leg continuing on its initial trajectory from y0 */

                /* right leg turned a corner at y0+dy2 */

                loy = cy2;

                hiy = cy1;

                if (loy < iy1) loy = iy1;

                if (hiy > iy2) hiy = iy2;

                if (loy < hiy) {

                    jlong lx = PGRAM_INIT_X(loy,  x0,  y0, lslope);

                    jlong rx = PGRAM_INIT_X(loy, dx2, dy2, lslope);

                    (*pPrim->funcs.fillparallelogram)(&rasInfo,

                                                      ix1, loy, ix2, hiy,

                                                      lx, ldx, rx, ldx,

                                                      pixel, pPrim, &compInfo);

                }

            }

            /* Bottom triangular portion. */

            loy = (cy1 > cy2) ? cy1 : cy2;

            if (loy < iy1) loy = iy1;

            hiy = iy2;

            if (loy < hiy) {

                /* left leg turned its corner at y0+dy1, now moving right */

                /* right leg turned its corner at y0+dy2, now moving left */

                jlong lx = PGRAM_INIT_X(loy, dx1, dy1, rslope);

                jlong rx = PGRAM_INIT_X(loy, dx2, dy2, lslope);

                (*pPrim->funcs.fillparallelogram)(&rasInfo,

                                                  ix1, loy, ix2, hiy,

                                                  lx, rdx, rx, ldx,

                                                  pixel, pPrim, &compInfo);

            }

        }

        SurfaceData_InvokeRelease(env, sdOps, &rasInfo);

    }

    SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);

}