Context Navigation

OS2DDRAW.CPP@ 6804

Visit:

Last change on this file since 6804 was 6804, checked in by sandervl, 24 years ago
set primary surface screen caps to that of PM desktop instead of 640x480x8bpp
File size: 76.2 KB

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

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

Download in other formats:

Original Format