--- a/jdk/src/windows/native/sun/java2d/windows/ddrawUtils.cpp Fri Aug 08 08:52:18 2008 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1804 +0,0 @@
-/*
- * Copyright 2000-2006 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.
- */
-
-#define INITGUID
-#include "Trace.h"
-#include "ddrawUtils.h"
-#include "ddrawObject.h"
-#include "awt_Multimon.h"
-#include "awt_MMStub.h"
-#include "dxInit.h"
-#include "WindowsFlags.h"
-#include "D3DContext.h"
-
-//
-// Globals
-//
-DDrawObjectStruct **ddInstance;
-int maxDDDevices = 0;
-int currNumDevices = 0;
-CriticalSection ddInstanceLock;
-extern BOOL isAppActive;
-extern HINSTANCE hLibDDraw; // DDraw Library handle
-extern jfieldID ddSurfacePuntedID;
-
-extern "C" void Win32OSSD_DisableDD(JNIEnv *env, Win32SDOps *wsdo);
-
-//
-// Constants
-//
-#define MAX_BUSY_ATTEMPTS 50 // Arbitrary number of times to attempt
- // an operation that returns a busy error
-
-//
-// Macros
-//
-
-/**
- * This macro is just a shortcut for the various places in the
- * code where we want to call a ddraw function and print any error
- * if the result is not equal to DD_OK. The errorString passed
- * in is for debugging/tracing purposes only.
- */
-#define DD_FUNC(func, errorString) { \
- HRESULT ddResult = func; \
- if (ddResult != DD_OK) { \
- DebugPrintDirectDrawError(ddResult, errorString); \
- } \
-}
-/**
- * Same as above, only return FALSE when done (to be used only in
- * functions that should return FALSE on a ddraw failure).
- */
-#define DD_FUNC_RETURN(func, errorString) { \
- HRESULT ddResult = func; \
- if (ddResult != DD_OK) { \
- DebugPrintDirectDrawError(ddResult, errorString); \
- return FALSE; \
- } \
-}
-
-//
-// INLINE functions
-//
-
-// Attaches the clipper object of a given surface to
-// the primary. Note that this action only happens if the
-// surface is onscreen (clipping only makes sense for onscreen windows)
-INLINE void AttachClipper(Win32SDOps *wsdo) {
- if (wsdo->window && wsdo->ddInstance->hwndFullScreen == NULL) {
- J2dTraceLn(J2D_TRACE_VERBOSE, "AttachClipper");
- HRESULT ddResult;
- ddResult = wsdo->ddInstance->clipper->SetHWnd(0, wsdo->window);
- if (ddResult != DD_OK) {
- DebugPrintDirectDrawError(ddResult, "AttachClipper");
- }
- }
-}
-
-//
-// Functions
-//
-
-/**
- * Returns the ddInstance associated with a particular HMONITOR
- */
-DDrawObjectStruct *GetDDInstanceForDevice(HMONITOR hMon)
-{
- J2dTraceLn(J2D_TRACE_VERBOSE, "GetDDInstanceForDevice");
- DDrawObjectStruct *tmpDdInstance = NULL;
- ddInstanceLock.Enter();
- if (currNumDevices == 1) {
- // Non multimon situation
- if (ddInstance[0])
- {
- tmpDdInstance = ddInstance[0];
- }
- } else {
- for (int i = 0; i < currNumDevices; ++i) {
- if (ddInstance[i]
- && hMon == ddInstance[i]->hMonitor)
- {
- tmpDdInstance = ddInstance[i];
- break;
- }
- }
- }
- if (tmpDdInstance != NULL && !tmpDdInstance->accelerated) {
- // Some failure situations (see DDSetupDevice in dxInit.cpp) can cause
- // a ddInstance object to become invalid. If this happens, we should
- // not be using this ddInstance object at all, so return NULL.
- tmpDdInstance = NULL;
- }
- ddInstanceLock.Leave();
- return tmpDdInstance;
-}
-
-/**
- * Can return FALSE if there was some problem during ddraw
- * initialization for this screen, or if this screen does not
- * support some of the capabilities necessary for running ddraw
- * correctly.
- */
-BOOL DDCanCreatePrimary(HMONITOR hMon) {
- DDrawObjectStruct *tmpDdInstance = GetDDInstanceForDevice(hMon);
- return (useDD && ddInstance && tmpDdInstance);
-}
-
-/**
- * Can return FALSE if the device that the surfaceData object
- * resides on cannot support accelerated Blt's. Some devices
- * can perform basic ddraw Lock/Unlock commands but cannot
- * handle the ddraw Blt command.
- */
-BOOL DDCanBlt(Win32SDOps *wsdo) {
- return (useDD && wsdo->ddInstance && wsdo->ddInstance->canBlt);
-}
-
-/**
- * Can return FALSE if either ddraw is not enabled at all (problems
- * during initialization) or the device associated with the hMon object
- * cannot support the basic required capabilities (in
- * which case the ddInstance for that device will be set to NULL).
- */
-BOOL DeviceUseDDraw(HMONITOR hMon) {
- DDrawObjectStruct *tmpDdInstance = GetDDInstanceForDevice(hMon);
- return (useDD && tmpDdInstance && tmpDdInstance->ddObject);
-}
-
-/**
- * Can return FALSE if either ddraw is not enabled at all (problems
- * during initialization) or the device associated with the hMon object
- * cannot support the basic required capabilities (in
- * which case the ddInstance for that device will be set to NULL).
- */
-BOOL DeviceUseD3D(HMONITOR hMon) {
- DDrawObjectStruct *tmpDdInstance = GetDDInstanceForDevice(hMon);
- return (useDD && tmpDdInstance && tmpDdInstance->ddObject &&
- tmpDdInstance->ddObject->IsD3DEnabled());
-}
-
-/**
- * Can return FALSE if either ddraw is not enabled at all (problems
- * during initialization) or the device that the surfaceData object
- * resides on cannot support the basic required capabilities (in
- * which case the ddInstance for that device will be set to NULL).
- */
-BOOL DDUseDDraw(Win32SDOps *wsdo) {
- return (useDD && wsdo->ddInstance && wsdo->ddInstance->valid);
-}
-
-
-/**
- * Release the resources consumed by ddraw. This will be called
- * by the DllMain function when it receives a PROCESS_DETACH method,
- * meaning that the application is done with awt. We need to release
- * these ddraw resources because of potential memory leaks, but
- * more importantly, because if we don't release a primary surface
- * that has been locked and not unlocked, then we may cause
- * ddraw to be corrupted on this system until reboot.
- * IMPORTANT: because we do not use any locks around this release,
- * we assume that this function is called only during the
- * PROCESS_DETACH procedure described above. Any other situation
- * could cause unpredictable results.
- */
-void DDRelease()
-{
- J2dTraceLn(J2D_TRACE_INFO, "DDRelease");
-
- // Note that we do not lock the ddInstanceLock CriticalSection.
- // Normally we should do that in this kind of situation (to ensure
- // that the ddInstance used in all release calls is the same on).
- // But in this case we do not want the release of a locked surface
- // to be hampered by some bad CriticalSection deadlock, so we
- // will just release ddInstance anyway.
- // Anyway, if users of this function call it properly (as
- // documented above), then there should be no problem.
- try {
- if (hLibDDraw) {
- ::FreeLibrary(hLibDDraw);
- hLibDDraw = NULL;
- }
- hLibDDraw = NULL;
- if (ddInstance) {
- for (int i = 0; i < currNumDevices; ++i) {
- ReleaseDDInstance(ddInstance[i]);
- }
- free(ddInstance);
- }
- } catch (...) {
- // Handle all exceptions by simply returning.
- // There are some cases where the OS may have already
- // released our objects for us (e.g., NT4) and we have
- // no way of knowing, but the above call into Release will
- // cause an exception to be thrown by dereferencing
- // already-released ddraw objects
- }
-}
-
-
-/**
- * Create the primary surface. Note that we do not take the ddInstanceLock
- * here; we assume that our callers are taking that lock for us.
- */
-BOOL DDCreatePrimary(Win32SDOps *wsdo) {
- J2dTraceLn(J2D_TRACE_INFO, "DDCreatePrimary");
- BOOL ret = TRUE;
-
- if (wsdo != NULL && wsdo->device != NULL) {
- HMONITOR hMon;
- hMon = (HMONITOR)wsdo->device->GetMonitor();
- DDrawObjectStruct *tmpDdInstance = GetDDInstanceForDevice(hMon);
- // Check if we need to recreate the primary for this device.
- // If we are in full-screen mode, we do not need to change
- // the primary unless the number of back buffers has changed.
- if (tmpDdInstance == NULL) {
- return FALSE;
- }
- if (tmpDdInstance->hwndFullScreen == NULL ||
- tmpDdInstance->context != CONTEXT_NORMAL)
- {
- ret = DDSetupDevice(tmpDdInstance,
- AwtWin32GraphicsDevice::GetDxCapsForDevice(hMon));
- tmpDdInstance->context = CONTEXT_NORMAL;
- }
- if (ret) {
- tmpDdInstance->valid = TRUE;
- }
- return ret;
- }
- return ret;
-}
-
-/**
- * Returns a DDrawSurface which should be used for performing DDraw sync.
- *
- * On systems other than Windows Vista, a primary surface is returned.
- *
- * On Windows Vista, a 1x1 scratch offscreen surface will be created and
- * maintained, because locking the primary surface will cause DWM to be
- * disabled for the run of the application.
- *
- * Note: this method must be called while ddInstance lock is held.
- * Note: a "DDINSTANCE_USABLE" non-null argument is assumed.
- */
-// 4978973: Only lock one pixel to flush; avoids GDI flicker artifacts
-// and only fill one pixel in the sync surface
-static RECT tinyRect = { 0, 0, 1, 1 };
-static DDrawSurface* DDGetSyncSurface(DDrawObjectStruct *tmpDdInstance)
-{
- static BOOL bIsVista = IS_WINVISTA;
- static DDBLTFX ddBltFx;
- DDrawSurface *lpSyncSurface;
-
- if (bIsVista) {
- lpSyncSurface = tmpDdInstance->syncSurface;
-
- if (lpSyncSurface != NULL) {
- // return the existing surface if it wasn't lost or it was
- // restored succesfully
- if (SUCCEEDED(lpSyncSurface->IsLost()) ||
- SUCCEEDED(lpSyncSurface->Restore()))
- {
- // we need to render to the sync surface so that DDraw
- // will flush the pipeline when we lock it in DDSync
- lpSyncSurface->Blt(&tinyRect, NULL, NULL,
- DDBLT_COLORFILL | DDBLT_WAIT,
- &ddBltFx);
- return lpSyncSurface;
- }
- J2dTraceLn(J2D_TRACE_WARNING, "DDGetSyncSurface: failed to restore"
- " sync surface, recreating");
- delete lpSyncSurface;
- }
-
- // this doesn't need to be done every time in the fast path
- ddBltFx.dwSize = sizeof(ddBltFx);
- ddBltFx.dwFillColor = 0xffffffff;
-
- lpSyncSurface =
- tmpDdInstance->ddObject->
- CreateDDOffScreenSurface(1, 1, 24/*ignored*/,
- TR_OPAQUE,
- DDSCAPS_VIDEOMEMORY);
- tmpDdInstance->syncSurface = lpSyncSurface;
- } else {
- lpSyncSurface = tmpDdInstance->primary;
- }
-
- return lpSyncSurface;
-}
-
-void
-DDFreeSyncSurface(DDrawObjectStruct *tmpDdInstance)
-{
- J2dTraceLn(J2D_TRACE_INFO, "DDFreeSyncSurface");
- if (tmpDdInstance != NULL && tmpDdInstance->syncSurface != NULL) {
- delete tmpDdInstance->syncSurface;
- tmpDdInstance->syncSurface = NULL;
- }
-}
-
-/**
- * Synchronize graphics pipeline by calling Lock/Unlock on primary
- * surface
- */
-void DDSync()
-{
- int attempts = 0;
- HRESULT ddResult;
- DDrawSurface *lpSyncSurface = NULL;
-
- J2dTraceLn(J2D_TRACE_INFO, "DDSync");
- // REMIND: need to handle errors here
- ddInstanceLock.Enter();
- for (int i = 0; i < currNumDevices; ++i) {
- DDrawObjectStruct *tmpDdInstance = ddInstance[i];
-
- if (!DDINSTANCE_USABLE(tmpDdInstance)) {
- continue;
- }
- lpSyncSurface = DDGetSyncSurface(tmpDdInstance);
- if (lpSyncSurface == NULL) {
- J2dRlsTraceLn1(J2D_TRACE_ERROR,
- "DDSync: no sync surface for device %d", i);
- continue;
- }
- // Spin while busy up to some finite number of times
- do {
- ddResult = lpSyncSurface->Lock(&tinyRect, NULL,
- DDLOCK_WAIT, NULL);
- } while ((ddResult == DDERR_SURFACEBUSY) &&
- (++attempts < MAX_BUSY_ATTEMPTS));
- if (ddResult == DD_OK) {
- ddResult = lpSyncSurface->Unlock(&tinyRect);
- }
- }
- ddInstanceLock.Leave();
- J2dTraceLn(J2D_TRACE_VERBOSE, "DDSync done");
-}
-
-
-/**
- * Simple clip check against the window of the given surface data.
- * If the clip list is complex or if the clip list intersects
- * the visible region of the window then return FALSE, meaning
- * that the clipping is sufficiently complex that the caller
- * may want to find an alternative means (other than ddraw) of
- * performing an operation.
- */
-BOOL DDClipCheck(Win32SDOps *wsdo, RECT *operationRect)
-{
- static struct {
- RGNDATAHEADER rdh;
- RECT rects[1];
- } rgnData;
- unsigned long rgnSize = sizeof(rgnData);
- HRESULT ddResult;
-
- J2dTraceLn(J2D_TRACE_VERBOSE, "DDClipCheck");
-
- if (!wsdo->window) {
- // Offscreen surfaces need no clipping
- return TRUE;
- }
-
- // If ddResult not OK, could be because of a complex clipping region
- // (Our rgnData structure only has space for a simple rectangle region).
- // Thus, we return FALSE and attach the clipper object.
- DDrawObjectStruct *tmpDdInstance = wsdo->ddInstance;
- if (!DDINSTANCE_USABLE(tmpDdInstance)) {
- return FALSE;
- }
- if (wsdo->window == tmpDdInstance->hwndFullScreen) {
- // Fullscreen surfaces need no clipping
- return TRUE;
- }
- DD_FUNC(tmpDdInstance->clipper->SetHWnd(0, wsdo->window),
- "DDClipCheck: SetHWnd");
- ddResult = tmpDdInstance->clipper->GetClipList(NULL, (RGNDATA*)&rgnData,
- &rgnSize);
- if (ddResult == DDERR_REGIONTOOSMALL) {
- // Complex clipping region
- // REMIND: could be more clever here and actually check operationRect
- // against all rectangles in clipList, but this works for now.
- return FALSE;
- }
- // Check intersection of clip region with operationRect. If clip region
- // smaller, then we have a simple clip case.
- // If no operationRect, then check against entire window bounds.
- if (operationRect) {
- if (operationRect->left < rgnData.rects[0].left ||
- operationRect->top < rgnData.rects[0].top ||
- operationRect->right > rgnData.rects[0].right ||
- operationRect->bottom > rgnData.rects[0].bottom)
- {
- return FALSE;
- }
- } else {
- RECT winrect;
- ::GetWindowRect(wsdo->window, &winrect);
- if (winrect.left < rgnData.rects[0].left ||
- winrect.top < rgnData.rects[0].top ||
- winrect.right > rgnData.rects[0].right ||
- winrect.bottom > rgnData.rects[0].bottom)
- {
- return FALSE;
- }
- }
- return TRUE;
-}
-
-
-/**
- * Lock the surface.
- */
-BOOL DDLock(JNIEnv *env, Win32SDOps *wsdo, RECT *lockRect,
- SurfaceDataRasInfo *pRasInfo)
-{
- J2dTraceLn1(J2D_TRACE_INFO, "DDLock: wsdo->lpSurface=0x%x", wsdo->lpSurface);
-
- int attempts = 0;
-
- if (wsdo->gdiOpPending) {
- // This sync is really for flushing any pending GDI
- // operations. On ATI boards GdiFlush() doesn't do the trick,
- // only locking the primary works.
- DDSync();
- wsdo->gdiOpPending = FALSE;
- }
- while (attempts++ < MAX_BUSY_ATTEMPTS) {
- if (!wsdo->ddInstance->valid) {
- // If dd object became invalid, don't bother calling Lock
- // Note: This check should not be necessary because we should
- // do the right thing in any case - catch the error, try to
- // restore the surface, fai, etc. But there seem to be problems
- // with ddraw that sometimes cause it to hang in the Restore and
- // Lock calls. Better to avoid the situation as much as we can and
- // bail out early.
- J2dTraceLn(J2D_TRACE_ERROR,
- "DDLock: wsdo->ddInstance invalid");
- return FALSE;
- }
- HRESULT ddResult = wsdo->lpSurface->Lock(lockRect, pRasInfo,
- DDLOCK_WAIT, NULL);
- // Spin on the busy-type errors, else return having failed or succeeded
- switch (ddResult) {
- case DD_OK:
- return TRUE;
- case DDERR_WASSTILLDRAWING:
- case DDERR_SURFACEBUSY:
- J2dTraceLn(J2D_TRACE_WARNING, "DDLock: surface busy...");
- break;
- case DDERR_SURFACELOST:
- J2dTraceLn(J2D_TRACE_WARNING, "DDLock: surface lost");
- wsdo->RestoreSurface(env, wsdo);
- return FALSE;
- case DDERR_GENERIC:
- J2dRlsTraceLn(J2D_TRACE_ERROR, "DDLock: unexpected error");
- if (wsdo->window == NULL) {
- Win32OSSD_DisableDD(env, wsdo);
- }
- return FALSE;
- default:
- DebugPrintDirectDrawError(ddResult, "DDLock");
- return FALSE;
- }
- }
- // If we get here, then there was an error in the function and we
- // should return false
- return FALSE;
-}
-
-
-/**
- * Unlock the surface
- */
-void DDUnlock(JNIEnv *env, Win32SDOps *wsdo)
-{
- J2dTraceLn1(J2D_TRACE_INFO, "DDUnlock: wsdo->lpSurface=0x%x", wsdo->lpSurface);
-
- HRESULT ddResult = wsdo->lpSurface->Unlock(NULL);
- // Spin on the busy-type errors, else return having failed or succeeded
- switch (ddResult) {
- case DD_OK:
- return;
- case DDERR_NOTLOCKED:
- J2dTraceLn(J2D_TRACE_ERROR, "DDUnlock: Surface not locked");
- return;
- case DDERR_SURFACELOST:
- J2dTraceLn(J2D_TRACE_WARNING, "DDUnlock: Surface lost");
- wsdo->RestoreSurface(env, wsdo);
- return;
- default:
- DebugPrintDirectDrawError(ddResult, "DDUnlock");
- return;
- }
-}
-
-/**
- * Fill given surface with given color in given RECT bounds
- */
-BOOL DDColorFill(JNIEnv *env, jobject sData, Win32SDOps *wsdo,
- RECT *fillRect, jint color)
-{
- DDBLTFX ddBltFx;
- HRESULT ddResult;
- int attempts = 0;
-
- J2dTraceLn(J2D_TRACE_VERBOSE, "DDColorFill");
- J2dTraceLn5(J2D_TRACE_VERBOSE,
- " color=0x%x l=%-4d t=%-4d r=%-4d b=%-4d",
- color, fillRect->left, fillRect->top, fillRect->right,
- fillRect->bottom);
- ddBltFx.dwSize = sizeof(ddBltFx);
- ddBltFx.dwFillColor = color;
- AttachClipper(wsdo);
- while (attempts++ < MAX_BUSY_ATTEMPTS) {
- ddResult = wsdo->lpSurface->Blt(fillRect, NULL, NULL,
- DDBLT_COLORFILL | DDBLT_WAIT,
- &ddBltFx);
- // Spin on the busy-type errors, else return having failed or succeeded
- switch (ddResult) {
- case DD_OK:
- return TRUE;
- case DDERR_INVALIDRECT:
- J2dTraceLn4(J2D_TRACE_ERROR,
- "DDColorFill: Invalid rect for colorfill "\
- "l=%-4d t=%-4d r=%-4d b=%-4d",
- fillRect->left, fillRect->top,
- fillRect->right, fillRect->bottom);
- return FALSE;
- case DDERR_SURFACEBUSY:
- J2dTraceLn(J2D_TRACE_WARNING, "DDColorFill: surface busy");
- break;
- case DDERR_SURFACELOST:
- J2dTraceLn(J2D_TRACE_WARNING, "DDColorfill: surface lost");
- wsdo->RestoreSurface(env, wsdo);
- return FALSE;
- default:
- DebugPrintDirectDrawError(ddResult, "DDColorFill");
- }
- }
- J2dTraceLn(J2D_TRACE_VERBOSE, "DDColorFill done");
- return FALSE;
-}
-
-void ManageOffscreenSurfaceBlt(JNIEnv *env, Win32SDOps *wsdo)
-{
- J2dTraceLn(J2D_TRACE_INFO, "ManageOffscreenSurfaceBlt");
- wsdo->surfacePuntData.pixelsReadSinceBlt = 0;
- if (wsdo->surfacePuntData.numBltsSinceRead >=
- wsdo->surfacePuntData.numBltsThreshold)
- {
- if (wsdo->surfacePuntData.usingDDSystem) {
- if (wsdo->surfacePuntData.lpSurfaceVram->Blt(NULL,
- wsdo->surfacePuntData.lpSurfaceSystem,
- NULL, DDBLT_WAIT, NULL) == DD_OK)
- {
- J2dTraceLn2(J2D_TRACE_VERBOSE,
- " Unpunting sys to VRAM: 0x%x -> 0x%x",
- wsdo->surfacePuntData.lpSurfaceVram,
- wsdo->surfacePuntData.lpSurfaceSystem);
- wsdo->lpSurface = wsdo->surfacePuntData.lpSurfaceVram;
- wsdo->surfacePuntData.usingDDSystem = FALSE;
- // Now: double our threshhold to prevent thrashing; we
- // don't want to keep punting and un-punting our surface
- wsdo->surfacePuntData.numBltsThreshold *= 2;
- // Notify the Java level that this surface has
- // been unpunted so that future copies to this surface
- // from accelerated src surfaces will do the right thing.
- jobject sdObject = env->NewLocalRef(wsdo->sdOps.sdObject);
- if (sdObject) {
- // Only bother with this optimization if the
- // reference is still valid
- env->SetBooleanField(sdObject, ddSurfacePuntedID, JNI_FALSE);
- env->DeleteLocalRef(sdObject);
- }
- }
- }
- } else {
- wsdo->surfacePuntData.numBltsSinceRead++;
- }
-}
-
-/**
- * Copy data from src to dst using src and dst rectangles
- */
-BOOL DDBlt(JNIEnv *env, Win32SDOps *wsdoSrc, Win32SDOps *wsdoDst,
- RECT *rDst, RECT *rSrc, CompositeInfo *compInfo)
-{
- int attempts = 0;
- DWORD bltFlags = DDBLT_WAIT;
-
- J2dTraceLn(J2D_TRACE_INFO, "DDBlt");
- J2dTraceLn4(J2D_TRACE_INFO, " src rect: l=%-4d t=%-4d r=%-4d b=%-4d",
- rSrc->left, rSrc->top, rSrc->right, rSrc->bottom);
- J2dTraceLn4(J2D_TRACE_INFO, " dst rect: l=%-4d t=%-4d r=%-4d b=%-4d",
- rDst->left, rDst->top, rDst->right, rDst->bottom);
-
- // Note: the primary can only have one clipper attached to it at
- // any time. This seems weird to set it to src then dst, but this
- // works because either: both are the same window (devCopyArea),
- // neither are windows (both offscreen), or only one is a window
- // (Blt). We can't get here from a windowA -> windowB copy operation.
- AttachClipper(wsdoSrc);
- AttachClipper(wsdoDst);
-
- // Administrate system-surface punt mechanism for offscreen images
- if (!wsdoSrc->window && !wsdoSrc->surfacePuntData.disablePunts) {
- ManageOffscreenSurfaceBlt(env, wsdoSrc);
- }
- if (wsdoSrc->transparency == TR_BITMASK) {
- bltFlags |= DDBLT_KEYSRC;
- }
- while (attempts++ < MAX_BUSY_ATTEMPTS) {
- HRESULT ddResult =
- wsdoDst->lpSurface->Blt(rDst, wsdoSrc->lpSurface,
- rSrc, bltFlags, NULL);
-
- // Spin on the busy-type errors or return having failed or succeeded
- switch (ddResult) {
- case DD_OK:
- return TRUE;
- case DDERR_SURFACEBUSY:
- J2dTraceLn(J2D_TRACE_WARNING, "DDBlt: surface busy");
- break;
- case DDERR_SURFACELOST:
- /**
- * Only restore the Dst if it is truly lost; "restoring" an
- * offscreen surface simply sets a flag and throws an exception,
- * thus guaranteeing that the Src restore below will not happen.
- * So if the Src stays Lost and we keep trying to restore an un-Lost
- * Dst, then we will never actually do the restore on the Src.
- */
- if (wsdoDst->lpSurface->IsLost() != DD_OK) {
- J2dTraceLn(J2D_TRACE_WARNING, "DDBlt: dst surface lost");
- wsdoDst->RestoreSurface(env, wsdoDst);
- }
- if (wsdoSrc->lpSurface->IsLost() != DD_OK) {
- J2dTraceLn(J2D_TRACE_WARNING, "DDBlt: src surface lost");
- wsdoSrc->RestoreSurface(env, wsdoSrc);
- }
- return FALSE;
- default:
- DebugPrintDirectDrawError(ddResult, "DDBlt");
- return FALSE;
- }
- }
- return FALSE;
-}
-
-/**
- * Set the color key information for this surface. During a
- * blit operation, pixels of the specified color will not be
- * drawn (resulting in transparent areas of the image). Note
- * that the "transparency" field in the Win32SDOps structure must
- * be set to TR_BITMASK for the color key information to have an effect.
- */
-void DDSetColorKey(JNIEnv *env, Win32SDOps *wsdo, jint color)
-{
- J2dTraceLn(J2D_TRACE_VERBOSE, "DDSetColorKey");
- DDCOLORKEY ddck;
- HRESULT ddResult;
-
- ddck.dwColorSpaceLowValue = color;
- ddck.dwColorSpaceHighValue = color;
-
- ddResult = wsdo->lpSurface->SetColorKey(DDCKEY_SRCBLT, &ddck);
-
- if (ddResult != DD_OK) {
- DebugPrintDirectDrawError(ddResult, "DDSetColorKey");
- }
-}
-
-
-/**
- * Swaps the surface memory of the front and back buffers.
- * Flips memory from the source surface to the destination surface.
- */
-BOOL DDFlip(JNIEnv *env, Win32SDOps *src, Win32SDOps *dest)
-{
- J2dTraceLn(J2D_TRACE_INFO, "DDFlip");
- int attempts = 0;
- while (attempts++ < MAX_BUSY_ATTEMPTS) {
- HRESULT ddResult = src->lpSurface->Flip(dest->lpSurface);
- // Spin on the busy-type errors or return having failed or succeeded
- switch (ddResult) {
- case DD_OK:
- return TRUE;
- case DDERR_SURFACEBUSY:
- J2dTraceLn(J2D_TRACE_WARNING, "DDFlip: surface busy");
- break;
- case DDERR_SURFACELOST:
- if (dest->lpSurface->IsLost() != DD_OK) {
- J2dTraceLn(J2D_TRACE_WARNING, "DDFlip: dst surface lost");
- dest->RestoreSurface(env, dest);
- }
- if (src->lpSurface->IsLost() != DD_OK) {
- J2dTraceLn(J2D_TRACE_WARNING, "DDFlip: src surface lost");
- src->RestoreSurface(env, src);
- }
- return FALSE;
- default:
- DebugPrintDirectDrawError(ddResult, "DDFlip");
- return FALSE;
- }
- }
- return FALSE;
-}
-
-
-/**
- * Mark the given ddInstance structure as invalid. This flag
- * can then be used to detect rendering with an invalid ddraw
- * object later (to avoid further ddraw errors) or to detect
- * when it is time to create a new ddraw object. Recreation
- * happens when we are asked to create a new surface but the
- * current ddInstance global structure is invalid.
- */
-void DDInvalidateDDInstance(DDrawObjectStruct *ddInst) {
- J2dTraceLn(J2D_TRACE_INFO, "DDInvalidateDDInstance");
- if (useDD) {
- if (ddInst != NULL) {
- // Invalidate given instance of ddInstance
- ddInst->valid = FALSE;
- } else {
- // Invalidate global ddInstance. This occurs at the start
- // of a display-change event.
- for (int i = 0; i < currNumDevices; ++i) {
- if (ddInstance[i] && ddInstance[i]->hwndFullScreen == NULL) {
- ddInstance[i]->valid = FALSE;
- }
- }
- }
- }
-}
-
-/**
- * Utility routine: release all elements of given ddInst structure
- * and free the memory consumed by ddInst. Note that this may be
- * called during a failed DDCreateDDObject, so any null fields were
- * not yet initialized and should not be released.
- */
-void ReleaseDDInstance(DDrawObjectStruct *ddInst)
-{
- J2dTraceLn(J2D_TRACE_INFO, "ReleaseDDInstance");
- if (ddInst) {
- if (ddInst->primary) {
- delete ddInst->primary;
- ddInst->primary = NULL;
- }
- if (ddInst->clipper) {
- delete ddInst->clipper;
- ddInst->clipper = NULL;
- }
- if (ddInst->ddObject) {
- delete ddInst->ddObject;
- ddInst->ddObject = NULL;
- }
- free(ddInst);
- }
-}
-
-/**
- * Enters full-screen exclusive mode, setting the hwnd as the screen
- */
-BOOL DDEnterFullScreen(HMONITOR hMon, HWND hwnd, HWND topLevelHwnd)
-{
- HRESULT ddResult = DD_OK;
- // Sleep so that programatically full-screen cannot be entered
- // and left multiple times quickly enough to crash the driver
- static DWORD prevTime = 0;
- DWORD currTime = ::GetTickCount();
- DWORD timeDiff = (currTime - prevTime);
- if (timeDiff < 500) {
- ::Sleep(500 - timeDiff);
- }
- prevTime = currTime;
-
- DDrawObjectStruct *tmpDdInstance = GetDDInstanceForDevice(hMon);
- tmpDdInstance->ddObject->SetCooperativeLevel(topLevelHwnd,
- DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE);
- if (ddResult != DD_OK) {
- DebugPrintDirectDrawError(ddResult, "DDEnterFullScreen");
- return FALSE;
- }
- if (tmpDdInstance->primary) {
- // No clipping necessary in fullscreen mode. Elsewhere,
- // we avoid setting the clip list for the fullscreen window,
- // so we should also null-out the clipper object for the
- // primary surface in that case. Bug 4737785.
- tmpDdInstance->primary->SetClipper(NULL);
- }
- tmpDdInstance->hwndFullScreen = hwnd;
- tmpDdInstance->context = CONTEXT_ENTER_FULL_SCREEN;
-
- return TRUE;
-}
-
-
-/**
- * Exits full-screen exclusive mode
- */
-BOOL DDExitFullScreen(HMONITOR hMon, HWND hwnd)
-{
- // Sleep so that programatically full-screen cannot be entered
- // and left multiple times quickly enough to crash the driver
- static DWORD prevTime = 0;
- DWORD currTime = ::GetTickCount();
- DWORD timeDiff = (currTime - prevTime);
- if (timeDiff < 500) {
- ::Sleep(500 - timeDiff);
- }
- prevTime = currTime;
-
- J2dTraceLn(J2D_TRACE_INFO, "DDExitFullScreen");
- DDrawObjectStruct *tmpDdInstance = GetDDInstanceForDevice(hMon);
- tmpDdInstance->context = CONTEXT_EXIT_FULL_SCREEN;
- if (!tmpDdInstance || !tmpDdInstance->ddObject ||
- !tmpDdInstance->ddObject->RestoreDDDisplayMode()) {
- return FALSE;
- }
- J2dTraceLn1(J2D_TRACE_VERBOSE,
- "DDExitFullScreen: Restoring cooperative level hwnd=0x%x",
- hwnd);
- HRESULT ddResult =
- tmpDdInstance->ddObject->SetCooperativeLevel(NULL, DDSCL_NORMAL);
- if (ddResult != DD_OK) {
- DebugPrintDirectDrawError(ddResult, "DDExitFullScreen");
- return FALSE;
- }
- if (tmpDdInstance->clipper == NULL) {
- // May not have created clipper if we were in FS mode during
- // primary creation
- tmpDdInstance->clipper = tmpDdInstance->ddObject->CreateDDClipper();
- }
- if (tmpDdInstance->clipper != NULL) {
- tmpDdInstance->primary->SetClipper(tmpDdInstance->clipper);
- }
- J2dTraceLn(J2D_TRACE_VERBOSE,
- "DDExitFullScreen: Restored cooperative level");
- tmpDdInstance->hwndFullScreen = NULL;
- tmpDdInstance->context = CONTEXT_NORMAL;
- return TRUE;
-}
-
-/**
- * Gets the current display mode; sets the values in displayMode
- */
-BOOL DDGetDisplayMode(HMONITOR hMon, DDrawDisplayMode& displayMode)
-{
- DDrawObjectStruct *tmpDdInstance = GetDDInstanceForDevice(hMon);
- if (tmpDdInstance && tmpDdInstance->ddObject) {
- return tmpDdInstance->ddObject->GetDDDisplayMode(displayMode);
- } else {
- return FALSE;
- }
-}
-
-/**
- * Sets the display mode to the supplied mode
- */
-BOOL DDSetDisplayMode(HMONITOR hMon, DDrawDisplayMode& displayMode)
-{
- DDrawObjectStruct *tmpDdInstance = GetDDInstanceForDevice(hMon);
- if (tmpDdInstance) {
- tmpDdInstance->context = CONTEXT_DISPLAY_CHANGE;
- }
- if (tmpDdInstance && tmpDdInstance->ddObject) {
- int attempts = 0;
- while (attempts++ < MAX_BUSY_ATTEMPTS) {
- HRESULT ddResult = tmpDdInstance->ddObject->SetDDDisplayMode(
- displayMode);
- // Spin on the busy-type errors or return having failed or succeeded
- switch (ddResult) {
- case DD_OK:
- return TRUE;
- case DDERR_SURFACEBUSY:
- J2dTraceLn(J2D_TRACE_WARNING,
- "DDSetDisplayMode: surface busy");
- break;
- default:
- DebugPrintDirectDrawError(ddResult, "DDSetDisplayMode");
- return FALSE;
- }
- }
- return FALSE;
- } else {
- return FALSE;
- }
-}
-
-/**
- * Enumerates all display modes, calling the supplied callback for each
- * display mode returned by the system
- */
-BOOL DDEnumDisplayModes(HMONITOR hMon, DDrawDisplayMode* constraint,
- DDrawDisplayMode::Callback callback, void* context)
-{
- DDrawObjectStruct *tmpDdInstance = GetDDInstanceForDevice(hMon);
- if (tmpDdInstance && tmpDdInstance->ddObject) {
- return tmpDdInstance->ddObject->EnumDDDisplayModes(
- constraint, callback, context);
- } else {
- return FALSE;
- }
-}
-
-/**
- * Attempts to restore surface. This will only succeed if the system is
- * in a state that allows the surface to be restored. If a restore
- * results in a DDERR_WRONGMODE, then the surface must be recreated
- * entirely; we do this by invalidating the surfaceData and recreating
- * it from scratch (at the Java level).
- */
-BOOL DDRestoreSurface(Win32SDOps *wsdo)
-{
- J2dTraceLn1(J2D_TRACE_INFO, "DDRestoreSurface, wsdo->lpSurface=0x%x",
- wsdo->lpSurface);
-
- DDrawObjectStruct *tmpDdInstance = wsdo->ddInstance;
- if (tmpDdInstance == NULL || !tmpDdInstance->accelerated) {
- return FALSE;
- }
- // Don't try to restore an inactive primary in full-screen mode
- if (!isAppActive && wsdo->window &&
- wsdo->window == tmpDdInstance->hwndFullScreen) {
- return FALSE;
- }
- if (wsdo->lpSurface->IsLost() == DD_OK) {
- J2dTraceLn(J2D_TRACE_VERBOSE, "DDRestoreSurface: surface memory ok");
- }
- else {
- J2dTraceLn(J2D_TRACE_WARNING,
- "DDRestoreSurface: surface memory lost, trying to restore");
- HRESULT ddResult;
- ddResult = wsdo->lpSurface->Restore();
- if (ddResult == DDERR_WRONGMODE) {
- // Strange full-screen bug; return false to avoid a hang.
- // Note that we should never get this error in full-screen mode.
- if (wsdo->window == tmpDdInstance->hwndFullScreen) {
- return FALSE;
- }
- // Wrong mode: display depth has been changed.
- J2dRlsTraceLn(J2D_TRACE_ERROR,
- "DDRestoreSurface failure: DDERR_WRONGMODE");
- if (wsdo->window) {
- /**
- * If this is a window surface, invalidate this
- * object's ddInstance and return the approriate error. The
- * surfaceData will later be invalidated, disposed, and
- * re-created with the new and correct depth information.
- * Only invalidate for windows because offscreen surfaces
- * have other means of being re-created and do not necessarily
- * mean that the ddInstance object is invalid for other surfaces
- */
- DDInvalidateDDInstance(wsdo->ddInstance);
- }
- return FALSE;
- } else if (ddResult != DD_OK) {
- DebugPrintDirectDrawError(ddResult, "DDRestoreSurface");
- return FALSE;
- }
- }
- if (!tmpDdInstance->valid) {
- tmpDdInstance->valid = TRUE;
- }
- return TRUE;
-}
-
-jint DDGetAvailableMemory(HMONITOR hMon)
-{
- J2dTraceLn(J2D_TRACE_INFO, "DDGetAvailableMemory");
- DWORD dwFree;
- DDrawObjectStruct *tmpDdInstance = GetDDInstanceForDevice(hMon);
- if (!useDD || !tmpDdInstance || !tmpDdInstance->valid) {
- return 0;
- }
-
- HRESULT ddResult = tmpDdInstance->ddObject->GetDDAvailableVidMem(&dwFree);
- if (ddResult != DD_OK) {
- DebugPrintDirectDrawError(ddResult, "GetAvailableMemory");
- }
-
- return (jint)dwFree;
-}
-
-
-/**
- * Creates either an offscreen or onscreen ddraw surface, depending
- * on the value of wsdo->window. Handles the common
- * framework of surface creation, such as ddInstance management,
- * and passes off the functionality of actual surface creation to
- * other functions. Successful creation results in a return value
- * of TRUE.
- */
-BOOL DDCreateSurface(Win32SDOps *wsdo)
-{
- J2dTraceLn(J2D_TRACE_INFO, "DDCreateSurface");
- HMONITOR hMon;
- hMon = (HMONITOR)wsdo->device->GetMonitor();
- DDrawObjectStruct *tmpDdInstance = GetDDInstanceForDevice(hMon);
-
- wsdo->ddInstance = NULL; // default value in case of error
- wsdo->lpSurface = NULL; // default value in case of error
-
- if (wsdo->window) {
- if (tmpDdInstance &&
- tmpDdInstance->backBufferCount != wsdo->backBufferCount &&
- tmpDdInstance->hwndFullScreen == wsdo->window)
- {
- tmpDdInstance->context = CONTEXT_CHANGE_BUFFER_COUNT;
- tmpDdInstance->backBufferCount = wsdo->backBufferCount;
- }
- if (!tmpDdInstance || !tmpDdInstance->valid ||
- tmpDdInstance->context != CONTEXT_NORMAL
- ) {
- // Only recreate dd object on primary create. Given our current
- // model of displayChange event propagation, we can only guarantee
- // that the system has been properly prepared for a recreate when
- // we recreate a primary surface. The offscreen surfaces may
- // be recreated at any time.
- // Recreating ddraw at offscreen surface creation time has caused
- // rendering artifacts as well as unexplainable hangs in ddraw
- // calls.
- ddInstanceLock.Enter();
- BOOL success = DDCreatePrimary(wsdo);
- ddInstanceLock.Leave();
- if (!success) {
- return FALSE;
- }
- tmpDdInstance = GetDDInstanceForDevice(hMon);
- }
- // restore the primary if it's lost
- if (tmpDdInstance->primary != NULL &&
- FAILED(tmpDdInstance->primary->IsLost()) &&
- FAILED(tmpDdInstance->primary->Restore()))
- {
- J2dRlsTraceLn(J2D_TRACE_ERROR,
- "DDCreateSurface: failed to restore primary surface");
- return FALSE;
- }
- // non-null window means onscreen surface. Primary already
- // exists, just need to cache a pointer to it in this wsdo
- wsdo->lpSurface = tmpDdInstance->primary;
- } else {
- if (!tmpDdInstance || !tmpDdInstance->valid) {
- // Don't recreate the ddraw object here (see note above), but
- // do fail this creation. We will come back here eventually
- // after an onscreen surface has been created (and the new
- // ddraw object to go along with it).
- return FALSE;
- }
- if (!DDCreateOffScreenSurface(wsdo, tmpDdInstance)) {
- J2dRlsTraceLn(J2D_TRACE_ERROR,
- "DDCreateSurface: Failed creating offscreen surface");
- return FALSE;
- }
- }
- wsdo->ddInstance = tmpDdInstance;
- J2dTraceLn2(J2D_TRACE_VERBOSE,
- "DDCreateSurface: succeeded ddInst=0x%x wsdo->lpSurface=0x%x",
- tmpDdInstance, wsdo->lpSurface);
- return TRUE;
-}
-
-/**
- * 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 DDSurfaceDepthsCompatible(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;
-}
-
-
-/**
- * Creates offscreen surface. Examines the display mode information
- * for the current ddraw object and uses that to create this new
- * surface.
- */
-BOOL DDCreateOffScreenSurface(Win32SDOps *wsdo,
- DDrawObjectStruct *ddInst)
-{
- J2dTraceLn(J2D_TRACE_INFO, "DDCreateOffScreenSurface");
-
- wsdo->lpSurface =
- ddInst->ddObject->CreateDDOffScreenSurface(wsdo->w, wsdo->h,
- wsdo->depth, wsdo->transparency, DDSCAPS_VIDEOMEMORY);
- if (!ddInst->primary || (ddInst->primary->IsLost() != DD_OK)) {
- if (wsdo->lpSurface) {
- delete wsdo->lpSurface;
- wsdo->lpSurface = NULL;
- }
- if (ddInst->primary) {
- // attempt to restore primary
- ddInst->primary->Restore();
- if (ddInst->primary->IsLost() == DD_OK) {
- // Primary restored: create the offscreen surface again
- wsdo->lpSurface =
- ddInst->ddObject->CreateDDOffScreenSurface(wsdo->w, wsdo->h,
- wsdo->depth, wsdo->transparency,
- DDSCAPS_VIDEOMEMORY);
- if (ddInst->primary->IsLost() != DD_OK) {
- // doubtful, but possible that it is lost again
- // If so, delete the surface and get out of here
- if (wsdo->lpSurface) {
- delete wsdo->lpSurface;
- wsdo->lpSurface = NULL;
- }
- }
- }
- }
- }
- if (wsdo->lpSurface != NULL && (wsdo->transparency != TR_TRANSLUCENT)) {
- /**
- * 4941350: Double-check that the depth of the surface just created
- * is compatible with the depth requested. Note that we ignore texture
- * (translucent) surfaces as those depths may differ between Java and
- * native representations.
- */
- int surfaceDepth = wsdo->lpSurface->GetSurfaceDepth();
- if (!DDSurfaceDepthsCompatible(wsdo->depth, surfaceDepth)) {
- J2dTraceLn2(J2D_TRACE_WARNING,
- "DDCreateOffScreenSurface: Surface depth mismatch: "\
- "intended=%d actual=%d",
- wsdo->depth, surfaceDepth);
- DDReleaseSurfaceMemory(wsdo->lpSurface);
- wsdo->lpSurface = NULL;
- }
- }
- return (wsdo->lpSurface != NULL);
-}
-
-
-/**
- * Gets an attached surface, such as a back buffer, from a parent
- * surface. Sets the lpSurface member of the wsdo supplied to
- * the attached surface.
- */
-BOOL DDGetAttachedSurface(JNIEnv *env, Win32SDOps* wsdo_parent,
- Win32SDOps* wsdo)
-{
- J2dTraceLn(J2D_TRACE_INFO, "DDGetAttachedSurface");
- HMONITOR hMon = (HMONITOR)wsdo_parent->device->GetMonitor();
- DDrawObjectStruct *tmpDdInstance = GetDDInstanceForDevice(hMon);
-
- wsdo->ddInstance = NULL; // default value in case of error
- wsdo->lpSurface = NULL; // default value in case of error
-
- if (!tmpDdInstance || !tmpDdInstance->valid ||
- wsdo_parent->lpSurface == NULL)
- {
- J2dTraceLn2(J2D_TRACE_WARNING,
- "DDGetAttachedSurface: unable to get attached "\
- "surface for wsdo=0%x wsdo_parent=0%x", wsdo, wsdo_parent);
- return FALSE;
- }
- DDrawSurface* pNew = wsdo_parent->lpSurface->GetDDAttachedSurface();
- if (pNew == NULL) {
- return FALSE;
- }
- wsdo->lpSurface = pNew;
- wsdo->ddInstance = tmpDdInstance;
- J2dTraceLn1(J2D_TRACE_VERBOSE,
- "DDGetAttachedSurface: succeeded wsdo->lpSurface=0x%x",
- wsdo->lpSurface);
- return TRUE;
-}
-
-
-/**
- * Destroys resources associated with a surface
- */
-void DDDestroySurface(Win32SDOps *wsdo)
-{
- J2dTraceLn1(J2D_TRACE_INFO, "DDDestroySurface: wsdo->lpSurface=0x%x",
- wsdo->lpSurface);
-
- if (!wsdo->lpSurface) {
- // null surface means it was never created; simply return
- return;
- }
- if (!wsdo->window) {
- // offscreen surface
- delete wsdo->lpSurface;
- wsdo->lpSurface = NULL;
- }
- J2dTraceLn1(J2D_TRACE_VERBOSE,
- "DDDestroySurface: ddInstance->refCount=%d",
- wsdo->ddInstance->refCount);
-}
-
-/**
- * Releases ddraw resources associated with a surface. Note that
- * the DDrawSurface object is still valid, but the underlying
- * DirectDraw surface is released.
- */
-void DDReleaseSurfaceMemory(DDrawSurface *lpSurface)
-{
- J2dTraceLn1(J2D_TRACE_INFO,
- "DDReleaseSurfaceMemory: lpSurface=0x%x", lpSurface);
-
- if (!lpSurface) {
- // null surface means it was never created; simply return
- return;
- }
- HRESULT ddResult = lpSurface->ReleaseSurface();
-}
-
-/*
- * This function returns whether or not surfaces should be replaced
- * in response to a WM_DISPLAYCHANGE message. If we are a full-screen
- * application that has lost its surfaces, we do not want to replace
- * our surfaces in response to a WM_DISPLAYCHANGE.
- */
-BOOL DDCanReplaceSurfaces(HWND hwnd)
-{
- J2dTraceLn1(J2D_TRACE_VERBOSE, "DDCanReplaceSurfaces: hwnd=0x%x", hwnd);
- DDrawObjectStruct *tmpDdInstance = NULL;
- ddInstanceLock.Enter();
- for (int i = 0; i < currNumDevices; i++) {
- tmpDdInstance = ddInstance[i];
- if (DDINSTANCE_USABLE(tmpDdInstance)) {
- J2dTraceLn2(J2D_TRACE_VERBOSE,
- " ddInstance[%d]->hwndFullScreen=0x%x",
- i, tmpDdInstance->hwndFullScreen);
- if (tmpDdInstance->hwndFullScreen != NULL &&
- tmpDdInstance->context == CONTEXT_NORMAL &&
- (tmpDdInstance->hwndFullScreen == hwnd || hwnd == NULL)) {
- ddInstanceLock.Leave();
- return FALSE;
- }
- }
- }
- ddInstanceLock.Leave();
- return TRUE;
-}
-
-/*
- * This function prints the DirectDraw error associated with
- * the given errNum
- */
-void PrintDirectDrawError(DWORD errNum, char *message)
-{
- char buffer[255];
-
- GetDDErrorString(errNum, buffer);
- printf("%s:: %s\n", message, buffer);
-}
-
-
-/*
- * This function prints the DirectDraw error associated with
- * the given errNum
- */
-void DebugPrintDirectDrawError(DWORD errNum, char *message)
-{
- char buffer[255];
-
- GetDDErrorString(errNum, buffer);
- J2dRlsTraceLn2(J2D_TRACE_ERROR, "%s: %s", message, buffer);
-}
-
-
-/*
- * This function prints the error string into the given buffer
- */
-void GetDDErrorString(DWORD errNum, char *buffer)
-{
- switch (errNum) {
- case DDERR_ALREADYINITIALIZED:
- sprintf(buffer, "DirectDraw Error: DDERR_ALREADYINITIALIZED");
- break;
- case DDERR_CANNOTATTACHSURFACE:
- sprintf(buffer, "DirectDraw Error: DDERR_CANNOTATTACHSURFACE");
- break;
- case DDERR_CANNOTDETACHSURFACE:
- sprintf(buffer, "DirectDraw Error: DDERR_CANNOTDETACHSURFACE");
- break;
- case DDERR_CURRENTLYNOTAVAIL:
- sprintf(buffer, "DirectDraw Error: DDERR_CURRENTLYNOTAVAIL");
- break;
- case DDERR_EXCEPTION:
- sprintf(buffer, "DirectDraw Error: DDERR_EXCEPTION");
- break;
- case DDERR_GENERIC:
- sprintf(buffer, "DirectDraw Error: DDERR_GENERIC");
- break;
- case DDERR_HEIGHTALIGN:
- sprintf(buffer, "DirectDraw Error: DDERR_HEIGHTALIGN");
- break;
- case DDERR_INCOMPATIBLEPRIMARY:
- sprintf(buffer, "DirectDraw Error: DDERR_INCOMPATIBLEPRIMARY");
- break;
- case DDERR_INVALIDCAPS:
- sprintf(buffer, "DirectDraw Error: DDERR_INVALIDCAPS");
- break;
- case DDERR_INVALIDCLIPLIST:
- sprintf(buffer, "DirectDraw Error: DDERR_INVALIDCLIPLIST");
- break;
- case DDERR_INVALIDMODE:
- sprintf(buffer, "DirectDraw Error: DDERR_INVALIDMODE");
- break;
- case DDERR_INVALIDOBJECT:
- sprintf(buffer, "DirectDraw Error: DDERR_INVALIDOBJECT");
- break;
- case DDERR_INVALIDPARAMS:
- sprintf(buffer, "DirectDraw Error: DDERR_INVALIDPARAMS");
- break;
- case DDERR_INVALIDPIXELFORMAT:
- sprintf(buffer, "DirectDraw Error: DDERR_INVALIDPIXELFORMAT");
- break;
- case DDERR_INVALIDRECT:
- sprintf(buffer, "DirectDraw Error: DDERR_INVALIDRECT");
- break;
- case DDERR_LOCKEDSURFACES:
- sprintf(buffer, "DirectDraw Error: DDERR_LOCKEDSURFACES");
- break;
- case DDERR_NO3D:
- sprintf(buffer, "DirectDraw Error: DDERR_NO3D");
- break;
- case DDERR_NOALPHAHW:
- sprintf(buffer, "DirectDraw Error: DDERR_NOALPHAHW");
- break;
- case DDERR_NOCLIPLIST:
- sprintf(buffer, "DirectDraw Error: DDERR_NOCLIPLIST");
- break;
- case DDERR_NOCOLORCONVHW:
- sprintf(buffer, "DirectDraw Error: DDERR_NOCOLORCONVHW");
- break;
- case DDERR_NOCOOPERATIVELEVELSET:
- sprintf(buffer, "DirectDraw Error: DDERR_NOCOOPERATIVELEVELSET");
- break;
- case DDERR_NOCOLORKEY:
- sprintf(buffer, "DirectDraw Error: DDERR_NOCOLORKEY");
- break;
- case DDERR_NOCOLORKEYHW:
- sprintf(buffer, "DirectDraw Error: DDERR_NOCOLORKEYHW");
- break;
- case DDERR_NODIRECTDRAWSUPPORT:
- sprintf(buffer, "DirectDraw Error: DDERR_NODIRECTDRAWSUPPORT");
- break;
- case DDERR_NOEXCLUSIVEMODE:
- sprintf(buffer, "DirectDraw Error: DDERR_NOEXCLUSIVEMODE");
- break;
- case DDERR_NOFLIPHW:
- sprintf(buffer, "DirectDraw Error: DDERR_NOFLIPHW");
- break;
- case DDERR_NOGDI:
- sprintf(buffer, "DirectDraw Error: DDERR_NOGDI");
- break;
- case DDERR_NOMIRRORHW:
- sprintf(buffer, "DirectDraw Error: DDERR_NOMIRRORHW");
- break;
- case DDERR_NOTFOUND:
- sprintf(buffer, "DirectDraw Error: DDERR_NOTFOUND");
- break;
- case DDERR_NOOVERLAYHW:
- sprintf(buffer, "DirectDraw Error: DDERR_NOOVERLAYHW");
- break;
- case DDERR_NORASTEROPHW:
- sprintf(buffer, "DirectDraw Error: DDERR_NORASTEROPHW");
- break;
- case DDERR_NOROTATIONHW:
- sprintf(buffer, "DirectDraw Error: DDERR_NOROTATIONHW");
- break;
- case DDERR_NOSTRETCHHW:
- sprintf(buffer, "DirectDraw Error: DDERR_NOSTRETCHHW");
- break;
- case DDERR_NOT4BITCOLOR:
- sprintf(buffer, "DirectDraw Error: DDERR_NOT4BITCOLOR");
- break;
- case DDERR_NOT4BITCOLORINDEX:
- sprintf(buffer, "DirectDraw Error: DDERR_NOT4BITCOLORINDEX");
- break;
- case DDERR_NOT8BITCOLOR:
- sprintf(buffer, "DirectDraw Error: DDERR_NOT8BITCOLOR");
- break;
- case DDERR_NOTEXTUREHW:
- sprintf(buffer, "DirectDraw Error: DDERR_NOTEXTUREHW");
- break;
- case DDERR_NOVSYNCHW:
- sprintf(buffer, "DirectDraw Error: DDERR_NOVSYNCHW");
- break;
- case DDERR_NOZBUFFERHW:
- sprintf(buffer, "DirectDraw Error: DDERR_NOZBUFFERHW");
- break;
- case DDERR_NOZOVERLAYHW:
- sprintf(buffer, "DirectDraw Error: DDERR_NOZOVERLAYHW");
- break;
- case DDERR_OUTOFCAPS:
- sprintf(buffer, "DirectDraw Error: DDERR_OUTOFCAPS");
- break;
- case DDERR_OUTOFMEMORY:
- sprintf(buffer, "DirectDraw Error: DDERR_OUTOFMEMORY");
- break;
- case DDERR_OUTOFVIDEOMEMORY:
- sprintf(buffer, "DirectDraw Error: DDERR_OUTOFVIDEOMEMORY");
- break;
- case DDERR_OVERLAYCANTCLIP:
- sprintf(buffer, "DirectDraw Error: DDERR_OVERLAYCANTCLIP");
- break;
- case DDERR_OVERLAYCOLORKEYONLYONEACTIVE:
- sprintf(buffer, "DirectDraw Error: DDERR_OVERLAYCOLORKEYONLYONEACTIVE");
- break;
- case DDERR_PALETTEBUSY:
- sprintf(buffer, "DirectDraw Error: DDERR_PALETTEBUSY");
- break;
- case DDERR_COLORKEYNOTSET:
- sprintf(buffer, "DirectDraw Error: DDERR_COLORKEYNOTSET");
- break;
- case DDERR_SURFACEALREADYATTACHED:
- sprintf(buffer, "DirectDraw Error: DDERR_SURFACEALREADYATTACHED");
- break;
- case DDERR_SURFACEALREADYDEPENDENT:
- sprintf(buffer, "DirectDraw Error: DDERR_SURFACEALREADYDEPENDENT");
- break;
- case DDERR_SURFACEBUSY:
- sprintf(buffer, "DirectDraw Error: DDERR_SURFACEBUSY");
- break;
- case DDERR_CANTLOCKSURFACE:
- sprintf(buffer, "DirectDraw Error: DDERR_CANTLOCKSURFACE");
- break;
- case DDERR_SURFACEISOBSCURED:
- sprintf(buffer, "DirectDraw Error: DDERR_SURFACEISOBSCURED");
- break;
- case DDERR_SURFACELOST:
- sprintf(buffer, "DirectDraw Error: DDERR_SURFACELOST");
- break;
- case DDERR_SURFACENOTATTACHED:
- sprintf(buffer, "DirectDraw Error: DDERR_SURFACENOTATTACHED");
- break;
- case DDERR_TOOBIGHEIGHT:
- sprintf(buffer, "DirectDraw Error: DDERR_TOOBIGHEIGHT");
- break;
- case DDERR_TOOBIGSIZE:
- sprintf(buffer, "DirectDraw Error: DDERR_TOOBIGSIZE");
- break;
- case DDERR_TOOBIGWIDTH:
- sprintf(buffer, "DirectDraw Error: DDERR_TOOBIGWIDTH");
- break;
- case DDERR_UNSUPPORTED:
- sprintf(buffer, "DirectDraw Error: DDERR_UNSUPPORTED");
- break;
- case DDERR_UNSUPPORTEDFORMAT:
- sprintf(buffer, "DirectDraw Error: DDERR_UNSUPPORTEDFORMAT");
- break;
- case DDERR_UNSUPPORTEDMASK:
- sprintf(buffer, "DirectDraw Error: DDERR_UNSUPPORTEDMASK");
- break;
- case DDERR_VERTICALBLANKINPROGRESS:
- sprintf(buffer, "DirectDraw Error: DDERR_VERTICALBLANKINPROGRESS");
- break;
- case DDERR_WASSTILLDRAWING:
- sprintf(buffer, "DirectDraw Error: DDERR_WASSTILLDRAWING");
- break;
- case DDERR_XALIGN:
- sprintf(buffer, "DirectDraw Error: DDERR_XALIGN");
- break;
- case DDERR_INVALIDDIRECTDRAWGUID:
- sprintf(buffer, "DirectDraw Error: DDERR_INVALIDDIRECTDRAWGUID");
- break;
- case DDERR_DIRECTDRAWALREADYCREATED:
- sprintf(buffer, "DirectDraw Error: DDERR_DIRECTDRAWALREADYCREATED");
- break;
- case DDERR_NODIRECTDRAWHW:
- sprintf(buffer, "DirectDraw Error: DDERR_NODIRECTDRAWHW");
- break;
- case DDERR_PRIMARYSURFACEALREADYEXISTS:
- sprintf(buffer, "DirectDraw Error: DDERR_PRIMARYSURFACEALREADYEXISTS");
- break;
- case DDERR_NOEMULATION:
- sprintf(buffer, "DirectDraw Error: DDERR_NOEMULATION");
- break;
- case DDERR_REGIONTOOSMALL:
- sprintf(buffer, "DirectDraw Error: DDERR_REGIONTOOSMALL");
- break;
- case DDERR_CLIPPERISUSINGHWND:
- sprintf(buffer, "DirectDraw Error: DDERR_CLIPPERISUSINGHWND");
- break;
- case DDERR_NOCLIPPERATTACHED:
- sprintf(buffer, "DirectDraw Error: DDERR_NOCLIPPERATTACHED");
- break;
- case DDERR_NOHWND:
- sprintf(buffer, "DirectDraw Error: DDERR_NOHWND");
- break;
- case DDERR_HWNDSUBCLASSED:
- sprintf(buffer, "DirectDraw Error: DDERR_HWNDSUBCLASSED");
- break;
- case DDERR_HWNDALREADYSET:
- sprintf(buffer, "DirectDraw Error: DDERR_HWNDALREADYSET");
- break;
- case DDERR_NOPALETTEATTACHED:
- sprintf(buffer, "DirectDraw Error: DDERR_NOPALETTEATTACHED");
- break;
- case DDERR_NOPALETTEHW:
- sprintf(buffer, "DirectDraw Error: DDERR_NOPALETTEHW");
- break;
- case DDERR_BLTFASTCANTCLIP:
- sprintf(buffer, "DirectDraw Error: DDERR_BLTFASTCANTCLIP");
- break;
- case DDERR_NOBLTHW:
- sprintf(buffer, "DirectDraw Error: DDERR_NOBLTHW");
- break;
- case DDERR_NODDROPSHW:
- sprintf(buffer, "DirectDraw Error: DDERR_NODDROPSHW");
- break;
- case DDERR_OVERLAYNOTVISIBLE:
- sprintf(buffer, "DirectDraw Error: DDERR_OVERLAYNOTVISIBLE");
- break;
- case DDERR_NOOVERLAYDEST:
- sprintf(buffer, "DirectDraw Error: DDERR_NOOVERLAYDEST");
- break;
- case DDERR_INVALIDPOSITION:
- sprintf(buffer, "DirectDraw Error: DDERR_INVALIDPOSITION");
- break;
- case DDERR_NOTAOVERLAYSURFACE:
- sprintf(buffer, "DirectDraw Error: DDERR_NOTAOVERLAYSURFACE");
- break;
- case DDERR_EXCLUSIVEMODEALREADYSET:
- sprintf(buffer, "DirectDraw Error: DDERR_EXCLUSIVEMODEALREADYSET");
- break;
- case DDERR_NOTFLIPPABLE:
- sprintf(buffer, "DirectDraw Error: DDERR_NOTFLIPPABLE");
- break;
- case DDERR_CANTDUPLICATE:
- sprintf(buffer, "DirectDraw Error: DDERR_CANTDUPLICATE");
- break;
- case DDERR_NOTLOCKED:
- sprintf(buffer, "DirectDraw Error: DDERR_NOTLOCKED");
- break;
- case DDERR_CANTCREATEDC:
- sprintf(buffer, "DirectDraw Error: DDERR_CANTCREATEDC");
- break;
- case DDERR_NODC:
- sprintf(buffer, "DirectDraw Error: DDERR_NODC");
- break;
- case DDERR_WRONGMODE:
- sprintf(buffer, "DirectDraw Error: DDERR_WRONGMODE");
- break;
- case DDERR_IMPLICITLYCREATED:
- sprintf(buffer, "DirectDraw Error: DDERR_IMPLICITLYCREATED");
- break;
- case DDERR_NOTPALETTIZED:
- sprintf(buffer, "DirectDraw Error: DDERR_NOTPALETTIZED");
- break;
- case DDERR_UNSUPPORTEDMODE:
- sprintf(buffer, "DirectDraw Error: DDERR_UNSUPPORTEDMODE");
- break;
- case DDERR_NOMIPMAPHW:
- sprintf(buffer, "DirectDraw Error: DDERR_NOMIPMAPHW");
- break;
- case DDERR_INVALIDSURFACETYPE:
- sprintf(buffer, "DirectDraw Error: DDERR_INVALIDSURFACETYPE");
- break;
- case DDERR_DCALREADYCREATED:
- sprintf(buffer, "DirectDraw Error: DDERR_DCALREADYCREATED");
- break;
- case DDERR_CANTPAGELOCK:
- sprintf(buffer, "DirectDraw Error: DDERR_CANTPAGELOCK");
- break;
- case DDERR_CANTPAGEUNLOCK:
- sprintf(buffer, "DirectDraw Error: DDERR_CANTPAGEUNLOCK");
- break;
- case DDERR_NOTPAGELOCKED:
- sprintf(buffer, "DirectDraw Error: DDERR_NOTPAGELOCKED");
- break;
- case D3DERR_INVALID_DEVICE:
- sprintf(buffer, "Direct3D Error: D3DERR_INVALID_DEVICE");
- break;
- case D3DERR_INITFAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_INITFAILED");
- break;
- case D3DERR_DEVICEAGGREGATED:
- sprintf(buffer, "Direct3D Error: D3DERR_DEVICEAGGREGATED");
- break;
- case D3DERR_EXECUTE_CREATE_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_EXECUTE_CREATE_FAILED");
- break;
- case D3DERR_EXECUTE_DESTROY_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_EXECUTE_DESTROY_FAILED");
- break;
- case D3DERR_EXECUTE_LOCK_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_EXECUTE_LOCK_FAILED");
- break;
- case D3DERR_EXECUTE_UNLOCK_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_EXECUTE_UNLOCK_FAILED");
- break;
- case D3DERR_EXECUTE_LOCKED:
- sprintf(buffer, "Direct3D Error: D3DERR_EXECUTE_LOCKED");
- break;
- case D3DERR_EXECUTE_NOT_LOCKED:
- sprintf(buffer, "Direct3D Error: D3DERR_EXECUTE_NOT_LOCKED");
- break;
- case D3DERR_EXECUTE_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_EXECUTE_FAILED");
- break;
- case D3DERR_EXECUTE_CLIPPED_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_EXECUTE_CLIPPED_FAILED");
- break;
- case D3DERR_TEXTURE_NO_SUPPORT:
- sprintf(buffer, "Direct3D Error: D3DERR_TEXTURE_NO_SUPPORT");
- break;
- case D3DERR_TEXTURE_CREATE_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_TEXTURE_CREATE_FAILED");
- break;
- case D3DERR_TEXTURE_DESTROY_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_TEXTURE_DESTROY_FAILED");
- break;
- case D3DERR_TEXTURE_LOCK_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_TEXTURE_LOCK_FAILED");
- break;
- case D3DERR_TEXTURE_UNLOCK_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_TEXTURE_UNLOCK_FAILED");
- break;
- case D3DERR_TEXTURE_LOAD_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_TEXTURE_LOAD_FAILED");
- break;
- case D3DERR_TEXTURE_SWAP_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_TEXTURE_SWAP_FAILED");
- break;
- case D3DERR_TEXTURE_LOCKED:
- sprintf(buffer, "Direct3D Error: D3DERR_TEXTURE_LOCKED");
- break;
- case D3DERR_TEXTURE_NOT_LOCKED:
- sprintf(buffer, "Direct3D Error: D3DERR_TEXTURE_NOT_LOCKED");
- break;
- case D3DERR_TEXTURE_GETSURF_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_TEXTURE_GETSURF_FAILED");
- break;
- case D3DERR_MATRIX_CREATE_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_MATRIX_CREATE_FAILED");
- break;
- case D3DERR_MATRIX_DESTROY_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_MATRIX_DESTROY_FAILED");
- break;
- case D3DERR_MATRIX_SETDATA_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_MATRIX_SETDATA_FAILED");
- break;
- case D3DERR_MATRIX_GETDATA_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_MATRIX_GETDATA_FAILED");
- break;
- case D3DERR_SETVIEWPORTDATA_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_SETVIEWPORTDATA_FAILED");
- break;
- case D3DERR_INVALIDCURRENTVIEWPORT:
- sprintf(buffer, "Direct3D Error: D3DERR_INVALIDCURRENTVIEWPORT");
- break;
- case D3DERR_INVALIDPRIMITIVETYPE:
- sprintf(buffer, "Direct3D Error: D3DERR_INVALIDPRIMITIVETYPE");
- break;
- case D3DERR_INVALIDVERTEXTYPE:
- sprintf(buffer, "Direct3D Error: D3DERR_INVALIDVERTEXTYPE");
- break;
- case D3DERR_TEXTURE_BADSIZE:
- sprintf(buffer, "Direct3D Error: D3DERR_TEXTURE_BADSIZE");
- break;
- case D3DERR_INVALIDRAMPTEXTURE:
- sprintf(buffer, "Direct3D Error: D3DERR_INVALIDRAMPTEXTURE");
- break;
- case D3DERR_MATERIAL_CREATE_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_MATERIAL_CREATE_FAILED");
- break;
- case D3DERR_MATERIAL_DESTROY_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_MATERIAL_DESTROY_FAILED");
- break;
- case D3DERR_MATERIAL_SETDATA_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_MATERIAL_SETDATA_FAILED");
- break;
- case D3DERR_MATERIAL_GETDATA_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_MATERIAL_GETDATA_FAILED");
- break;
- case D3DERR_INVALIDPALETTE:
- sprintf(buffer, "Direct3D Error: D3DERR_INVALIDPALETTE");
- break;
- case D3DERR_ZBUFF_NEEDS_SYSTEMMEMORY:
- sprintf(buffer, "Direct3D Error: D3DERR_ZBUFF_NEEDS_SYSTEMMEMORY");
- break;
- case D3DERR_ZBUFF_NEEDS_VIDEOMEMORY:
- sprintf(buffer, "Direct3D Error: D3DERR_ZBUFF_NEEDS_VIDEOMEMORY");
- break;
- case D3DERR_SURFACENOTINVIDMEM:
- sprintf(buffer, "Direct3D Error: D3DERR_SURFACENOTINVIDMEM");
- break;
- case D3DERR_LIGHT_SET_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_LIGHT_SET_FAILED");
- break;
- case D3DERR_LIGHTHASVIEWPORT:
- sprintf(buffer, "Direct3D Error: D3DERR_LIGHTHASVIEWPORT");
- break;
- case D3DERR_LIGHTNOTINTHISVIEWPORT:
- sprintf(buffer, "Direct3D Error: D3DERR_LIGHTNOTINTHISVIEWPORT");
- break;
- case D3DERR_SCENE_IN_SCENE:
- sprintf(buffer, "Direct3D Error: D3DERR_SCENE_IN_SCENE");
- break;
- case D3DERR_SCENE_NOT_IN_SCENE:
- sprintf(buffer, "Direct3D Error: D3DERR_SCENE_NOT_IN_SCENE");
- break;
- case D3DERR_SCENE_BEGIN_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_SCENE_BEGIN_FAILED");
- break;
- case D3DERR_SCENE_END_FAILED:
- sprintf(buffer, "Direct3D Error: D3DERR_SCENE_END_FAILED");
- break;
- case D3DERR_INBEGIN:
- sprintf(buffer, "Direct3D Error: D3DERR_INBEGIN");
- break;
- case D3DERR_NOTINBEGIN:
- sprintf(buffer, "Direct3D Error: D3DERR_NOTINBEGIN");
- break;
- case D3DERR_NOVIEWPORTS:
- sprintf(buffer, "Direct3D Error: D3DERR_NOVIEWPORTS");
- break;
- case D3DERR_VIEWPORTDATANOTSET:
- sprintf(buffer, "Direct3D Error: D3DERR_VIEWPORTDATANOTSET");
- break;
- case D3DERR_VIEWPORTHASNODEVICE:
- sprintf(buffer, "Direct3D Error: D3DERR_VIEWPORTHASNODEVICE");
- break;
- case D3DERR_NOCURRENTVIEWPORT:
- sprintf(buffer, "Direct3D Error: D3DERR_NOCURRENTVIEWPORT");
- break;
- default:
- sprintf(buffer, "DirectX Error Unknown 0x%x", errNum);
- break;
- }
-
-}