/*
 * Copyright (c) 1999, 2015, 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 "sun_java2d_windows_GDIWindowSurfaceData.h"

#include "GDIWindowSurfaceData.h"
#include "GraphicsPrimitiveMgr.h"
#include "Region.h"
#include "Disposer.h"
#include "WindowsFlags.h"
#include "awt_Component.h"
#include "awt_Palette.h"
#include "awt_Win32GraphicsDevice.h"
#include "gdefs.h"
#include "Trace.h"
#include "Devices.h"

#include "jni_util.h"

static LockFunc GDIWinSD_Lock;
static GetRasInfoFunc GDIWinSD_GetRasInfo;
static UnlockFunc GDIWinSD_Unlock;
static DisposeFunc GDIWinSD_Dispose;
static SetupFunc GDIWinSD_Setup;
static GetDCFunc GDIWinSD_GetDC;
static ReleaseDCFunc GDIWinSD_ReleaseDC;
static InvalidateSDFunc GDIWinSD_InvalidateSD;

static HBRUSH   nullbrush;
static HPEN     nullpen;

static jclass xorCompClass;

static jboolean beingShutdown = JNI_FALSE;
static volatile LONG timeStamp = 0;
extern CriticalSection windowMoveLock;

extern "C"
{
GeneralDisposeFunc DisposeThreadGraphicsInfo;
jobject JNI_GetCurrentThread(JNIEnv *env);
int threadInfoIndex = TLS_OUT_OF_INDEXES;

static jclass threadClass = NULL;
static jmethodID currentThreadMethodID = NULL;

void SetupThreadGraphicsInfo(JNIEnv *env, GDIWinSDOps *wsdo) {
    J2dTraceLn(J2D_TRACE_INFO, "SetupThreadGraphicsInfo");

    // REMIND: handle error when creation fails
    ThreadGraphicsInfo *info =
        (ThreadGraphicsInfo*)TlsGetValue(threadInfoIndex);
    if (info == NULL) {
        info = new ThreadGraphicsInfo;
        ZeroMemory(info, sizeof(ThreadGraphicsInfo));
        TlsSetValue(threadInfoIndex, (LPVOID)info);
        J2dTraceLn2(J2D_TRACE_VERBOSE,
                    "  current batch limit for for thread 0x%x is %d",
                     GetCurrentThreadId(), ::GdiGetBatchLimit());
        J2dTraceLn(J2D_TRACE_VERBOSE, "  setting to the limit to 1");
        // Fix for bug 4374079
        ::GdiSetBatchLimit(1);

        Disposer_AddRecord(env, JNI_GetCurrentThread(env),
                           DisposeThreadGraphicsInfo,
                           ptr_to_jlong(info));
    }

    HDC oldhDC = info->hDC;
    // the hDC is NULL for offscreen surfaces - we don't store it
    // in TLS as it must be created new every time.

    if( ((oldhDC == NULL) && wsdo->window != NULL) ||
         (info->wsdo != wsdo) ||
         (info->wsdoTimeStamp != wsdo->timeStamp) )
    {

        // Init graphics state, either because this is our first time
        // using it in this thread or because this thread is now
        // dealing with a different window than it was last time.

        //check extra condition:
        //(info->wsdoTimeStamp != wsdo->timeStamp).
        //Checking memory addresses (info->wsdo != wsdo) will not detect
        //that wsdo points to a newly allocated structure in case
        //that structure just got allocated at a "recycled" memory location
        //which previously was pointed by info->wsdo
        //see bug# 6859086

        // Release cached DC. We use deferred DC releasing mechanism because
        // the DC is associated with cached wsdo and component peer,
        // which may've been disposed by this time, and we have
        // no means of checking against it.
        if (oldhDC != NULL) {
            MoveDCToPassiveList(oldhDC, info->hWnd);
            info->hDC = NULL;
            info->hWnd = NULL;
        }

        if (wsdo->window != NULL){
            HDC hDC;
            // This is a window surface
            // First, init the HDC object
            AwtComponent *comp = GDIWindowSurfaceData_GetComp(env, wsdo);
            if (comp == NULL) {
                return;
            }
            hDC = comp->GetDCFromComponent();
            if (hDC != NULL) {
                ::SelectObject(hDC, nullbrush);
                ::SelectObject(hDC, nullpen);
                ::SelectClipRgn(hDC, (HRGN) NULL);
                ::SetROP2(hDC, R2_COPYPEN);
                wsdo->device->SelectPalette(hDC);
                // Note that on NT4 we don't need to do a realize here: the
                // palette-sharing takes care of color issues for us.  But
                // on win98 if we don't realize a DC's palette, that
                // palette does not appear to have correct access to the
                // logical->system mapping.
                wsdo->device->RealizePalette(hDC);

                // Second, init the rest of the graphics state
                ::GetClientRect(wsdo->window, &info->bounds);
                // Make window-relative from client-relative
                ::OffsetRect(&info->bounds, wsdo->insets.left, wsdo->insets.top);
                //Likewise, translate GDI calls from client-relative to window-relative
                ::OffsetViewportOrgEx(hDC, -wsdo->insets.left, -wsdo->insets.top, NULL);
            }

            // Finally, set these new values in the info for this thread
            info->hDC = hDC;
            info->hWnd = wsdo->window;
        }

        // cached brush and pen are not associated with any DC, and can be
        // reused, but have to set type to 0 to indicate that no pen/brush
        // were set to the new hdc
        info->type = 0;

        if (info->clip != NULL) {
            env->DeleteWeakGlobalRef(info->clip);
        }
        info->clip = NULL;

        if (info->comp != NULL) {
            env->DeleteWeakGlobalRef(info->comp);
        }
        info->comp = NULL;

        info->xorcolor = 0;
        info->patrop = PATCOPY;

        //store the address and time stamp of newly allocated GDIWinSDOps structure
        info->wsdo = wsdo;
        info->wsdoTimeStamp = wsdo->timeStamp;
    }
}

/**
 * Releases native data stored in Thread local storage.
 * Called by the Disposer when the associated thread dies.
 */
void DisposeThreadGraphicsInfo(JNIEnv *env, jlong tgi) {
    J2dTraceLn(J2D_TRACE_INFO, "DisposeThreadGraphicsInfo");
    ThreadGraphicsInfo *info = (ThreadGraphicsInfo*)jlong_to_ptr(tgi);
    if (info != NULL) {
        if (info->hDC != NULL) {
            // move the DC from the active dcs list to
            // the passive dc list to be released later
            MoveDCToPassiveList(info->hDC, info->hWnd);
        }

        if (info->clip != NULL) {
            env->DeleteWeakGlobalRef(info->clip);
        }
        if (info->comp != NULL) {
            env->DeleteWeakGlobalRef(info->comp);
        }

        if (info->brush != NULL) {
            info->brush->Release();
        }
        if (info->pen != NULL) {
            info->pen->Release();
        }

        delete info;
    }
}

/**
 * Returns current Thread object.
 */
jobject
JNI_GetCurrentThread(JNIEnv *env) {
    return env->CallStaticObjectMethod(threadClass, currentThreadMethodID);
} /* JNI_GetCurrentThread() */

/**
 * Return the data associated with this thread.
 * NOTE: This function assumes that the SetupThreadGraphicsInfo()
 * function has already been called for this situation (thread,
 * window, etc.), so we can assume that the thread info contains
 * a valid hDC.  This should usually be the case since GDIWinSD_Setup
 * is called as part of the GetOps() process.
 */
ThreadGraphicsInfo *GetThreadGraphicsInfo(JNIEnv *env,
                                          GDIWinSDOps *wsdo) {
    return (ThreadGraphicsInfo*)TlsGetValue(threadInfoIndex);
}

__inline HDC GetThreadDC(JNIEnv *env, GDIWinSDOps *wsdo) {
    ThreadGraphicsInfo *info =
        (ThreadGraphicsInfo *)GetThreadGraphicsInfo(env, wsdo);
    if (!info) {
        return (HDC) NULL;
    }
    return info->hDC;
}

} // extern "C"

/**
 * This source file contains support code for loops using the
 * SurfaceData interface to talk to a Win32 drawable from native
 * code.
 */

static BOOL GDIWinSD_CheckMonitorArea(GDIWinSDOps *wsdo,
                                     SurfaceDataBounds *bounds,
                                     HDC hDC)
{
    HWND hW = wsdo->window;
    BOOL retCode = TRUE;

    J2dTraceLn(J2D_TRACE_INFO, "GDIWinSD_CheckMonitorArea");
    int numScreens;
    {
        Devices::InstanceAccess devices;
        numScreens = devices->GetNumDevices();
    }
    if( numScreens > 1 ) {

        LPMONITORINFO miInfo;
        RECT rSect ={0,0,0,0};
        RECT rView ={bounds->x1, bounds->y1, bounds->x2, bounds->y2};
        retCode = FALSE;

        miInfo = wsdo->device->GetMonitorInfo();

        POINT ptOrig = {0, 0};
        ::ClientToScreen(hW, &ptOrig);
        ::OffsetRect(&rView,
            (ptOrig.x), (ptOrig.y));

        ::IntersectRect(&rSect,&rView,&(miInfo->rcMonitor));

        if( FALSE == ::IsRectEmpty(&rSect) ) {
            if( TRUE == ::EqualRect(&rSect,&rView) ) {
                retCode = TRUE;
            }
        }
    }
    return retCode;
}

extern "C" {

void
initThreadInfoIndex()
{
    if (threadInfoIndex == TLS_OUT_OF_INDEXES) {
        threadInfoIndex = TlsAlloc();
    }
}


/**
 * Utility function to make sure that native and java-level
 * surface depths are matched.  They can be mismatched when display-depths
 * change, either between the creation of the Java surfaceData structure
 * and the native ddraw surface, or later when a surface is automatically
 * adjusted to be the new display depth (even if it was created in a different
 * depth to begin with)
 */
BOOL SurfaceDepthsCompatible(int javaDepth, int nativeDepth)
{
    if (nativeDepth != javaDepth) {
        switch (nativeDepth) {
        case 0: // Error condition: something is wrong with the surface
        case 8:
        case 24:
            // Java and native surface depths should match exactly for
            // these cases
            return FALSE;
            break;
        case 16:
            // Java surfaceData should be 15 or 16 bits
            if (javaDepth < 15 || javaDepth > 16) {
                return FALSE;
            }
            break;
        case 32:
            // Could have this native depth for either 24- or 32-bit
            // Java surfaceData
            if (javaDepth != 24 && javaDepth != 32) {
                return FALSE;
            }
            break;
        default:
            // should not get here, but if we do something is odd, so
            // just register a failure
            return FALSE;
        }
    }
    return TRUE;
}


/*
 * Class:     sun_java2d_windows_GDIWindowSurfaceData
 * Method:    initIDs
 * Signature: ()V
 */
JNIEXPORT void JNICALL
Java_sun_java2d_windows_GDIWindowSurfaceData_initIDs(JNIEnv *env, jclass wsd,
                                                 jclass XORComp)
{
    jclass tc;
    J2dTraceLn(J2D_TRACE_INFO, "GDIWindowSurfaceData_initIDs");
    nullbrush = (HBRUSH) ::GetStockObject(NULL_BRUSH);
    nullpen = (HPEN) ::GetStockObject(NULL_PEN);

    initThreadInfoIndex();

    xorCompClass = (jclass)env->NewGlobalRef(XORComp);
    if (env->ExceptionCheck()) {
        return;
    }

    tc = env->FindClass("java/lang/Thread");
    DASSERT(tc != NULL);
    CHECK_NULL(tc);

    threadClass = (jclass)env->NewGlobalRef(tc);
    DASSERT(threadClass != NULL);
    CHECK_NULL(threadClass);

    currentThreadMethodID =
        env->GetStaticMethodID(threadClass,
                               "currentThread",  "()Ljava/lang/Thread;");
    DASSERT(currentThreadMethodID != NULL);
}

#undef ExceptionOccurred

/*
 * Class:     sun_java2d_windows_GDIWindowSurfaceData
 * Method:    initOps
 * Signature: (Ljava/lang/Object;IIIIII)V
 */
JNIEXPORT void JNICALL
Java_sun_java2d_windows_GDIWindowSurfaceData_initOps(JNIEnv *env, jobject wsd,
                                                 jobject peer, jint depth,
                                                 jint redMask, jint greenMask,
                                                 jint blueMask, jint screen)
{
    J2dTraceLn(J2D_TRACE_INFO, "GDIWindowSurfaceData_initOps");
    GDIWinSDOps *wsdo = (GDIWinSDOps *)SurfaceData_InitOps(env, wsd, sizeof(GDIWinSDOps));
    if (wsdo == NULL) {
        JNU_ThrowOutOfMemoryError(env, "Initialization of SurfaceData failed.");
        return;
    }
    wsdo->timeStamp = InterlockedIncrement(&timeStamp); //creation time stamp
    wsdo->sdOps.Lock = GDIWinSD_Lock;
    wsdo->sdOps.GetRasInfo = GDIWinSD_GetRasInfo;
    wsdo->sdOps.Unlock = GDIWinSD_Unlock;
    wsdo->sdOps.Dispose = GDIWinSD_Dispose;
    wsdo->sdOps.Setup = GDIWinSD_Setup;
    wsdo->GetDC = GDIWinSD_GetDC;
    wsdo->ReleaseDC = GDIWinSD_ReleaseDC;
    wsdo->InvalidateSD = GDIWinSD_InvalidateSD;
    wsdo->invalid = JNI_FALSE;
    wsdo->lockType = WIN32SD_LOCK_UNLOCKED;
    wsdo->peer = env->NewWeakGlobalRef(peer);
    if (env->ExceptionOccurred()) {
        return;
    }
    wsdo->depth = depth;
    wsdo->pixelMasks[0] = redMask;
    wsdo->pixelMasks[1] = greenMask;
    wsdo->pixelMasks[2] = blueMask;
    // Init the DIB pixelStride and pixel masks according to
    // the pixel depth. In the 8-bit case, there are no
    // masks as a palette DIB is used instead. Likewise
    // in the 24-bit case, Windows doesn't expect the masks
    switch (depth) {
        case 8:
            wsdo->pixelStride = 1;
            break;
        case 15: //555
            wsdo->pixelStride = 2;
            break;
        case 16: //565
            wsdo->pixelStride = 2;
            break;
        case 24:
            wsdo->pixelStride = 3;
            break;
        case 32: //888
            wsdo->pixelStride = 4;
            break;
    }
    // GDIWindowSurfaceData_GetWindow will throw NullPointerException
    // if wsdo->window is NULL
    wsdo->window = GDIWindowSurfaceData_GetWindow(env, wsdo);
    J2dTraceLn2(J2D_TRACE_VERBOSE, "  wsdo=0x%x wsdo->window=0x%x",
                wsdo, wsdo->window);

    {
        Devices::InstanceAccess devices;
        wsdo->device = devices->GetDeviceReference(screen, FALSE);
    }
    if (wsdo->device == NULL ||
        !SurfaceDepthsCompatible(depth, wsdo->device->GetBitDepth()))
    {
        if (wsdo->device != NULL) {
            J2dTraceLn2(J2D_TRACE_WARNING,
                        "GDIWindowSurfaceData_initOps: Surface depth mismatch: "\
                        "wsdo->depth=%d device depth=%d. Surface invalidated.",
                        wsdo->depth, wsdo->device->GetBitDepth());
        } else {
            J2dTraceLn1(J2D_TRACE_WARNING,
                        "GDIWindowSurfaceData_initOps: Incorrect "\
                        "screen number (screen=%d). Surface invalidated.",
                        screen);
        }

        wsdo->invalid = JNI_TRUE;
    }
    wsdo->surfaceLock = new CriticalSection();
    wsdo->bitmap = NULL;
    wsdo->bmdc = NULL;
    wsdo->bmCopyToScreen = FALSE;
}

JNIEXPORT GDIWinSDOps * JNICALL
GDIWindowSurfaceData_GetOps(JNIEnv *env, jobject sData)
{
    SurfaceDataOps *ops = SurfaceData_GetOps(env, sData);
    // REMIND: There was originally a condition check here to make sure
    // that we were really dealing with a GDIWindowSurfaceData object, but
    // it did not allow for the existence of other win32-accelerated
    // surface data objects (e.g., Win32OffScreenSurfaceData).  I've
    // removed the check for now, but we should replace it with another,
    // more general check against Win32-related surfaces.
    return (GDIWinSDOps *) ops;
}

JNIEXPORT GDIWinSDOps * JNICALL
GDIWindowSurfaceData_GetOpsNoSetup(JNIEnv *env, jobject sData)
{
    // use the 'no setup' version of GetOps
    SurfaceDataOps *ops = SurfaceData_GetOpsNoSetup(env, sData);
    return (GDIWinSDOps *) ops;
}

JNIEXPORT AwtComponent * JNICALL
GDIWindowSurfaceData_GetComp(JNIEnv *env, GDIWinSDOps *wsdo)
{
    PDATA pData;
    jobject localObj = env->NewLocalRef(wsdo->peer);

    if (localObj == NULL || (pData = JNI_GET_PDATA(localObj)) == NULL) {
        J2dTraceLn1(J2D_TRACE_WARNING,
                    "GDIWindowSurfaceData_GetComp: Null pData? pData=0x%x",
                    pData);
        if (beingShutdown == JNI_TRUE) {
            wsdo->invalid = JNI_TRUE;
            return (AwtComponent *) NULL;
        }
        try {
            AwtToolkit::GetInstance().VerifyActive();
        } catch (awt_toolkit_shutdown&) {
            beingShutdown = JNI_TRUE;
            wsdo->invalid = JNI_TRUE;
            return (AwtComponent *) NULL;
        }
        if (wsdo->invalid == JNI_TRUE) {
            SurfaceData_ThrowInvalidPipeException(env,
                "GDIWindowSurfaceData: bounds changed");
        } else {
            JNU_ThrowNullPointerException(env, "component argument pData");
        }
        return (AwtComponent *) NULL;
    }
    return static_cast<AwtComponent*>(pData);
}

JNIEXPORT HWND JNICALL
GDIWindowSurfaceData_GetWindow(JNIEnv *env, GDIWinSDOps *wsdo)
{
    HWND window = wsdo->window;

    if (window == (HWND) NULL) {
        AwtComponent *comp = GDIWindowSurfaceData_GetComp(env, wsdo);
        if (comp == NULL) {
            J2dTraceLn(J2D_TRACE_WARNING,
                   "GDIWindowSurfaceData_GetWindow: null component");
            return (HWND) NULL;
        }
        comp->GetInsets(&wsdo->insets);
        window = comp->GetHWnd();
        if (::IsWindow(window) == FALSE) {
            J2dRlsTraceLn(J2D_TRACE_ERROR,
                          "GDIWindowSurfaceData_GetWindow: disposed component");
            JNU_ThrowNullPointerException(env, "disposed component");
            return (HWND) NULL;
        }
        wsdo->window = window;
    }

    return window;
}

} /* extern "C" */

static jboolean GDIWinSD_SimpleClip(JNIEnv *env, GDIWinSDOps *wsdo,
                                   SurfaceDataBounds *bounds,
                                   HDC hDC)
{
    RECT rClip;

    J2dTraceLn(J2D_TRACE_INFO, "GDIWinSD_SimpleClip");
    if (hDC == NULL) {
        return JNI_FALSE;
    }

    int nComplexity = ::GetClipBox(hDC, &rClip);

    switch (nComplexity) {
    case COMPLEXREGION:
        {
            J2dTraceLn(J2D_TRACE_VERBOSE,
                       "  complex clipping region");
            // if complex user/system clip, more detailed testing required
            // check to see if the view itself has a complex clip.
            // ::GetClipBox is only API which returns overlapped window status
            // so we set the rView as our clip, and then see if resulting
            // clip is complex.
            // Only other way to figure this out would be to walk the
            // overlapping windows (no API to get the actual visible clip
            // list).  Then we'd still have to merge that info with the
            // clip region for the dc (if it exists).
            // REMIND: we can cache the CreateRectRgnIndirect result,
            // and only override with ::SetRectRgn

            // First, create a region handle (need existing HRGN for
            // the following call).
            HRGN rgnSave = ::CreateRectRgn(0, 0, 0, 0);
            int  clipStatus = ::GetClipRgn(hDC, rgnSave);
            if (-1 == clipStatus) {
                J2dTraceLn(J2D_TRACE_WARNING,
                           "GDIWinSD_SimpleClip: failed due to clip status");
                ::DeleteObject(rgnSave);
                return JNI_FALSE;
            }
            HRGN rgnBounds = ::CreateRectRgn(
                bounds->x1 - wsdo->insets.left,
                bounds->y1 - wsdo->insets.top,
                bounds->x2 - wsdo->insets.left,
                bounds->y2 - wsdo->insets.top);
            ::SelectClipRgn(hDC, rgnBounds);
            nComplexity = ::GetClipBox(hDC, &rClip);
            ::SelectClipRgn(hDC, clipStatus? rgnSave: NULL);
            ::DeleteObject(rgnSave);
            ::DeleteObject(rgnBounds);

            // Now, test the new clip box.  If it's still not a
            // SIMPLE region, then our bounds must intersect part of
            // the clipping article
            if (SIMPLEREGION != nComplexity) {
                J2dTraceLn(J2D_TRACE_WARNING,
                           "GDIWinSD_SimpleClip: failed due to complexity");
                return JNI_FALSE;
            }
        }
        // NOTE: No break here - we want to fall through into the
        // SIMPLE case, adjust our bounds by the new rClip rect
        // and make sure that our locking bounds are not empty.
    case SIMPLEREGION:
        J2dTraceLn(J2D_TRACE_VERBOSE, "  simple clipping region");
        // Constrain the bounds to the given clip box
        if (bounds->x1 < rClip.left) {
            bounds->x1 = rClip.left;
        }
        if (bounds->y1 < rClip.top) {
            bounds->y1 = rClip.top;
        }
        if (bounds->x2 > rClip.right) {
            bounds->x2 = rClip.right;
        }
        if (bounds->y2 > rClip.bottom) {
            bounds->y2 = rClip.bottom;
        }
        // If the bounds are 0 or negative, then the bounds have
        // been obscured by the clip box, so return FALSE
        if ((bounds->x2 <= bounds->x1) ||
            (bounds->y2 <= bounds->y1)) {
            // REMIND: We should probably do something different here
            // instead of simply returning FALSE.  Since the bounds are
            // empty we won't end up drawing anything, so why spend the
            // effort of returning false and having GDI do a LOCK_BY_DIB?
            // Perhaps we need a new lock code that will indicate that we
            // shouldn't bother drawing?
            J2dTraceLn(J2D_TRACE_WARNING,
                       "GDIWinSD_SimpleClip: failed due to empty bounds");
            return JNI_FALSE;
        }
        break;
    case NULLREGION:
    case ERROR:
    default:
        J2dTraceLn1(J2D_TRACE_ERROR,
                   "GDIWinSD_SimpleClip: failed due to incorrect complexity=%d",
                    nComplexity);
        return JNI_FALSE;
    }

    return JNI_TRUE;
}

