Context Navigation

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

Visit:

Last change on this file since 9526 was 9464, checked in by sandervl, 23 years ago
only resize window when going into fullscreen
File size: 77.8 KB

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

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

Download in other formats: