/*

 * 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->hDC = 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;

        }

        // 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);

        }

        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);

    tc = env->FindClass("java/lang/Thread");

    DASSERT(tc != NULL);

    threadClass = (jclass)env->NewGlobalRef(tc);

    DASSERT(threadClass != NULL);

    currentThreadMethodID =

        env->GetStaticMethodID(threadClass,

                               "currentThread",  "()Ljava/lang/Thread;");

    DASSERT(currentThreadMethodID != NULL);

}

/*

 * 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);

    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);