v2_04_14_src

Former-commit-id: 7fc0c92fb4c1f9dc744aefc42d4acaf08de38d85

Include/dxwnd.h

@@ -275,6 +275,8 @@
 #define CLIPMENU			0x00800000 // Include window menu in mouse clipper area
 #define BACKGROUNDPRIORITY	0x01000000 // Lower process priority when in background state
 #define OFFSCREENZBUFFER	0x02000000 // Allow building plain surfaces and ZBuffer on offscreen videomemory surfaces
+#define VIRTUALHEAP			0x04000000 // Remap heap calls to C library memory allocation routines
+#define ZBUFFERHARDCLEAN	0x08000000 // Clean ZBUFFER the hard way (memset 0xFF on whole surface buffer ....)
 
 // logging Tflags DWORD:
 #define OUTTRACE			0x00000001 // enables tracing to dxwnd.log in general

build/dxwnd.dll

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7a79583def56483a293f270aec77c751598364449eb1d729d4fa4512f8c2b010
+oid sha256:73c4aac223a633aa820b3761678170f484fb15a016ecd2c41e77d5c820e3dd46
-size 787456
+size 791552

build/dxwnd.exe

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5789a039f251a7d64e49573c0f7cc63fea3369f091782fb92fe6efb7c899d94a
+oid sha256:933a86972f0a96e62d8c5f4b656315cf09d656d2a131d1685acdd231b7ac2139
-size 675840
+size 677376

build/dxwnd.ini

@@ -0,0 +1,183 @@
+[window]
+exportpath=D:\Games\Age of Empires Trial\
+exepath=D:\Games\Sid Meiers Alpha Centauri Demo\
+posx=-666
+posy=95
+sizx=320
+sizy=200
+[target]
+title0=Planet of the Apes
+path0=D:\Games\Planet of the Apes\pota.exe
+startfolder0=
+launchpath0=
+module0=
+opengllib0=
+notes0=
+registry0=
+ver0=0
+monitorid0=0
+coord0=0
+flag0=203423795
+flagg0=1207959552
+flagh0=524308
+flagi0=138412068
+flagj0=67129472
+flagk0=-1879044096
+flagl0=1048576
+flagm0=0
+tflag0=0
+dflag0=0
+posx0=-1050
+posy0=100
+sizx0=800
+sizy0=600
+maxfps0=0
+initts0=0
+winver0=0
+maxres0=-1
+swapeffect0=0
+maxddinterface0=7
+slowratio0=2
+scanline0=1
+initresw0=0
+initresh0=0
+title1=Sid Meiers Alpha Centauri Demo
+path1=D:\Games\Sid Meiers Alpha Centauri Demo\terran.exe
+startfolder1=
+launchpath1=
+module1=
+opengllib1=
+notes1=
+registry1=
+ver1=0
+monitorid1=-1
+coord1=0
+flag1=673185826
+flagg1=1207959616
+flagh1=32788
+flagi1=138420228
+flagj1=4224
+flagk1=65536
+flagl1=0
+flagm1=0
+tflag1=-2147477245
+dflag1=0
+posx1=50
+posy1=50
+sizx1=800
+sizy1=600
+maxfps1=0
+initts1=0
+winver1=0
+maxres1=0
+swapeffect1=0
+maxddinterface1=7
+slowratio1=2
+scanline1=0
+initresw1=800
+initresh1=600
+title2=Diablo
+path2=D:\Games\Diablo\Diablo.exe
+startfolder2=
+launchpath2=
+module2=
+opengllib2=
+notes2=
+registry2=
+ver2=1
+monitorid2=0
+coord2=0
+flag2=138428450
+flagg2=1241514000
+flagh2=8212
+flagi2=4194304
+flagj2=128
+flagk2=262144
+flagl2=0
+flagm2=1024
+tflag2=0
+dflag2=0
+posx2=50
+posy2=50
+sizx2=800
+sizy2=600
+maxfps2=0
+initts2=0
+winver2=0
+maxres2=0
+swapeffect2=0
+maxddinterface2=7
+slowratio2=1
+scanline2=1
+initresw2=0
+initresh2=0
+title3=TOCA Touring Car Championship demo
+path3=D:\Games\tocademo\tourcars.exe
+startfolder3=
+launchpath3=D:\Games\tocademo\setup.exe
+module3=
+opengllib3=
+notes3=
+registry3=\n[HKEY_LOCAL_MACHINE\SOFTWARE\Codemasters]\n\n[HKEY_LOCAL_MACHINE\SOFTWARE\Codemasters\Touring Car]\n"GameDirectory"="F:\\Games\\tourcar\\"\n"CD_Drive"="."\n"Install_Drive"="F:"\n"CardHintIndex"=dword:00000000\n"ShowRunInfo"=dword:00000000\n"S3RunInfo"=dword:00000000\n\n
+ver3=0
+monitorid3=-1
+coord3=0
+flag3=673185834
+flagg3=1073741824
+flagh3=528
+flagi3=136314880
+flagj3=4224
+flagk3=65536
+flagl3=0
+flagm3=33554432
+tflag3=-2147477245
+dflag3=0
+posx3=50
+posy3=50
+sizx3=800
+sizy3=600
+maxfps3=0
+initts3=0
+winver3=0
+maxres3=0
+swapeffect3=0
+maxddinterface3=7
+slowratio3=2
+scanline3=0
+initresw3=800
+initresh3=600
+title4=empires.exe
+path4=D:\Games\Age of Empires Trial\empires.exe
+startfolder4=
+launchpath4=
+module4=
+opengllib4=
+notes4=
+registry4=
+ver4=0
+monitorid4=-1
+coord4=0
+flag4=673710114
+flagg4=1207959552
+flagh4=8212
+flagi4=138412036
+flagj4=4224
+flagk4=65536
+flagl4=0
+flagm4=2097152
+tflag4=0
+dflag4=0
+posx4=50
+posy4=50
+sizx4=800
+sizy4=600
+maxfps4=0
+initts4=0
+winver4=0
+maxres4=0
+swapeffect4=0
+maxddinterface4=7
+slowratio4=2
+scanline4=0
+initresw4=800
+initresh4=600

build/readme-relnotes.txt

@@ -1533,4 +1533,17 @@ fix: moved USER32/InvalidateRect hooker to always activate it and further reduce
 fix: fixed virtual registry tags that introduced extra characters in key string expansion
 add: hooked SelectClipRgn - preliminary to attempt fixing "Sid Meier's Alpha Centauri"
 fix: fixed unsupported call to SetWindowsHook(WH_CBT, NULL). Fixes "Starsiege" deaf mouse control.
-fix: completed and rebuilt proxy dlls to be aligned with current DxWnd structure
+fix: completed and rebuilt proxy dlls to be aligned with current DxWnd structure
+
+v2.04.14
+fix: virtual registry parser, token names now case insensitive (es. "path" = "Path")
+fix: virtual registry crash when replacing tokens and lplpData is NULL
+fix: virtual registry return code, must not return ERROR_MORE_DATA when lpData is NULL (fixes "Rollcage II")
+fix: eliminated error message in virtual palette processing when color depth is 8 bits
+fix: improved logging in EnumDisplayModes wrapper
+fix: EnumDisplayModes wrapper for nonemulated nonwindowed mode
+fix: deleted improper input clipper destruction after primary surface destruction. Fixes "Settlers III" clipper problems
+add: virtual heap (makes some "Wing Commander" games work)
+fix: freak help->about...
+add: GUI "Tools->Recover system colors" utility
+

dll/advapi.cpp

@@ -84,7 +84,7 @@ static int ReplaceVar(char *pData, LPBYTE *lplpData, LPDWORD lpcbData)
 	char sTokenValue[MAX_PATH];
 	// search for a matching token
 	for(iTokenIndex=0; sTokenLabels[iTokenIndex]; iTokenIndex++){
-		if(!strncmp(pData, sTokenLabels[iTokenIndex], strlen(sTokenLabels[iTokenIndex]))) break;
+		if(!_strnicmp(pData, sTokenLabels[iTokenIndex], strlen(sTokenLabels[iTokenIndex]))) break;
 	}
 	// set token label length
 	iLabelLength = strlen(sTokenLabels[iTokenIndex]);
@@ -102,7 +102,7 @@ static int ReplaceVar(char *pData, LPBYTE *lplpData, LPDWORD lpcbData)
 	// set output vars if not NULL
 	iTokenLength = strlen(sTokenValue);
 	OutTraceR("REPLACED token=%d val=\"%s\" len=%d\n", iTokenIndex, sTokenValue, iTokenLength);
-	if(lplpData) {
+	if(*lplpData) {
 		strcpy((char *)*lplpData, sTokenValue);
 		*lplpData += iTokenLength;
 	}
@@ -316,9 +316,12 @@ static DWORD GetKeyValue(
 			}
 			if(lpcbData) (*lpcbData)++; // extra space for string terminator ?
 			if(lpData && lpcbData) if(*lpcbData < cbData) *lpb = 0; // string terminator
-			OutTraceR("%s: type=REG_SZ cbData=%x Data=\"%s\"\n", 
+			OutTraceR("%s: type=REG_SZ cbData=%d Data=\"%s\"\n", 
 				ApiName, lpcbData ? *lpcbData : 0, lpData ? (char *)lpData : "(NULL)");
-			res=(*lpcbData > cbData) ? ERROR_MORE_DATA : ERROR_SUCCESS;
+			// v2.04.14 fix: ERROR_MORE_DATA should be returned only in case lpData is not NULL
+			res=ERROR_SUCCESS;
+			if(lpData && lpcbData)
+				if (*lpcbData > cbData) res = ERROR_MORE_DATA;
 			break;
 		}
 		if(!strncmp(pData,"dword:",strlen("dword:"))){ //dword value
@@ -378,10 +381,10 @@ static void LogKeyValue(char *ApiName, LONG res, LPDWORD lpType, LPBYTE lpData,
 {
 	char sInfo[1024];
 	if(res) {
-		OutTrace("%s: ERROR res=%x\n", ApiName, res);
+		OutTrace("%s: ERROR res=%d\n", ApiName, res);
 		return;
 	}
-	sprintf(sInfo, "%s: res=0 size=%d type=%x(%s)", 
+	sprintf(sInfo, "%s: res=ERROR_SUCCESS size=%d type=%x(%s)", 
 		ApiName, lpcbData?*lpcbData:0, lpType?*lpType:0, lpType?ExplainRegType(*lpType):"none");
 	if(lpType && lpData && lpcbData) {
 		DWORD cbData = *lpcbData;

dll/ddblit.cpp

@@ -112,6 +112,11 @@ static HRESULT sBltNoPrimary(int dxversion, Blt_Type pBlt, char *api, LPDIRECTDR
 #endif
 		}
 		break;
+	case DDERR_SURFACELOST:
+		lpdds->Restore();
+		res= (*pBlt)(lpdds, lpdestrect, lpddssrc, lpsrcrect ? &srcrect : NULL, dwflags, lpddbltfx);
+		OutTraceDW("Blt SURFACELOST RETRY: ret=%x(%s)\n", res, ExplainDDError(res)); 
+		break;
 	default:
 		break;
 	}
@@ -267,6 +272,11 @@ static HRESULT sBltToPrimary(int dxversion, Blt_Type pBlt, char *api, LPDIRECTDR
 				if (res) BlitError(res, lpsrcrect, lpdestrect, __LINE__);
 				(*pReleaseSMethod(dxversion))((LPDIRECTDRAWSURFACE)lpddsTmp);
 			}
+			if(res==DDERR_SURFACELOST){
+				lpdds->Restore();
+				res=(*pPrimaryBlt)(dxversion, pBlt, lpdds, lpdestrect, lpddssrc, lpsrcrect, lpddbltfx);
+				OutTraceDW("Blt SURFACELOST RETRY: ret=%x(%s) at %d\n", res, ExplainDDError(res), __LINE__); 
+			}
 			if(dxw.dwFlags1 & SUPPRESSDXERRORS) res=DD_OK;
 		}
 

dll/ddcreates.cpp

@@ -1052,7 +1052,11 @@ HRESULT WINAPI extCreateSurface(int dxversion, CreateSurface_Type pCreateSurface
 			// v2.03.82: save ZBUFFER capabilities for later fix in D3D CreateDevice
 			OutTraceDW("CreateSurface: lpDDZBuffer=%x save ZBUFFER caps=%x(%s)\n", *lplpdds, lpddsd->ddsCaps.dwCaps, ExplainDDSCaps(lpddsd->ddsCaps.dwCaps));
 			lpDDZBuffer = *lplpdds;
+			// save surface size expressed in bytes
+			extern int ZBufferSize;
+			ZBufferSize = lpddsd->dwWidth * lpddsd->dwHeight * (lpddsd->ddpfPixelFormat.dwZBufferBitDepth >> 3); 
 			dxwcdb.PushCaps(*lplpdds, lpddsd->ddsCaps.dwCaps);
+			OutTraceDW("CreateSurface: ZBufferSize=%d\n", ZBufferSize);
 		}
 	}
 

dll/ddraw.cpp

@@ -425,6 +425,7 @@ extern PALETTEENTRY DefaultSystemPalette[256];
 LPDIRECTDRAWSURFACE lpDDSEmu_Prim=NULL;
 LPDIRECTDRAWSURFACE lpDDSEmu_Back=NULL;
 LPDIRECTDRAWSURFACE lpDDZBuffer=NULL; // BEWARE! Likely, this global is useless ....
+int ZBufferSize; 
 // v2.1.87: lpPrimaryDD is the DIRECTDRAW object to which the primary surface and all 
 // the service objects (emulated backbuffer, emulater primary, ....) are attached.
 LPDIRECTDRAW lpPrimaryDD=NULL;
@@ -686,6 +687,10 @@ void mySetPalette(int dwstart, int dwcount, LPPALETTEENTRY lpentries)
 				:
 				(((DWORD)PalColor.peRed & 0xF8) << 8) + (((DWORD)PalColor.peGreen & 0xF8) << 3) + (((DWORD)PalColor.peBlue &0xF8) >> 3);
 			break;
+		case 8: // it may happen in unemulated modes
+			PaletteEntries[i + dwstart] =
+				(((DWORD)PalColor.peRed) << 16) + (((DWORD)PalColor.peGreen) << 8) + ((DWORD)PalColor.peBlue);
+			break;
 		default:
 			OutTraceDW("ASSERT: unsupported Color BPP=%d\n", dxw.ActualPixelFormat.dwRGBBitCount);
 			break;
@@ -3402,8 +3407,12 @@ HRESULT WINAPI extGetPalette(int dxversion, GetPalette_Type pGetPalette, LPDIREC
 		res=DD_OK;
 	}
 
-	if (res) OutTraceE("GetPalette: ERROR res=%x(%s)\n", res, ExplainDDError(res));
+	if (res) {
-	else OutTraceDDRAW("GetPalette: OK\n");
+		OutTraceE("GetPalette: ERROR res=%x(%s)\n", res, ExplainDDError(res));
+	}
+	else {
+		OutTraceDDRAW("GetPalette: OK lplpddp=%x\n", *lplpddp);
+	}
 	return res;
 }
 
@@ -3650,7 +3659,6 @@ static HRESULT WINAPI extLockDir(int dxversion, Lock_Type pLock, LPDIRECTDRAWSUR
 	HRESULT res, res2;
 	static RECT client;
 	POINT upleft={0,0};
-	LPDIRECTDRAWSURFACE lpDDSPrim;
 	Blt_Type pBlt;
 	GetGDISurface_Type pGetGDISurface;
 
@@ -3675,7 +3683,7 @@ static HRESULT WINAPI extLockDir(int dxversion, Lock_Type pLock, LPDIRECTDRAWSUR
 
 	// V2.02.43: Empire Earth does some test Lock operations apparently before the primary surface is created
 	if(lpPrimaryDD){
-		lpDDSPrim=0;
+		LPDIRECTDRAWSURFACE lpDDSPrim = 0;
 		res2=(*pGetGDISurface)(lpPrimaryDD, &lpDDSPrim);
 		if(res2)
 			OutTraceE("Lock: GetGDISurface ERROR res=%x(%s) at %d\n", res2, ExplainDDError(res2), __LINE__);
@@ -3794,7 +3802,20 @@ static HRESULT WINAPI extUnlock(int dxversion, Unlock4_Type pUnlock, LPDIRECTDRA
 		OutTrace("Unlock(%d): lpdds=%x%s %s\n", dxversion, lpdds, (IsPrim ? "(PRIM)": (IsBack ? "(BACK)" : "")), sRect);
 	}
 
-	pBlt = pGetBltMethod(dxversion);
+	if ((dxw.dwFlags8 & ZBUFFERHARDCLEAN) && (dxwcdb.GetCaps(lpdds) & DDSCAPS_ZBUFFER)){
+		DWORD dwSize = (dxversion<4)?sizeof(DDSURFACEDESC):sizeof(DDSURFACEDESC2);
+		DDSURFACEDESC2 ddsd;
+		memset(&ddsd, 0, dwSize);
+		ddsd.dwSize = dwSize;
+		res=(*pUnlock)(lpdds, NULL); 
+		if(res) OutTraceDW("Unlock ZBUFFER: Unlock err=%x at %d\n", res, __LINE__);
+		res=(*pLockMethod(dxversion))(lpdds, NULL, (LPDDSURFACEDESC)&ddsd, DDLOCK_SURFACEMEMORYPTR|DDLOCK_WRITEONLY, 0);
+		if(res) OutTraceDW("Unlock ZBUFFER: Lock err=%x at %d\n", res, __LINE__);
+		memset(ddsd.lpSurface, 0xFF, ZBufferSize);
+		res=(*pUnlock)(lpdds, lprect); 
+		if(res) OutTraceDW("Unlock ZBUFFER: Unlock err=%x at %d\n", res, __LINE__);
+		return res;
+	}
 
 	switch(dxversion){
 		case 4:
@@ -3858,6 +3879,7 @@ static HRESULT WINAPI extUnlock(int dxversion, Unlock4_Type pUnlock, LPDIRECTDRA
 	res=(*pUnlock)(lpdds, lprect); 
 	if(res==DDERR_NOTLOCKED) res=DD_OK; // ignore not locked error
 	if (IsPrim && res==DD_OK) {
+		pBlt = pGetBltMethod(dxversion);
 		if(dxversion < 4) lprect=NULL; // v2.03.60
 		res=sBlt(dxversion, pBlt, "Unlock", lpdds, lprect, lpdds, lprect, NULL, 0, FALSE);
 	}
@@ -3885,17 +3907,46 @@ HRESULT WINAPI extUnlock7(LPDIRECTDRAWSURFACE lpdds, LPRECT lprect)
 static HRESULT WINAPI extUnlockDir(int dxversion, Unlock4_Type pUnlock, LPDIRECTDRAWSURFACE lpdds, LPRECT lprect)
 {
 	HRESULT res;
-	//RECT screen, rect;
 	BOOL IsPrim;
 	BOOL IsBack;
-	LPDIRECTDRAWSURFACE lpDDSPrim;
-	GetGDISurface_Type pGetGDISurface;
 	Blt_Type pBlt;
 	RECT rect;
 
 	IsPrim=dxwss.IsAPrimarySurface(lpdds);
 	IsBack=dxwss.IsABackBufferSurface(lpdds);
 
+	if(IsTraceDDRAW){
+		char sRect[81];
+		switch(dxversion){
+			case 1:
+			case 2:
+			case 3:
+				sprintf_s(sRect, 80, "lpvoid=%x", lprect);
+				break;
+			case 4:
+			case 7:
+				if (lprect) sprintf_s(sRect, 80, "rect=(%d,%d)-(%d,%d)", lprect->left, lprect->top, lprect->right, lprect->bottom);
+				else strcpy(sRect, "rect=(NULL)");
+				break;
+		}
+		OutTrace("Unlock(%d): lpdds=%x%s %s\n", dxversion, lpdds, (IsPrim ? "(PRIM)": (IsBack ? "(BACK)" : "")), sRect);
+	}
+
+	if ((dxw.dwFlags8 & ZBUFFERHARDCLEAN) && (dxwcdb.GetCaps(lpdds) & DDSCAPS_ZBUFFER)){
+		DWORD dwSize = (dxversion<4)?sizeof(DDSURFACEDESC):sizeof(DDSURFACEDESC2);
+		DDSURFACEDESC2 ddsd;
+		memset(&ddsd, 0, dwSize);
+		ddsd.dwSize = dwSize;
+		res=(*pUnlock)(lpdds, NULL); 
+		if(res) OutTraceDW("Unlock ZBUFFER: Unlock err=%x at %d\n", res, __LINE__);
+		res=(*pLockMethod(dxversion))(lpdds, NULL, (LPDDSURFACEDESC)&ddsd, DDLOCK_SURFACEMEMORYPTR|DDLOCK_WRITEONLY, 0);
+		if(res) OutTraceDW("Unlock ZBUFFER: Lock err=%x at %d\n", res, __LINE__);
+		memset(ddsd.lpSurface, 0xFF, ZBufferSize);
+		res=(*pUnlock)(lpdds, lprect); 
+		if(res) OutTraceDW("Unlock ZBUFFER: Unlock err=%x at %d\n", res, __LINE__);
+		return res;
+	}
+
 	switch(dxversion){
 		case 4:
 			// v2.02.92: found in Fifa 2000: lpRect is completely ignored, receiving bogus values like (-1, -1, -1, -1}
@@ -3914,28 +3965,13 @@ static HRESULT WINAPI extUnlockDir(int dxversion, Unlock4_Type pUnlock, LPDIRECT
 			break;
 	}
 
-	if(IsTraceDDRAW){
-		char sRect[81];
-		switch(dxversion){
-			case 1:
-			case 2:
-			case 3:
-				sprintf_s(sRect, 80, "lpvoid=%x", lprect);
-				break;
-			case 4:
-			case 7:
-				if (lprect) sprintf_s(sRect, 80, "rect=(%d,%d)-(%d,%d)", lprect->left, lprect->top, lprect->right, lprect->bottom);
-				else strcpy(sRect, "rect=(NULL)");
-				break;
-		}
-		OutTrace("Unlock(%d): lpdds=%x%s %s\n", dxversion, lpdds, (IsPrim ? "(PRIM)": (IsBack ? "(BACK)" : "")), sRect);
-	}
-
 	// v2.04.09: for IDirectDraw methods use iBakBufferVersion instead of dxversion ...
 	pBlt = pGetBltMethod(dxversion);
-	pGetGDISurface = pGetGDISurfaceMethod(iBakBufferVersion);
 
 	if(dxw.dwFlags1 & LOCKEDSURFACE){
+		LPDIRECTDRAWSURFACE lpDDSPrim = 0;
+		GetGDISurface_Type pGetGDISurface = pGetGDISurfaceMethod(iBakBufferVersion);
+
 		(*pGetGDISurface)(lpPrimaryDD, &lpDDSPrim);
 		if(lpdds==lpDDSPrim && lpDDSBuffer){
 			RECT client;
@@ -3954,11 +3990,11 @@ static HRESULT WINAPI extUnlockDir(int dxversion, Unlock4_Type pUnlock, LPDIRECT
 
 	res=(*pUnlock)(lpdds, lprect);
 	if(res==DDERR_NOTLOCKED) res=DD_OK; // ignore not locked error
-	if (res) OutTraceE("Unlock ERROR res=%x(%s) at %d\n",res, ExplainDDError(res), __LINE__);
 	if (IsPrim && res==DD_OK) {
 		if(dxversion < 4) lprect=NULL; // v2.03.60
 		res=sBlt(dxversion, pBlt, "Unlock", lpdds, lprect, lpdds, lprect, NULL, 0, FALSE);
 	}
+	if (res) OutTraceE("Unlock ERROR res=%x(%s) at %d\n",res, ExplainDDError(res), __LINE__);
 	if(dxw.dwFlags1 & SUPPRESSDXERRORS) res=DD_OK;
 	if((dxw.dwFlags5 & TEXTUREMASK) && (!IsPrim)) {
 		// Texture Handling on Unlock
@@ -4141,13 +4177,19 @@ HRESULT WINAPI EnumModesCallbackDumper(LPDDSURFACEDESC lpDDSurfaceDesc, LPVOID l
 {
 	OutTrace("EnumModesCallback:\n");
 	OutTrace("\tdwSize=%d\n", lpDDSurfaceDesc->dwSize);
+	OutTrace("\tddpfPixelFormat depth=%d rgba=(%X-%X-%X-%X)\n", 
+		lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount,
+		lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask,
+		lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask,
+		lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask,
+		lpDDSurfaceDesc->ddpfPixelFormat.dwRGBAlphaBitMask);
 	OutTrace("\tdwFlags=%x(%s)\n", lpDDSurfaceDesc->dwFlags, ExplainFlags(lpDDSurfaceDesc->dwFlags));
  	OutTrace("\tdwWidth x dwHeight=(%d,%d)\n", lpDDSurfaceDesc->dwWidth, lpDDSurfaceDesc->dwHeight);
 	OutTrace("\tlPitch=%d\n", lpDDSurfaceDesc->lPitch);
-	OutTrace("\tdwBackBufferCount=%d\n", lpDDSurfaceDesc->dwBackBufferCount);
+	//OutTrace("\tdwBackBufferCount=%d\n", lpDDSurfaceDesc->dwBackBufferCount);
 	OutTrace("\tdwRefreshRate=%d\n", lpDDSurfaceDesc->dwRefreshRate);
-	OutTrace("\tlpSurface=%x\n", lpDDSurfaceDesc->lpSurface);
+	//OutTrace("\tlpSurface=%x\n", lpDDSurfaceDesc->lpSurface);
-	OutTrace("\tCaps=%x(%s)\n", lpDDSurfaceDesc->ddsCaps.dwCaps, ExplainDDSCaps(lpDDSurfaceDesc->ddsCaps.dwCaps));
+	//OutTrace("\tCaps=%x(%s)\n", lpDDSurfaceDesc->ddsCaps.dwCaps, ExplainDDSCaps(lpDDSurfaceDesc->ddsCaps.dwCaps));
 	//if ((NewContext_Type *)lpContext->dxversion >= 4) {
 	//	OutTrace("\tddpfPixelFormat %s\n", DumpPixelFormat((LPDDSURFACEDESC2)lpDDSurfaceDesc));
 	//}
@@ -4241,10 +4283,23 @@ HRESULT WINAPI myEnumModesFilterNative(LPDDSURFACEDESC lpDDSurfaceDesc, LPVOID l
 
 	if(CheckResolutionLimit(lpDDSurfaceDesc)) return DDENUMRET_OK;
 	res=(*((NewContext_Type *)lpContext)->lpCallback)(lpDDSurfaceDesc, ((NewContext_Type *)lpContext)->lpContext);
-	OutTraceDW("EnumDisplayModes(D): native size=(%d,%d) res=%x\n", lpDDSurfaceDesc->dwWidth, lpDDSurfaceDesc->dwHeight, res);
+	OutTraceDW("EnumDisplayModes(D): native size=(%d,%d) bpp=%d res=%x\n", lpDDSurfaceDesc->dwWidth, lpDDSurfaceDesc->dwHeight, lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount, res);
 	return res;
 }
 
+static char *sDisplayModesFlags(DWORD dwFlags)
+{
+	static char sBuf[81];
+	size_t l;
+	strcpy(sBuf, "DDEDM_");
+	if(dwFlags & DDEDM_REFRESHRATES) strcat(sBuf, "REFRESHRATES+");  
+	if(dwFlags & DDEDM_STANDARDVGAMODES) strcat(sBuf, "STANDARDVGAMODES+");  
+	l=strlen(sBuf);
+	if (l>strlen("DDEDM_")) sBuf[l-1]=0; // delete last '+' if any
+	else sBuf[0]=0;
+	return(sBuf);
+}
+
 HRESULT WINAPI extEnumDisplayModes(int dxversion, EnumDisplayModes1_Type pEnumDisplayModes, LPDIRECTDRAW lpdd, DWORD dwflags, LPDDSURFACEDESC lpddsd, LPVOID lpContext, LPDDENUMMODESCALLBACK cb)
 {
 	HRESULT res;
@@ -4254,7 +4309,8 @@ HRESULT WINAPI extEnumDisplayModes(int dxversion, EnumDisplayModes1_Type pEnumDi
 	OutTraceDDRAW("EnumDisplayModes(D%d): lpdd=%x flags=%x lpddsd=%x callback=%x\n", dxversion, lpdd, dwflags, lpddsd, cb);
 	if(lpddsd) OutTraceDDRAW("EnumDisplayModes(D): %s\n", LogSurfaceAttributes(lpddsd, "EnumDisplayModes", __LINE__));
 
-	if(dxw.dwFlags4 & NATIVERES){
+	if ((dxw.dwFlags4 & NATIVERES) ||
+		(!(dxw.dwFlags1 & EMULATESURFACE) && !dxw.Windowize)){ // v2.04.14 - make nonemulated nonwindowed mode work ...
 		NewContext.dwWidth = 0;
 		NewContext.dwHeight = 0;
 		NewContext.lpContext = lpContext;
@@ -4424,7 +4480,9 @@ HRESULT WINAPI extReleaseS(ReleaseS_Type pReleaseS, LPDIRECTDRAWSURFACE lpdds)
 		if(IsPrim || IsBack) dxwss.UnrefSurface(lpdds);
 
 		// when releasing primary surface, erase clipping region
-		if(IsPrim && (dxw.dwFlags1 & CLIPCURSOR)) dxw.EraseClipCursor();
+		// v2.04.14: commented out, better not to! The game could close and reopen a new primary surface.
+		// fixes "Settlers III" clipping problems
+		// if(IsPrim && (dxw.dwFlags1 & CLIPCURSOR)) dxw.EraseClipCursor();
 		
 		// clear service surface pointers
 		if (dxw.dwFlags1 & EMULATESURFACE) {

dll/dxhelper.cpp

@@ -1825,6 +1825,7 @@ char *ExplainDDError(DWORD c)
 		case DDERR_WASSTILLDRAWING: 		 	eb="DDERR_WASSTILLDRAWING"; break;
 		case DDERR_WRONGMODE: 		 			eb="DDERR_WRONGMODE"; break;
 		case DDERR_XALIGN: 		 				eb="DDERR_XALIGN"; break;
+		case DDERR_NOTONMIPMAPSUBLEVEL:			eb="DDERR_NOTONMIPMAPSUBLEVEL"; break;
 		// D3D errors
 		case D3DERR_WRONGTEXTUREFORMAT: 		eb="D3DERR_WRONGTEXTUREFORMAT"; break;
 		case D3DERR_UNSUPPORTEDCOLOROPERATION: 	eb="D3DERR_UNSUPPORTEDCOLOROPERATION"; break;

dll/dxwcore.cpp

@@ -468,6 +468,10 @@ void dxwCore::SetClipCursor()
 	}
 
 	// check for errors to avoid setting random clip regions
+	//if((*pIsWindowVisible)(hWnd)){
+	//	OutTraceE("SetClipCursor: not visible\n");
+	//	return;
+	//}
 	if(!(*pGetClientRect)(hWnd, &Rect)){
 		OutTraceE("SetClipCursor: GetClientRect ERROR err=%d at %d\n", GetLastError(), __LINE__);
 		return;

dll/dxwnd.cpp

@@ -27,7 +27,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "TlHelp32.h"
 
-#define VERSION "2.04.13"
+#define VERSION "2.04.14"
 
 #define DDTHREADLOCK 1
 
@@ -358,8 +358,8 @@ static char *FlagNames[9][32] ={{
 	"PRETENDVISIBLE", "RAWFORMAT", "WININSULATION", "FIXMOUSEHOOK",
 	"DDSFORMAT", "HOOKWING32", "SEQUENCEDIAT", "D3D8BACK16",
 	"MARKWING32", "DYNAMICZCLEAN", "MARKGDI32", "DUMPDIBSECTION",
-	"DUMPDEVCONTEXT", "QUALITYFONTS", "ALLOWSYSMEMON3DDEV", "",
+	"DUMPDEVCONTEXT", "QUALITYFONTS", "ALLOWSYSMEMON3DDEV", "CLIPMENU",
-	"", "", "", "",
+	"BACKGROUNDPRIORITY", "OFFSCREENZBUFFER", "VIRTUALHEAP", "ZBUFFERHARDCLEAN",
 	"", "", "", "",
 	},{
 	// TFlags

dll/kernel32.cpp

@@ -20,6 +20,14 @@ LPVOID WINAPI extVirtualAlloc(LPVOID, SIZE_T, DWORD, DWORD);
 UINT WINAPI extWinExec(LPCSTR, UINT);
 BOOL WINAPI extSetPriorityClass(HANDLE, DWORD);
 BOOL WINAPI extGlobalUnlock(HGLOBAL);
+LPVOID WINAPI extHeapAlloc(HANDLE, DWORD, SIZE_T);
+LPVOID WINAPI extHeapReAlloc(HANDLE, DWORD, LPVOID, SIZE_T);
+HANDLE WINAPI extHeapCreate(DWORD, SIZE_T, SIZE_T);
+BOOL WINAPI extHeapFree(HANDLE, DWORD, LPVOID);
+BOOL WINAPI extHeapValidate(HANDLE, DWORD, LPVOID);
+SIZE_T WINAPI extHeapCompact(HANDLE, DWORD);
+HANDLE WINAPI extGetProcessHeap(void);
+BOOL WINAPI extHeapDestroy(HANDLE);
 
 typedef LPVOID (WINAPI *VirtualAlloc_Type)(LPVOID, SIZE_T, DWORD, DWORD);
 typedef BOOL (WINAPI *CreateProcessA_Type)(LPCTSTR, LPTSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, 
@@ -27,12 +35,26 @@ typedef BOOL (WINAPI *CreateProcessA_Type)(LPCTSTR, LPTSTR, LPSECURITY_ATTRIBUTE
 typedef BOOL (WINAPI *SetPriorityClass_Type)(HANDLE, DWORD);
 typedef UINT (WINAPI *WinExec_Type)(LPCSTR, UINT);
 typedef BOOL (WINAPI *GlobalUnlock_Type)(HGLOBAL);
+typedef LPVOID (WINAPI *HeapAlloc_Type)(HANDLE, DWORD, SIZE_T);
+typedef LPVOID (WINAPI *HeapReAlloc_Type)(HANDLE, DWORD, LPVOID, SIZE_T);
+typedef HANDLE (WINAPI *HeapCreate_Type)(DWORD, SIZE_T, SIZE_T);
+typedef BOOL (WINAPI *HeapFree_Type)(HANDLE, DWORD, LPVOID);
+typedef SIZE_T (WINAPI *HeapCompact_Type)(HANDLE, DWORD);
+typedef HANDLE (WINAPI *GetProcessHeap_Type)(void);
+typedef BOOL (WINAPI *HeapDestroy_Type)(HANDLE);
 
 CreateProcessA_Type pCreateProcessA = NULL;
 VirtualAlloc_Type pVirtualAlloc = NULL;
 WinExec_Type pWinExec = NULL;
 SetPriorityClass_Type pSetPriorityClass = NULL;
 GlobalUnlock_Type pGlobalUnlock = NULL;
+HeapAlloc_Type pHeapAlloc;
+HeapReAlloc_Type pHeapReAlloc;
+HeapCreate_Type pHeapCreate;
+HeapFree_Type pHeapFree, pHeapValidate;
+HeapCompact_Type pHeapCompact;
+GetProcessHeap_Type pGetProcessHeap;
+HeapDestroy_Type pHeapDestroy;
 
 typedef BOOL (WINAPI *FreeLibrary_Type)(HMODULE);
 FreeLibrary_Type pFreeLibrary = NULL;
@@ -79,6 +101,18 @@ static HookEntryEx_Type Hooks[]={
 	{HOOK_IAT_CANDIDATE, 0, 0, NULL, 0, 0} // terminator
 };
 
+static HookEntryEx_Type HeapHooks[]={
+	{HOOK_IAT_CANDIDATE, 0, "HeapCreate", (FARPROC)HeapCreate, (FARPROC *)&pHeapCreate, (FARPROC)extHeapCreate},
+	{HOOK_IAT_CANDIDATE, 0, "HeapAlloc", (FARPROC)HeapAlloc, (FARPROC *)&pHeapAlloc, (FARPROC)extHeapAlloc},
+	{HOOK_IAT_CANDIDATE, 0, "HeapReAlloc", (FARPROC)HeapReAlloc, (FARPROC *)&pHeapReAlloc, (FARPROC)extHeapReAlloc},
+	{HOOK_IAT_CANDIDATE, 0, "HeapFree", (FARPROC)HeapFree, (FARPROC *)&pHeapFree, (FARPROC)extHeapFree},
+	{HOOK_IAT_CANDIDATE, 0, "HeapValidate", (FARPROC)HeapFree, (FARPROC *)&pHeapFree, (FARPROC)extHeapFree},
+	{HOOK_IAT_CANDIDATE, 0, "HeapCompact", (FARPROC)HeapCompact, (FARPROC *)&pHeapCompact, (FARPROC)extHeapCompact},
+	{HOOK_IAT_CANDIDATE, 0, "HeapDestroy", (FARPROC)HeapDestroy, (FARPROC *)&pHeapDestroy, (FARPROC)extHeapDestroy},
+	{HOOK_IAT_CANDIDATE, 0, "GetProcessHeap", (FARPROC)GetProcessHeap, (FARPROC *)&pGetProcessHeap, (FARPROC)extGetProcessHeap},
+	{HOOK_IAT_CANDIDATE, 0, 0, NULL, 0, 0} // terminator
+};
+
 static HookEntryEx_Type FixAllocHooks[]={
 	{HOOK_IAT_CANDIDATE, 0, "VirtualAlloc", (FARPROC)VirtualAlloc, (FARPROC *)&pVirtualAlloc, (FARPROC)extVirtualAlloc},
 	{HOOK_IAT_CANDIDATE, 0, 0, NULL, 0, 0} // terminator
@@ -127,6 +161,7 @@ void HookKernel32(HMODULE module)
 	if(dxw.dwFlags2 & TIMESTRETCH) HookLibraryEx(module, TimeHooks, libname);
 	if(dxw.dwFlags2 & FAKEVERSION) HookLibraryEx(module, VersionHooks, libname);
 	if(dxw.dwFlags6 & LEGACYALLOC) HookLibraryEx(module, FixAllocHooks, libname);
+	if(dxw.dwFlags8 & VIRTUALHEAP) HookLibraryEx(module, HeapHooks, libname);
 }
 
 void HookKernel32Init()
@@ -137,6 +172,7 @@ void HookKernel32Init()
 	HookLibInitEx(TimeHooks);
 	HookLibInitEx(VersionHooks);
 	HookLibInitEx(FixAllocHooks);
+	HookLibInitEx(HeapHooks);
 }
 
 FARPROC Remap_kernel32_ProcAddress(LPCSTR proc, HMODULE hModule)
@@ -167,6 +203,10 @@ FARPROC Remap_kernel32_ProcAddress(LPCSTR proc, HMODULE hModule)
 
 	if(dxw.dwFlags6 & LEGACYALLOC)
 		if (addr=RemapLibraryEx(proc, hModule, FixAllocHooks)) return addr;
+
+	if(dxw.dwFlags8 & VIRTUALHEAP)
+		if (addr=RemapLibraryEx(proc, hModule, HeapHooks)) return addr;
+
 	return NULL;
 }
 
@@ -1495,4 +1535,230 @@ BOOL WINAPI extGlobalUnlock(HGLOBAL hMem)
 		hLastMem = hMem;
 	}
 	return ret;
-}
+}
+
+// ---------------------------------------------------------------------
+// Virtual Heap
+// ---------------------------------------------------------------------
+
+static LPVOID VHeapMin = (LPVOID)0xFFFFFFFF;
+static LPVOID VHeapMax = (LPVOID)0x00000000;
+static int iProg = 1;
+
+#if 0
+
+LPVOID WINAPI extHeapAlloc(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes)
+{
+	LPVOID ret;
+	OutTraceB("HeapAlloc: heap=%x flags=%x bytes=%d\n", hHeap, dwFlags, dwBytes);
+	if(((DWORD)hHeap >= 0xDEADBEEF) && ((DWORD)hHeap < 0xDEADBEEF + iProg)){
+		ret = malloc(dwBytes);
+		if(ret){
+			if(ret > VHeapMax) VHeapMax = ret;
+			if(ret < VHeapMin) VHeapMin = ret;
+		}
+		OutTraceB("HeapAlloc: (virtual) ret=%x\n", ret);
+	}
+	else {
+		ret = (*pHeapAlloc)(hHeap, dwFlags, dwBytes);
+		OutTraceB("HeapAlloc: ret=%x\n", ret);
+	}
+	return ret;
+}
+
+LPVOID WINAPI extHeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dwBytes)
+{
+	LPVOID ret;
+	OutTraceB("HeapReAlloc: heap=%x flags=%x mem=%x bytes=%d\n", hHeap, dwFlags, lpMem, dwBytes);
+	if(((DWORD)hHeap >= 0xDEADBEEF) && ((DWORD)hHeap < 0xDEADBEEF + iProg)){
+		ret = realloc(lpMem, dwBytes);
+		if(ret){
+			if(ret > VHeapMax) VHeapMax = ret;
+			if(ret < VHeapMin) VHeapMin = ret;
+		}
+		OutTraceB("HeapReAlloc: (virtual) ret=%x\n", ret);
+	}
+	else {
+		ret = (*pHeapReAlloc)(hHeap, dwFlags, lpMem, dwBytes);
+		OutTraceB("HeapReAlloc: ret=%X\n", ret);
+	}
+	return ret;
+}
+
+BOOL WINAPI extHeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem)
+{
+	BOOL ret;
+	OutTraceB("HeapFree: heap=%x flags=%x mem=%x\n", hHeap, dwFlags, lpMem);
+	if((lpMem >= VHeapMin) && (lpMem <= VHeapMax)){
+		free(lpMem);
+		ret = TRUE;
+		OutTraceB("HeapFree: (virtual) ret=%x\n", ret);
+	}
+	else {
+		ret = (*pHeapFree)(hHeap, dwFlags, lpMem);
+		OutTraceB("HeapFree: ret=%x\n", ret);
+	}
+	return ret;
+}
+
+BOOL WINAPI extHeapValidate(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem)
+{
+	BOOL ret;
+	OutTraceB("HeapValidate: heap=%x flags=%x mem=%x\n", hHeap, dwFlags, lpMem);
+	if((lpMem >= VHeapMin) && (lpMem <= VHeapMax)){
+		ret = TRUE;
+		OutTraceB("HeapValidate: (virtual) ret=%x\n", ret);
+	}
+	else {
+		ret = (*pHeapValidate)(hHeap, dwFlags, lpMem);
+		OutTraceB("HeapValidate: ret=%x\n", ret);
+	}
+	return ret;
+}
+
+SIZE_T WINAPI extHeapCompact(HANDLE hHeap, DWORD dwFlags)
+{
+	SIZE_T ret;
+	OutTraceB("HeapCompact: heap=%x flags=%x\n", hHeap, dwFlags);
+	if(((DWORD)hHeap >= 0xDEADBEEF) && ((DWORD)hHeap < 0xDEADBEEF + iProg)){
+		ret = 100000; // just a number ....
+		OutTraceB("HeapCompact: (virtual) ret=%d\n", ret);
+	}
+	else {
+		ret = (*pHeapCompact)(hHeap, dwFlags);
+		OutTraceB("HeapCompact: ret=%d\n", ret);
+	}
+	return ret;
+}
+
+HANDLE WINAPI extHeapCreate(DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaximumSize)
+{
+	HANDLE ret;
+	OutTraceB("HeapCreate: flags=%x size(init-max)=(%d-%d)\n", flOptions, dwInitialSize, dwMaximumSize);
+	//flOptions &= ~HEAP_NO_SERIALIZE;
+	//ret = (*pHeapCreate)(flOptions, dwInitialSize, dwMaximumSize);
+	ret = (HANDLE)(0xDEADBEEF + iProg++);
+	OutTraceB("HeapCreate: (virtual) ret=%X\n", ret);
+	return ret;
+}
+
+HANDLE WINAPI extGetProcessHeap(void)
+{
+	OutTraceB("GetProcessHeap: (virtual) ret=0xDEADBEEF\n");
+	return (HANDLE)0xDEADBEEF;
+}
+
+BOOL WINAPI extHeapDestroy(HANDLE hHeap)
+{
+	BOOL ret;
+	OutTraceB("HeapDestroy: heap=%x\n", hHeap);
+	if(((DWORD)hHeap >= 0xDEADBEEF) && ((DWORD)hHeap < 0xDEADBEEF + iProg))
+		ret = TRUE;
+	else 
+		ret = (*pHeapDestroy)(hHeap);
+	OutTraceB("HeapDestroy: ret=%x\n", ret);
+	return ret;
+}
+
+#else
+
+LPVOID WINAPI extHeapAlloc(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes)
+{
+	LPVOID ret;
+	OutTraceB("HeapAlloc: heap=%x flags=%x bytes=%d\n", hHeap, dwFlags, dwBytes);
+	ret = malloc(dwBytes);
+	if(ret){
+		if(ret > VHeapMax) VHeapMax = ret;
+		if(ret < VHeapMin) VHeapMin = ret;
+	}
+	OutTraceB("HeapAlloc: (virtual) ret=%x\n", ret);
+	return ret;
+}
+
+LPVOID WINAPI extHeapReAlloc(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dwBytes)
+{
+	LPVOID ret;
+	OutTraceB("HeapReAlloc: heap=%x flags=%x mem=%x bytes=%d\n", hHeap, dwFlags, lpMem, dwBytes);
+	ret = realloc(lpMem, dwBytes);
+	if(ret){
+		if(ret > VHeapMax) VHeapMax = ret;
+		if(ret < VHeapMin) VHeapMin = ret;
+	}
+	OutTraceB("HeapReAlloc: (virtual) ret=%x\n", ret);
+	return ret;
+}
+
+BOOL WINAPI extHeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem)
+{
+	BOOL ret;
+	OutTraceB("HeapFree: heap=%x flags=%x mem=%x\n", hHeap, dwFlags, lpMem);
+	if((lpMem >= VHeapMin) && (lpMem <= VHeapMax)){
+		free(lpMem);
+		ret = TRUE;
+		OutTraceB("HeapFree: (virtual) ret=%x\n", ret);
+	}
+	else {
+		ret = (*pHeapFree)(hHeap, dwFlags, lpMem);
+		OutTraceB("HeapFree: ret=%x\n", ret);
+	}
+	return ret;
+}
+
+BOOL WINAPI extHeapValidate(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem)
+{
+	BOOL ret;
+	OutTraceB("HeapValidate: heap=%x flags=%x mem=%x\n", hHeap, dwFlags, lpMem);
+	if((lpMem >= VHeapMin) && (lpMem <= VHeapMax)){
+		ret = TRUE;
+		OutTraceB("HeapValidate: (virtual) ret=%x\n", ret);
+	}
+	else {
+		ret = (*pHeapValidate)(hHeap, dwFlags, lpMem);
+		OutTraceB("HeapValidate: ret=%x\n", ret);
+	}
+	return ret;
+}
+
+SIZE_T WINAPI extHeapCompact(HANDLE hHeap, DWORD dwFlags)
+{
+	SIZE_T ret;
+	OutTraceB("HeapCompact: heap=%x flags=%x\n", hHeap, dwFlags);
+	if(((DWORD)hHeap >= 0xDEADBEEF) && ((DWORD)hHeap < 0xDEADBEEF + iProg)){
+		ret = 100000; // just a number ....
+		OutTraceB("HeapCompact: (virtual) ret=%d\n", ret);
+	}
+	else {
+		ret = (*pHeapCompact)(hHeap, dwFlags);
+		OutTraceB("HeapCompact: ret=%d\n", ret);
+	}
+	return ret;
+}
+
+HANDLE WINAPI extHeapCreate(DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaximumSize)
+{
+	HANDLE ret;
+	OutTraceB("HeapCreate: flags=%x size(init-max)=(%d-%d)\n", flOptions, dwInitialSize, dwMaximumSize);
+	ret = (HANDLE)(0xDEADBEEF + iProg++);
+	OutTraceB("HeapCreate: (virtual) ret=%X\n", ret);
+	return ret;
+}
+
+HANDLE WINAPI extGetProcessHeap(void)
+{
+	OutTraceB("GetProcessHeap: (virtual) ret=0xDEADBEEF\n");
+	return (HANDLE)0xDEADBEEF;
+}
+
+BOOL WINAPI extHeapDestroy(HANDLE hHeap)
+{
+	BOOL ret;
+	OutTraceB("HeapDestroy: heap=%x\n", hHeap);
+	if(((DWORD)hHeap >= 0xDEADBEEF) && ((DWORD)hHeap < 0xDEADBEEF + iProg))
+		ret = TRUE;
+	else 
+		ret = (*pHeapDestroy)(hHeap);
+	OutTraceB("HeapDestroy: ret=%x\n", ret);
+	return ret;
+}
+
+#endif

dll/queryint.cpp

@@ -227,4 +227,3 @@ HRESULT WINAPI extQueryInterfaceDX(int dxversion, QueryInterface_Type pQueryInte
 
 	return res;
 }
-

dll/user32.cpp

@@ -77,7 +77,7 @@ static HookEntryEx_Type Hooks[]={
 	{HOOK_HOT_CANDIDATE, 0, "GetWindowLongA", (FARPROC)GetWindowLongA, (FARPROC *)&pGetWindowLongA, (FARPROC)extGetWindowLongA}, 
 	{HOOK_HOT_CANDIDATE, 0, "SetWindowLongW", (FARPROC)SetWindowLongW, (FARPROC *)&pSetWindowLongW, (FARPROC)extSetWindowLongW},
 	{HOOK_HOT_CANDIDATE, 0, "GetWindowLongW", (FARPROC)GetWindowLongW, (FARPROC *)&pGetWindowLongW, (FARPROC)extGetWindowLongW}, 
-	{HOOK_IAT_CANDIDATE, 0, "IsWindowVisible", (FARPROC)NULL, (FARPROC *)&pIsWindowVisible, (FARPROC)extIsWindowVisible},
+	{HOOK_IAT_CANDIDATE, 0, "IsWindowVisible", (FARPROC)IsWindowVisible, (FARPROC *)&pIsWindowVisible, (FARPROC)extIsWindowVisible}, // ref. in dxw.SetClipper, CreateWindowCommon
 	{HOOK_IAT_CANDIDATE, 0, "GetTopWindow", (FARPROC)GetTopWindow, (FARPROC *)&pGetTopWindow, (FARPROC)extGetTopWindow},
 	// hot by MinHook since v2.03.07
 	{HOOK_HOT_CANDIDATE, 0, "SystemParametersInfoA", (FARPROC)SystemParametersInfoA, (FARPROC *)&pSystemParametersInfoA, (FARPROC)extSystemParametersInfoA},
@@ -676,6 +676,13 @@ BOOL WINAPI extShowWindow(HWND hwnd, int nCmdShow)
 		return TRUE;
 	}
 
+	if(dxw.Windowize && dxw.IsFullScreen() && dxw.IsDesktop(hwnd)){
+		if(dxw.dwFlags1 & CLIPCURSOR){
+			OutTraceDW("ShowWindow: clipper on main win %s\n", (nCmdShow==SW_HIDE)?"OFF":"ON");
+			(nCmdShow==SW_HIDE) ? dxw.EraseClipCursor() : dxw.SetClipCursor();
+		}
+	}
+
 	nOrigCmd = nCmdShow;
 	if (dxw.dwFlags1 & PREVENTMAXIMIZE){
 		if(nCmdShow==SW_MAXIMIZE){
@@ -1756,6 +1763,8 @@ static HWND WINAPI CreateWindowCommon(
 		(*pShowWindow)(hwnd, SW_SHOWNORMAL);
 	}
 
+	//if (isNewDesktop) dxw.SethWnd(hwnd);
+
 	if ((dxw.dwFlags1 & FIXWINFRAME) && !(dwStyle & WS_CHILD) && dxw.IsDesktop(hwnd))
 		dxw.FixWindowFrame(hwnd);
 
@@ -1929,31 +1938,29 @@ LRESULT WINAPI extCallWindowProcW(WNDPROC lpPrevWndFunc, HWND hwnd, UINT Msg, WP
 		return res;
 }
 
-LRESULT WINAPI extDefWindowProcA(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
+static LRESULT WINAPI DefWindowProcCommon(char *Label, DefWindowProc_Type pDefWindowProc, HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
 {
 	// v2.02.30: fix (Imperialism II): apply to main window only !!!
 	// v2.03.50: fix - do clip cursor only after the window has got focus
+	// v2.04.14: fix - erase clip cursor when window loses focus !!!
 	HRESULT res;
 	res = (HRESULT)-1;
-	if(IsTraceW) ExplainMsg("DefWindowProcA", hwnd, Msg, wParam, lParam);
+	if(IsTraceW) ExplainMsg(Label, hwnd, Msg, wParam, lParam);
-	if(hwnd == dxw.GethWnd()) res=FixWindowProc("DefWindowProcA", hwnd, Msg, wParam, &lParam);
+	if(hwnd == dxw.GethWnd()) res=FixWindowProc(Label, hwnd, Msg, wParam, &lParam);
-	if (res==(HRESULT)-1) res = (*pDefWindowProcA)(hwnd, Msg, wParam, lParam);
+	if (res==(HRESULT)-1) res = (*pDefWindowProc)(hwnd, Msg, wParam, lParam);
-	if((Msg == WM_SETFOCUS) && (dxw.dwFlags1 & CLIPCURSOR)) dxw.SetClipCursor();
+	if(dxw.dwFlags1 & CLIPCURSOR){
+		switch(Msg){
+			case WM_SETFOCUS: dxw.SetClipCursor(); break;
+			case WM_KILLFOCUS: dxw.EraseClipCursor(); break; // v2.04.14: forgotten case ....
+		}
+	}
 	return res;
 }
 
 LRESULT WINAPI extDefWindowProcW(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
-{
+{ return DefWindowProcCommon("DefWindowProcW", pDefWindowProcW, hwnd, Msg, wParam, lParam); }
-	// v2.02.30: fix (Imperialism II): apply to main window only !!!
+LRESULT WINAPI extDefWindowProcA(HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam)
-	// v2.03.50: fix - do clip cursor only after the window has got focus
+{ return DefWindowProcCommon("DefWindowProcA", pDefWindowProcA, hwnd, Msg, wParam, lParam); }
-	HRESULT res;
-	res = (HRESULT)-1;
-	if(IsTraceW) ExplainMsg("DefWindowProcW", hwnd, Msg, wParam, lParam);
-	if(hwnd == dxw.GethWnd()) res=FixWindowProc("DefWindowProcW", hwnd, Msg, wParam, &lParam);
-	if (res==(HRESULT)-1) res = (*pDefWindowProcW)(hwnd, Msg, wParam, lParam);
-	if((Msg == WM_SETFOCUS) && (dxw.dwFlags1 & CLIPCURSOR)) dxw.SetClipCursor();
-	return res;
-}
 
 static int HandleRect(char *ApiName, void *pFun, HDC hdc, const RECT *lprc, HBRUSH hbr)
 {
@@ -2031,14 +2038,9 @@ static int HandleRect(char *ApiName, void *pFun, HDC hdc, const RECT *lprc, HBRU
 }
 
 int WINAPI extFillRect(HDC hdc, const RECT *lprc, HBRUSH hbr)
-{
+{ return HandleRect("FillRect", (void *)pFillRect, hdc, lprc, hbr); }
-	return HandleRect("FillRect", (void *)pFillRect, hdc, lprc, hbr);
-}
-
 int WINAPI extFrameRect(HDC hdc, const RECT *lprc, HBRUSH hbr)
-{
+{ return HandleRect("FrameRect", (void *)pFrameRect, hdc, lprc, hbr); }
-	return HandleRect("FrameRect", (void *)pFrameRect, hdc, lprc, hbr);
-}
 
 BOOL WINAPI extInvertRect(HDC hdc, const RECT *lprc)
 {

host/TabCompat.cpp

@@ -32,8 +32,8 @@ void CTabCompat::DoDataExchange(CDataExchange* pDX)
 	DDX_Check(pDX, IDC_SINGLEPROCAFFINITY, cTarget->m_SingleProcAffinity);
 	DDX_Check(pDX, IDC_USELASTCORE, cTarget->m_UseLastCore);
 	DDX_Check(pDX, IDC_HANDLEEXCEPTIONS, cTarget->m_HandleExceptions);
+	DDX_Check(pDX, IDC_VIRTUALHEAP, cTarget->m_VirtualHeap);
 	DDX_Check(pDX, IDC_LIMITRESOURCES, cTarget->m_LimitResources);
-	DDX_Check(pDX, IDC_SUPPRESSIME, cTarget->m_SuppressIME);
 	DDX_Check(pDX, IDC_CDROMDRIVETYPE, cTarget->m_CDROMDriveType);
 	DDX_Check(pDX, IDC_FONTBYPASS, cTarget->m_FontBypass);
 	DDX_Check(pDX, IDC_BUFFEREDIOFIX, cTarget->m_BufferedIOFix);

host/TabDirect3D.cpp

@@ -31,6 +31,7 @@ void CTabDirect3D::DoDataExchange(CDataExchange* pDX)
 	DDX_Check(pDX, IDC_ZBUFFERCLEAN, cTarget->m_ZBufferClean);
 	DDX_Check(pDX, IDC_ZBUFFER0CLEAN, cTarget->m_ZBuffer0Clean);
 	DDX_Check(pDX, IDC_DYNAMICZCLEAN, cTarget->m_DynamicZClean);
+	DDX_Check(pDX, IDC_ZBUFFERHARDCLEAN, cTarget->m_ZBufferHardClean);
 	DDX_Check(pDX, IDC_NOPOWER2FIX, cTarget->m_NoPower2Fix);
 	DDX_Check(pDX, IDC_NOD3DRESET, cTarget->m_NoD3DReset);
 	DDX_Check(pDX, IDC_SUPPRESSD3DEXT, cTarget->m_SuppressD3DExt);

host/TabWindow.cpp

@@ -43,6 +43,7 @@ void CTabWindow::DoDataExchange(CDataExchange* pDX)
 	DDX_Check(pDX, IDC_UNLOCKZORDER, cTarget->m_UnlockZOrder);
 	DDX_Check(pDX, IDC_NODESTROYWINDOW, cTarget->m_NoDestroyWindow);
 	DDX_Check(pDX, IDC_ACTIVATEAPP, cTarget->m_ActivateApp);
+	DDX_Check(pDX, IDC_SUPPRESSIME, cTarget->m_SuppressIME);
 
 	DDX_Radio(pDX, IDC_FREEMOVE, cTarget->m_WinMovementType);
 

host/TargetDlg.cpp

@@ -59,6 +59,7 @@ CTargetDlg::CTargetDlg(CWnd* pParent /*=NULL*/)
 	m_ImportTable = FALSE;
 	m_TraceHooks = FALSE;
 	m_HandleExceptions = FALSE;
+	m_VirtualHeap = FALSE;
 	m_SuppressIME = FALSE;
 	m_SuppressD3DExt = FALSE;
 	m_Enum16bitModes = FALSE;
@@ -113,6 +114,7 @@ CTargetDlg::CTargetDlg(CWnd* pParent /*=NULL*/)
 	m_ZBufferClean = FALSE;
 	m_ZBuffer0Clean = FALSE;
 	m_DynamicZClean = FALSE;
+	m_ZBufferHardClean = FALSE;
 	m_ZBufferAlways = FALSE;
 	m_HotPatchAlways = FALSE;
 	m_FreezeInjectedSon = FALSE;

host/TargetDlg.h

@@ -163,12 +163,9 @@ public:
 	BOOL	m_NoDDExclusiveMode;
 	BOOL	m_CreateDesktop;
 	BOOL	m_AllowSysmemOn3DDev;
-	//BOOL	m_ForceVSync;
-	//BOOL	m_ForceNoVSync;
-	//BOOL	m_ForceWait;
-	//BOOL	m_ForceNoWait;
 	BOOL	m_HandleAltF4;
 	BOOL	m_HandleExceptions;
+	BOOL	m_VirtualHeap;
 	BOOL	m_SkipFPS;
 	BOOL	m_LimitFPS;
 	BOOL	m_ShowFPS;
@@ -221,6 +218,7 @@ public:
 	BOOL	m_ZBufferClean;
 	BOOL	m_ZBuffer0Clean;
 	BOOL	m_DynamicZClean;
+	BOOL	m_ZBufferHardClean;
 	BOOL	m_ZBufferAlways;
 	BOOL	m_HotPatchAlways;
 	BOOL	m_FreezeInjectedSon;

host/dxwndhost.cpp

@@ -43,6 +43,7 @@ BOOL gAutoHideMode = FALSE;
 BOOL gQuietMode = FALSE;
 BOOL gMustDie = FALSE;
 int iProgIndex;
+DWORD SysColors[32];
 extern char m_ConfigFileName[20+1] = "dxwnd.ini";
 
 class CNewCommandLineInfo : public CCommandLineInfo
@@ -239,7 +240,11 @@ BOOL CDxwndhostApp::InitInstance()
     if (bCheckAdminRights && (GetVersionEx(&osver)) && (osver.dwMajorVersion >= 6)){
 		DxSelfElevate((CDxwndhostView *)NULL);
 	}
-	return TRUE;
+
+	// save system colors for later recovery
+	for(int index=COLOR_SCROLLBAR; index<=COLOR_MENUBAR; index++) SysColors[index]=0; // initialize
+	for(int index=COLOR_SCROLLBAR; index<=COLOR_MENUBAR; index++) SysColors[index]=::GetSysColor(index);
+	return TRUE; 
 }
 
 
@@ -250,17 +255,20 @@ class CAboutDlg : public CDialog
 {
 public:
 	CAboutDlg();
+	virtual BOOL OnInitDialog();
 
 // Data Dialog 
 	//{{AFX_DATA(CAboutDlg)
 	enum { IDD = IDD_ABOUTBOX };
 	CString	m_Version;
+	CString	m_Thanks;
 	//}}AFX_DATA
 
 	// ClassWizard generated virtual function overrides.
 	//{{AFX_VIRTUAL(CAboutDlg)
 	protected:
 	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV Support
+	virtual void OnTimer(UINT_PTR);
 	//}}AFX_VIRTUAL
 
 // Implementation
@@ -283,13 +291,52 @@ void CAboutDlg::DoDataExchange(CDataExchange* pDX)
 	CDialog::DoDataExchange(pDX);
 	//{{AFX_DATA_MAP(CAboutDlg)
 	DDX_Text(pDX, IDC_VERSION, m_Version);
+	DDX_Text(pDX, IDC_THANKS, m_Thanks);
 	//}}AFX_DATA_MAP
 }
 
+#define ID_HELP_SCROLL 999
+
+BOOL CAboutDlg::OnInitDialog()
+{
+	CDialog::OnInitDialog();
+	SetTimer(ID_HELP_SCROLL, 600, NULL);
+	return TRUE;  // return TRUE unless you set the focus to a control
+}
+
+CString Thanks[] = {
+"Aqrit for proxies, many tweaks & hot patching schema",
+"AxXxB and Old-Games.ru teammates for ZBUFFER fix",
+"Fabian \"ryg\" Giesen & others for DXT1/5 compression",
+"FunkyFr3sh for fixes in proxy dll",
+"Gsky916 for chinese translation",
+"Jari Kommpa for ddraw wrapper source and d3d hints",
+"Jiri Dvorak for his d3d8 wrapper with 16bpp emulation",
+"Luigi Auriemma for injection syncronization",
+"Michael Koch for d3d9 proxy dll",
+"Narzoul for sharing DC handling code",
+"Olly (www.ollydbg.de) for OllyDBG & disasm lib",
+"RomSteady for his kind encouragement",
+"Ryan Geiss for his bilinear filter code",
+"TigerhawkT3 for html manual pages",
+"Tsuda Kageyu for MinHook dll",
+""};
+
+#define THANKSKOUNT 15
+
+void CAboutDlg::OnTimer(UINT_PTR nIDEvent)
+{
+	static int i=0;
+	int j;
+	CString RolledThanks;
+	for(j=i; j<THANKSKOUNT; j++) RolledThanks.AppendFormat("%s\n", Thanks[j]);
+	for(j=0; j<i          ; j++) RolledThanks.AppendFormat("%s\n", Thanks[j]);
+	this->SetDlgItemTextA(IDC_THANKS, RolledThanks);
+	i=(i+1)%THANKSKOUNT;
+}
+
 BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
-	//{{AFX_MSG_MAP(CAboutDlg)
+	ON_WM_TIMER()
-		// There is no message handler.
-	//}}AFX_MSG_MAP
 END_MESSAGE_MAP()
 
 // The application command to run the dialog
@@ -300,7 +347,26 @@ void CDxwndhostApp::OnAppAbout()
 	GetDllVersion(tmp);
 	sprintf(ver, "DLL version %s", tmp);
 	aboutDlg.m_Version = ver;
+	aboutDlg.m_Thanks = "";
+//	aboutDlg.m_Thanks = "\
+//Aqrit for proxies, many tweaks & hot patching schema\n\
+//AxXxB and Old-Games.ru teammates for ZBUFFER fix\n\
+//Fabian \"ryg\" Giesen & others for DXT1/5 compression\n\
+//FunkyFr3sh for fixes in proxy dll\n\
+//Gsky916 for chinese translation\n\
+//Jari Kommpa for ddraw wrapper source and d3d hints\n\
+//Jiri Dvorak for his d3d8 wrapper with 16bpp emulation\n\
+//Luigi Auriemma for injection syncronization\n\
+//Michael Koch for d3d9 proxy dll\n\
+//Narzoul for sharing DC handling code\n\
+//Olly (www.ollydbg.de) for OllyDBG & disasm lib\n\
+//RomSteady for his kind encouragement\n\
+//Ryan Geiss for his bilinear filter code\n\
+//TigerhawkT3 for html manual pages\n\
+//Tsuda Kageyu for MinHook dll\n\
+//";
 	aboutDlg.DoModal();
+	aboutDlg.KillTimer(ID_HELP_SCROLL);
 }
 
 void CDxwndhostApp::OnViewHelp()

host/dxwndhostView.cpp

@@ -151,6 +151,7 @@ BEGIN_MESSAGE_MAP(CDxwndhostView, CListView)
 	ON_COMMAND(ID_DESKTOPCOLORDEPTH_32BPP, OnDesktopcolordepth32bpp)
 	ON_COMMAND(ID_TOOLS_RECOVERSCREENMODE, OnRecoverScreenMode)
 	ON_COMMAND(ID_TOOLS_CLEARCOMPATIBILITYFLAGS, OnClearCompatibilityFlags)
+	ON_COMMAND(ID_TOOLS_RECOVERSYSTEMCOLORS, OnRecoverSystemColors)
 	ON_COMMAND(ID_MOVE_TOP, OnMoveTop)
 	ON_COMMAND(ID_MOVE_UP, OnMoveUp)
 	ON_COMMAND(ID_MOVE_DOWN, OnMoveDown)
@@ -376,6 +377,7 @@ void SetTargetFromDlg(TARGETMAP *t, CTargetDlg *dlg)
 	if(dlg->m_RegistryOp) t->tflags |= OUTREGISTRY;
 	if(dlg->m_TraceHooks) t->tflags |= TRACEHOOKS;
 	if(dlg->m_HandleExceptions) t->flags |= HANDLEEXCEPTIONS;
+	if(dlg->m_VirtualHeap) t->flags8 |= VIRTUALHEAP;
 	if(dlg->m_LimitResources) t->flags2 |= LIMITRESOURCES;
 	if(dlg->m_CDROMDriveType) t->flags3 |= CDROMDRIVETYPE;
 	if(dlg->m_HideCDROMEmpty) t->flags4 |= HIDECDROMEMPTY;
@@ -386,6 +388,7 @@ void SetTargetFromDlg(TARGETMAP *t, CTargetDlg *dlg)
 	if(dlg->m_ZBufferClean) t->flags4 |= ZBUFFERCLEAN;
 	if(dlg->m_ZBuffer0Clean) t->flags4 |= ZBUFFER0CLEAN;
 	if(dlg->m_DynamicZClean) t->flags8 |= DYNAMICZCLEAN;
+	if(dlg->m_ZBufferHardClean) t->flags8 |= ZBUFFERHARDCLEAN;
 	if(dlg->m_ZBufferAlways) t->flags4 |= ZBUFFERALWAYS;
 	if(dlg->m_HotPatchAlways) t->flags4 |= HOTPATCHALWAYS;
 	if(dlg->m_FreezeInjectedSon) t->flags5 |= FREEZEINJECTEDSON;
@@ -705,6 +708,7 @@ static void SetDlgFromTarget(TARGETMAP *t, CTargetDlg *dlg)
 	dlg->m_RegistryOp = t->tflags & OUTREGISTRY ? 1 : 0;
 	dlg->m_TraceHooks = t->tflags & TRACEHOOKS ? 1 : 0;
 	dlg->m_HandleExceptions = t->flags & HANDLEEXCEPTIONS ? 1 : 0;
+	dlg->m_VirtualHeap = t->flags8 & VIRTUALHEAP ? 1 : 0;
 	dlg->m_SuppressIME = t->flags2 & SUPPRESSIME ? 1 : 0;
 	dlg->m_SuppressD3DExt = t->flags3 & SUPPRESSD3DEXT ? 1 : 0;
 	dlg->m_Enum16bitModes = t->flags7 & ENUM16BITMODES ? 1 : 0;
@@ -756,6 +760,7 @@ static void SetDlgFromTarget(TARGETMAP *t, CTargetDlg *dlg)
 	dlg->m_ZBufferClean = t->flags4 & ZBUFFERCLEAN ? 1 : 0;
 	dlg->m_ZBuffer0Clean = t->flags4 & ZBUFFER0CLEAN ? 1 : 0;
 	dlg->m_DynamicZClean = t->flags8 & DYNAMICZCLEAN ? 1 : 0;
+	dlg->m_ZBufferHardClean = t->flags8 & ZBUFFERHARDCLEAN ? 1 : 0;
 	dlg->m_ZBufferAlways = t->flags4 & ZBUFFERALWAYS ? 1 : 0;
 	dlg->m_HotPatchAlways = t->flags4 & HOTPATCHALWAYS ? 1 : 0;
 	dlg->m_FreezeInjectedSon = t->flags5 & FREEZEINJECTEDSON ? 1 : 0;
@@ -2714,6 +2719,9 @@ void CDxwndhostView::OnRButtonDown(UINT nFlags, CPoint point)
 	case ID_TOOLS_CLEARCOMPATIBILITYFLAGS:
 		OnClearCompatibilityFlags();
 		break;
+	case ID_TOOLS_RECOVERSYSTEMCOLORS:
+		OnRecoverSystemColors();
+		break;
 	case ID_MOVE_TOP:
 		OnMoveTop();
 		break;
@@ -3517,6 +3525,19 @@ void CDxwndhostView::OnRecoverScreenMode()
 	RevertScreenChanges(&this->InitDevMode);
 }
 
+void CDxwndhostView::OnRecoverSystemColors()
+{
+	extern DWORD SysColors[];
+	//for(int index=COLOR_SCROLLBAR; index<=COLOR_MENUBAR; index++) {
+	for(int index=COLOR_SCROLLBAR; index<=COLOR_BTNHIGHLIGHT; index++) { // don't mess with taskbar ...
+		if(SysColors[index]) {
+			INT colors[1];
+			colors[0]=index;
+			::SetSysColors(1, colors, &SysColors[index]);
+		}
+	}
+}
+
 void CDxwndhostView::OnClearCompatibilityFlags()
 {
 	int i;

host/dxwndhostView.h

@@ -113,6 +113,7 @@ protected:
 	afx_msg void OnDesktopcolordepth32bpp();
 	afx_msg void OnRecoverScreenMode();
 	afx_msg void OnClearCompatibilityFlags();
+	afx_msg void OnRecoverSystemColors();
 	afx_msg void OnMoveTop();
 	afx_msg void OnMoveUp();
 	afx_msg void OnMoveDown();