static jint GDIWinSD_Lock(JNIEnv *env,
                         SurfaceDataOps *ops,
                         SurfaceDataRasInfo *pRasInfo,
                         jint lockflags)
{
    GDIWinSDOps *wsdo = (GDIWinSDOps *) ops;
    int ret = SD_SUCCESS;
    HDC hDC;
    J2dTraceLn(J2D_TRACE_INFO, "GDIWinSD_Lock");

    /* This surfaceLock replaces an earlier implementation which used a
    monitor associated with the peer.  That implementation was prone
    to deadlock problems, so it was replaced by a lock that does not
    have dependencies outside of this thread or object.
    However, this lock doesn't necessarily do all that we want.
    For example, a user may issue a call which results in a DIB lock
    and another call which results in a DDraw Blt.  We can't guarantee
    what order these operations happen in (they are driver and
    video-card dependent), so locking around the issue of either of
    those calls won't necessarily guarantee a particular result.
    The real solution might be to move away from mixing our
    rendering API's.  That is, if we only used DDraw, then we could
    guarantee that all rendering operations would happen in a given
    order.  Similarly for GDI.  But by mixing them, we leave our
    code at the mercy of driver bugs.*/
    wsdo->surfaceLock->Enter();
    if (wsdo->invalid == JNI_TRUE) {
        J2dTraceLn(J2D_TRACE_WARNING, "GDIWinSD_Lock: surface is invalid");
        wsdo->surfaceLock->Leave();
        if (beingShutdown != JNI_TRUE) {
            SurfaceData_ThrowInvalidPipeException(env,
                "GDIWindowSurfaceData: bounds changed");
        }
        return SD_FAILURE;
    }
    if (wsdo->lockType != WIN32SD_LOCK_UNLOCKED) {
        wsdo->surfaceLock->Leave();
        if (!safe_ExceptionOccurred(env)) {
            JNU_ThrowInternalError(env, "Win32 LockRasData cannot nest locks");
        }
        return SD_FAILURE;
    }

    hDC = wsdo->GetDC(env, wsdo, 0, NULL, NULL, NULL, 0);
    if (hDC == NULL) {
        wsdo->surfaceLock->Leave();
        if (beingShutdown != JNI_TRUE) {
            JNU_ThrowNullPointerException(env, "HDC for component");
        }
        return SD_FAILURE;
    }

    if (lockflags & SD_LOCK_RD_WR) {
        // Do an initial clip to the client region of the window
        RECT crect;
        ::GetClientRect(wsdo->window, &crect);

        // Translate to window coords
        crect.left += wsdo->insets.left;
        crect.top += wsdo->insets.top;
        crect.right += wsdo->insets.left;
        crect.bottom += wsdo->insets.top;

        SurfaceDataBounds *bounds = &pRasInfo->bounds;

        if (bounds->x1 < crect.left) {
            bounds->x1 = crect.left;
        }
        if (bounds->y1 < crect.top) {
            bounds->y1 = crect.top;
        }
        if (bounds->x2 > crect.right) {
            bounds->x2 = crect.right;
        }
        if (bounds->y2 > crect.bottom) {
            bounds->y2 = crect.bottom;
        }

        if (bounds->x2 > bounds->x1 && bounds->y2 > bounds->y1) {
            wsdo->lockType = WIN32SD_LOCK_BY_DIB;
            if (lockflags & SD_LOCK_FASTEST) {
                ret = SD_SLOWLOCK;
            }
            J2dTraceLn(J2D_TRACE_VERBOSE, " locked by DIB");
        } else {
            wsdo->ReleaseDC(env, wsdo, hDC);
            wsdo->lockType = WIN32SD_LOCK_UNLOCKED;
            wsdo->surfaceLock->Leave();
            ret = SD_FAILURE;
            J2dTraceLn(J2D_TRACE_ERROR,
                       "GDIWinSD_Lock: error locking by DIB");
        }
    } else {
        J2dTraceLn(J2D_TRACE_VERBOSE, "GDIWinSD_Lock: surface wasn't locked");
        /* They didn't lock for anything - we won't give them anything */
        wsdo->ReleaseDC(env, wsdo, hDC);
        wsdo->lockType = WIN32SD_LOCK_UNLOCKED;
        wsdo->surfaceLock->Leave();
        ret = SD_FAILURE;
    }

    wsdo->lockFlags = lockflags;
    return ret;
}

static void GDIWinSD_GetRasInfo(JNIEnv *env,
                               SurfaceDataOps *ops,
                               SurfaceDataRasInfo *pRasInfo)
{
    GDIWinSDOps *wsdo = (GDIWinSDOps *) ops;
    jint lockflags = wsdo->lockFlags;
    J2dTraceLn(J2D_TRACE_INFO, "GDIWinSD_GetRasInfo");
    HDC hDC = GetThreadDC(env, wsdo);

    if (wsdo->lockType == WIN32SD_LOCK_UNLOCKED) {
        memset(pRasInfo, 0, sizeof(*pRasInfo));
        return;
    }

    if (wsdo->lockType == WIN32SD_LOCK_BY_DIB) {
        int x, y, w, h;
        int pixelStride = wsdo->pixelStride;
        // do not subtract insets from x,y as we take care of it in SD_GetDC
        x = pRasInfo->bounds.x1;
        y = pRasInfo->bounds.y1;
        w = pRasInfo->bounds.x2 - x;
        h = pRasInfo->bounds.y2 - y;

        struct tagBitmapheader  {
            BITMAPINFOHEADER bmiHeader;
            union {
                DWORD           dwMasks[3];
                RGBQUAD         palette[256];
            } colors;
        } bmi;

        // Need to create bitmap if we don't have one already or
        // if the existing one is not large enough for this operation
        // or if we are in 8 bpp display mode (because we need to
        // make sure that the latest palette info gets loaded into
        // the bitmap)
        // REMIND: we should find some way to dynamically force bitmap
        // recreation only when the palette changes
        if (pixelStride == 1 || !wsdo->bitmap || (w > wsdo->bmWidth) ||
            (h > wsdo->bmHeight))
        {
            if (wsdo->bitmap) {
                // delete old objects
                J2dTraceLn(J2D_TRACE_VERBOSE,
                           "GDIWinSD_GetRasInfo: recreating GDI bitmap");
                if (wsdo->bmdc) {   // should not be null
                    ::SelectObject(wsdo->bmdc, wsdo->oldmap);
                    ::DeleteDC(wsdo->bmdc);
                    wsdo->bmdc = 0;
                }
                ::DeleteObject(wsdo->bitmap);
                wsdo->bitmap = 0;
            }
            bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
            bmi.bmiHeader.biWidth = w;
            bmi.bmiHeader.biHeight = -h;
            wsdo->bmWidth = w;
            wsdo->bmHeight = h;
            bmi.bmiHeader.biPlanes = 1;
            bmi.bmiHeader.biBitCount = pixelStride * 8;
            // 1,3 byte use BI_RGB, 2,4 byte use BI_BITFIELD...
            bmi.bmiHeader.biCompression =
                (pixelStride & 1)
                    ? BI_RGB
                    : BI_BITFIELDS;
            bmi.bmiHeader.biSizeImage = 0;
            bmi.bmiHeader.biXPelsPerMeter = 0;
            bmi.bmiHeader.biYPelsPerMeter = 0;
            bmi.bmiHeader.biClrUsed = 0;
            bmi.bmiHeader.biClrImportant = 0;
            if (pixelStride == 1) {
                // we can use systemEntries here because
                // RGBQUAD is xRGB and systemEntries are stored as xRGB
                memcpy(bmi.colors.palette, wsdo->device->GetSystemPaletteEntries(),
                       sizeof(bmi.colors.palette));
            } else {
                // For non-index cases, init the masks for the pixel depth
                for (int i = 0; i < 3; i++) {
                    bmi.colors.dwMasks[i] = wsdo->pixelMasks[i];
                }
            }

            // REMIND: This would be better if moved to the Lock function
            // so that errors could be dealt with.
            wsdo->bitmap = ::CreateDIBSection(hDC, (BITMAPINFO *) &bmi,
                                              DIB_RGB_COLORS, &wsdo->bmBuffer, NULL, 0);
            if (wsdo->bitmap != 0) {
                // scanStride is cached along with reuseable bitmap
                // Round up to the next DWORD boundary
                wsdo->bmScanStride = (wsdo->bmWidth * pixelStride + 3) & ~3;
                wsdo->bmdc = ::CreateCompatibleDC(hDC);
                if (wsdo->bmdc == 0) {
                    ::DeleteObject(wsdo->bitmap);
                    wsdo->bitmap = 0;
                } else {
                    wsdo->oldmap = (HBITMAP) ::SelectObject(wsdo->bmdc,
                                                            wsdo->bitmap);
                }
            }
        }
        if (wsdo->bitmap != 0) {
            if (lockflags & SD_LOCK_NEED_PIXELS) {
                int ret = ::BitBlt(wsdo->bmdc, 0, 0, w, h,
                                   hDC, x, y, SRCCOPY);
                ::GdiFlush();
            }
            wsdo->x = x;
            wsdo->y = y;
            wsdo->w = w;
            wsdo->h = h;
            pRasInfo->rasBase = (char *)wsdo->bmBuffer - (x*pixelStride +
                                y*wsdo->bmScanStride);
            pRasInfo->pixelStride = pixelStride;
            pRasInfo->pixelBitOffset = 0;
            pRasInfo->scanStride = wsdo->bmScanStride;
            if (lockflags & SD_LOCK_WRITE) {
                // If the user writes to the bitmap then we should
                // copy the bitmap to the screen during Unlock
                wsdo->bmCopyToScreen = TRUE;
            }
        } else {
            pRasInfo->rasBase = NULL;
            pRasInfo->pixelStride = 0;
            pRasInfo->pixelBitOffset = 0;
            pRasInfo->scanStride = 0;
        }
    } else {
        /* They didn't lock for anything - we won't give them anything */
        pRasInfo->rasBase = NULL;
        pRasInfo->pixelStride = 0;
        pRasInfo->pixelBitOffset = 0;
        pRasInfo->scanStride = 0;
    }
    if (wsdo->lockFlags & SD_LOCK_LUT) {
        pRasInfo->lutBase =
            (long *) wsdo->device->GetSystemPaletteEntries();
        pRasInfo->lutSize = 256;
    } else {
        pRasInfo->lutBase = NULL;
        pRasInfo->lutSize = 0;
    }
    if (wsdo->lockFlags & SD_LOCK_INVCOLOR) {
        pRasInfo->invColorTable = wsdo->device->GetSystemInverseLUT();
        ColorData *cData = wsdo->device->GetColorData();
        pRasInfo->redErrTable = cData->img_oda_red;
        pRasInfo->grnErrTable = cData->img_oda_green;
        pRasInfo->bluErrTable = cData->img_oda_blue;
    } else {
        pRasInfo->invColorTable = NULL;
        pRasInfo->redErrTable = NULL;
        pRasInfo->grnErrTable = NULL;
        pRasInfo->bluErrTable = NULL;
    }
    if (wsdo->lockFlags & SD_LOCK_INVGRAY) {
        pRasInfo->invGrayTable =
            wsdo->device->GetColorData()->pGrayInverseLutData;
    } else {
        pRasInfo->invGrayTable = NULL;
    }
}

static void GDIWinSD_Setup(JNIEnv *env,
                          SurfaceDataOps *ops)
{
    // Call SetupTGI to ensure that this thread already has a DC that is
    // compatible with this window.  This means that we won't be calling
    // ::SendMessage(GETDC) in the middle of a lock procedure, which creates
    // a potential deadlock situation.
    // Note that calling SetupTGI here means that anybody needing a DC
    // later in this rendering process need only call GetTGI, which
    // assumes that the TGI structure is valid for this thread/window.
    SetupThreadGraphicsInfo(env, (GDIWinSDOps*)ops);
}


static void GDIWinSD_Unlock(JNIEnv *env,
                           SurfaceDataOps *ops,
                           SurfaceDataRasInfo *pRasInfo)
{
    GDIWinSDOps *wsdo = (GDIWinSDOps *) ops;
    J2dTraceLn(J2D_TRACE_INFO, "GDIWinSD_Unlock");
    HDC hDC = GetThreadDC(env, wsdo);

    if (wsdo->lockType == WIN32SD_LOCK_UNLOCKED) {
        if (!safe_ExceptionOccurred(env)) {
            JNU_ThrowInternalError(env,
                                   "Unmatched unlock on Win32 SurfaceData");
        }
        return;
    }

    if (wsdo->lockType == WIN32SD_LOCK_BY_DIB) {
        if (wsdo->lockFlags & SD_LOCK_WRITE) {
            J2dTraceLn(J2D_TRACE_VERBOSE,
                       "GDIWinSD_Unlock: do Blt of the bitmap");
            if (wsdo->bmCopyToScreen && ::IsWindowVisible(wsdo->window)) {
                // Don't bother copying to screen if our window has gone away
                // or if the bitmap was not actually written to during this
                // Lock/Unlock procedure.
                ::BitBlt(hDC, wsdo->x, wsdo->y, wsdo->w, wsdo->h,
                    wsdo->bmdc, 0, 0, SRCCOPY);
                ::GdiFlush();
            }
            wsdo->bmCopyToScreen = FALSE;
        }
        wsdo->lockType = WIN32SD_LOCK_UNLOCKED;
        wsdo->ReleaseDC(env, wsdo, hDC);
    }
    wsdo->surfaceLock->Leave();
}

