source: trunk/src/gdi32/devcontext.cpp

Last change on this file was 22062, checked in by dmik, 13 years ago

gdi32: Fix crash in ResetDCW() caused by accessing invalid memory.

The implementation made in r21998 contained bug: it would not copy
driver specific data into an OEM version of the structure which would cause
WGSS to access unallocated memory.
File size: 20.0 KB
RevLine 
[10469]1/* $Id: devcontext.cpp,v 1.3 2004-02-18 14:05:48 sandervl Exp $ */
[10373]2
3/*
4 * GDI32 device context apis
5 *
6 * Copyright 1998 Sander van Leeuwen (sandervl@xs4all.nl)
7 * Copyright 1998 Patrick Haller
8 * Copyright 2003 Innotek Systemberatung GmbH (sandervl@innotek.de)
9 *
10 * Project Odin Software License can be found in LICENSE.TXT
11 *
12 */
13#include <os2win.h>
14#include <stdlib.h>
15#include <stdarg.h>
16#include <string.h>
17#include <odinwrap.h>
18#include <misc.h>
19#include "callback.h"
20#include "unicode.h"
21#include "dibsect.h"
22#include <codepage.h>
23#include "oslibgpi.h"
24#include "oslibgdi.h"
25#include <dcdata.h>
26#include <winuser32.h>
27#include "font.h"
28#include <stats.h>
29#include <objhandle.h>
30#include <winspool.h>
31#include "region.h"
32#include <wingdi32.h>
33
34#define DBG_LOCALLOG DBG_devcontext
35#include "dbglocal.h"
36
37typedef BOOL (* WIN32API PFN_SPLQUERYPMQUEUENAME)(LPSTR pDeviceName, LPSTR lpszPMQueue, INT cbPMQueue);
38
39#ifdef DEBUG
40void dprintfDEVMODE(DEVMODEA *lpInitData);
41#else
42#define dprintfDEVMODE(a)
43#endif
44
45static const char *szDisplay = "DISPLAY";
46
47//******************************************************************************
48// GetPMQueueName
49//
50// Get the PM printer queue name associated with the printer name
51//
52// NOTE: We can't have a hardcoded dependency on WINSPOOL in GDI32, so get the
53// function address dynamically
54//
55//******************************************************************************
[21630]56BOOL WIN32API GetPMQueueName(LPSTR pDeviceName, LPSTR lpszPMQueue, INT cbPMQueue)
[10373]57{
[21304]58 static HINSTANCE hInstance = 0;
59 static PFN_SPLQUERYPMQUEUENAME pfnSplQueryPMQueueName = NULL;
60
61 if(hInstance == 0) hInstance = LoadLibraryA("WINSPOOL.DRV");
62
63 if(hInstance) {
64 pfnSplQueryPMQueueName = (PFN_SPLQUERYPMQUEUENAME)GetProcAddress(hInstance, "SplQueryPMQueueName");
65 if(pfnSplQueryPMQueueName) {
66 return pfnSplQueryPMQueueName(pDeviceName, lpszPMQueue, cbPMQueue);
67 }
68 }
69 DebugInt3();
[10373]70 return FALSE;
71}
72//******************************************************************************
73//******************************************************************************
74HDC WIN32API CreateDCA(LPCSTR lpszDriver, LPCSTR lpszDevice, LPCSTR lpszOutput, const DEVMODEA *lpInitData)
75{
76 HDC hdc;
77 char szDevice[256];
78
79 // 2001-05-28 PH
80 // Ziff Davis Benchmarks come in here with "display".
81 // Obviously, Windows does accept case-insensitive driver names,
82 // whereas Open32 doesn't.
83 if(lpszDriver && !stricmp(lpszDriver, szDisplay)) {
84 lpszDriver = szDisplay;
85 }
86 else
87 { //Check if it's a printer device
[21630]88 if(GetPMQueueName((LPSTR)lpszDevice, szDevice, sizeof(szDevice)) == TRUE)
[10373]89 {
90 dprintf(("Rename printer %s to PM Queue %s", lpszDevice, szDevice));
91 lpszDevice = szDevice;
[10469]92
[10373]93 //Must ignore port name here or else the wrong queue might be used
[10469]94 //(unless we are told to print to file)
95 if (lpszOutput && strcmp(lpszOutput, "FILE:") != 0 && strcmp(lpszOutput, "FILE") != 0)
96 lpszOutput = NULL;
[10373]97 }
98 }
99
100 //SvL: Open32 tests lpszDriver for NULL even though it's ignored
101 if(lpszDriver == NULL) {
102 lpszDriver = lpszDevice;
103 }
104
105 if(lpInitData) {
106 dprintfDEVMODE((DEVMODEA *)lpInitData);
107 }
108
109 hdc = O32_CreateDC(lpszDriver, lpszDevice, lpszOutput, lpInitData);
110 if(hdc) {
111 OSLibGpiSetCp(hdc, GetDisplayCodepage());
112 STATS_CreateDCA(hdc, lpszDriver, lpszDevice, lpszOutput, lpInitData);
113 }
114
115 dprintf(("GDI32: CreateDCA %s %s %s %x returned %x", lpszDriver, lpszDevice, lpszOutput, lpInitData, hdc));
116 return hdc;
117}
118//******************************************************************************
119//******************************************************************************
120HDC WIN32API CreateDCW( LPCWSTR arg1, LPCWSTR arg2, LPCWSTR arg3, const DEVMODEW * arg4)
121{
122 char *astring4, *astring5;
123
124 char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
125 char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
126 char *astring3 = UnicodeToAsciiString((LPWSTR)arg3);
127
128 if(arg4)
129 {
130 astring4 = UnicodeToAsciiString((LPWSTR)(arg4->dmDeviceName));
131 astring5 = UnicodeToAsciiString((LPWSTR)(arg4->dmFormName));
132 }
133
134 HDC rc;
135 DEVMODEA devmode;
136
137 if(arg4)
138 {
139 strcpy((char*)devmode.dmDeviceName, astring4);
140 strcpy((char*)devmode.dmFormName, astring5);
141
142 devmode.dmSpecVersion = arg4->dmSpecVersion;
143 devmode.dmDriverVersion = arg4->dmDriverVersion;
144 devmode.dmSize = arg4->dmSize;
145 devmode.dmDriverExtra = arg4->dmDriverExtra;
146 devmode.dmFields = arg4->dmFields;
[21916]147#if defined (__GNUC__) || (__IBMCPP__ == 360)
[10373]148 devmode.dmOrientation = arg4->dmOrientation;
149 devmode.dmPaperSize = arg4->dmPaperSize;
150 devmode.dmPaperLength = arg4->dmPaperLength;
[21630]151 devmode.dmPaperWidth = arg4->dmPaperWidth;
[10373]152#else
153 devmode.s1.dmOrientation = arg4->s1.dmOrientation;
154 devmode.s1.dmPaperSize = arg4->s1.dmPaperSize;
155 devmode.s1.dmPaperLength = arg4->s1.dmPaperLength;
[21630]156 devmode.s1.dmPaperWidth = arg4->s1.dmPaperWidth;
[10373]157#endif
158 devmode.dmScale = arg4->dmScale;
159 devmode.dmCopies = arg4->dmCopies;
160 devmode.dmDefaultSource = arg4->dmDefaultSource;
161 devmode.dmPrintQuality = arg4->dmPrintQuality;
162 devmode.dmColor = arg4->dmColor;
163 devmode.dmDuplex = arg4->dmDuplex;
164 devmode.dmYResolution = arg4->dmYResolution;
165 devmode.dmTTOption = arg4->dmTTOption;
166 devmode.dmCollate = arg4->dmCollate;
167 devmode.dmLogPixels = arg4->dmLogPixels;
168 devmode.dmBitsPerPel = arg4->dmBitsPerPel;
169 devmode.dmPelsWidth = arg4->dmPelsWidth;
170 devmode.dmPelsHeight = arg4->dmPelsHeight;
171 devmode.dmDisplayFlags = arg4->dmDisplayFlags;
172 devmode.dmDisplayFrequency = arg4->dmDisplayFrequency;
173 devmode.dmICMMethod = arg4->dmICMMethod;
174 devmode.dmICMIntent = arg4->dmICMIntent;
175 devmode.dmMediaType = arg4->dmMediaType;
176 devmode.dmDitherType = arg4->dmDitherType;
177 devmode.dmReserved1 = arg4->dmReserved1;
178 devmode.dmReserved2 = arg4->dmReserved2;
179 rc = CreateDCA(astring1,astring2,astring3,&devmode);
180 }
181 else
182 rc = CreateDCA(astring1,astring2,astring3, NULL);
183
184 FreeAsciiString(astring1);
185 FreeAsciiString(astring2);
186 FreeAsciiString(astring3);
187
188 if(arg4)
189 {
190 FreeAsciiString(astring4);
191 FreeAsciiString(astring5);
192 }
193
194 return rc;
195}
196//******************************************************************************
197//******************************************************************************
198HDC WIN32API CreateICA(LPCSTR lpszDriver, LPCSTR lpszDevice, LPCSTR lpszOutput,
199 const DEVMODEA *lpdvmInit)
200{
201 HDC hdc;
202 char szDevice[256];
203
204 //SvL: Open32 tests for "DISPLAY"
205 if(lpszDriver && !stricmp(lpszDriver, szDisplay)) {
206 lpszDriver = szDisplay;
207 }
208 else
209 { //Check if it's a printer device
[21630]210 if(GetPMQueueName((LPSTR)lpszDevice, szDevice, sizeof(szDevice)) == TRUE)
[10373]211 {
212 dprintf(("Rename printer %s to PM Queue %s", lpszDevice, szDevice));
213 lpszDevice = szDevice;
214 //Must ignore port name here or else the wrong queue might be used
[10469]215 //(unless we are told to print to file)
216 if (lpszOutput && strcmp(lpszOutput, "FILE:") != 0 && strcmp(lpszOutput, "FILE") != 0)
217 lpszOutput = NULL;
[10373]218 }
219 }
[21630]220
[10373]221 //SvL: Open32 tests lpszDriver for NULL even though it's ignored
222 if(lpszDriver == NULL) {
223 lpszDriver = lpszDevice;
224 }
225 hdc = O32_CreateIC(lpszDriver, lpszDevice, lpszOutput, lpdvmInit);
226
227 dprintf(("GDI32: CreateICA %s %s %s %x returned %x", lpszDriver, lpszDevice, lpszOutput, lpdvmInit, hdc));
228
229 if(hdc) STATS_CreateICA(hdc, lpszDriver, lpszDevice, lpszOutput, lpdvmInit);
230 return hdc;
231}
232//******************************************************************************
233//******************************************************************************
234HDC WIN32API CreateICW( LPCWSTR arg1, LPCWSTR arg2, LPCWSTR arg3, const DEVMODEW * arg4)
235{
236 char *astring4, *astring5;
237
238 char *astring1 = UnicodeToAsciiString((LPWSTR)arg1);
239 char *astring2 = UnicodeToAsciiString((LPWSTR)arg2);
240 char *astring3 = UnicodeToAsciiString((LPWSTR)arg3);
241 if(arg4)
242 {
243 astring4 = UnicodeToAsciiString((LPWSTR)(arg4->dmDeviceName));
244 astring5 = UnicodeToAsciiString((LPWSTR)(arg4->dmFormName));
245 }
246
247 HDC rc;
248 DEVMODEA devmode;
249
250 if(arg4)
251 {
252 strcpy((char*)devmode.dmDeviceName, astring4);
253 strcpy((char*)devmode.dmFormName, astring5);
254
255 devmode.dmSpecVersion = arg4->dmSpecVersion;
256 devmode.dmDriverVersion = arg4->dmDriverVersion;
257 devmode.dmSize = arg4->dmSize;
258 devmode.dmDriverExtra = arg4->dmDriverExtra;
259 devmode.dmFields = arg4->dmFields;
[21916]260#if defined (__GNUC__) || (__IBMCPP__ == 360)
[10373]261 devmode.dmOrientation = arg4->dmOrientation;
262 devmode.dmPaperSize = arg4->dmPaperSize;
263 devmode.dmPaperLength = arg4->dmPaperLength;
[21630]264 devmode.dmPaperWidth = arg4->dmPaperWidth;
[10373]265#else
266 devmode.s1.dmOrientation = arg4->s1.dmOrientation;
267 devmode.s1.dmPaperSize = arg4->s1.dmPaperSize;
268 devmode.s1.dmPaperLength = arg4->s1.dmPaperLength;
269 devmode.s1.dmPaperWidth = arg4->s1.dmPaperWidth;
270#endif
271 devmode.dmScale = arg4->dmScale;
272 devmode.dmCopies = arg4->dmCopies;
273 devmode.dmDefaultSource = arg4->dmDefaultSource;
274 devmode.dmPrintQuality = arg4->dmPrintQuality;
275 devmode.dmColor = arg4->dmColor;
276 devmode.dmDuplex = arg4->dmDuplex;
277 devmode.dmYResolution = arg4->dmYResolution;
278 devmode.dmTTOption = arg4->dmTTOption;
279 devmode.dmCollate = arg4->dmCollate;
280 devmode.dmLogPixels = arg4->dmLogPixels;
281 devmode.dmBitsPerPel = arg4->dmBitsPerPel;
282 devmode.dmPelsWidth = arg4->dmPelsWidth;
283 devmode.dmPelsHeight = arg4->dmPelsHeight;
284 devmode.dmDisplayFlags = arg4->dmDisplayFlags;
285 devmode.dmDisplayFrequency = arg4->dmDisplayFrequency;
286 devmode.dmICMMethod = arg4->dmICMMethod;
287 devmode.dmICMIntent = arg4->dmICMIntent;
288 devmode.dmMediaType = arg4->dmMediaType;
289 devmode.dmDitherType = arg4->dmDitherType;
290 devmode.dmReserved1 = arg4->dmReserved1;
291 devmode.dmReserved2 = arg4->dmReserved2;
292
293 rc = CreateICA(astring1,astring2,astring3,&devmode);
294 }
295 else
296 rc = CreateICA(astring1,astring2,astring3, NULL);
297
298 FreeAsciiString(astring1);
299 FreeAsciiString(astring2);
300 FreeAsciiString(astring3);
301 if(arg4)
302 {
303 FreeAsciiString(astring4);
304 FreeAsciiString(astring5);
305 }
306
307 return rc;
308}
309//******************************************************************************
310//******************************************************************************
311HDC WIN32API CreateCompatibleDC( HDC hdc)
312{
313 HDC newHdc;
314
315 newHdc = O32_CreateCompatibleDC(hdc);
316 ULONG oldcp = OSLibGpiQueryCp(hdc);
317 if (!oldcp) /* If new DC is to be created */
318 oldcp = GetDisplayCodepage();
319
320 if(newHdc) STATS_CreateCompatibleDC(hdc, newHdc);
321 OSLibGpiSetCp(newHdc, oldcp);
322 //PF Open32 seems not to move coordinates to 0,0 in newHdc
323 MoveToEx(newHdc, 0, 0 , NULL);
324
325 return newHdc;
326}
327//******************************************************************************
328//******************************************************************************
329BOOL WIN32API DeleteDC(HDC hdc)
330{
331 pDCData pHps = (pDCData)OSLibGpiQueryDCData((HPS)hdc);
332 if(!pHps)
333 {
334 dprintf(("WARNING: DeleteDC %x; invalid hdc!", hdc));
335 SetLastError(ERROR_INVALID_HANDLE);
336 return 0;
337 }
338 SetLastError(ERROR_SUCCESS);
339
340 DIBSection *dsect = DIBSection::findHDC(hdc);
341 if(dsect)
342 {
343 //remove previously selected dibsection
344 dprintf(("DeleteDC %x, unselect DIB section %x", hdc, dsect->GetBitmapHandle()));
345 dsect->UnSelectDIBObject();
346 }
347
348 //Must call ReleaseDC for window dcs
349 if(pHps->hdcType == TYPE_1) {
350 return ReleaseDC(OS2ToWin32Handle(pHps->hwnd), hdc);
351 }
352
353 STATS_DeleteDC(hdc);
354 return O32_DeleteDC(hdc);
355}
356//******************************************************************************
357//******************************************************************************
358int WIN32API SaveDC( HDC hdc)
359{
360 int id;
361 pDCData pHps = (pDCData)OSLibGpiQueryDCData((HPS)hdc);
362 if(!pHps)
363 {
364 dprintf(("WARNING: SaveDC %x; invalid hdc!", hdc));
365 SetLastError(ERROR_INVALID_HANDLE);
366 return 0;
367 }
368
369 HRGN hClipRgn = 0;
370 if(pHps->hrgnWin32Clip) {
371 // Make a copy of our current clip region
[21630]372 // (the visible region remains untouched!)
[10373]373 hClipRgn = GdiCopyClipRgn(pHps);
374 }
375
376 id = O32_SaveDC(hdc);
377 if(id == 0) {
378 dprintf(("ERROR: GDI32: SaveDC %x FAILED", hdc));
379 if(hClipRgn) GdiDestroyRgn(pHps, hClipRgn);
380 return 0;
381 }
382 //overwrite the current clip region with the copy
[10442]383 dprintf2(("New win32 clip region %x", hClipRgn));
[10373]384 pHps->hrgnWin32Clip = hClipRgn;
385 return id;
386}
387//******************************************************************************
388//******************************************************************************
389BOOL WIN32API RestoreDC(HDC hdc, int id)
390{
391 BOOL ret;
392 HRGN hrgnOldClip = 0;
393
394 pDCData pHps = (pDCData)OSLibGpiQueryDCData((HPS)hdc);
395 if(!pHps)
396 {
397 dprintf(("WARNING: RestoreDC %x; invalid hdc!", hdc));
398 SetLastError(ERROR_INVALID_HANDLE);
399 return 0;
400 }
401
402 hrgnOldClip = pHps->hrgnWin32Clip;
403 ret = O32_RestoreDC(hdc, id);
404 if(ret == FALSE) {
405 dprintf(("ERROR: GDI32: RestoreDC %x %d FAILED", hdc, id));
406 }
407 else {
408 //Destroy copy of the clip region that we made in SaveDC
409 if(hrgnOldClip) GdiDestroyRgn(pHps, hrgnOldClip);
410
411 // Activate previous clip region
412 GdiCombineVisRgnClipRgn(pHps, pHps->hrgnWin32Clip, RGN_AND);
[10442]413
414 dprintf2(("New win32 clip region %x", pHps->hrgnWin32Clip));
[10373]415 }
416 return ret;
417}
418//******************************************************************************
419//******************************************************************************
420HDC WIN32API ResetDCA(HDC hdc, const DEVMODEA *lpInitData)
421{
[21630]422 if(lpInitData)
[10373]423 {
424 dprintfDEVMODE((DEVMODEA *)lpInitData);
425 }
426 HDC ret =O32_ResetDC(hdc, lpInitData);
427 return ret;
428}
429//******************************************************************************
430//******************************************************************************
431HDC WIN32API ResetDCW( HDC arg1, const DEVMODEW * arg2)
432{
[22062]433 PDEVMODEA pdevmodea = (PDEVMODEA)malloc(sizeof(DEVMODEA) + arg2->dmDriverExtra);
434 if (!pdevmodea)
435 {
436 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
437 return NULL;
438 }
[21998]439
[22062]440 pdevmodea->dmSpecVersion = arg2->dmSpecVersion;
441 pdevmodea->dmDriverVersion = arg2->dmDriverVersion;
442 pdevmodea->dmSize = sizeof(DEVMODEA);
443 pdevmodea->dmDriverExtra = arg2->dmDriverExtra;
444 pdevmodea->dmFields = arg2->dmFields;
[21998]445
[22062]446 pdevmodea->dmOrientation = arg2->dmOrientation;
447 pdevmodea->dmPaperSize = arg2->dmPaperSize;
448 pdevmodea->dmPaperLength = arg2->dmPaperLength;
449 pdevmodea->dmPaperWidth = arg2->dmPaperWidth;
450 pdevmodea->dmPosition = arg2->dmPosition;
[21998]451
[22062]452 pdevmodea->dmScale = arg2->dmScale;
453 pdevmodea->dmCopies = arg2->dmCopies;
454 pdevmodea->dmDefaultSource = arg2->dmDefaultSource;
455 pdevmodea->dmPrintQuality = arg2->dmPrintQuality;
456 pdevmodea->dmColor = arg2->dmColor;
457 pdevmodea->dmDuplex = arg2->dmDuplex;
458 pdevmodea->dmYResolution = arg2->dmYResolution;
459 pdevmodea->dmTTOption = arg2->dmTTOption;
460 pdevmodea->dmCollate = arg2->dmCollate;
[21998]461
[22062]462 pdevmodea->dmLogPixels = arg2->dmLogPixels;
463 pdevmodea->dmBitsPerPel = arg2->dmBitsPerPel;
464 pdevmodea->dmPelsWidth = arg2->dmPelsWidth;
465 pdevmodea->dmPelsHeight = arg2->dmPelsHeight;
466 pdevmodea->dmDisplayFlags = arg2->dmDisplayFlags;
467 pdevmodea->dmDisplayFrequency = arg2->dmDisplayFrequency;
468 pdevmodea->dmICMMethod = arg2->dmICMMethod;
469 pdevmodea->dmICMIntent = arg2->dmICMIntent;
470 pdevmodea->dmMediaType = arg2->dmMediaType;
471 pdevmodea->dmDitherType = arg2->dmDitherType;
472 pdevmodea->dmReserved1 = arg2->dmReserved1;
473 pdevmodea->dmReserved2 = arg2->dmReserved2;
474 pdevmodea->dmPanningWidth = arg2->dmPanningWidth;
475 pdevmodea->dmPanningHeight = arg2->dmPanningHeight;
[21998]476
[22062]477 lstrcpynWtoA(pdevmodea->dmDeviceName, arg2->dmDeviceName, CCHDEVICENAME);
478 lstrcpynWtoA(pdevmodea->dmFormName, arg2->dmFormName, CCHFORMNAME);
[21998]479
[22062]480 /* copy private driver data */
481 memcpy(((PBYTE)pdevmodea) + pdevmodea->dmSize, ((PBYTE)arg2) + arg2->dmSize, pdevmodea->dmDriverExtra);
482
483 HDC ret = (HDC)O32_ResetDC(arg1, pdevmodea);
484
485 free(pdevmodea);
486
487 return ret;
[10373]488}
489//******************************************************************************
490//******************************************************************************
491#ifdef DEBUG
492void dprintfDEVMODE(DEVMODEA *lpInitData)
493{
494 dprintf(("devmode.dmSpecVersion %x", lpInitData->dmSpecVersion));
495 dprintf(("devmode.dmDriverVersion %x",lpInitData->dmDriverVersion));
496 dprintf(("devmode.dmSize %x", lpInitData->dmSize));
497 dprintf(("devmode.dmDriverExtra %x", lpInitData->dmDriverExtra));
498 dprintf(("devmode.dmFields %x", lpInitData->dmFields));
[21916]499#if defined (__GNUC__) || (__IBMCPP__ == 360)
[10373]500 dprintf(("devmode.dmOrientation %x", lpInitData->dmOrientation));
501 dprintf(("devmode.dmPaperSize %x", lpInitData->dmPaperSize));
502 dprintf(("devmode.dmPaperLength %x", lpInitData->dmPaperLength));
503 dprintf(("devmode.dmPaperWidth %x", lpInitData->dmPaperWidth));
504#else
505 dprintf(("devmode.dmOrientation %x", lpInitData->s1.dmOrientation));
506 dprintf(("devmode.dmPaperSize %x", lpInitData->s1.dmPaperSize));
507 dprintf(("devmode.dmPaperLength %x", lpInitData->s1.dmPaperLength));
508 dprintf(("devmode.dmPaperWidth %x", lpInitData->s1.dmPaperWidth));
509#endif
510 dprintf(("devmode.dmScale %x", lpInitData->dmScale));
511 dprintf(("devmode.dmCopies %x", lpInitData->dmCopies));
512 dprintf(("devmode.dmDefaultSource %x", lpInitData->dmDefaultSource));
513 dprintf(("devmode.dmPrintQuality %x", lpInitData->dmPrintQuality));
514 dprintf(("devmode.dmColor %x", lpInitData->dmColor));
515 dprintf(("devmode.dmDuplex %x", lpInitData->dmDuplex));
516 dprintf(("devmode.dmYResolution %x", lpInitData->dmYResolution));
517 dprintf(("devmode.dmTTOption %x", lpInitData->dmTTOption));
518 dprintf(("devmode.dmCollate %x", lpInitData->dmCollate));
519 dprintf(("devmode.dmLogPixels %x", lpInitData->dmLogPixels));
520 dprintf(("devmode.dmBitsPerPel %x", lpInitData->dmBitsPerPel));
521 dprintf(("devmode.dmPelsWidth %x", lpInitData->dmPelsWidth));
522 dprintf(("devmode.dmPelsHeight %x", lpInitData->dmPelsHeight));
523 dprintf(("devmode.dmDisplayFlags %x", lpInitData->dmDisplayFlags));
524 dprintf(("devmode.dmDisplayFrequency %x", lpInitData->dmDisplayFrequency));
525 dprintf(("devmode.dmICMMethod %x", lpInitData->dmICMMethod));
526 dprintf(("devmode.dmICMIntent %x", lpInitData->dmICMIntent));
527 dprintf(("devmode.dmMediaType %x", lpInitData->dmMediaType));
528 dprintf(("devmode.dmDitherType %x", lpInitData->dmDitherType));
529 dprintf(("devmode.dmReserved1 %x", lpInitData->dmReserved1));
530 dprintf(("devmode.dmReserved2 %x", lpInitData->dmReserved2));
531}
532#endif
533//******************************************************************************
534//******************************************************************************
Note: See TracBrowser for help on using the repository browser.