source: trunk/src/gdi32/devcontext.cpp@ 22005

Last change on this file since 22005 was 21998, checked in by dmik, 14 years ago

gdi32: Implement wide version of ResetDC().

Used by recent OpenJDK.
File size: 19.6 KB
Line 
1/* $Id: devcontext.cpp,v 1.3 2004-02-18 14:05:48 sandervl Exp $ */
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//******************************************************************************
56BOOL WIN32API GetPMQueueName(LPSTR pDeviceName, LPSTR lpszPMQueue, INT cbPMQueue)
57{
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();
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
88 if(GetPMQueueName((LPSTR)lpszDevice, szDevice, sizeof(szDevice)) == TRUE)
89 {
90 dprintf(("Rename printer %s to PM Queue %s", lpszDevice, szDevice));
91 lpszDevice = szDevice;
92
93 //Must ignore port name here or else the wrong queue might be used
94 //(unless we are told to print to file)
95 if (lpszOutput && strcmp(lpszOutput, "FILE:") != 0 && strcmp(lpszOutput, "FILE") != 0)
96 lpszOutput = NULL;
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;
147#if defined (__GNUC__) || (__IBMCPP__ == 360)
148 devmode.dmOrientation = arg4->dmOrientation;
149 devmode.dmPaperSize = arg4->dmPaperSize;
150 devmode.dmPaperLength = arg4->dmPaperLength;
151 devmode.dmPaperWidth = arg4->dmPaperWidth;
152#else
153 devmode.s1.dmOrientation = arg4->s1.dmOrientation;
154 devmode.s1.dmPaperSize = arg4->s1.dmPaperSize;
155 devmode.s1.dmPaperLength = arg4->s1.dmPaperLength;
156 devmode.s1.dmPaperWidth = arg4->s1.dmPaperWidth;
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
210 if(GetPMQueueName((LPSTR)lpszDevice, szDevice, sizeof(szDevice)) == TRUE)
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
215 //(unless we are told to print to file)
216 if (lpszOutput && strcmp(lpszOutput, "FILE:") != 0 && strcmp(lpszOutput, "FILE") != 0)
217 lpszOutput = NULL;
218 }
219 }
220
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;
260#if defined (__GNUC__) || (__IBMCPP__ == 360)
261 devmode.dmOrientation = arg4->dmOrientation;
262 devmode.dmPaperSize = arg4->dmPaperSize;
263 devmode.dmPaperLength = arg4->dmPaperLength;
264 devmode.dmPaperWidth = arg4->dmPaperWidth;
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
372 // (the visible region remains untouched!)
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
383 dprintf2(("New win32 clip region %x", hClipRgn));
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);
413
414 dprintf2(("New win32 clip region %x", pHps->hrgnWin32Clip));
415 }
416 return ret;
417}
418//******************************************************************************
419//******************************************************************************
420HDC WIN32API ResetDCA(HDC hdc, const DEVMODEA *lpInitData)
421{
422 if(lpInitData)
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{
433 DEVMODEA devmodea;
434
435 devmodea.dmSpecVersion = arg2->dmSpecVersion;
436 devmodea.dmDriverVersion = arg2->dmDriverVersion;
437 devmodea.dmSize = sizeof(DEVMODEW);
438 devmodea.dmDriverExtra = arg2->dmDriverExtra;
439 devmodea.dmFields = arg2->dmFields;
440
441 devmodea.dmOrientation = arg2->dmOrientation;
442 devmodea.dmPaperSize = arg2->dmPaperSize;
443 devmodea.dmPaperLength = arg2->dmPaperLength;
444 devmodea.dmPaperWidth = arg2->dmPaperWidth;
445 devmodea.dmPosition = arg2->dmPosition;
446
447 devmodea.dmScale = arg2->dmScale;
448 devmodea.dmCopies = arg2->dmCopies;
449 devmodea.dmDefaultSource = arg2->dmDefaultSource;
450 devmodea.dmPrintQuality = arg2->dmPrintQuality;
451 devmodea.dmColor = arg2->dmColor;
452 devmodea.dmDuplex = arg2->dmDuplex;
453 devmodea.dmYResolution = arg2->dmYResolution;
454 devmodea.dmTTOption = arg2->dmTTOption;
455 devmodea.dmCollate = arg2->dmCollate;
456
457 devmodea.dmLogPixels = arg2->dmLogPixels;
458 devmodea.dmBitsPerPel = arg2->dmBitsPerPel;
459 devmodea.dmPelsWidth = arg2->dmPelsWidth;
460 devmodea.dmPelsHeight = arg2->dmPelsHeight;
461 devmodea.dmDisplayFlags = arg2->dmDisplayFlags;
462 devmodea.dmDisplayFrequency = arg2->dmDisplayFrequency;
463 devmodea.dmICMMethod = arg2->dmICMMethod;
464 devmodea.dmICMIntent = arg2->dmICMIntent;
465 devmodea.dmMediaType = arg2->dmMediaType;
466 devmodea.dmDitherType = arg2->dmDitherType;
467 devmodea.dmReserved1 = arg2->dmReserved1;
468 devmodea.dmReserved2 = arg2->dmReserved2;
469 devmodea.dmPanningWidth = arg2->dmPanningWidth;
470 devmodea.dmPanningHeight = arg2->dmPanningHeight;
471
472 lstrcpynWtoA(devmodea.dmDeviceName, arg2->dmDeviceName, CCHDEVICENAME);
473 lstrcpynWtoA(devmodea.dmFormName, arg2->dmFormName, CCHFORMNAME);
474
475 return (HDC)O32_ResetDC(arg1, &devmodea);
476}
477//******************************************************************************
478//******************************************************************************
479#ifdef DEBUG
480void dprintfDEVMODE(DEVMODEA *lpInitData)
481{
482 dprintf(("devmode.dmSpecVersion %x", lpInitData->dmSpecVersion));
483 dprintf(("devmode.dmDriverVersion %x",lpInitData->dmDriverVersion));
484 dprintf(("devmode.dmSize %x", lpInitData->dmSize));
485 dprintf(("devmode.dmDriverExtra %x", lpInitData->dmDriverExtra));
486 dprintf(("devmode.dmFields %x", lpInitData->dmFields));
487#if defined (__GNUC__) || (__IBMCPP__ == 360)
488 dprintf(("devmode.dmOrientation %x", lpInitData->dmOrientation));
489 dprintf(("devmode.dmPaperSize %x", lpInitData->dmPaperSize));
490 dprintf(("devmode.dmPaperLength %x", lpInitData->dmPaperLength));
491 dprintf(("devmode.dmPaperWidth %x", lpInitData->dmPaperWidth));
492#else
493 dprintf(("devmode.dmOrientation %x", lpInitData->s1.dmOrientation));
494 dprintf(("devmode.dmPaperSize %x", lpInitData->s1.dmPaperSize));
495 dprintf(("devmode.dmPaperLength %x", lpInitData->s1.dmPaperLength));
496 dprintf(("devmode.dmPaperWidth %x", lpInitData->s1.dmPaperWidth));
497#endif
498 dprintf(("devmode.dmScale %x", lpInitData->dmScale));
499 dprintf(("devmode.dmCopies %x", lpInitData->dmCopies));
500 dprintf(("devmode.dmDefaultSource %x", lpInitData->dmDefaultSource));
501 dprintf(("devmode.dmPrintQuality %x", lpInitData->dmPrintQuality));
502 dprintf(("devmode.dmColor %x", lpInitData->dmColor));
503 dprintf(("devmode.dmDuplex %x", lpInitData->dmDuplex));
504 dprintf(("devmode.dmYResolution %x", lpInitData->dmYResolution));
505 dprintf(("devmode.dmTTOption %x", lpInitData->dmTTOption));
506 dprintf(("devmode.dmCollate %x", lpInitData->dmCollate));
507 dprintf(("devmode.dmLogPixels %x", lpInitData->dmLogPixels));
508 dprintf(("devmode.dmBitsPerPel %x", lpInitData->dmBitsPerPel));
509 dprintf(("devmode.dmPelsWidth %x", lpInitData->dmPelsWidth));
510 dprintf(("devmode.dmPelsHeight %x", lpInitData->dmPelsHeight));
511 dprintf(("devmode.dmDisplayFlags %x", lpInitData->dmDisplayFlags));
512 dprintf(("devmode.dmDisplayFrequency %x", lpInitData->dmDisplayFrequency));
513 dprintf(("devmode.dmICMMethod %x", lpInitData->dmICMMethod));
514 dprintf(("devmode.dmICMIntent %x", lpInitData->dmICMIntent));
515 dprintf(("devmode.dmMediaType %x", lpInitData->dmMediaType));
516 dprintf(("devmode.dmDitherType %x", lpInitData->dmDitherType));
517 dprintf(("devmode.dmReserved1 %x", lpInitData->dmReserved1));
518 dprintf(("devmode.dmReserved2 %x", lpInitData->dmReserved2));
519}
520#endif
521//******************************************************************************
522//******************************************************************************
Note: See TracBrowser for help on using the repository browser.