/*
 * REMIND: This mechanism is just a prototype of a way to manage a
 * small cache of DC objects.  It is incomplete in the following ways:
 *
 * - It is not thread-safe!  It needs appropriate locking and release calls
 *   (perhaps the AutoDC mechanisms from Kestrel)
 * - It does hardly any error checking (What if GetDCEx returns NULL?)
 * - It cannot handle printer DCs and their resolution
 * - It should probably "live" in the native SurfaceData object to allow
 *   alternate implementations for printing and embedding
 * - It doesn't handle XOR
 * - It caches the client bounds to determine if clipping is really needed
 *   (no way to invalidate the cached bounds and there is probably a better
 *    way to manage clip validation in any case)
 */

#define COLORFOR(c)     (PALETTERGB(((c)>>16)&0xff,((c)>>8)&0xff,((c)&0xff)))

COLORREF CheckGrayColor(GDIWinSDOps *wsdo, int c) {
    if (wsdo->device->GetGrayness() != GS_NOTGRAY) {
        int g = (77 *(c & 0xFF) +
                 150*((c >> 8) & 0xFF) +
                 29 *((c >> 16) & 0xFF) + 128) / 256;
        c = g | (g << 8) | (g << 16);
    }
    return COLORFOR(c);
}

static HDC GDIWinSD_GetDC(JNIEnv *env, GDIWinSDOps *wsdo,
                         jint type, jint *patrop,
                         jobject clip, jobject comp, jint color)
{
    J2dTraceLn(J2D_TRACE_INFO, "GDIWinSD_GetDC");

    if (wsdo->invalid == JNI_TRUE) {
        if (beingShutdown != JNI_TRUE) {
            SurfaceData_ThrowInvalidPipeException(env, "bounds changed");
        }
        return (HDC) NULL;
    }

    ThreadGraphicsInfo *info = GetThreadGraphicsInfo(env, wsdo);
    GDIWinSD_InitDC(env, wsdo, info, type, patrop, clip, comp, color);
    return env->ExceptionCheck() ? (HDC)NULL : info->hDC;
}

JNIEXPORT void JNICALL
GDIWinSD_InitDC(JNIEnv *env, GDIWinSDOps *wsdo, ThreadGraphicsInfo *info,
               jint type, jint *patrop,
               jobject clip, jobject comp, jint color)
{
    J2dTraceLn(J2D_TRACE_INFO, "GDIWinSD_InitDC");

    // init clip
    if (clip == NULL) {
        if (info->type & CLIP) {
            ::SelectClipRgn(info->hDC, (HRGN) NULL);
            info->type ^= CLIP;
        }
        if (info->clip != NULL) {
            env->DeleteWeakGlobalRef(info->clip);
            info->clip = NULL;
        }
    } else if (!env->IsSameObject(clip, info->clip)) {
        SurfaceDataBounds span;
        RegionData clipInfo;
        if (Region_GetInfo(env, clip, &clipInfo)) {
            // return; // REMIND: What to do here?
        }

        if (Region_IsEmpty(&clipInfo)) {
            HRGN hrgn = ::CreateRectRgn(0, 0, 0, 0);
            ::SelectClipRgn(info->hDC, hrgn);
            ::DeleteObject(hrgn);
            info->type |= CLIP;
        } else if (Region_IsRectangular(&clipInfo)) {
            if (clipInfo.bounds.x1 <= info->bounds.left &&
                clipInfo.bounds.y1 <= info->bounds.top &&
                clipInfo.bounds.x2 >= info->bounds.right &&
                clipInfo.bounds.y2 >= info->bounds.bottom)
            {
                if (info->type & CLIP) {
                    ::SelectClipRgn(info->hDC, (HRGN) NULL);
                    info->type ^= CLIP;
                }
            } else {
                // Make the window-relative rect a client-relative
                // one for Windows
                HRGN hrgn =
                    ::CreateRectRgn(clipInfo.bounds.x1 - wsdo->insets.left,
                                    clipInfo.bounds.y1 - wsdo->insets.top,
                                    clipInfo.bounds.x2 - wsdo->insets.left,
                                    clipInfo.bounds.y2 - wsdo->insets.top);
                ::SelectClipRgn(info->hDC, hrgn);
                ::DeleteObject(hrgn);
                info->type |= CLIP;
            }
        } else {
            int leftInset = wsdo->insets.left;
            int topInset = wsdo->insets.top;
            Region_StartIteration(env, &clipInfo);
            jint numrects = Region_CountIterationRects(&clipInfo);
            RGNDATA *lpRgnData;
            try {
                lpRgnData = (RGNDATA *) SAFE_SIZE_STRUCT_ALLOC(safe_Malloc,
                    sizeof(RGNDATAHEADER), numrects, sizeof(RECT));
            } catch (std::bad_alloc&) {
                JNU_ThrowOutOfMemoryError(env, "Initialization of surface region data failed.");
                return;
            }
            const DWORD nCount = sizeof(RGNDATAHEADER) + numrects * sizeof(RECT);
            lpRgnData->rdh.dwSize = sizeof(RGNDATAHEADER);
            lpRgnData->rdh.iType = RDH_RECTANGLES;
            lpRgnData->rdh.nCount = numrects;
            lpRgnData->rdh.nRgnSize = 0;
            lpRgnData->rdh.rcBound.left = clipInfo.bounds.x1 - leftInset;
            lpRgnData->rdh.rcBound.top = clipInfo.bounds.y1 - topInset;
            lpRgnData->rdh.rcBound.right = clipInfo.bounds.x2 - leftInset;
            lpRgnData->rdh.rcBound.bottom = clipInfo.bounds.y2 - topInset;
            RECT *pRect = (RECT *) &(((RGNDATA *)lpRgnData)->Buffer);
            while (Region_NextIteration(&clipInfo, &span)) {
                pRect->left = span.x1 - leftInset;
                pRect->top = span.y1 - topInset;
                pRect->right = span.x2 - leftInset;
                pRect->bottom = span.y2 - topInset;
                pRect++;
            }
            Region_EndIteration(env, &clipInfo);
            HRGN hrgn = ::ExtCreateRegion(NULL, nCount, lpRgnData);
            free(lpRgnData);
            ::SelectClipRgn(info->hDC, hrgn);
            ::DeleteObject(hrgn);
            info->type |= CLIP;
        }
        if (info->clip != NULL) {
            env->DeleteWeakGlobalRef(info->clip);
        }
        info->clip = env->NewWeakGlobalRef(clip);
        if (env->ExceptionCheck()) {
            return;
        }
    }

    // init composite
    if ((comp == NULL) || !env->IsInstanceOf(comp, xorCompClass)) {
        if (info->comp != NULL) {
            env->DeleteWeakGlobalRef(info->comp);
            info->comp = NULL;
            info->patrop = PATCOPY;
            ::SetROP2(info->hDC, R2_COPYPEN);
        }
    } else {
        if (!env->IsSameObject(comp, info->comp)) {
            info->xorcolor = GrPrim_CompGetXorColor(env, comp);
            if (info->comp != NULL) {
                env->DeleteWeakGlobalRef(info->comp);
            }
            info->comp = env->NewWeakGlobalRef(comp);
            info->patrop = PATINVERT;
            ::SetROP2(info->hDC, R2_XORPEN);
        }
        color ^= info->xorcolor;
    }

    if (patrop != NULL) {
        *patrop = info->patrop;
    }

    // init brush and pen
    if (type & BRUSH) {
        if (info->brushclr != color || (info->brush == NULL)) {
            if (info->type & BRUSH) {
                ::SelectObject(info->hDC, nullbrush);
                info->type ^= BRUSH;
            }
            if (info->brush != NULL) {
                info->brush->Release();
            }
            info->brush = AwtBrush::Get(CheckGrayColor(wsdo, color));
            info->brushclr = color;
        }
        if ((info->type & BRUSH) == 0) {
            ::SelectObject(info->hDC, info->brush->GetHandle());
            info->type ^= BRUSH;
        }
    } else if (type & NOBRUSH) {
        if (info->type & BRUSH) {
            ::SelectObject(info->hDC, nullbrush);
            info->type ^= BRUSH;
        }
    }
    if (type & PEN) {
        if (info->penclr != color || (info->pen == NULL)) {
            if (info->type & PEN) {
                ::SelectObject(info->hDC, nullpen);
                info->type ^= PEN;
            }
            if (info->pen != NULL) {
                info->pen->Release();
            }
            info->pen = AwtPen::Get(CheckGrayColor(wsdo, color));
            info->penclr = color;
        }
        if ((info->type & PEN) == 0) {
            ::SelectObject(info->hDC, info->pen->GetHandle());
            info->type ^= PEN;
        }
    } else if (type & NOPEN) {
        if (info->type & PEN) {
            ::SelectObject(info->hDC, nullpen);
            info->type ^= PEN;
        }
    }
}

static void GDIWinSD_ReleaseDC(JNIEnv *env, GDIWinSDOps *wsdo, HDC hDC)
{
    J2dTraceLn(J2D_TRACE_INFO, "GDIWinSD_ReleaseDC");
    // Don't actually do anything here: every thread holds its own
    // wsdo-specific DC until the thread goes away or the wsdo
    // is disposed.
}


static void GDIWinSD_InvalidateSD(JNIEnv *env, GDIWinSDOps *wsdo)
{
    J2dTraceLn(J2D_TRACE_INFO, "GDIWinSD_InvalidateSD");
    J2dTraceLn2(J2D_TRACE_VERBOSE, "  wsdo=0x%x wsdo->window=0x%x",
                wsdo, wsdo->window);

    wsdo->invalid = JNI_TRUE;
}


/*
 * Method:    GDIWinSD_Dispose
 */
static void
GDIWinSD_Dispose(JNIEnv *env, SurfaceDataOps *ops)
{
    J2dTraceLn(J2D_TRACE_INFO, "GDIWinSD_Dispose");
    // ops is assumed non-null as it is checked in SurfaceData_DisposeOps
    GDIWinSDOps *wsdo = (GDIWinSDOps*)ops;
    if (wsdo->bitmap) {
        // delete old objects
        J2dTraceLn(J2D_TRACE_VERBOSE, "  disposing the GDI bitmap");
        if (wsdo->bmdc) {   // should not be null
            ::SelectObject(wsdo->bmdc, wsdo->oldmap);
            ::DeleteDC(wsdo->bmdc);
            wsdo->bmdc = 0;
        }
        ::DeleteObject(wsdo->bitmap);
        wsdo->bitmap = 0;
    }
    env->DeleteWeakGlobalRef(wsdo->peer);
    if (wsdo->device != NULL) {
        wsdo->device->Release();
        wsdo->device = NULL;
    }
    delete wsdo->surfaceLock;
}


/*
 * Class:     sun_java2d_windows_GDIWindowSurfaceData
 * Method:    invalidateSD
 * Signature: ()V
 */
JNIEXPORT void JNICALL
Java_sun_java2d_windows_GDIWindowSurfaceData_invalidateSD(JNIEnv *env, jobject wsd)
{
    J2dTraceLn(J2D_TRACE_INFO, "GDIWindowSurfaceData_invalidateSD");
    GDIWinSDOps *wsdo = GDIWindowSurfaceData_GetOpsNoSetup(env, wsd);
    if (wsdo != NULL) {
        wsdo->InvalidateSD(env, wsdo);
    }
}