Context Navigation

OS2DDRAW.CPP@ 9156

Visit:

Last change on this file since 9156 was 9156, checked in by sandervl, 23 years ago
PF: Added custom function to hide mouse cursor when the primary surface (screen) is locked by the app to prevent display corruption with color/animated mouse pointers
File size: 77.4 KB

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

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

Download in other formats:

Original Format