Context Navigation

OS2DDRAW.CPP@ 6499

Visit:

Last change on this file since 6499 was 6030, checked in by sandervl, 24 years ago
Partly implemented DrawEnumDisplayModes4
File size: 75.8 KB

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

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

Download in other formats:

Original Format