Context Navigation

source: trunk/src/ddraw/ddraw2d.cpp@ 9532

Visit:

Last change on this file since 9532 was 9532, checked in by sandervl, 23 years ago
Removed IOPL override code
File size: 77.7 KB

Line
1	/* $Id: ddraw2d.cpp,v 1.4 2002-12-20 10:38:25 sandervl Exp $ */
2
3	/*
4	* DX Draw base class implementation
5	*
6	* Copyright 1998 Sander van Leeuwen
7	* Copyright 1999 Markus Montkowski
8	* Copyright 2000 Przemyslaw Dobrowolski
9	* Copyright 2001 Michal Necasek
10	*
11	* Project Odin Software License can be found in LICENSE.TXT
12	*
13	*/
14	#define _OS2WIN_H
15	#define FAR
16
17	#include <odin.h>
18	#include <winbase.h>
19	#include <stdlib.h>
20	#include <string.h>
21	#include <memory.h>
22	#include <winuser32.h>
23
24	#define INITGUID
25	#include "ddraw2d.h"
26	#include "clipper.h"
27	#include "palette.h"
28	#include "surface.h"
29	#include <misc.h>
30	#include <string.h>
31	#include <winreg.h>
32	#include <winuser.h>
33	#include <winerror.h>
34	#include <options.h>
35	#include "os2util.h"
36	#include "os2fsdd.h"
37	// include with the videomodes we support
38	// better would be to get these modes from the card
39	// But for now we use standard VESA 2.0 modes with 70Hz
40	#include "os2ddrawmodes.h"
41	#include "os2DDWindow.h"
42	#include "os2palset.h"
43
44	#define KEY_DIRECT2 "\\Software\\Win32OS2\\Direct2"
45	#define KEY_DIRECT2DRAW "\\Software\\Win32OS2\\Direct2\\Draw"
46
47
48	BOOL bUseFSDD = FALSE;
49	BOOL fNoFSDD = FALSE;
50	BOOL fHideCursorOnLock = FALSE;
51
52	FOURCC SupportedFourCCs[] = {FOURCC_SCRN,FOURCC_LUT8,FOURCC_R565,FOURCC_RGB3,FOURCC_RGB4};
53
54	#define MAX_DIVE_FOURCC 32
55	int nrOfDiveFourCCs = 0;
56	FOURCC DiveFOURCCs[MAX_DIVE_FOURCC] = {0};
57
58	//******************************************************************************
59	//Force DirectDraw to report only one fullscreen mode (useful for custom builds)
60	//******************************************************************************
61	void WIN32API SetCustomFullScreenMode(DWORD dwWidth, DWORD dwHeight, DWORD dwBPP)
62	{
63	NUM_MODES_DIVE = 1;
64
65	dprintf(("SetCustomFullScreenMode (%d,%d) bpp %d", dwWidth, dwHeight, dwBPP));
66	ModesDive[0].iXRes = dwWidth;
67	ModesDive[0].iYRes = dwHeight;
68	ModesDive[0].iBits = dwBPP;
69	ModesDive[0].iRatio = 0;
70	fNoFSDD = TRUE;
71	}
72	//******************************************************************************
73	//Force DirectSurface Lock & Unlock methods to hide & show the mouse cursor
74	//******************************************************************************
75	BOOL WIN32API SetCustomHideCursorOnLock(BOOL state)
76	{
77	BOOL preState = fHideCursorOnLock;
78	fHideCursorOnLock = state;
79	return preState;
80	}
81	//******************************************************************************
82	//******************************************************************************
83	OS2IDirectDraw::OS2IDirectDraw(GUID *lpGUID) :
84	Referenced(0), lastError(DD_OK),
85	pFrameBuffer(NULL), hwndClient(0), screenwidth(640),
86	screenheight(480), screenbpp(8),PrimaryExists(FALSE),pPrimSurf(NULL)
87
88	{
89	HKEY hkDirectDraw2;
90	DWORD dwVSize, dwVType;
91	ULONG rc;
92
93	// Setup table for 3d devices
94	Vtbl3D.AddRef = D3DAddRef;
95	Vtbl3D.Release = D3DRelease;
96	Vtbl3D.QueryInterface = D3DQueryInterface;
97	Vtbl3D.Initialize = D3DInitialize;
98	Vtbl3D.EnumDevices = D3DEnumDevices;
99	Vtbl3D.CreateLight = D3DCreateLight;
100	Vtbl3D.CreateMaterial = D3DCreateMaterial;
101	Vtbl3D.CreateViewport = D3DCreateViewport;
102	Vtbl3D.FindDevice = D3DFindDevice;
103
104	// Org Interface
105	Vtbl.AddRef = DrawAddRef;
106	Vtbl.Release = DrawRelease;
107	Vtbl.QueryInterface = DrawQueryInterface;
108	Vtbl.Compact = DrawCompact;
109	Vtbl.CreateClipper = DrawCreateClipper;
110	Vtbl.CreatePalette = DrawCreatePalette;
111	Vtbl.CreateSurface = DrawCreateSurface;
112	Vtbl.DuplicateSurface = DrawDuplicateSurface;
113	Vtbl.EnumDisplayModes = DrawEnumDisplayModes;
114	Vtbl.EnumSurfaces = DrawEnumSurfaces;
115	Vtbl.FlipToGDISurface = DrawFlipToGDISurface;
116	Vtbl.GetCaps = DrawGetCaps;
117	Vtbl.GetDisplayMode = DrawGetDisplayMode;
118	Vtbl.GetFourCCCodes = DrawGetFourCCCodes;
119	Vtbl.GetGDISurface = DrawGetGDISurface;
120	Vtbl.GetMonitorFrequency = DrawGetMonitorFrequency;
121	Vtbl.GetScanLine = DrawGetScanLine;
122	Vtbl.GetVerticalBlankStatus = DrawGetVerticalBlankStatus;
123	Vtbl.Initialize = DrawInitialize;
124	Vtbl.RestoreDisplayMode = DrawRestoreDisplayMode;
125	Vtbl.SetCooperativeLevel = DrawSetCooperativeLevel;
126	Vtbl.SetDisplayMode = DrawSetDisplayMode;
127	Vtbl.WaitForVerticalBlank = DrawWaitForVerticalBlank;
128
129	// V2 Interface
130
131	Vtbl2.AddRef = DrawAddRef;
132	Vtbl2.Release = DrawRelease;
133	Vtbl2.QueryInterface = DrawQueryInterface;
134	Vtbl2.Compact = DrawCompact;
135	Vtbl2.CreateClipper = DrawCreateClipper;
136	Vtbl2.CreatePalette = DrawCreatePalette;
137	Vtbl2.CreateSurface = DrawCreateSurface;
138	Vtbl2.DuplicateSurface = DrawDuplicateSurface;
139	Vtbl2.EnumDisplayModes = DrawEnumDisplayModes;
140	Vtbl2.EnumSurfaces = DrawEnumSurfaces;
141	Vtbl2.FlipToGDISurface = DrawFlipToGDISurface;
142	Vtbl2.GetCaps = DrawGetCaps;
143	Vtbl2.GetDisplayMode = DrawGetDisplayMode;
144	Vtbl2.GetFourCCCodes = DrawGetFourCCCodes;
145	Vtbl2.GetGDISurface = DrawGetGDISurface;
146	Vtbl2.GetMonitorFrequency = DrawGetMonitorFrequency;
147	Vtbl2.GetScanLine = DrawGetScanLine;
148	Vtbl2.GetVerticalBlankStatus = DrawGetVerticalBlankStatus;
149	Vtbl2.Initialize = DrawInitialize;
150	Vtbl2.RestoreDisplayMode = DrawRestoreDisplayMode;
151	Vtbl2.SetCooperativeLevel = DrawSetCooperativeLevel;
152	Vtbl2.SetDisplayMode = DrawSetDisplayMode2;
153	Vtbl2.WaitForVerticalBlank = DrawWaitForVerticalBlank;
154	Vtbl2.GetAvailableVidMem = DrawGetAvailableVidMem;
155
156	// New V4 interface
157	Vtbl4.AddRef = DrawAddRef; // todo change to a DrawAddRef4 as handling this has changed
158	Vtbl4.Release = DrawRelease; // see above
159	Vtbl4.QueryInterface = DrawQueryInterface;
160	Vtbl4.Compact = DrawCompact;
161	Vtbl4.CreateClipper = DrawCreateClipper;
162	Vtbl4.CreatePalette = DrawCreatePalette;
163	Vtbl4.CreateSurface = DrawCreateSurface4;//
164	Vtbl4.DuplicateSurface = DrawDuplicateSurface4;//
165	Vtbl4.EnumDisplayModes = DrawEnumDisplayModes4;//
166	Vtbl4.EnumSurfaces = DrawEnumSurfaces4; //
167	Vtbl4.FlipToGDISurface = DrawFlipToGDISurface;
168	Vtbl4.GetCaps = DrawGetCaps;
169	Vtbl4.GetDisplayMode = DrawGetDisplayMode4;//
170	Vtbl4.GetFourCCCodes = DrawGetFourCCCodes;
171	Vtbl4.GetGDISurface = DrawGetGDISurface4;//
172	Vtbl4.GetMonitorFrequency = DrawGetMonitorFrequency;
173	Vtbl4.GetScanLine = DrawGetScanLine;
174	Vtbl4.GetVerticalBlankStatus = DrawGetVerticalBlankStatus;
175	Vtbl4.Initialize = DrawInitialize;
176	Vtbl4.RestoreDisplayMode = DrawRestoreDisplayMode;
177	Vtbl4.SetCooperativeLevel = DrawSetCooperativeLevel;
178	Vtbl4.SetDisplayMode = DrawSetDisplayMode2;
179	Vtbl4.WaitForVerticalBlank = DrawWaitForVerticalBlank;
180	Vtbl4.GetAvailableVidMem = DrawGetAvailableVidMem4;
181	Vtbl4.GetSurfaceFromDC = DrawGetSurfaceFromDC;
182	Vtbl4.RestoreAllSurfaces = DrawRestoreAllSurfaces;
183	Vtbl4.TestCooperativeLevel = DrawTestCooperativeLevel;
184	Vtbl4.GetDeviceIdentifier = DrawGetDeviceIdentifier;
185
186	if(lpGUID && *lpGUID == IID_IDirect3D)
187	{
188	dprintf(("DDRAW: D3D Interface -> using V4 Interface"));
189
190	lpVtbl = &Vtbl4;
191	}
192	else
193	{
194	if(lpGUID && *lpGUID == IID_IDirectDraw4)
195	{
196	dprintf(("DDRAW: V4 Interface\n"));
197	lpVtbl = &Vtbl4;
198	}
199	else
200	{
201	dprintf(("DDRAW: <V4 Interface\n"));
202	lpVtbl = (IDirectDraw4Vtbl *) &Vtbl;
203	}
204	}
205
206	lpVtbl2 = lpVtbl;
207
208	pdwUnknownData = (DWORD) malloc (255sizeof(DWORD));
209	for(int i= 0 ;i<255;i++)
210	pdwUnknownData[i] = 0;
211
212	rc = DiveOpen( &hDive,
213	FALSE,
214	&pFrameBuffer);
215	if(rc)
216	{
217	dprintf(("DDRAW: ERROR: DiveOpen returned %d\n", rc));
218	lastError = DDERR_GENERIC;
219	hDive = NULL;
220	}
221	else
222	{
223	dprintf(("DDRAW: DiveOpen OK Framebuufer at 0x%08X\n",pFrameBuffer));
224	}
225	memset( &dCaps,
226	0,
227	sizeof(DIVE_CAPS) );
228	dCaps.ulStructLen = sizeof(DIVE_CAPS);
229	dCaps.ulFormatLength = sizeof(DiveFOURCCs);
230	dCaps.pFormatData = &DiveFOURCCs[0];
231
232	rc = DiveQueryCaps( &dCaps, DIVE_BUFFER_SCREEN);
233
234	dprintf(("DDRAW: DiveQueryCaps rc=0x%08X\n",rc));
235
236	FOURCC pFourCC = (FOURCC )dCaps.pFormatData;
237	nrOfDiveFourCCs = dCaps.ulInputFormats;
238	for(i=0;i<dCaps.ulInputFormats+dCaps.ulOutputFormats;i++) {
239	if(i < dCaps.ulInputFormats) {
240	dprintf(("INPUT FOURCC %C%C%C%C", (char)(pFourCC[i]), (char)(pFourCC[i] >> 8), (char)(pFourCC[i] >> 16), (char)(pFourCC[i] >> 24)));
241	}
242	else dprintf(("OUTPUT FOURCC %C%C%C%C", (char)(pFourCC[i]), (char)(pFourCC[i] >> 8), (char)(pFourCC[i] >> 16), (char)(pFourCC[i] >> 24)));
243	}
244
245	pdwUnknownData[235] = dCaps.ulHorizontalResolution;
246	pdwUnknownData[236] = dCaps.ulVerticalResolution;
247	pdwUnknownData[241] = dCaps.ulDepth;
248
249	screenwidth = dCaps.ulHorizontalResolution;
250	screenheight = dCaps.ulVerticalResolution;
251	screenbpp = dCaps.ulDepth;
252
253	// Shall we run in FS mode ?
254	if(ERROR_SUCCESS==RegOpenKeyA(HKEY_LOCAL_MACHINE,KEY_DIRECT2DRAW,&hkDirectDraw2))
255	{
256	dwVSize = 4;
257	dwVType = REG_DWORD;
258	if(ERROR_SUCCESS!=RegQueryValueExA(hkDirectDraw2,"Fullscreen",NULL,&dwVType,(LPBYTE)&bScale,&dwVSize))
259	bScale = FALSE;
260	}
261	else
262	bScale = FALSE;
263
264	// Check to see if FS DDraw is enabled in ODIN.INI
265	if (!fNoFSDD && PROFILE_GetOdinIniBool(ODINDDRAW_SECTION, "Fullscreen", FALSE))
266	{
267	#if 0
268	rc = InitIO();
269
270	if(rc) // try to get IOPL for the thread
271	{
272	dprintf(("DDRAW: No IOPL"));
273	}
274	else
275	{
276	dprintf(("DDRAW: IOPL 3!"));
277	}
278	#endif
279
280	rc = LoadPMIService();
281	dprintf(("DDRAW: LoadPMIService() rc=0x%08X",rc));
282
283	if (!rc) {
284	SetUpModeTable();
285
286	bUseFSDD = TRUE;
287	dprintf(("DDRAW: Fullscreen enabled",rc));
288	}
289	}
290	}
291	//******************************************************************************
292	//******************************************************************************
293	OS2IDirectDraw::~OS2IDirectDraw()
294	{
295	dprintf(("DDRAW: OS2IDirectDraw::~OS2IDirectDraw()"));
296
297	if (hDive)
298	DiveClose(hDive);
299
300	// Safety call in case the program did set the pal to all black
301	// so if the destructor gets called we might be able change this back
302	OS2ResetPhysPalette();
303
304	// FSDDRAW additions
305	// we need this in Full Screen, but don't do anything in windowed
306	// session.
307	if (bUseFSDD) {
308	RestorePM();
309	FreeModeTable();
310	}
311	}
312	//******************************************************************************
313	//******************************************************************************
314	FOURCC OS2IDirectDraw::GetScreenFourCC()
315	{
316	return SupportedFourCCs[screenbpp>>3];
317	}
318	//******************************************************************************
319	//******************************************************************************
320	BOOL OS2IDirectDraw::IsFourCCSupported(FOURCC fourcc)
321	{
322	for(int i=0;i<nrOfDiveFourCCs;i++) {
323	if(DiveFOURCCs[i] == fourcc) {
324	return TRUE;
325	}
326	}
327	return FALSE;
328	}
329	//******************************************************************************
330	//******************************************************************************
331	HRESULT WIN32API DrawQueryInterface(THIS This, REFIID riid, LPVOID FAR * ppvObj)
332	{
333	OS2IDirectDraw me = (OS2IDirectDraw )This;
334
335	dprintf(("DDRAW: OS2IDirectDraw::QueryInterface %x %x %x", This, riid, ppvObj));
336
337	*ppvObj = NULL;
338
339	if(!IsEqualGUID(riid, CLSID_DirectDraw) &&
340	!IsEqualGUID(riid, IID_IDirectDraw) &&
341	!IsEqualGUID(riid, IID_IDirectDraw2) &&
342	!IsEqualGUID(riid, IID_IDirectDraw4) &&
343	!IsEqualGUID(riid, IID_IDirect3D))
344	// !IsEqualGUID(riid, IID_IUnknown))
345	return E_NOINTERFACE;
346
347	// ToDo Better way of returning differnent interfaces for same class
348	if(IsEqualGUID(riid, IID_IDirect3D))
349	{
350	me->lpVtbl3D = &me->Vtbl3D;
351	me->lpVtbl3D2 = me->lpVtbl3D;
352	me->pdwUnknownData3D = me->pdwUnknownData;
353	*ppvObj = (LPVOID)&me->lpVtbl3D;
354	DrawAddRef(This);
355	return DD_OK;
356	}
357	else
358	{
359	if(IsEqualGUID(riid, IID_IDirectDraw4))
360	{
361	dprintf(("DDRAW: IID_IDirectDraw4 Interface"));
362	me->lpVtbl = &me->Vtbl4;
363	}
364	else
365	{
366	if(IsEqualGUID(riid, IID_IDirectDraw2))
367	{
368	dprintf(("DDRAW: IID_IDirectDraw2 Interface"));
369	me->lpVtbl = (IDirectDraw4Vtbl *) &me->Vtbl2;
370	}
371	else
372	{
373	dprintf(("DDRAW: IID_IDirectDraw Interface"));
374	me->lpVtbl = (IDirectDraw4Vtbl *) &me->Vtbl;
375	}
376	}
377	}
378	me->lpVtbl2 = me->lpVtbl;
379	*ppvObj = This;
380	DrawAddRef(This);
381
382	return(DD_OK);
383	}
384	//******************************************************************************
385	//******************************************************************************
386	ULONG WIN32API DrawAddRef(THIS This)
387	{
388	OS2IDirectDraw me = (OS2IDirectDraw )This;
389
390	dprintf(("DDRAW: OS2IDirectDraw::AddRef %d", me->Referenced+1));
391
392	return ++me->Referenced;
393	}
394	//******************************************************************************
395	//******************************************************************************
396	ULONG WIN32API DrawRelease(THIS This)
397	{
398	OS2IDirectDraw me = (OS2IDirectDraw )This;
399	ULONG rc;
400
401	dprintf(("DDRAW: OS2IDirectDraw::Release %d", me->Referenced-1));
402	dprintf(("DDRAW: OS2IDirectDraw::%X", me));
403
404	if(me->Referenced)
405	{
406
407	me->Referenced--;
408	if(me->Referenced == 0)
409	{
410	delete(me);
411	rc = 0;
412	}
413	else
414	rc = me->Referenced;
415	}
416	else
417	rc = 0;
418
419	return rc;
420	}
421	//******************************************************************************
422	//******************************************************************************
423	HRESULT WIN32API DrawCompact(THIS)
424	{
425	dprintf(("DDRAW: Compact"));
426
427	return(DD_OK);
428	}
429	//******************************************************************************
430	//******************************************************************************
431	HRESULT WIN32API DrawCreateClipper(THIS This, DWORD, LPDIRECTDRAWCLIPPER FAR lplpDD, IUnknown FAR )
432	{
433	OS2IDirectDraw me = (OS2IDirectDraw )This;
434	OS2IDirectDrawClipper *newclip;
435	HRESULT rc;
436
437	newclip = new OS2IDirectDrawClipper(me);
438
439	dprintf(("DDRAW: CreateClipper"));
440
441	if(newclip == NULL)
442	{
443	rc = DDERR_OUTOFMEMORY;
444	}
445	else
446	{
447	newclip->Vtbl.AddRef((IDirectDrawClipper *)newclip);
448	rc = newclip->GetLastError();
449	if(rc != DD_OK)
450	{
451	*lplpDD = NULL;
452	delete newclip;
453	}
454	else
455	lplpDD = (IDirectDrawClipper )newclip;
456	}
457
458	return(rc);
459	}
460	//******************************************************************************
461	//******************************************************************************
462	HRESULT WIN32API DrawCreatePalette(THIS This, DWORD dwFlags,
463	LPPALETTEENTRY lpColorTable,
464	LPDIRECTDRAWPALETTE FAR *lplpDD,
465	IUnknown FAR *pUnkOuter)
466	{
467	OS2IDirectDraw me = (OS2IDirectDraw )This;
468	OS2IDirectDrawPalette *newpal;
469	HRESULT rc = DD_OK;
470	int palsize = 0;
471
472	if(dwFlags & DDPCAPS_8BITENTRIES)
473	{
474	// We Don't support Indexed palettes...
475
476	rc = DDERR_INVALIDPARAMS;
477	}
478
479	if(dwFlags & DDPCAPS_2BIT)
480	palsize = 4;
481	if(dwFlags & DDPCAPS_4BIT)
482	palsize = 16;
483	if(dwFlags & DDPCAPS_8BIT)
484	palsize = 256;
485	if(dwFlags & DDPCAPS_ALLOW256)
486	palsize = 256;
487
488	if(palsize == 0)
489	rc = DDERR_INVALIDPARAMS;
490
491	if(DD_OK == rc)
492	{
493	dprintf(("DDRAW: CreatePalette with %d colors", palsize));
494
495	newpal = new OS2IDirectDrawPalette((VOID*)me, palsize, lpColorTable, dwFlags);
496
497	if(newpal == NULL)
498	{
499	rc = DDERR_OUTOFMEMORY;
500	}
501	else
502	{
503	newpal->Vtbl.AddRef((IDirectDrawPalette *)newpal);
504	rc = newpal->GetLastError();
505
506	if(DD_OK != rc)
507	{
508	*lplpDD = NULL;
509	delete newpal;
510	}
511	else
512	lplpDD = (IDirectDrawPalette )newpal;
513	}
514	}
515
516	return(rc);
517	}
518	//******************************************************************************
519	//******************************************************************************
520	HRESULT WIN32API DrawCreateSurface(THIS This, LPDDSURFACEDESC lpDDSurfaceDesc,
521	LPDIRECTDRAWSURFACE FAR *lplpDD,
522	IUnknown FAR *pUnkOuter)
523	{
524	OS2IDirectDraw me = (OS2IDirectDraw )This;
525	OS2IDirectDrawSurface *newsurf;
526	HRESULT rc;
527
528	dprintf(("DDRAW: CreateSurface\n"));
529	dprintf(("DDRAW: dwSize %d\n", lpDDSurfaceDesc->dwSize));
530	dprintf(("DDRAW: dwFlags %X\n", lpDDSurfaceDesc->dwFlags));
531	dprintf(("DDRAW: dwHeight %d\n", lpDDSurfaceDesc->dwHeight));
532	dprintf(("DDRAW: dwWidth %d\n", lpDDSurfaceDesc->dwWidth));
533	dprintf(("DDRAW: lPitch %d\n", lpDDSurfaceDesc->lPitch));
534	dprintf(("DDRAW: dwBackBufferCount %d\n", lpDDSurfaceDesc->dwBackBufferCount));
535	dprintf(("DDRAW: dwMipMapCount %d\n", lpDDSurfaceDesc->dwMipMapCount));
536	dprintf(("DDRAW: dwAlphaBitDepth %d\n", lpDDSurfaceDesc->dwAlphaBitDepth));
537	dprintf(("DDRAW: ddsCaps.dwCaps %X\n", lpDDSurfaceDesc->ddsCaps.dwCaps));
538
539	newsurf = new OS2IDirectDrawSurface(me, (LPDDSURFACEDESC2)lpDDSurfaceDesc);
540	if(newsurf == NULL)
541	{
542	rc = DDERR_OUTOFMEMORY;
543	}
544	else
545	{
546	newsurf->Vtbl.AddRef((IDirectDrawSurface *)newsurf);
547	rc = newsurf->GetLastError();
548	if(rc != DD_OK)
549	{
550	dprintf(("DDRAW: Error createing Surface rc = %d\n\n", rc));
551	*lplpDD = NULL;
552	delete newsurf;
553	}
554	else
555	lplpDD = (IDirectDrawSurface )newsurf;
556
557	dprintf(("DDRAW: New Surface created at %08X\n\n", newsurf));
558	}
559
560	return(rc);
561	}
562	//******************************************************************************
563	//******************************************************************************
564	HRESULT WIN32API DrawCreateSurface4(THIS This, LPDDSURFACEDESC2 lpDDSurfaceDesc2,
565	LPDIRECTDRAWSURFACE4 FAR *lplpDD,
566	IUnknown FAR *pUnkOuter)
567	{
568	OS2IDirectDraw me = (OS2IDirectDraw )This;
569	OS2IDirectDrawSurface *newsurf;
570	HRESULT rc;
571
572	dprintf(("DDRAW: CreateSurface4\n"));
573	dprintf(("DDRAW: dwSize %d\n", lpDDSurfaceDesc2->dwSize));
574	dprintf(("DDRAW: dwHeight %d\n", lpDDSurfaceDesc2->dwHeight));
575	dprintf(("DDRAW: dwWidth %d\n", lpDDSurfaceDesc2->dwWidth));
576	dprintf(("DDRAW: lPitch %d\n", lpDDSurfaceDesc2->lPitch));
577	dprintf(("DDRAW: dwBackBufferCount %d\n", lpDDSurfaceDesc2->dwBackBufferCount));
578	dprintf(("DDRAW: dwMipMapCount %d\n", lpDDSurfaceDesc2->dwMipMapCount));
579	dprintf(("DDRAW: dwAlphaBitDepth %d\n", lpDDSurfaceDesc2->dwAlphaBitDepth));
580	dprintf(("DDRAW: ddsCaps.dwCaps %X\n", lpDDSurfaceDesc2->ddsCaps.dwCaps));
581
582	newsurf = new OS2IDirectDrawSurface(me, lpDDSurfaceDesc2);
583
584	if(newsurf == NULL)
585	{
586	rc = DDERR_OUTOFMEMORY;
587	}
588	else
589	{
590	newsurf->Vtbl.AddRef((IDirectDrawSurface *)newsurf);
591	rc = newsurf->GetLastError();
592	if(rc != DD_OK)
593	{
594	dprintf(("DDRAW: Error createing Surface\n\n"));
595	*lplpDD = NULL;
596
597	delete newsurf;
598	}
599	else
600	lplpDD = (IDirectDrawSurface4 )newsurf;
601
602	dprintf(("DDRAW: New Surface created at %08X\n\n", newsurf));
603	}
604
605	return(rc);
606	}
607	//******************************************************************************
608	//******************************************************************************
609	HRESULT WIN32API DrawDuplicateSurface(THIS, LPDIRECTDRAWSURFACE, LPDIRECTDRAWSURFACE FAR * )
610	{
611	dprintf(("DDRAW: DuplicateSurface NIY\n"));
612
613	return(DD_OK);
614	}
615	//******************************************************************************
616	//******************************************************************************
617	HRESULT WIN32API DrawDuplicateSurface4(THIS, LPDIRECTDRAWSURFACE4, LPDIRECTDRAWSURFACE4 FAR * )
618	{
619	dprintf(("DDRAW: DuplicateSurface4 NIY\n"));
620
621	return(DD_OK);
622	}
623	//******************************************************************************
624	//******************************************************************************
625	HRESULT WIN32API DrawEnumDisplayModes( THIS This,
626	DWORD dwFlags,
627	LPDDSURFACEDESC lpDDSurfaceDesc,
628	LPVOID lpContext,
629	LPDDENUMMODESCALLBACK lpDDEnumModesCallback)
630	{
631	int iMode = 0;
632	DDSURFACEDESC DDSurfAct;
633	BOOL fCallAgain;
634	OS2IDirectDraw me = (OS2IDirectDraw )This;
635
636	dprintf(("DDRAW: EnumDisplayModes\n"));
637
638	// Check for Pointer to callback function
639	if (NULL == lpDDEnumModesCallback)
640	{
641	dprintf(("DDRAW: EnumDisplayModes : Error NO EnumFunction passed in\n"));
642
643	return(DDERR_GENERIC);
644	}
645
646
647	// Setting up the surface
648	// During enum we report resolution and bitdepth, maybe we should
649	// also report back : Caps and Pitch
650	memset(&DDSurfAct,0,sizeof(DDSURFACEDESC));
651	DDSurfAct.dwSize = sizeof(DDSURFACEDESC);
652	DDSurfAct.dwFlags = DDSD_HEIGHT \| DDSD_WIDTH \| DDSD_PIXELFORMAT ;
653	// Only report the bitdepth hope this is ok this way, we must set the BitMask fields
654
655	DDSurfAct.ddpfPixelFormat.dwSize = sizeof (DDPIXELFORMAT);
656	DDSurfAct.ddpfPixelFormat.dwFlags = DDPF_RGB;
657	// Check if we use DIVE or Voodoo
658	if(me->lpVtbl != (IDirectDraw4Vtbl *) &(me->Vtbl3D))
659	{
660	// DIVE modes
661
662	dprintf(("DDRAW: EnumDisplayModes : DIVE modes\n"));
663
664	// Enumerate all modes ?
665	if (NULL==lpDDSurfaceDesc)
666	{
667	// Check if we shall report 320x200 mode
668
669	dprintf(("DDRAW: EnumDisplayModes : ALL modes\n"));
670
671	//SvL: Don't report 320x200 if we've been told to report only one
672	// display mode
673	if(NUM_MODES_DIVE != 1 && (dwFlags & DDEDM_STANDARDVGAMODES))
674	{
675	dprintf(("DDRAW: EnumDisplayModes : STANDARDVGAMODES\n"));
676
677	DDSurfAct.dwHeight = ModesDive[0].iYRes;
678	DDSurfAct.dwWidth = ModesDive[0].iXRes;
679	DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesDive[0].iBits;
680	DDSurfAct.ddpfPixelFormat.dwFlags \|= DDPF_PALETTEINDEXED8 ;
681	if(!lpDDEnumModesCallback(&DDSurfAct,lpContext))
682	{
683	dprintf(("DDRAW: EnumDisplayModes : Enum done\n"));
684	return (DD_OK);
685	}
686	}
687	// Don't know the flag for Mode X so we skip reporting it
688
689	// Now report all our modes
690	iMode = min(2, NUM_MODES_DIVE-1);
691	fCallAgain = TRUE;
692	do
693	{
694	// if the mode fits in the current resolution report it
695	// Change this if we support Fullscreen later !!!
696
697	if(ModesDive[iMode].iXRes <= me->dCaps.ulHorizontalResolution)
698	{
699	DDSurfAct.dwHeight = ModesDive[iMode].iYRes;
700	DDSurfAct.dwWidth = ModesDive[iMode].iXRes;
701	DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesDive[iMode].iBits;
702	switch(ModesDive[iMode].iBits)
703	{
704	case 8:
705	DDSurfAct.ddpfPixelFormat.dwFlags \|= DDPF_PALETTEINDEXED8;
706	break;
707	case 16:
708	// VESA uses 565 encoding in 16 bit modes
709	DDSurfAct.ddpfPixelFormat.dwFlags &= ~DDPF_PALETTEINDEXED8;
710	DDSurfAct.ddpfPixelFormat.dwRBitMask = 0x0000F800;
711	DDSurfAct.ddpfPixelFormat.dwGBitMask = 0x000007E0;
712	DDSurfAct.ddpfPixelFormat.dwBBitMask = 0x0000001F;
713	break;
714	case 24:
715	case 32:
716	// VESA uses per default RGB4
717	DDSurfAct.ddpfPixelFormat.dwFlags &= ~DDPF_PALETTEINDEXED8;
718	DDSurfAct.ddpfPixelFormat.dwRBitMask = 0x00FF0000;
719	DDSurfAct.ddpfPixelFormat.dwGBitMask = 0x0000FF00;
720	DDSurfAct.ddpfPixelFormat.dwBBitMask = 0x000000FF;
721	break;
722	default:
723	break;
724	}
725	dprintf( ("EnumDisplayModes : Enum Mode %dx%d @ %d\n",
726	DDSurfAct.dwHeight,
727	DDSurfAct.dwWidth,
728	DDSurfAct.ddpfPixelFormat.dwRGBBitCount));
729	fCallAgain = lpDDEnumModesCallback(&DDSurfAct,lpContext);
730	dprintf( ("EnumDisplayModes : Callback returned with %d\n",
731	fCallAgain));
732	}
733	iMode++;
734	}
735	while( (iMode < NUM_MODES_DIVE) &&
736	(ModesDive[iMode].iBits <= me->dCaps.ulDepth) &&
737	(TRUE==fCallAgain) );
738	}
739	else
740	{
741	// No, so filter modes with lpDDSurfaceDesc
742
743	// Return Error if the program want to use other than the 3 supported values
744	// for filtering
745
746	if (lpDDSurfaceDesc->dwFlags & !(DDSD_WIDTH\|DDSD_HEIGHT\|DDSD_PIXELFORMAT))
747	return(DDERR_INVALIDPARAMS);
748
749	iMode = 0;
750	if( (dwFlags & DDEDM_STANDARDVGAMODES) &&
751	(
752	(((lpDDSurfaceDesc->dwFlags & DDSD_WIDTH)&&
753	(ModesDive[iMode].iXRes==lpDDSurfaceDesc->dwWidth)
754	)\|\|(!(lpDDSurfaceDesc->dwFlags & DDSD_WIDTH)))&&
755	(((lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT)&&
756	(ModesDive[iMode].iYRes==lpDDSurfaceDesc->dwHeight))\|\|
757	(!(lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT)))&&
758	(((lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT) &&
759	(ModesDive[iMode].iBits==lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount))\|\|
760	(!(lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT)))
761	)
762	)
763	{
764	DDSurfAct.dwHeight = ModesDive[0].iYRes;
765	DDSurfAct.dwWidth = ModesDive[0].iXRes;
766	DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesDive[0].iBits;
767	DDSurfAct.ddpfPixelFormat.dwFlags \|= DDPF_PALETTEINDEXED8;
768	if(!lpDDEnumModesCallback(&DDSurfAct,lpContext))
769	{
770	return (DD_OK);
771	}
772	}
773	// Don't know the flag for Mode X so we skip reporting it
774
775	// Now report all our modes
776	iMode = min(2, NUM_MODES_DIVE-1);
777	fCallAgain = TRUE;
778	do
779	{
780	// if the mode fits in the current resolution and the filter applies report it
781	// Change this if we support Fullscreen later !!!
782	if( (ModesDive[iMode].iXRes <= me->dCaps.ulHorizontalResolution)&&
783	(
784	(((lpDDSurfaceDesc->dwFlags & DDSD_WIDTH)&&
785	(ModesDive[iMode].iXRes==lpDDSurfaceDesc->dwWidth))\|\|
786	(!(lpDDSurfaceDesc->dwFlags & DDSD_WIDTH)))&&
787	(((lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT)&&
788	(ModesDive[iMode].iYRes==lpDDSurfaceDesc->dwHeight))\|\|
789	(!(lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT)))&&
790	(((lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT) &&
791	(ModesDive[iMode].iBits==lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount))\|\|
792	(!(lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT)))
793	)
794	)
795	{
796	DDSurfAct.dwHeight = ModesDive[iMode].iYRes;
797	DDSurfAct.dwWidth = ModesDive[iMode].iXRes;
798	DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesDive[iMode].iBits;
799	switch(ModesDive[iMode].iBits)
800	{
801	case 8:
802	DDSurfAct.ddpfPixelFormat.dwFlags \|= DDPF_PALETTEINDEXED8;
803	break;
804	case 16:
805	// VESA uses 565 encoding in 16 bit modes
806	DDSurfAct.ddpfPixelFormat.dwFlags &= ~DDPF_PALETTEINDEXED8;
807	DDSurfAct.ddpfPixelFormat.dwRBitMask = 0x0000F800;
808	DDSurfAct.ddpfPixelFormat.dwGBitMask = 0x000007E0;
809	DDSurfAct.ddpfPixelFormat.dwBBitMask = 0x0000001F;
810	break;
811	case 24:
812	case 32:
813	// VESA uses per default RGB4
814	DDSurfAct.ddpfPixelFormat.dwFlags &= ~DDPF_PALETTEINDEXED8;
815	DDSurfAct.ddpfPixelFormat.dwRBitMask = 0x00FF0000;
816	DDSurfAct.ddpfPixelFormat.dwGBitMask = 0x0000FF00;
817	DDSurfAct.ddpfPixelFormat.dwBBitMask = 0x000000FF;
818	break;
819	default:
820	break;
821	}
822
823	dprintf(("Call lpDDEnumModesCallback with mode (%d,%d) bps %d", DDSurfAct.dwWidth, DDSurfAct.dwHeight, ModesDive[iMode].iBits));
824	fCallAgain = lpDDEnumModesCallback(&DDSurfAct,lpContext);
825	}
826	iMode++;
827	}
828	while((ModesDive[iMode].iBits <= me->dCaps.ulDepth) &&
829	(iMode < NUM_MODES_DIVE) && (TRUE==fCallAgain));
830
831	}
832	}
833	else
834	{
835
836	// VOODOO modes
837
838	// Enumerate all modes ?
839	if (NULL==lpDDSurfaceDesc)
840	{
841
842	// report all our modes
843	iMode = 0;
844	fCallAgain = TRUE;
845	do
846	{
847	DDSurfAct.dwHeight = ModesVoodoo[iMode].iYRes;
848	DDSurfAct.dwWidth = ModesVoodoo[iMode].iXRes;
849	DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesVoodoo[iMode].iBits;
850
851	fCallAgain = lpDDEnumModesCallback(&DDSurfAct,lpContext);
852	iMode++;
853	}
854	while((iMode < NUM_MODES_VOODOO) && (TRUE==fCallAgain));
855	}
856	else
857	{
858	// No, so filter modes with lpDDSurfaceDesc
859
860	// Return Error if the program want to use other than the 3 supported values
861	// for filtering
862
863	if (lpDDSurfaceDesc->dwFlags & !(DDSD_WIDTH\|DDSD_HEIGHT\|DDSD_PIXELFORMAT))
864	{
865	return(DDERR_INVALIDPARAMS);
866	}
867
868	iMode = 2;
869	fCallAgain = TRUE;
870	// All reported mode are 16bit
871	DDSurfAct.ddpfPixelFormat.dwRBitMask = 0x0000F800;
872	DDSurfAct.ddpfPixelFormat.dwGBitMask = 0x000007E0;
873	DDSurfAct.ddpfPixelFormat.dwBBitMask = 0x0000001F;
874	do
875	{
876	// if the mode fits the filter applies report it
877	if(
878	(((lpDDSurfaceDesc->dwFlags & DDSD_WIDTH)&&
879	(ModesVoodoo[iMode].iXRes==lpDDSurfaceDesc->dwWidth))\|\|
880	(!(lpDDSurfaceDesc->dwFlags & DDSD_WIDTH)))&&
881	(((lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT)&&
882	(ModesVoodoo[iMode].iYRes==lpDDSurfaceDesc->dwHeight))\|\|
883	(!(lpDDSurfaceDesc->dwFlags & DDSD_HEIGHT)))&&
884	(((lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT) &&
885	(ModesVoodoo[iMode].iBits==lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount))\|\|
886	(!(lpDDSurfaceDesc->dwFlags & DDSD_PIXELFORMAT)))
887	)
888	{
889	DDSurfAct.dwHeight = ModesVoodoo[iMode].iYRes;
890	DDSurfAct.dwWidth = ModesVoodoo[iMode].iXRes;
891	DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesVoodoo[iMode].iBits;
892
893	fCallAgain = lpDDEnumModesCallback(&DDSurfAct,lpContext);
894	}
895	iMode++;
896	}
897	while((iMode < NUM_MODES_VOODOO) && (TRUE==fCallAgain));
898
899	}
900
901	}
902	return(DD_OK);
903	}
904	//******************************************************************************
905	//******************************************************************************
906	HRESULT WIN32API DrawEnumDisplayModes4(THIS This, DWORD dwFlags, LPDDSURFACEDESC2 lpDDSurfaceDesc2,
907	LPVOID lpContext, LPDDENUMMODESCALLBACK2 lpDDEnumModesCallback2)
908	{
909	int iMode = 0;
910	DDSURFACEDESC2 DDSurfAct;
911	BOOL fCallAgain;
912	OS2IDirectDraw me = (OS2IDirectDraw )This;
913
914	dprintf(("DDRAW: EnumDisplayModes4"));
915
916	// Check for Pointer to callback function
917	if (NULL == lpDDEnumModesCallback2)
918	{
919	dprintf(("DDRAW: EnumDisplayModes4 : Error NO EnumFunction passed in\n"));
920
921	return(DDERR_GENERIC);
922	}
923
924
925	// Setting up the surface
926	// During enum we report resolution and bitdepth, maybe we should
927	// also report back : Caps and Pitch
928	memset(&DDSurfAct,0,sizeof(DDSURFACEDESC2));
929	DDSurfAct.dwSize = sizeof(DDSURFACEDESC2);
930	DDSurfAct.dwFlags = DDSD_HEIGHT \| DDSD_WIDTH \| DDSD_PIXELFORMAT ;
931	// Only report the bitdepth hope this is ok this way, we must set the BitMask fields
932
933	DDSurfAct.ddpfPixelFormat.dwSize = sizeof (DDPIXELFORMAT);
934	DDSurfAct.ddpfPixelFormat.dwFlags = DDPF_RGB;
935
936	// Check if we use DIVE or Voodoo
937	if(me->lpVtbl != (IDirectDraw4Vtbl *) &(me->Vtbl3D))
938	{
939	// DIVE modes
940
941	dprintf(("DDRAW: EnumDisplayModes : DIVE modes\n"));
942
943	// Enumerate all modes ?
944	if (NULL==lpDDSurfaceDesc2)
945	{
946	// Check if we shall report 320x200 mode
947
948	dprintf(("DDRAW: EnumDisplayModes : ALL modes\n"));
949
950	//SvL: Don't report 320x200 if we've been told to report only one
951	// display mode
952	if(NUM_MODES_DIVE != 1 && (dwFlags & DDEDM_STANDARDVGAMODES))
953	{
954	dprintf(("DDRAW: EnumDisplayModes : STANDARDVGAMODES\n"));
955
956	DDSurfAct.dwHeight = ModesDive[0].iYRes;
957	DDSurfAct.dwWidth = ModesDive[0].iXRes;
958	DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesDive[0].iBits;
959	DDSurfAct.ddpfPixelFormat.dwFlags \|= DDPF_PALETTEINDEXED8 ;
960	if(!lpDDEnumModesCallback2(&DDSurfAct,lpContext))
961	{
962	dprintf(("DDRAW: EnumDisplayModes : Enum done\n"));
963	return (DD_OK);
964	}
965	}
966	// Don't know the flag for Mode X so we skip reporting it
967
968	// Now report all our modes
969	iMode = min(2, NUM_MODES_DIVE-1);
970	fCallAgain = TRUE;
971	do
972	{
973	// if the mode fits in the current resolution report it
974	// Change this if we support Fullscreen later !!!
975
976	if(ModesDive[iMode].iXRes <= me->dCaps.ulHorizontalResolution)
977	{
978	DDSurfAct.dwHeight = ModesDive[iMode].iYRes;
979	DDSurfAct.dwWidth = ModesDive[iMode].iXRes;
980	DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesDive[iMode].iBits;
981	switch(ModesDive[iMode].iBits)
982	{
983	case 8:
984	DDSurfAct.ddpfPixelFormat.dwFlags \|= DDPF_PALETTEINDEXED8;
985	break;
986	case 16:
987	// VESA uses 565 encoding in 16 bit modes
988	DDSurfAct.ddpfPixelFormat.dwFlags &= ~DDPF_PALETTEINDEXED8;
989	DDSurfAct.ddpfPixelFormat.dwRBitMask = 0x0000F800;
990	DDSurfAct.ddpfPixelFormat.dwGBitMask = 0x000007E0;
991	DDSurfAct.ddpfPixelFormat.dwBBitMask = 0x0000001F;
992	break;
993	case 24:
994	case 32:
995	// VESA uses per default RGB4
996	DDSurfAct.ddpfPixelFormat.dwFlags &= ~DDPF_PALETTEINDEXED8;
997	DDSurfAct.ddpfPixelFormat.dwRBitMask = 0x00FF0000;
998	DDSurfAct.ddpfPixelFormat.dwGBitMask = 0x0000FF00;
999	DDSurfAct.ddpfPixelFormat.dwBBitMask = 0x000000FF;
1000	break;
1001	default:
1002	break;
1003	}
1004	dprintf( ("EnumDisplayModes : Enum Mode %dx%d @ %d\n",
1005	DDSurfAct.dwHeight,
1006	DDSurfAct.dwWidth,
1007	DDSurfAct.ddpfPixelFormat.dwRGBBitCount));
1008	fCallAgain = lpDDEnumModesCallback2(&DDSurfAct,lpContext);
1009	dprintf( ("EnumDisplayModes : Callback returned with %d\n",
1010	fCallAgain));
1011	}
1012	iMode++;
1013	}
1014	while( (iMode < NUM_MODES_DIVE) &&
1015	(ModesDive[iMode].iBits <= me->dCaps.ulDepth) &&
1016	(TRUE==fCallAgain) );
1017	}
1018	else
1019	{
1020	// No, so filter modes with lpDDSurfaceDesc2
1021
1022	// Return Error if the program want to use other than the 3 supported values
1023	// for filtering
1024
1025	if (lpDDSurfaceDesc2->dwFlags & !(DDSD_WIDTH\|DDSD_HEIGHT\|DDSD_PIXELFORMAT))
1026	return(DDERR_INVALIDPARAMS);
1027
1028	iMode = 0;
1029	if( (dwFlags & DDEDM_STANDARDVGAMODES) &&
1030	(
1031	(((lpDDSurfaceDesc2->dwFlags & DDSD_WIDTH)&&
1032	(ModesDive[iMode].iXRes==lpDDSurfaceDesc2->dwWidth)
1033	)\|\|(!(lpDDSurfaceDesc2->dwFlags & DDSD_WIDTH)))&&
1034	(((lpDDSurfaceDesc2->dwFlags & DDSD_HEIGHT)&&
1035	(ModesDive[iMode].iYRes==lpDDSurfaceDesc2->dwHeight))\|\|
1036	(!(lpDDSurfaceDesc2->dwFlags & DDSD_HEIGHT)))&&
1037	(((lpDDSurfaceDesc2->dwFlags & DDSD_PIXELFORMAT) &&
1038	(ModesDive[iMode].iBits==lpDDSurfaceDesc2->ddpfPixelFormat.dwRGBBitCount))\|\|
1039	(!(lpDDSurfaceDesc2->dwFlags & DDSD_PIXELFORMAT)))
1040	)
1041	)
1042	{
1043	DDSurfAct.dwHeight = ModesDive[0].iYRes;
1044	DDSurfAct.dwWidth = ModesDive[0].iXRes;
1045	DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesDive[0].iBits;
1046	DDSurfAct.ddpfPixelFormat.dwFlags \|= DDPF_PALETTEINDEXED8;
1047	if(!lpDDEnumModesCallback2(&DDSurfAct,lpContext))
1048	{
1049	return (DD_OK);
1050	}
1051	}
1052	// Don't know the flag for Mode X so we skip reporting it
1053
1054	// Now report all our modes
1055	iMode = min(2, NUM_MODES_DIVE-1);
1056	fCallAgain = TRUE;
1057	do
1058	{
1059	// if the mode fits in the current resolution and the filter applies report it
1060	// Change this if we support Fullscreen later !!!
1061	if( (ModesDive[iMode].iXRes <= me->dCaps.ulHorizontalResolution)&&
1062	(
1063	(((lpDDSurfaceDesc2->dwFlags & DDSD_WIDTH)&&
1064	(ModesDive[iMode].iXRes==lpDDSurfaceDesc2->dwWidth))\|\|
1065	(!(lpDDSurfaceDesc2->dwFlags & DDSD_WIDTH)))&&
1066	(((lpDDSurfaceDesc2->dwFlags & DDSD_HEIGHT)&&
1067	(ModesDive[iMode].iYRes==lpDDSurfaceDesc2->dwHeight))\|\|
1068	(!(lpDDSurfaceDesc2->dwFlags & DDSD_HEIGHT)))&&
1069	(((lpDDSurfaceDesc2->dwFlags & DDSD_PIXELFORMAT) &&
1070	(ModesDive[iMode].iBits==lpDDSurfaceDesc2->ddpfPixelFormat.dwRGBBitCount))\|\|
1071	(!(lpDDSurfaceDesc2->dwFlags & DDSD_PIXELFORMAT)))
1072	)
1073	)
1074	{
1075	DDSurfAct.dwHeight = ModesDive[iMode].iYRes;
1076	DDSurfAct.dwWidth = ModesDive[iMode].iXRes;
1077	DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesDive[iMode].iBits;
1078	switch(ModesDive[iMode].iBits)
1079	{
1080	case 8:
1081	DDSurfAct.ddpfPixelFormat.dwFlags \|= DDPF_PALETTEINDEXED8;
1082	break;
1083	case 16:
1084	// VESA uses 565 encoding in 16 bit modes
1085	DDSurfAct.ddpfPixelFormat.dwFlags &= ~DDPF_PALETTEINDEXED8;
1086	DDSurfAct.ddpfPixelFormat.dwRBitMask = 0x0000F800;
1087	DDSurfAct.ddpfPixelFormat.dwGBitMask = 0x000007E0;
1088	DDSurfAct.ddpfPixelFormat.dwBBitMask = 0x0000001F;
1089	break;
1090	case 24:
1091	case 32:
1092	// VESA uses per default RGB4
1093	DDSurfAct.ddpfPixelFormat.dwFlags &= ~DDPF_PALETTEINDEXED8;
1094	DDSurfAct.ddpfPixelFormat.dwRBitMask = 0x00FF0000;
1095	DDSurfAct.ddpfPixelFormat.dwGBitMask = 0x0000FF00;
1096	DDSurfAct.ddpfPixelFormat.dwBBitMask = 0x000000FF;
1097	break;
1098	default:
1099	break;
1100	}
1101
1102	dprintf(("Call lpDDEnumModesCallback with mode (%d,%d) bps %d", DDSurfAct.dwWidth, DDSurfAct.dwHeight, ModesDive[iMode].iBits));
1103	fCallAgain = lpDDEnumModesCallback2(&DDSurfAct,lpContext);
1104	}
1105	iMode++;
1106	}
1107	while((ModesDive[iMode].iBits <= me->dCaps.ulDepth) &&
1108	(iMode < NUM_MODES_DIVE) && (TRUE==fCallAgain));
1109
1110	}
1111	}
1112	else
1113	{
1114
1115	// VOODOO modes
1116
1117	// Enumerate all modes ?
1118	if (NULL==lpDDSurfaceDesc2)
1119	{
1120
1121	// report all our modes
1122	iMode = 0;
1123	fCallAgain = TRUE;
1124	do
1125	{
1126	DDSurfAct.dwHeight = ModesVoodoo[iMode].iYRes;
1127	DDSurfAct.dwWidth = ModesVoodoo[iMode].iXRes;
1128	DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesVoodoo[iMode].iBits;
1129
1130	fCallAgain = lpDDEnumModesCallback2(&DDSurfAct,lpContext);
1131	iMode++;
1132	}
1133	while((iMode < NUM_MODES_VOODOO) && (TRUE==fCallAgain));
1134	}
1135	else
1136	{
1137	// No, so filter modes with lpDDSurfaceDesc2
1138
1139	// Return Error if the program want to use other than the 3 supported values
1140	// for filtering
1141
1142	if (lpDDSurfaceDesc2->dwFlags & !(DDSD_WIDTH\|DDSD_HEIGHT\|DDSD_PIXELFORMAT))
1143	{
1144	return(DDERR_INVALIDPARAMS);
1145	}
1146
1147	iMode = 2;
1148	fCallAgain = TRUE;
1149	// All reported mode are 16bit
1150	DDSurfAct.ddpfPixelFormat.dwRBitMask = 0x0000F800;
1151	DDSurfAct.ddpfPixelFormat.dwGBitMask = 0x000007E0;
1152	DDSurfAct.ddpfPixelFormat.dwBBitMask = 0x0000001F;
1153	do
1154	{
1155	// if the mode fits the filter applies report it
1156	if(
1157	(((lpDDSurfaceDesc2->dwFlags & DDSD_WIDTH)&&
1158	(ModesVoodoo[iMode].iXRes==lpDDSurfaceDesc2->dwWidth))\|\|
1159	(!(lpDDSurfaceDesc2->dwFlags & DDSD_WIDTH)))&&
1160	(((lpDDSurfaceDesc2->dwFlags & DDSD_HEIGHT)&&
1161	(ModesVoodoo[iMode].iYRes==lpDDSurfaceDesc2->dwHeight))\|\|
1162	(!(lpDDSurfaceDesc2->dwFlags & DDSD_HEIGHT)))&&
1163	(((lpDDSurfaceDesc2->dwFlags & DDSD_PIXELFORMAT) &&
1164	(ModesVoodoo[iMode].iBits==lpDDSurfaceDesc2->ddpfPixelFormat.dwRGBBitCount))\|\|
1165	(!(lpDDSurfaceDesc2->dwFlags & DDSD_PIXELFORMAT)))
1166	)
1167	{
1168	DDSurfAct.dwHeight = ModesVoodoo[iMode].iYRes;
1169	DDSurfAct.dwWidth = ModesVoodoo[iMode].iXRes;
1170	DDSurfAct.ddpfPixelFormat.dwRGBBitCount = ModesVoodoo[iMode].iBits;
1171
1172	fCallAgain = lpDDEnumModesCallback2(&DDSurfAct,lpContext);
1173	}
1174	iMode++;
1175	}
1176	while((iMode < NUM_MODES_VOODOO) && (TRUE==fCallAgain));
1177
1178	}
1179
1180	}
1181	return(DD_OK);
1182	}
1183
1184	//******************************************************************************
1185	//******************************************************************************
1186	HRESULT WIN32API DrawEnumSurfaces(THIS, DWORD, LPDDSURFACEDESC, LPVOID,LPDDENUMSURFACESCALLBACK )
1187	{
1188	dprintf(("DDRAW: EnumSurfaces NIY\n"));
1189
1190	return(DD_OK);
1191	}
1192
1193	//******************************************************************************
1194	//******************************************************************************
1195	HRESULT WIN32API DrawEnumSurfaces4(THIS, DWORD, LPDDSURFACEDESC2, LPVOID,LPDDENUMSURFACESCALLBACK2 )
1196	{
1197	dprintf(("DDRAW: EnumSurfaces4 NIY\n"));
1198
1199	return(DD_OK);
1200	}
1201
1202	//******************************************************************************
1203	//******************************************************************************
1204	HRESULT WIN32API DrawFlipToGDISurface(THIS)
1205	{
1206	dprintf(("DDRAW: FlipToGDISurface NIY\n"));
1207
1208	return(DD_OK);
1209	}
1210
1211	//******************************************************************************
1212	//******************************************************************************
1213	HRESULT WIN32API DrawGetCaps(THIS This, LPDDCAPS lpDDDriverCaps, LPDDCAPS lpDDHELCaps)
1214	{
1215	DWORD dwSize;
1216	OS2IDirectDraw me = (OS2IDirectDraw )This;
1217
1218	dprintf(("DDRAW: DDGetCaps %x %x %x", This, lpDDDriverCaps, lpDDHELCaps));
1219
1220	if( (NULL==lpDDDriverCaps) && (NULL==lpDDHELCaps) )
1221	return(DDERR_INVALIDPARAMS);
1222
1223	if(NULL!=lpDDDriverCaps)
1224	{
1225	// Caller want Driver Caps
1226
1227	dprintf(("DDRAW: Driver\n"));
1228
1229	if( (sizeof(DDCAPS)!=lpDDDriverCaps->dwSize) &&
1230	(sizeof(DDCAPS_DX5)!=lpDDDriverCaps->dwSize) &&
1231	(sizeof(DDCAPS_DX3)!=lpDDDriverCaps->dwSize) )
1232	{
1233	dprintf( ("Size %d Not supported ",
1234	lpDDDriverCaps->dwSize));
1235	return(DDERR_INVALIDPARAMS);
1236	}
1237	// Clear structure so we only have to set the supported flags
1238
1239	dwSize = lpDDDriverCaps->dwSize;
1240	memset( lpDDDriverCaps,
1241	0,
1242	lpDDDriverCaps->dwSize);
1243
1244
1245	// Reset the size
1246	lpDDDriverCaps->dwSize = dwSize;
1247
1248	// Now report the CAPs back which we support
1249	lpDDDriverCaps->dwCaps = DDCAPS_BLT \| // We do blitting
1250	DDCAPS_BLTSTRETCH \|
1251	DDCAPS_BLTCOLORFILL \| // We do colorfills
1252	DDCAPS_BLTDEPTHFILL \|
1253	DDCAPS_COLORKEY \| // We support Colorkeying
1254	DDCAPS_COLORKEYHWASSIST \| // But we (may) use the CPU
1255	DDCAPS_GDI \| // Maybe check if we are on Voodoo ?
1256	DDCAPS_PALETTEVSYNC \| // Got VSync
1257	// DDCAPS_READSCANLINE \|
1258	DDCAPS_BLTFOURCC;
1259	lpDDDriverCaps->dwCaps2 = DDCAPS2_CERTIFIED \| // Who cares so say yes
1260	DDCAPS2_CANRENDERWINDOWED \| // Better check for Voodoo ?!
1261	DDCAPS2_COPYFOURCC \| // yepp memcpy will do this
1262	DDCAPS2_NONLOCALVIDMEM \| // All surfaces are in memory
1263	DDCAPS2_WIDESURFACES; // Any size you want!
1264
1265	lpDDDriverCaps->dwCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
1266
1267	lpDDDriverCaps->dwFXCaps = DDFXCAPS_BLTMIRRORUPDOWN \|
1268	DDFXCAPS_BLTMIRRORLEFTRIGHT; // DIVE supports this, do we also ?
1269	// Maybe later add stretching support?
1270
1271	lpDDDriverCaps->dwPalCaps = DDPCAPS_8BIT \| // Only 8 Bits pals
1272	DDPCAPS_ALLOW256 \| // But all 256 colors
1273	DDPCAPS_VSYNC \| // Vsync yet
1274	DDPCAPS_PRIMARYSURFACE; //
1275	lpDDDriverCaps->dwVidMemTotal = me->dCaps.ulApertureSize; // total video memory
1276	lpDDDriverCaps->dwVidMemFree = me->dCaps.ulApertureSize; // total free video memory
1277
1278	lpDDDriverCaps->dwNumFourCCCodes = MAX_FOURCC_CODES; // number of supported FOURCC codes
1279	/*
1280	ToDo: must finde out ow the array is used for this
1281	lpDDDriverCaps->dwRops[DD_ROP_SPACE] = SRCCOPY \|
1282	BLACKNESS \|
1283	WHITENESS; // Raster OPs implemented
1284	*/
1285	lpDDDriverCaps->dwSVBCaps = DDCAPS_BLT \| // We do blitting
1286	DDCAPS_BLTCOLORFILL \| // We do colorfills
1287	DDCAPS_COLORKEY \| // We support Colorkeying
1288	DDCAPS_COLORKEYHWASSIST;
1289	lpDDDriverCaps->dwSVBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
1290	lpDDDriverCaps->dwSVBFXCaps = DDCAPS_BLT \| // We do blitting
1291	DDCAPS_BLTCOLORFILL \| // We do colorfills
1292	DDCAPS_COLORKEY \| // We support Colorkeying
1293	DDCAPS_COLORKEYHWASSIST;
1294	/*
1295	ToDo: must finde out ow the array is used for this
1296	lpDDDriverCaps->dwSVBRops[DD_ROP_SPACE] = SRCCOPY \|
1297	BLACKNESS \|
1298	WHITENESS; // Raster OPs implemented
1299	*/
1300	lpDDDriverCaps->dwVSBCaps = DDCAPS_BLT \| // We do blitting
1301	DDCAPS_BLTCOLORFILL \| // We do colorfills
1302	DDCAPS_COLORKEY \| // We support Colorkeying
1303	DDCAPS_COLORKEYHWASSIST;
1304	lpDDDriverCaps->dwVSBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
1305	lpDDDriverCaps->dwVSBFXCaps = DDCAPS_BLT \| // We do blitting
1306	DDCAPS_BLTCOLORFILL \| // We do colorfills
1307	DDCAPS_COLORKEY \| // We support Colorkeying
1308	DDCAPS_COLORKEYHWASSIST;
1309	/*
1310	ToDo: must finde out ow the array is used for this
1311	lpDDDriverCaps->dwVSBRops[DD_ROP_SPACE] = SRCCOPY \|
1312	BLACKNESS \|
1313	WHITENESS; // Raster OPs implemented
1314	*/
1315	lpDDDriverCaps->dwSSBCaps = DDCAPS_BLT \| // We do blitting
1316	DDCAPS_BLTCOLORFILL \| // We do colorfills
1317	DDCAPS_COLORKEY \| // We support Colorkeying
1318	DDCAPS_COLORKEYHWASSIST;
1319	lpDDDriverCaps->dwSSBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
1320	lpDDDriverCaps->dwSSBFXCaps = DDCAPS_BLT \| // We do blitting
1321	DDCAPS_BLTCOLORFILL \| // We do colorfills
1322	DDCAPS_COLORKEY \| // We support Colorkeying
1323	DDCAPS_COLORKEYHWASSIST;
1324	/*
1325	ToDo: must finde out ow the array is used for this
1326	lpDDDriverCaps->dwSSBRops[SRCCOPY] = 1;
1327	lpDDDriverCaps->dwSSBRops[BLACKNESS] = 1;
1328	lpDDDriverCaps->dwSSBRops[WHITENESS] = 1; // Raster OPs implemented
1329	*/
1330	// These are ony in >DX5
1331	if(dwSize>sizeof(DDCAPS_DX3))
1332	{
1333	lpDDDriverCaps->dwSVBCaps2 = //DDCAPS2_CANRENDERWINDOWED \| // Better check for Voodoo ?!
1334	DDCAPS2_COPYFOURCC \| // yepp memcpy will do this
1335	DDCAPS2_WIDESURFACES; // Any size you want!
1336	lpDDDriverCaps->dwNLVBCaps = DDCAPS_BLT \| // We do blitting
1337	DDCAPS_BLTCOLORFILL \| // We do colorfills
1338	DDCAPS_COLORKEY \| // We support Colorkeying
1339	DDCAPS_COLORKEYHWASSIST;
1340	lpDDDriverCaps->dwNLVBCaps2 = //DDCAPS2_CANRENDERWINDOWED \| // Better check for Voodoo ?!
1341	DDCAPS2_COPYFOURCC \| // yepp memcpy will do this
1342	DDCAPS2_WIDESURFACES; // Any size you want!
1343	lpDDDriverCaps->dwNLVBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
1344	lpDDDriverCaps->dwNLVBFXCaps = DDCAPS_BLT \| // We do blitting
1345	DDCAPS_BLTCOLORFILL \| // We do colorfills
1346	DDCAPS_COLORKEY \| // We support Colorkeying
1347	DDCAPS_COLORKEYHWASSIST;
1348	lpDDDriverCaps->dwNLVBRops[DD_ROP_SPACE];// ToDo: Again the array ...
1349
1350	// General Surface caps only in DX6
1351	if(dwSize>sizeof(DDCAPS_DX5))
1352	{
1353	lpDDDriverCaps->ddsCaps.dwCaps = DDSCAPS_ALPHA \| DDSCAPS_BACKBUFFER \|
1354	DDSCAPS_COMPLEX \| DDSCAPS_FLIP \|
1355	DDSCAPS_FRONTBUFFER \| DDSCAPS_LOCALVIDMEM \|
1356	DDSCAPS_NONLOCALVIDMEM \| DDSCAPS_OFFSCREENPLAIN \|
1357	// DDSCAPS_OVERLAY \|
1358	DDSCAPS_PALETTE \| DDSCAPS_PRIMARYSURFACE \|
1359	DDSCAPS_SYSTEMMEMORY \|DDSCAPS_VIDEOMEMORY \|
1360	DDSCAPS_VISIBLE;
1361
1362	#ifdef USE_OPENGL
1363	lpDDDriverCaps->dwCaps \|= DDCAPS_3D \| DDCAPS_ZBLTS;
1364	// ToDO find and put the value for DDCAPS2_NO2DDURING3DSCENE in ddraw.h
1365	// lpDDDriverCaps->dwCaps2 \|= DDCAPS2_NO2DDURING3DSCENE;
1366	lpDDDriverCaps->ddsCaps.dwCaps \|= DDSCAPS_3DDEVICE \| DDSCAPS_MIPMAP \|
1367	DDSCAPS_TEXTURE \| DDSCAPS_ZBUFFER;
1368	#endif
1369	}
1370	}
1371
1372
1373	}
1374
1375	if(NULL!=lpDDHELCaps)
1376	{
1377	// Caller wants HEL Caps
1378	dprintf(("DDRAW: CHEL\n"));
1379
1380	//SvL: PowerDVD uses size 316
1381	if( (sizeof(DDCAPS) != lpDDHELCaps->dwSize) &&
1382	(sizeof(DDCAPS_DX5) != lpDDHELCaps->dwSize) &&
1383	(sizeof(DDCAPS_DX3) != lpDDHELCaps->dwSize) )
1384	{
1385	dprintf( ("Size %d Not supported ",
1386	lpDDHELCaps->dwSize));
1387	return(DDERR_INVALIDPARAMS);
1388	}
1389	// Clear structure so we only have to set the supported flags
1390
1391	dwSize = lpDDHELCaps->dwSize;
1392	memset( lpDDHELCaps,
1393	0,
1394	lpDDHELCaps->dwSize);
1395
1396	// Reset the size
1397	lpDDHELCaps->dwSize = dwSize;
1398
1399	// Now report the CAPs back which we support
1400	lpDDHELCaps->dwCaps = DDCAPS_BLT \| // We do blitting
1401	DDCAPS_BLTCOLORFILL \| // We do colorfills
1402	DDCAPS_COLORKEY \| // We support Colorkeying
1403	//SvL: This is the emulation layer; no hw support here
1404	// DDCAPS_COLORKEYHWASSIST \| // But we (may) use the CPU
1405	DDCAPS_GDI \| // Maybe check if we are on Voodoo ?
1406	DDCAPS_PALETTEVSYNC \| // Got VSync
1407	DDCAPS_BLTFOURCC;
1408
1409	lpDDHELCaps->dwCaps2 = DDCAPS2_CERTIFIED \| // Who cares so say yes
1410	DDCAPS2_CANRENDERWINDOWED \| // Better check for Voodoo ?!
1411	DDCAPS2_COPYFOURCC \| // yepp memcpy will do this
1412	DDCAPS2_NONLOCALVIDMEM \| // All surfaces are in memory
1413	DDCAPS2_WIDESURFACES; // Any size you want!
1414
1415	lpDDHELCaps->dwCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
1416
1417	lpDDHELCaps->dwFXCaps = DDFXCAPS_BLTMIRRORUPDOWN \|
1418	DDFXCAPS_BLTMIRRORLEFTRIGHT; // DIVE supports this, do we also ?
1419	// Maybe later add stretching support?
1420
1421	lpDDHELCaps->dwPalCaps = DDPCAPS_8BIT \| // Only 8 Bits pals
1422	DDPCAPS_ALLOW256 \| // But all 256 colors
1423	DDPCAPS_VSYNC \| // Vsync yet
1424	DDPCAPS_PRIMARYSURFACE;
1425
1426	//Video memory for emulation layer must be 0 (verified in NT)
1427	lpDDHELCaps->dwVidMemTotal = 0; // total video memory
1428	lpDDHELCaps->dwVidMemFree = 0; // total free video memory
1429
1430	lpDDHELCaps->dwNumFourCCCodes = MAX_FOURCC_CODES; // number of supported FOURCC codes
1431	lpDDHELCaps->dwRops[DD_ROP_SPACE]; // supported raster ops
1432	lpDDHELCaps->dwSVBCaps = DDCAPS_BLT \| // We do blitting
1433	DDCAPS_BLTCOLORFILL \| // We do colorfills
1434	DDCAPS_COLORKEY \| // We support Colorkeying
1435	DDCAPS_COLORKEYHWASSIST;
1436	lpDDHELCaps->dwSVBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
1437	lpDDHELCaps->dwSVBFXCaps; // .
1438	lpDDHELCaps->dwSVBRops[DD_ROP_SPACE]; // .
1439	lpDDHELCaps->dwVSBCaps = DDCAPS_BLT \| // We do blitting
1440	DDCAPS_BLTCOLORFILL \| // We do colorfills
1441	DDCAPS_COLORKEY \| // We support Colorkeying
1442	DDCAPS_COLORKEYHWASSIST;
1443	lpDDHELCaps->dwVSBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
1444	lpDDHELCaps->dwVSBFXCaps; // .
1445	lpDDHELCaps->dwVSBRops[DD_ROP_SPACE]; // .
1446	lpDDHELCaps->dwSSBCaps = DDCAPS_BLT \| // We do blitting
1447	DDCAPS_BLTCOLORFILL \| // We do colorfills
1448	DDCAPS_COLORKEY \| // We support Colorkeying
1449	DDCAPS_COLORKEYHWASSIST;
1450	lpDDHELCaps->dwSSBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
1451	lpDDHELCaps->dwSSBFXCaps; // .
1452	lpDDHELCaps->dwSSBRops[DD_ROP_SPACE]; // .
1453	// These are ony in >DX5
1454	if(dwSize>sizeof(DDCAPS_DX3))
1455	{
1456	lpDDHELCaps->dwSVBCaps2 = DDCAPS2_CANRENDERWINDOWED \| // Better check for Voodoo ?!
1457	DDCAPS2_COPYFOURCC \| // yepp memcpy will do this
1458	DDCAPS2_WIDESURFACES; // Any size you want!
1459	lpDDHELCaps->dwNLVBCaps = DDCAPS_BLT \| // We do blitting
1460	DDCAPS_BLTCOLORFILL \| // We do colorfills
1461	DDCAPS_COLORKEY \| // We support Colorkeying
1462	DDCAPS_COLORKEYHWASSIST;
1463	lpDDHELCaps->dwNLVBCaps2 = DDCAPS2_CANRENDERWINDOWED \| // Better check for Voodoo ?!
1464	DDCAPS2_COPYFOURCC \| // yepp memcpy will do this
1465	DDCAPS2_WIDESURFACES; // Any size you want!
1466	lpDDHELCaps->dwNLVBCKeyCaps = DDCKEYCAPS_SRCBLT; // Only source transparent blitting
1467	lpDDHELCaps->dwNLVBFXCaps; // .
1468	lpDDHELCaps->dwNLVBRops[DD_ROP_SPACE];// .
1469	}
1470
1471	}
1472
1473	return(DD_OK);
1474	}
1475	//******************************************************************************
1476	//******************************************************************************
1477	HRESULT WIN32API DrawGetDisplayMode(THIS This, LPDDSURFACEDESC lpDDSurfaceDesc)
1478	{
1479	OS2IDirectDraw me = (OS2IDirectDraw )This;
1480
1481	dprintf(("DDRAW: GetDisplayMode %x %x", This, lpDDSurfaceDesc));
1482
1483	// Check Parameter
1484	if(NULL==lpDDSurfaceDesc)
1485	return(DDERR_INVALIDPARAMS);
1486
1487	if(sizeof(DDSURFACEDESC)!=lpDDSurfaceDesc->dwSize)
1488	return(DDERR_INVALIDPARAMS);
1489
1490	// We report back the DIVE caps. maybe we should set up a local DDSURFACEDESC
1491	// for the object so we can change the values when we switch modes (or say so)
1492	// as a program may use this function to check the values after a mode change
1493	// An other reason to to so is Voodoo supports maybe more functions
1494
1495	// Tell what we report
1496	lpDDSurfaceDesc->dwFlags = DDSD_HEIGHT \| DDSD_WIDTH \| DDSD_PIXELFORMAT;
1497	lpDDSurfaceDesc->dwHeight = me->dCaps.ulHorizontalResolution;
1498	lpDDSurfaceDesc->dwWidth = me->dCaps.ulVerticalResolution;
1499	// Set the PixelFormat
1500	lpDDSurfaceDesc->ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
1501
1502	lpDDSurfaceDesc->ddpfPixelFormat.dwFourCC = me->dCaps.fccColorEncoding;
1503	lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount = me->dCaps.ulDepth;
1504	lpDDSurfaceDesc->ddpfPixelFormat.dwRGBAlphaBitMask = 0; // No Alpha support
1505	switch(me->dCaps.ulDepth)
1506	{
1507	case 4:
1508	// Assume that no one will run OS/2 PM with less then 16 colors and try
1509	// to start a DirectX program ;)
1510	lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB \| DDPF_PALETTEINDEXED4;
1511	lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0;
1512	lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0;
1513	lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0;
1514	break;
1515	case 8:
1516	lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB \| DDPF_PALETTEINDEXED8 \|
1517	DDPF_FOURCC;
1518	lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0;
1519	lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0;
1520	lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0;
1521	break;
1522	case 15:
1523	case 16:
1524	lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount = 16; // No sure about 15Bit modes
1525	lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB \| DDPF_FOURCC;
1526	if (FOURCC_R555 == me->dCaps.fccColorEncoding)
1527	{
1528	lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x00007C00;
1529	lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x000003E0;
1530	lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x0000001F;
1531	}
1532	else
1533	{
1534	if(FOURCC_R565 == me->dCaps.fccColorEncoding)
1535	{
1536	lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x0000F800;
1537	lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x000007E0;
1538	lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x0000001F;
1539	}
1540	else
1541	{
1542	// R664
1543	lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x0000F800;
1544	lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x000003F0;
1545	lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x0000000F;
1546	}
1547	}
1548	break;
1549	case 24:
1550	lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB \| DDPF_FOURCC;
1551	if(FOURCC_RGB3 == me->dCaps.fccColorEncoding)
1552	{
1553	lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x00FF0000;
1554	lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
1555	lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x000000FF;
1556	}
1557	else
1558	{
1559	// BGR3
1560	lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x000000FF;
1561	lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
1562	lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x00FF0000;
1563	}
1564	break;
1565	case 32:
1566	lpDDSurfaceDesc->ddpfPixelFormat.dwFlags = DDPF_RGB \| DDPF_FOURCC;
1567	if(FOURCC_RGB4 == me->dCaps.fccColorEncoding)
1568	{
1569	lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x00FF0000;
1570	lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
1571	lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x000000FF;
1572	}
1573	else
1574	{
1575	// BGR4
1576	lpDDSurfaceDesc->ddpfPixelFormat.dwRBitMask = 0x000000FF;
1577	lpDDSurfaceDesc->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
1578	lpDDSurfaceDesc->ddpfPixelFormat.dwBBitMask = 0x00FF0000;
1579	}
1580	break;
1581	default:
1582	dprintf(("DDRAW: Unsupported mode\n"));
1583	return(DDERR_UNSUPPORTEDMODE);
1584	}
1585
1586	return(DD_OK);
1587	}
1588	//******************************************************************************
1589	//******************************************************************************
1590	HRESULT WIN32API DrawGetDisplayMode4(THIS This, LPDDSURFACEDESC2 lpDDSurfaceDesc2)
1591	{
1592	OS2IDirectDraw me = (OS2IDirectDraw )This;
1593
1594	dprintf(("DDRAW: GetDisplayMode4 %x %x", This, lpDDSurfaceDesc2));
1595
1596	// Check Parameter
1597	if(NULL==lpDDSurfaceDesc2)
1598	return(DDERR_INVALIDPARAMS);
1599
1600	if(sizeof(DDSURFACEDESC)!=lpDDSurfaceDesc2->dwSize)
1601	return(DDERR_INVALIDPARAMS);
1602
1603	// We report back the DIVE caps. maybe we should set up a local DDSURFACEDESC
1604	// for the object so we can change the values when we switch modes (or say so)
1605	// as a program may use this function to check the values after a mode change
1606	// An other reason to to so is Voodoo supports maybe more functions
1607
1608	// Tell what we report
1609	lpDDSurfaceDesc2->dwFlags = DDSD_HEIGHT \| DDSD_WIDTH \| DDSD_PIXELFORMAT;
1610	lpDDSurfaceDesc2->dwHeight = me->dCaps.ulHorizontalResolution;
1611	lpDDSurfaceDesc2->dwWidth = me->dCaps.ulVerticalResolution;
1612	// Set the PixelFormat
1613	lpDDSurfaceDesc2->ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
1614
1615	lpDDSurfaceDesc2->ddpfPixelFormat.dwFourCC = me->dCaps.fccColorEncoding;
1616	lpDDSurfaceDesc2->ddpfPixelFormat.dwRGBBitCount = me->dCaps.ulDepth;
1617	lpDDSurfaceDesc2->ddpfPixelFormat.dwRGBAlphaBitMask = 0; // No Alpha support
1618	switch(me->dCaps.ulDepth)
1619	{
1620	case 4:
1621	// Assume that no one will run OS/2 PM with less then 16 colors and try
1622	// to start a DirectX program ;)
1623	lpDDSurfaceDesc2->ddpfPixelFormat.dwFlags = DDPF_RGB \| DDPF_PALETTEINDEXED4;
1624	lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0;
1625	lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0;
1626	lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0;
1627	break;
1628	case 8:
1629	lpDDSurfaceDesc2->ddpfPixelFormat.dwFlags = DDPF_RGB \| DDPF_PALETTEINDEXED8 \|
1630	DDPF_FOURCC;
1631	lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0;
1632	lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0;
1633	lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0;
1634	break;
1635	case 15:
1636	case 16:
1637	lpDDSurfaceDesc2->ddpfPixelFormat.dwRGBBitCount = 16; // No sure about 15Bit modes
1638	lpDDSurfaceDesc2->ddpfPixelFormat.dwFlags = DDPF_RGB \| DDPF_FOURCC;
1639	if (FOURCC_R555 == me->dCaps.ulDepth)
1640	{
1641	lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x00007C00;
1642	lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x000003E0;
1643	lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x0000001F;
1644	}
1645	else
1646	{
1647	if(FOURCC_R565 == me->dCaps.fccColorEncoding)
1648	{
1649	lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x0000F800;
1650	lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x000007E0;
1651	lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x0000001F;
1652	}
1653	else
1654	{
1655	// R664
1656	lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x0000F800;
1657	lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x000003F0;
1658	lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x0000000F;
1659	}
1660	}
1661	break;
1662	case 24:
1663	lpDDSurfaceDesc2->ddpfPixelFormat.dwFlags = DDPF_RGB \| DDPF_FOURCC;
1664	if(FOURCC_RGB3 == me->dCaps.fccColorEncoding)
1665	{
1666	lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x00FF0000;
1667	lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
1668	lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x000000FF;
1669	}
1670	else
1671	{
1672	// BGR3
1673	lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x000000FF;
1674	lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
1675	lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x00FF0000;
1676	}
1677	break;
1678	case 32:
1679	lpDDSurfaceDesc2->ddpfPixelFormat.dwFlags = DDPF_RGB \| DDPF_FOURCC;
1680	if(FOURCC_RGB4 == me->dCaps.fccColorEncoding)
1681	{
1682	lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x00FF0000;
1683	lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
1684	lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x000000FF;
1685	}
1686	else
1687	{
1688	// BGR4
1689	lpDDSurfaceDesc2->ddpfPixelFormat.dwRBitMask = 0x000000FF;
1690	lpDDSurfaceDesc2->ddpfPixelFormat.dwGBitMask = 0x0000FF00;
1691	lpDDSurfaceDesc2->ddpfPixelFormat.dwBBitMask = 0x00FF0000;
1692	}
1693	break;
1694	default:
1695	dprintf(("DDRAW: Unsupported mode\n"));
1696	return(DDERR_UNSUPPORTEDMODE);
1697	}
1698
1699	return(DD_OK);
1700	}
1701	//******************************************************************************
1702	//******************************************************************************
1703	HRESULT WIN32API DrawGetFourCCCodes(THIS This, LPDWORD lpNumCodes, LPDWORD lpCodes)
1704	{
1705	DWORD dwFCC[MAX_FOURCC_CODES] = {FOURCC_LUT8,FOURCC_R565,FOURCC_R555,FOURCC_RGB3};
1706
1707	dprintf(("DDRAW: GetFourCCCodes %x %x %x", This, lpNumCodes, lpCodes));
1708
1709	if(NULL==lpNumCodes)
1710	return(DDERR_INVALIDPARAMS);
1711
1712	if(NULL==lpCodes)
1713	{
1714	#ifdef SUPPORT_ALL_DIVE_FOURCCS
1715	*lpNumCodes = nrOfDiveFourCCs;
1716	#else
1717	*lpNumCodes = MAX_FOURCC_CODES; // LUT8, R565, RGB3 are the FourCC we support for now
1718	#endif
1719	}
1720	else
1721	{
1722	#ifdef SUPPORT_ALL_DIVE_FOURCCS
1723	for(int i=0;(i<nrOfDiveFourCCs)&&(i<*lpNumCodes);i++)
1724	{
1725	*lpCodes = DiveFOURCCs[i];
1726	lpCodes++;
1727	}
1728	*lpNumCodes = nrOfDiveFourCCs;
1729	#else
1730	for(int i=0;(i<MAX_FOURCC_CODES)&&(i<*lpNumCodes);i++)
1731	{
1732	*lpCodes = dwFCC[i];
1733	lpCodes++;
1734	}
1735	*lpNumCodes = MAX_FOURCC_CODES;
1736	#endif
1737	}
1738	return(DD_OK);
1739	}
1740	//******************************************************************************
1741	//******************************************************************************
1742	HRESULT WIN32API DrawGetGDISurface(THIS, LPDIRECTDRAWSURFACE FAR *)
1743	{
1744	dprintf(("DDRAW: GetGDISurface NYI\n"));
1745
1746	return(DD_OK);
1747	}
1748	//******************************************************************************
1749	//******************************************************************************
1750	HRESULT WIN32API DrawGetGDISurface4(THIS, LPDIRECTDRAWSURFACE4 FAR *)
1751	{
1752	dprintf(("DDRAW: GetGDISurface NYI\n"));
1753
1754	return(DD_OK);
1755	}
1756	//******************************************************************************
1757	//******************************************************************************
1758	HRESULT WIN32API DrawGetMonitorFrequency(THIS This, LPDWORD lpdwFreq)
1759	{
1760	ULONG ulTime1, ulTime2;
1761	DWORD dwFlags = DDWAITVB_BLOCKBEGIN;
1762	dprintf(("DDRAW: GetMonitorFrequency\n"));
1763	if(NULL==lpdwFreq)
1764	return(DDERR_INVALIDPARAMS);
1765
1766
1767
1768	if(DD_OK==DrawWaitForVerticalBlank(This, dwFlags, 0))
1769	{
1770	ulTime1 = GetTickCount();
1771	// Timer has an accuracy of 4 ms so call it al least 4 times
1772	DrawWaitForVerticalBlank(This, dwFlags, 0);
1773	DrawWaitForVerticalBlank(This, dwFlags, 0);
1774	DrawWaitForVerticalBlank(This, dwFlags, 0);
1775	DrawWaitForVerticalBlank(This, dwFlags, 0);
1776	ulTime2 = GetTickCount();
1777	ulTime2 -= ulTime1;
1778	if(ulTime2) // paranoid check to avoid DIV0
1779	*lpdwFreq = 4000 / ulTime2;
1780	else
1781	*lpdwFreq = 70;
1782	}
1783	else
1784	{
1785	// Assume 70 Hz maybe better return DDERR_UNSUPPORTED if this function isn't mandatory
1786	*lpdwFreq = 70;
1787	}
1788
1789
1790
1791	return(DD_OK);
1792	}
1793	//******************************************************************************
1794	//******************************************************************************
1795	HRESULT WIN32API DrawGetScanLine(THIS, LPDWORD lpdwLine)
1796	{
1797	// BOOL bVertBlank;
1798	dprintf(("DDRAW: GetScanLine\n"));
1799	// ToDO find a way to get this position, so for now simply return DDERR_UNSUPPORTED
1800	// as we indicated in DDCAPS we don't support this.
1801
1802	return(DDERR_UNSUPPORTED);
1803
1804	//the following code could be used if we implement this
1805	/*
1806	if(NULL==lpdwLine)
1807	return(DDERR_INVALIDPARAMS);
1808	DrawGetVertcalBlackStatus(This,&bVertBlank);
1809	if(bVertBlank)
1810	return (DDERR_VERTICALBLANKINPROGRESS);
1811	*lpdwLine = GetLine(); // GetLine would be the function which gets us the line
1812	return(DD_OK);
1813	*/
1814	}
1815	//******************************************************************************
1816	//******************************************************************************
1817	HRESULT WIN32API DrawGetVerticalBlankStatus(THIS , LPBOOL lpbIsInVB)
1818	{
1819	// int rc;
1820	dprintf(("DDRAW: GetVerticalBlankStatus\n"));
1821	if(NULL==lpbIsInVB)
1822	return(DDERR_INVALIDPARAMS);
1823
1824	#if 0
1825	rc = io_init1();
1826
1827
1828	if(0==rc) // try to get IOPL for the thread
1829	{
1830	*lpbIsInVB = (c_inb1(0x3da)&0x08)!=0;
1831
1832	io_exit1(); // reset IOPL
1833
1834	return(DD_OK);
1835	}
1836	#else
1837	lpbIsInVB = ! (lpbIsInVB);
1838	#endif
1839	return(DDERR_UNSUPPORTED);
1840	}
1841	//******************************************************************************
1842	//******************************************************************************
1843	HRESULT WIN32API DrawInitialize(THIS, GUID FAR *)
1844	{
1845	dprintf(("DDRAW: Initialize\n"));
1846
1847	return(DD_OK);
1848	}
1849	//******************************************************************************
1850	//******************************************************************************
1851	HRESULT WIN32API DrawRestoreDisplayMode(THIS This)
1852	{
1853	OS2IDirectDraw me = (OS2IDirectDraw )This;
1854
1855	dprintf(("DDRAW: RestoreDisplayMode"));
1856
1857	// FSDDRAW additions
1858	ULONG ulModeInd;
1859	/* restore previous screen mode */
1860	if ((bUseFSDD) && (me->bInFullScreen))
1861	{
1862	SetSVGAMode(me->oldwidth, me->oldheight, me->oldbpp, 0xFF, &ulModeInd, NULL);
1863	RestorePM();
1864	/* restore DIVE caps entries */
1865	me->dCaps.ulScanLineBytes = me->oldscanlines;
1866	me->dCaps.ulHorizontalResolution = me->oldwidth;
1867	me->dCaps.ulVerticalResolution = me->oldheight;
1868	me->dCaps.ulDepth = me->oldbpp;
1869	}
1870
1871	return(DD_OK);
1872	}
1873	//******************************************************************************
1874	//******************************************************************************
1875	HRESULT WIN32API DrawSetCooperativeLevel(THIS This, HWND hwndClient, DWORD dwFlags)
1876	{
1877	OS2IDirectDraw me = (OS2IDirectDraw )This;
1878
1879	dprintf(("DDRAW: SetCooperativeLevel: hwnd %X, Flags %X\n", hwndClient, dwFlags));
1880
1881	if (!(dwFlags & (DDSCL_EXCLUSIVE\|DDSCL_NORMAL)))
1882	return DDERR_INVALIDPARAMS;
1883
1884	me->dwCoopMode = dwFlags;
1885
1886	if(dwFlags & DDSCL_NORMAL) {
1887	//normal mode, no window required
1888	if(dwFlags & DDSCL_FULLSCREEN) return DDERR_INVALIDPARAMS;
1889	}
1890	else {
1891	//fullscreen mode, window required
1892	if(!hwndClient) return DDERR_INVALIDPARAMS;
1893	if(!(dwFlags & DDSCL_FULLSCREEN)) return DDERR_INVALIDPARAMS;
1894	}
1895	me->hwndClient = hwndClient;
1896	if(hwndClient && (dwFlags & DDSCL_FULLSCREEN)) {
1897	//Changing the size of the win32 window in SetCooperativeLevel can
1898	//fail if this happens during WM_ADJUSTWINDOWPOS
1899	//NOTE: This is not a good solution, but a proper fix is more difficult
1900	// with the current window mess
1901	OSLibPostMessage(Win32ToOS2Handle(me->hwndClient), WIN32APP_DDRAWFULLSCREEN, me->screenwidth, me->screenheight);
1902	// SetWindowPos(me->hwndClient, HWND_TOP, 0, 0, me->screenwidth, me->screenheight,0);
1903	// ShowWindow(hwndClient, SW_SHOW);
1904	}
1905	return(DD_OK);
1906	}
1907	//******************************************************************************
1908	//******************************************************************************
1909	HRESULT WIN32API DrawSetDisplayMode2(THIS This, DWORD dwWidth, DWORD dwHeight,
1910	DWORD dwBPP, DWORD dwRefreshRate,
1911	DWORD dwFlags)
1912	{
1913	ULONG rc;
1914	OS2IDirectDraw me = (OS2IDirectDraw )This;
1915	SETUP_BLITTER sBlt;
1916
1917	dprintf(("DDRAW: SetDisplayMode2 to %dx%d with %d bits colors\n", dwWidth, dwHeight, dwBPP));
1918
1919	me->screenwidth = dwWidth;
1920	me->screenheight = dwHeight;
1921	me->screenbpp = dwBPP;
1922
1923	if(me->dwCoopMode & DDSCL_FULLSCREEN)
1924	{
1925	// FSDDRAW additions
1926	ULONG ulModeInd;
1927
1928	SetWindowPos(me->hwndClient, HWND_TOP,0,0,dwWidth,dwHeight,0);
1929	SetCursorPos(dwWidth / 2, dwHeight / 2);
1930
1931	if ((bUseFSDD) && (ModeInSVGAModeTable(dwWidth,dwHeight,dwBPP)))
1932	{
1933	KillPM();
1934
1935	rc = SetSVGAMode(dwWidth, dwHeight, dwBPP, 0xFF, &ulModeInd, NULL);
1936
1937	if (!rc) // When mode switched successfully
1938	{
1939	/* save old screen values */
1940	me->bInFullScreen=TRUE;
1941	me->oldwidth = me->dCaps.ulHorizontalResolution;
1942	me->oldheight = me->dCaps.ulVerticalResolution;
1943	me->oldscanlines = me->dCaps.ulScanLineBytes;
1944	me->oldbpp = me->dCaps.ulDepth;
1945
1946	/* now 'fix' some DIVE caps entries */
1947	me->dCaps.ulScanLineBytes = dwWidth * (dwBPP >> 3); /* FIX: use real value */
1948	me->dCaps.ulHorizontalResolution = dwWidth;
1949	me->dCaps.ulVerticalResolution = dwHeight;
1950	me->dCaps.ulDepth = dwBPP;
1951	}
1952	else
1953	// Display must be return to PM Session
1954	RestorePM();
1955	}
1956	}
1957
1958	memset(&sBlt,0,sizeof(sBlt));
1959	sBlt.ulStructLen = sizeof(sBlt);
1960	sBlt.fccSrcColorFormat = FOURCC_SCRN;
1961	sBlt.ulSrcWidth = dwWidth;
1962	sBlt.ulSrcHeight = dwHeight;
1963	sBlt.ulSrcPosX = 0;
1964	sBlt.ulSrcPosY = 0;
1965	sBlt.fccDstColorFormat = FOURCC_SCRN;
1966	sBlt.ulDstWidth = dwWidth;
1967	sBlt.ulDstHeight = dwHeight;
1968	sBlt.lDstPosX = 0;
1969	sBlt.lDstPosY = 0;
1970	sBlt.lScreenPosX = 0;
1971	sBlt.lScreenPosY = me->dCaps.ulVerticalResolution-dwHeight;
1972	sBlt.ulNumDstRects = DIVE_FULLY_VISIBLE;
1973
1974	rc = DiveSetupBlitter( me->hDive,
1975	&sBlt);
1976	dprintf((" DiveSetupBlitter rc=%d",rc));
1977
1978	return(DD_OK);
1979	}
1980	//******************************************************************************
1981	//******************************************************************************
1982	HRESULT WIN32API DrawSetDisplayMode(THIS This, DWORD dwWidth, DWORD dwHeight,
1983	DWORD dwBPP)
1984	{
1985	return DrawSetDisplayMode2(This, dwWidth, dwHeight, dwBPP, 70, 0);
1986	}
1987	//******************************************************************************
1988	//******************************************************************************
1989	HRESULT WIN32API DrawWaitForVerticalBlank(THIS, DWORD dwFlags, HANDLE hEvent)
1990	{
1991	// HRESULT rc;
1992	// int rci;
1993	// USHORT sel;
1994	dprintf(("DDRAW: WaitForVerticalBlank\n"));
1995
1996	if(DDWAITVB_BLOCKBEGINEVENT == dwFlags) // This parameter isn't support in DX
1997	return (DDERR_UNSUPPORTED);
1998
1999	return DD_OK;
2000
2001	#if 0
2002	rci = InitIO();
2003
2004	if(rci) // try to get IOPL for the thread
2005	{
2006	dprintf(("DDRAW: No IOPL\n"));
2007	return (DDERR_UNSUPPORTED); // we failed so return error that we don't support this
2008	}
2009	// AT this point we should have IOPL so lets use it!
2010	dprintf(("DDRAW: IOPL 3!\n"));
2011
2012	rc = DDERR_INVALIDPARAMS; // set returnvalue to fail
2013
2014	if(DDWAITVB_BLOCKBEGIN == dwFlags)
2015	{
2016	dprintf(("DDRAW: BLOCKBEGIN\n"));
2017
2018	while ((c_inb1(0x3da)&0x08)!=0); // Wait for end of vert. retrace if one is running
2019	while ((c_inb1(0x3da)&0x08)==0); // Wait for new start of retrace
2020	rc = DD_OK;
2021	}
2022
2023	if(DDWAITVB_BLOCKEND == dwFlags)
2024	{
2025	dprintf(("DDRAW: BLOCKEND\n"));
2026	rc = DD_OK;
2027	if((c_inb1(0x3da)&0x08)!=0) // Are we in a vert. retrace
2028	{
2029	while ((c_inb1(0x3da)&0x08)!=0); // Wait for end of retrace
2030	}
2031	else
2032	{
2033	while ((c_inb1(0x3da)&0x08)==0); // Wait for new start of retrace
2034	while ((c_inb1(0x3da)&0x08)!=0); // Wait for end of vert. retrace
2035	}
2036
2037	}
2038
2039
2040	// io_exit1();
2041
2042
2043	return (rc);
2044	#endif
2045	}
2046
2047	//******************************************************************************
2048	//* Added in the v2 interface *
2049	//******************************************************************************
2050	HRESULT WIN32API DrawGetAvailableVidMem(THIS, LPDDSCAPS lpDDSCaps,
2051	LPDWORD lpdwTotal, LPDWORD lpdwFree)
2052	{
2053	dprintf(("DDRAW: GetAvailableVidMem\n"));
2054
2055	// Check parameters
2056	if(NULL==lpDDSCaps)
2057	return(DDERR_INVALIDPARAMS);
2058
2059	if((NULL==lpdwTotal)&&(NULL==lpdwFree))
2060	return(DDERR_INVALIDPARAMS);
2061
2062	if(NULL!=lpdwTotal)
2063	lpdwTotal = 2048 1024;
2064
2065	if(NULL!=lpdwFree)
2066	lpdwFree = 2048 1024;
2067
2068	return(DD_OK);
2069	}
2070	//******************************************************************************
2071	//
2072	//******************************************************************************
2073	HRESULT WIN32API DrawGetAvailableVidMem4(THIS, LPDDSCAPS2 lpDDSCaps2,
2074	LPDWORD lpdwTotal, LPDWORD lpdwFree)
2075	{
2076	dprintf(("DDRAW: GetAvailableVidMem\n"));
2077
2078	// Check parameters
2079	if(NULL==lpDDSCaps2)
2080	return(DDERR_INVALIDPARAMS);
2081
2082	if((NULL==lpdwTotal)&&(NULL==lpdwFree))
2083	return(DDERR_INVALIDPARAMS);
2084
2085	if(NULL!=lpdwTotal)
2086	lpdwTotal = 2048 1024;
2087
2088	if(NULL!=lpdwFree)
2089	lpdwFree = 2048 1024;
2090
2091	return(DD_OK);
2092	}
2093	//******************************************************************************
2094	//* Added in the v4 interface *
2095	//******************************************************************************
2096	HRESULT WIN32API DrawGetSurfaceFromDC(THIS, HDC hdc, LPDIRECTDRAWSURFACE4 *)
2097	{
2098	dprintf(("DDRAW: GetSurfaceFromDC NYI\n"));
2099
2100	return(DD_OK);
2101	}
2102	//******************************************************************************
2103	//******************************************************************************
2104	HRESULT WIN32API DrawRestoreAllSurfaces(THIS)
2105	{
2106	dprintf(("DDRAW: RestoreAllSurfaces\n"));
2107
2108	return(DD_OK);
2109	}
2110	//******************************************************************************
2111	//******************************************************************************
2112	HRESULT WIN32API DrawTestCooperativeLevel(THIS)
2113	{
2114	dprintf(("DDRAW: TestCooperativeLevel\n"));
2115
2116	return(DD_OK);
2117	}
2118	//******************************************************************************
2119	//******************************************************************************
2120	HRESULT WIN32API DrawGetDeviceIdentifier( THIS, LPDDDEVICEIDENTIFIER lpdddi,
2121	DWORD dwFlags)
2122	{
2123	dprintf(("DDRAW: GetDeviceIdentifier Flags = %d\n",dwFlags));
2124	if(NULL==lpdddi)
2125	return DDERR_INVALIDPARAMS;
2126
2127
2128
2129	memset( lpdddi,
2130	0,
2131	sizeof(DDDEVICEIDENTIFIER));
2132	// ToDo: Cretae a GUID and put some better data inside
2133	strcpy( lpdddi->szDriver,
2134	"OS/2 DIVE Driver");
2135	strcpy( lpdddi->szDescription,
2136	"ODIN DD Emulation Driver");
2137
2138
2139
2140	return(DD_OK);
2141	}
2142	//******************************************************************************
2143	//******************************************************************************
2144	VOID OS2IDirectDraw::SwitchDisplay(HWND hwnd)
2145	{
2146	DWORD dwVType, dwVSize;
2147	HKEY hkDirectDraw2;
2148
2149
2150
2151	if (bScale)
2152	{
2153	if (ERROR_SUCCESS==RegOpenKeyA(HKEY_LOCAL_MACHINE,KEY_DIRECT2DRAW,&hkDirectDraw2))
2154	{
2155	dwVSize = 4;
2156	dwVType = REG_DWORD;
2157	if (ERROR_SUCCESS!=RegQueryValueExA( hkDirectDraw2, "Fullscreen", NULL, &dwVType,
2158	(LPBYTE)&bScale, &dwVSize))
2159	bScale = FALSE;
2160	}
2161	else
2162	bScale = FALSE;
2163	}
2164
2165
2166	}
2167	//******************************************************************************
2168	//******************************************************************************
2169

Note: See TracBrowser for help on using the repository browser.

Download in other formats: