?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Removed a few inter-dll dependencies.
[wine/multimedia.git] / graphics / win16drv / prtdrv.c
blob03a35534c72e2f27d5ca8f76463e7aee2464bfaa
1 /*
2 * Windows Device Context initialisation functions
3 *
4 * Copyright 1996,1997 John Harvey
5 */
6
7 #include <stdlib.h>
8 #include <string.h>
9 #include <sys/types.h>
10 #include <fcntl.h>
11 #include <unistd.h>
12 #include <errno.h>
13 #include "wine/winbase16.h"
14 #include "win16drv.h"
15 #include "heap.h"
16 #include "brush.h"
17 #include "callback.h"
18 #include "debugtools.h"
19 #include "bitmap.h"
20 #include "pen.h"
21
22 DEFAULT_DEBUG_CHANNEL(win16drv)
23
24 /* ### start build ### */
25 extern WORD CALLBACK PRTDRV_CallTo16_word_lwll (FARPROC16,LONG,WORD,LONG,LONG);
26 extern WORD CALLBACK PRTDRV_CallTo16_word_lwlll (FARPROC16,LONG,WORD,LONG,LONG,
27 LONG);
28 extern WORD CALLBACK PRTDRV_CallTo16_word_llll (FARPROC16,LONG,LONG,LONG,LONG);
29 extern WORD CALLBACK PRTDRV_CallTo16_word_lwwlllll (FARPROC16,LONG,WORD,WORD,
30 LONG,LONG,LONG,LONG,LONG);
31 extern LONG CALLBACK PRTDRV_CallTo16_long_lwlll (FARPROC16,LONG,WORD,LONG,LONG,
32 LONG);
33 extern WORD CALLBACK PRTDRV_CallTo16_word_lwwwwlwwwwllll (FARPROC16,LONG,WORD,
34 WORD,WORD,WORD,LONG,
35 WORD,WORD,WORD,WORD,
36 LONG,LONG,LONG,LONG);
37 extern LONG CALLBACK PRTDRV_CallTo16_long_lwwllwlllllw (FARPROC16,LONG,WORD,
38 WORD,LONG,LONG,WORD,
39 LONG,LONG,LONG,LONG,
40 LONG,WORD);
41 extern WORD CALLBACK PRTDRV_CallTo16_word_llwwlll (FARPROC16,LONG,LONG,WORD,
42 WORD,LONG,LONG,LONG);
43 extern WORD CALLBACK PRTDRV_CallTo16_word_wwlllllw (FARPROC16,WORD,WORD,LONG,
44 LONG,LONG,LONG,LONG,WORD);
45 extern LONG CALLBACK PRTDRV_CallTo16_long_llwll (FARPROC16,LONG,LONG,WORD,LONG,
46 LONG);
47
48 /* ### stop build ### */
49
50
51 #define MAX_PRINTER_DRIVERS 16
52 static LOADED_PRINTER_DRIVER *gapLoadedPrinterDrivers[MAX_PRINTER_DRIVERS];
53
54
55 static void GetPrinterDriverFunctions(HINSTANCE16 hInst, LOADED_PRINTER_DRIVER *pLPD)
56 {
57 #define LoadPrinterDrvFunc(A) pLPD->fn[FUNC_##A] = \
58 GetProcAddress16(hInst, MAKEINTRESOURCE16(ORD_##A))
59
60 LoadPrinterDrvFunc(BITBLT);
61 LoadPrinterDrvFunc(COLORINFO);
62 LoadPrinterDrvFunc(CONTROL);
63 LoadPrinterDrvFunc(DISABLE);
64 LoadPrinterDrvFunc(ENABLE);
65 LoadPrinterDrvFunc(ENUMDFONTS);
66 LoadPrinterDrvFunc(ENUMOBJ);
67 LoadPrinterDrvFunc(OUTPUT);
68 LoadPrinterDrvFunc(PIXEL);
69 LoadPrinterDrvFunc(REALIZEOBJECT);
70 LoadPrinterDrvFunc(STRBLT);
71 LoadPrinterDrvFunc(SCANLR);
72 LoadPrinterDrvFunc(DEVICEMODE);
73 LoadPrinterDrvFunc(EXTTEXTOUT);
74 LoadPrinterDrvFunc(GETCHARWIDTH);
75 LoadPrinterDrvFunc(DEVICEBITMAP);
76 LoadPrinterDrvFunc(FASTBORDER);
77 LoadPrinterDrvFunc(SETATTRIBUTE);
78 LoadPrinterDrvFunc(STRETCHBLT);
79 LoadPrinterDrvFunc(STRETCHDIBITS);
80 LoadPrinterDrvFunc(SELECTBITMAP);
81 LoadPrinterDrvFunc(BITMAPBITS);
82 LoadPrinterDrvFunc(EXTDEVICEMODE);
83 LoadPrinterDrvFunc(DEVICECAPABILITIES);
84 LoadPrinterDrvFunc(ADVANCEDSETUPDIALOG);
85 LoadPrinterDrvFunc(DIALOGFN);
86 LoadPrinterDrvFunc(PSEUDOEDIT);
87 TRACE("got func CONTROL 0x%p enable 0x%p enumDfonts 0x%p realizeobject 0x%p extextout 0x%p\n",
88 pLPD->fn[FUNC_CONTROL],
89 pLPD->fn[FUNC_ENABLE],
90 pLPD->fn[FUNC_ENUMDFONTS],
91 pLPD->fn[FUNC_REALIZEOBJECT],
92 pLPD->fn[FUNC_EXTTEXTOUT]);
93
94
95 }
96
97
98 static LOADED_PRINTER_DRIVER *FindPrinterDriverFromName(const char *pszDriver)
99 {
100 LOADED_PRINTER_DRIVER *pLPD = NULL;
101 int nDriverSlot = 0;
102
103 /* Look to see if the printer driver is already loaded */
104 while (pLPD == NULL && nDriverSlot < MAX_PRINTER_DRIVERS)
105 {
106 LOADED_PRINTER_DRIVER *ptmpLPD;
107 ptmpLPD = gapLoadedPrinterDrivers[nDriverSlot++];
108 if (ptmpLPD != NULL)
109 {
110 TRACE("Comparing %s,%s\n",ptmpLPD->szDriver,pszDriver);
111 /* Found driver store info, exit loop */
112 if (strcasecmp(ptmpLPD->szDriver, pszDriver) == 0)
113 pLPD = ptmpLPD;
114 }
115 }
116 return pLPD;
117 }
118
119 static LOADED_PRINTER_DRIVER *FindPrinterDriverFromPDEVICE(SEGPTR segptrPDEVICE)
120 {
121 LOADED_PRINTER_DRIVER *pLPD = NULL;
122
123 /* Find the printer driver associated with this PDEVICE */
124 /* Each of the PDEVICE structures has a PDEVICE_HEADER structure */
125 /* just before it */
126 if (segptrPDEVICE != (SEGPTR)NULL)
127 {
128 PDEVICE_HEADER *pPDH = (PDEVICE_HEADER *)
129 ((char *) PTR_SEG_TO_LIN(segptrPDEVICE) - sizeof(PDEVICE_HEADER));
130 pLPD = pPDH->pLPD;
131 }
132 return pLPD;
133 }
134
135 /*
136 * Load a printer driver, adding it self to the list of loaded drivers.
137 */
138
139 LOADED_PRINTER_DRIVER *LoadPrinterDriver(const char *pszDriver)
140 {
141 HINSTANCE16 hInst;
142 LOADED_PRINTER_DRIVER *pLPD = NULL;
143 int nDriverSlot = 0;
144 BOOL bSlotFound = FALSE;
145
146 /* First look to see if driver is loaded */
147 pLPD = FindPrinterDriverFromName(pszDriver);
148 if (pLPD != NULL)
149 {
150 /* Already loaded so increase usage count */
151 pLPD->nUsageCount++;
152 return pLPD;
153 }
154
155 /* Not loaded so try and find an empty slot */
156 while (!bSlotFound && nDriverSlot < MAX_PRINTER_DRIVERS)
157 {
158 if (gapLoadedPrinterDrivers[nDriverSlot] == NULL)
159 bSlotFound = TRUE;
160 else
161 nDriverSlot++;
162 }
163 if (!bSlotFound)
164 {
165 WARN("Too many printers drivers loaded\n");
166 return NULL;
167 }
168
169 {
170 char *drvName = malloc(strlen(pszDriver)+5);
171 strcpy(drvName, pszDriver);
172 strcat(drvName, ".DRV");
173 hInst = LoadLibrary16(drvName);
174 }
175
176
177 if (hInst <= 32)
178 {
179 /* Failed to load driver */
180 WARN("Failed to load printer driver %s\n", pszDriver);
181 } else {
182 TRACE("Loaded the library\n");
183 /* Allocate some memory for printer driver info */
184 pLPD = malloc(sizeof(LOADED_PRINTER_DRIVER));
185 memset(pLPD, 0 , sizeof(LOADED_PRINTER_DRIVER));
186
187 pLPD->hInst = hInst;
188 pLPD->szDriver = HEAP_strdupA(GetProcessHeap(),0,pszDriver);
189
190 /* Get DS for the printer module */
191 pLPD->ds_reg = hInst;
192
193 TRACE("DS for %s is %x\n", pszDriver, pLPD->ds_reg);
194
195 /* Get address of printer driver functions */
196 GetPrinterDriverFunctions(hInst, pLPD);
197
198 /* Set initial usage count */
199 pLPD->nUsageCount = 1;
200
201 /* Update table of loaded printer drivers */
202 pLPD->nIndex = nDriverSlot;
203 gapLoadedPrinterDrivers[nDriverSlot] = pLPD;
204 }
205
206 return pLPD;
207 }
208
209 /*
210 * Control (ordinal 3)
211 */
212 INT16 PRTDRV_Control(LPPDEVICE lpDestDev, WORD wfunction, SEGPTR lpInData, SEGPTR lpOutData)
213 {
214 /* wfunction == Escape code */
215 /* lpInData, lpOutData depend on code */
216
217 WORD wRet = 0;
218 LOADED_PRINTER_DRIVER *pLPD = NULL;
219
220 TRACE("%08x 0x%x %08lx %08lx\n", (unsigned int)lpDestDev, wfunction, lpInData, lpOutData);
221
222 if ((pLPD = FindPrinterDriverFromPDEVICE(lpDestDev)) != NULL)
223 {
224 if (pLPD->fn[FUNC_CONTROL] == NULL)
225 {
226 WARN("Not supported by driver\n");
227 return 0;
228 }
229 wRet = PRTDRV_CallTo16_word_lwll( pLPD->fn[FUNC_CONTROL],
230 (SEGPTR)lpDestDev, wfunction,
231 lpInData, lpOutData );
232 }
233 TRACE("return %x\n", wRet);
234 return wRet;
235 }
236
237 /*
238 * Enable (ordinal 5)
239 */
240 WORD PRTDRV_Enable(LPVOID lpDevInfo, WORD wStyle, LPCSTR lpDestDevType,
241 LPCSTR lpDeviceName, LPCSTR lpOutputFile, LPVOID lpData)
242 {
243 WORD wRet = 0;
244 LOADED_PRINTER_DRIVER *pLPD = NULL;
245
246 TRACE("%s %s\n",lpDestDevType, lpOutputFile);
247
248 /* Get the printer driver info */
249 if (wStyle == INITPDEVICE)
250 pLPD = FindPrinterDriverFromPDEVICE((SEGPTR)lpDevInfo);
251 else
252 pLPD = FindPrinterDriverFromName((char *)lpDeviceName);
253 if (pLPD != NULL) {
254 LONG lP5;
255 DeviceCaps *lP1;
256 LPSTR lP3,lP4;
257 WORD wP2;
258
259 if (!pLPD->fn[FUNC_ENABLE]) {
260 WARN("Not supported by driver\n");
261 return 0;
262 }
263
264 if (wStyle == INITPDEVICE)
265 lP1 = (DeviceCaps*)lpDevInfo;/* 16 bit segmented ptr already */
266 else
267 lP1 = SEGPTR_NEW(DeviceCaps);
268
269 wP2 = wStyle;
270
271 /* SEGPTR_STRDUP handles NULL like a charm ... */
272 lP3 = SEGPTR_STRDUP(lpDestDevType);
273 lP4 = SEGPTR_STRDUP(lpOutputFile);
274 lP5 = (LONG)lpData;
275
276 wRet = PRTDRV_CallTo16_word_lwlll(pLPD->fn[FUNC_ENABLE],
277 (wStyle==INITPDEVICE)?(SEGPTR)lP1:SEGPTR_GET(lP1),
278 wP2,
279 SEGPTR_GET(lP3),
280 SEGPTR_GET(lP4),
281 lP5);
282 SEGPTR_FREE(lP3);
283 SEGPTR_FREE(lP4);
284
285 /* Get the data back */
286 if (lP1 != 0 && wStyle != INITPDEVICE) {
287 memcpy(lpDevInfo,lP1,sizeof(DeviceCaps));
288 SEGPTR_FREE(lP1);
289 }
290 }
291 TRACE("return %x\n", wRet);
292 return wRet;
293 }
294
295
296 /*
297 * EnumDFonts (ordinal 6)
298 */
299 WORD PRTDRV_EnumDFonts(LPPDEVICE lpDestDev, LPSTR lpFaceName,
300 FARPROC16 lpCallbackFunc, LPVOID lpClientData)
301 {
302 WORD wRet = 0;
303 LOADED_PRINTER_DRIVER *pLPD = NULL;
304
305 TRACE("%08lx %s %p %p\n",
306 lpDestDev, lpFaceName, lpCallbackFunc, lpClientData);
307
308 if ((pLPD = FindPrinterDriverFromPDEVICE(lpDestDev)) != NULL)
309 {
310 LONG lP1, lP4;
311 LPBYTE lP2;
312
313 if (pLPD->fn[FUNC_ENUMDFONTS] == NULL) {
314 WARN("Not supported by driver\n");
315 return 0;
316 }
317
318 lP1 = (SEGPTR)lpDestDev;
319 if(lpFaceName)
320 lP2 = SEGPTR_STRDUP(lpFaceName);
321 else
322 lP2 = NULL;
323 lP4 = (LONG)lpClientData;
324 wRet = PRTDRV_CallTo16_word_llll( pLPD->fn[FUNC_ENUMDFONTS],
325 lP1, SEGPTR_GET(lP2),
326 (LONG)lpCallbackFunc,lP4);
327 if(lpFaceName)
328 SEGPTR_FREE(lP2);
329 } else
330 WARN("Failed to find device\n");
331
332 TRACE("return %x\n", wRet);
333 return wRet;
334 }
335 /*
336 * EnumObj (ordinal 7)
337 */
338 BOOL16 PRTDRV_EnumObj(LPPDEVICE lpDestDev, WORD iStyle,
339 FARPROC16 lpCallbackFunc, LPVOID lpClientData)
340 {
341 WORD wRet = 0;
342 LOADED_PRINTER_DRIVER *pLPD = NULL;
343
344 TRACE("(some params - fixme)\n");
345
346 if ((pLPD = FindPrinterDriverFromPDEVICE(lpDestDev)) != NULL)
347 {
348 LONG lP1, lP3, lP4;
349 WORD wP2;
350
351 if (pLPD->fn[FUNC_ENUMOBJ] == NULL)
352 {
353 WARN("Not supported by driver\n");
354 return 0;
355 }
356
357 lP1 = (SEGPTR)lpDestDev;
358
359 wP2 = iStyle;
360
361 /*
362 * Need to pass addres of function conversion function that will switch back to 32 bit code if necessary
363 */
364 lP3 = (LONG)lpCallbackFunc;
365
366 lP4 = (LONG)lpClientData;
367
368 wRet = PRTDRV_CallTo16_word_lwll( pLPD->fn[FUNC_ENUMOBJ],
369 lP1, wP2, lP3, lP4 );
370 }
371 else
372 WARN("Failed to find device\n");
373
374 TRACE("return %x\n", wRet);
375 return wRet;
376 }
377
378 /*
379 * Output (ordinal 8)
380 */
381 WORD PRTDRV_Output(LPPDEVICE lpDestDev,
382 WORD wStyle,
383 WORD wCount,
384 POINT16 *points,
385 LPLOGPEN16 lpPen,
386 LPLOGBRUSH16 lpBrush,
387 SEGPTR lpDrawMode,
388 HRGN hClipRgn)
389 {
390 WORD wRet = 0;
391 LOADED_PRINTER_DRIVER *pLPD = NULL;
392
393 TRACE("PRTDRV_OUTPUT %d\n", wStyle );
394
395 if ((pLPD = FindPrinterDriverFromPDEVICE(lpDestDev)) != NULL)
396 {
397 LONG lP1, lP5, lP6, lP7;
398 LPPOINT16 lP4;
399 LPRECT16 lP8;
400 WORD wP2, wP3;
401 int nSize;
402 if (pLPD->fn[FUNC_OUTPUT] == NULL)
403 {
404 WARN("Not supported by driver\n");
405 return 0;
406 }
407
408 lP1 = lpDestDev;
409 wP2 = wStyle;
410 wP3 = wCount;
411 nSize = sizeof(POINT16) * wCount;
412 lP4 = (LPPOINT16 )SEGPTR_ALLOC(nSize);
413 memcpy(lP4,points,nSize);
414 lP5 = SEGPTR_GET( lpPen );
415 lP6 = SEGPTR_GET( lpBrush );
416 lP7 = lpDrawMode;
417
418 if (hClipRgn)
419 {
420 DWORD size;
421 RGNDATA *clip;
422
423 size = GetRegionData( hClipRgn, 0, NULL );
424 clip = HeapAlloc( GetProcessHeap(), 0, size );
425 if(!clip)
426 {
427 WARN("Can't alloc clip array in PRTDRV_Output\n");
428 return FALSE;
429 }
430 GetRegionData( hClipRgn, size, clip );
431 if( clip->rdh.nCount == 0 )
432 {
433 wRet = PRTDRV_CallTo16_word_lwwlllll(pLPD->fn[FUNC_OUTPUT],
434 lP1, wP2, wP3,
435 SEGPTR_GET(lP4),
436 lP5, lP6, lP7,
437 (SEGPTR) NULL);
438 }
439 else
440 {
441 RECT *pRect;
442 lP8 = SEGPTR_NEW(RECT16);
443
444 for(pRect = (RECT *)clip->Buffer;
445 pRect < (RECT *)clip->Buffer + clip->rdh.nCount; pRect++)
446 {
447 CONV_RECT32TO16( pRect, lP8 );
448
449 TRACE("rect = %d,%d - %d,%d\n",
450 lP8->left, lP8->top, lP8->right, lP8->bottom );
451 wRet = PRTDRV_CallTo16_word_lwwlllll(pLPD->fn[FUNC_OUTPUT],
452 lP1, wP2, wP3,
453 SEGPTR_GET(lP4),
454 lP5, lP6, lP7,
455 SEGPTR_GET(lP8));
456 }
457 SEGPTR_FREE(lP8);
458 }
459 HeapFree( GetProcessHeap(), 0, clip );
460 }
461 else
462 {
463 wRet = PRTDRV_CallTo16_word_lwwlllll(pLPD->fn[FUNC_OUTPUT],
464 lP1, wP2, wP3,
465 SEGPTR_GET(lP4),
466 lP5, lP6, lP7, (SEGPTR) NULL);
467 }
468 SEGPTR_FREE(lP4);
469 }
470 TRACE("PRTDRV_Output return %d\n", wRet);
471 return wRet;
472 }
473
474 /*
475 * RealizeObject (ordinal 10)
476 */
477 DWORD PRTDRV_RealizeObject(LPPDEVICE lpDestDev, WORD wStyle,
478 LPVOID lpInObj, LPVOID lpOutObj,
479 SEGPTR lpTextXForm)
480 {
481 WORD dwRet = 0;
482 LOADED_PRINTER_DRIVER *pLPD = NULL;
483
484 TRACE("%08lx %04x %p %p %08lx\n",
485 lpDestDev, wStyle, lpInObj, lpOutObj, lpTextXForm);
486
487 if ((pLPD = FindPrinterDriverFromPDEVICE(lpDestDev)) != NULL)
488 {
489 LONG lP1, lP3, lP4, lP5;
490 WORD wP2;
491 LPBYTE lpBuf = NULL;
492 unsigned int nSize;
493
494 if (pLPD->fn[FUNC_REALIZEOBJECT] == NULL)
495 {
496 WARN("Not supported by driver\n");
497 return 0;
498 }
499
500 lP1 = lpDestDev;
501 wP2 = wStyle;
502
503 switch ((INT16)wStyle)
504 {
505 case DRVOBJ_BRUSH:
506 nSize = sizeof (LOGBRUSH16);
507 break;
508 case DRVOBJ_FONT:
509 nSize = sizeof(LOGFONT16);
510 break;
511 case DRVOBJ_PEN:
512 nSize = sizeof(LOGPEN16);
513 break;
514
515 case -DRVOBJ_BRUSH:
516 case -DRVOBJ_FONT:
517 case -DRVOBJ_PEN:
518 nSize = -1;
519 break;
520
521 case DRVOBJ_PBITMAP:
522 default:
523 WARN("Object type %d not supported\n", wStyle);
524 nSize = 0;
525
526 }
527
528 if(nSize != -1)
529 {
530 lpBuf = SEGPTR_ALLOC(nSize);
531 memcpy(lpBuf, lpInObj, nSize);
532 lP3 = SEGPTR_GET(lpBuf);
533 }
534 else
535 lP3 = SEGPTR_GET( lpInObj );
536
537 lP4 = SEGPTR_GET( lpOutObj );
538
539 lP5 = lpTextXForm;
540 TRACE("Calling Realize %08lx %04x %08lx %08lx %08lx\n",
541 lP1, wP2, lP3, lP4, lP5);
542 dwRet = PRTDRV_CallTo16_long_lwlll(pLPD->fn[FUNC_REALIZEOBJECT],
543 lP1, wP2, lP3, lP4, lP5);
544 if(lpBuf)
545 SEGPTR_FREE(lpBuf);
546
547 }
548 TRACE("return %x\n", dwRet);
549 return dwRet;
550 }
551
552 /*
553 * StretchBlt (ordinal 27)
554 */
555 DWORD PRTDRV_StretchBlt(LPPDEVICE lpDestDev,
556 WORD wDestX, WORD wDestY,
557 WORD wDestXext, WORD wDestYext,
558 LPPDEVICE lpSrcDev,
559 WORD wSrcX, WORD wSrcY,
560 WORD wSrcXext, WORD wSrcYext,
561 DWORD Rop3,
562 LPLOGBRUSH16 lpBrush,
563 SEGPTR lpDrawMode,
564 RECT16 *lpClipRect)
565 {
566 WORD wRet = 0;
567 LOADED_PRINTER_DRIVER *pLPD = NULL;
568
569 TRACE("(lots of params - fixme)\n");
570
571 if ((pLPD = FindPrinterDriverFromPDEVICE(lpDestDev)) != NULL)
572 {
573 LONG lP1,lP6, lP11, lP12, lP13;
574 LPRECT16 lP14;
575 WORD wP2, wP3, wP4, wP5, wP7, wP8, wP9, wP10;
576
577 if (pLPD->fn[FUNC_STRETCHBLT] == NULL)
578 {
579 WARN("Not supported by driver\n");
580 return 0;
581 }
582 lP1 = lpDestDev;
583 wP2 = wDestX;
584 wP3 = wDestY;
585 wP4 = wDestXext;
586 wP5 = wDestYext;
587 lP6 = lpSrcDev;
588 wP7 = wSrcX;
589 wP8 = wSrcY;
590 wP9 = wSrcXext;
591 wP10 = wSrcYext;
592 lP11 = Rop3;
593 lP12 = SEGPTR_GET( lpBrush );
594 lP13 = lpDrawMode;
595 if (lpClipRect != NULL)
596 {
597 lP14 = SEGPTR_NEW(RECT16);
598 memcpy(lP14,lpClipRect,sizeof(RECT16));
599
600 }
601 else
602 lP14 = 0L;
603 wRet = PRTDRV_CallTo16_word_lwwwwlwwwwllll(pLPD->fn[FUNC_STRETCHBLT],
604 lP1, wP2, wP3, wP4, wP5,
605 lP6, wP7, wP8, wP9, wP10,
606 lP11, lP12, lP13,
607 SEGPTR_GET(lP14));
608 SEGPTR_FREE(lP14);
609 TRACE("Called StretchBlt ret %d\n",wRet);
610 }
611 return wRet;
612 }
613
614 DWORD PRTDRV_ExtTextOut(LPPDEVICE lpDestDev, WORD wDestXOrg, WORD wDestYOrg,
615 RECT16 *lpClipRect, LPCSTR lpString, WORD wCount,
616 LPFONTINFO16 lpFontInfo, SEGPTR lpDrawMode,
617 SEGPTR lpTextXForm, SHORT *lpCharWidths,
618 RECT16 * lpOpaqueRect, WORD wOptions)
619 {
620 DWORD dwRet = 0;
621 LOADED_PRINTER_DRIVER *pLPD = NULL;
622
623 TRACE("(lots of params - fixme)\n");
624
625 if ((pLPD = FindPrinterDriverFromPDEVICE(lpDestDev)) != NULL)
626 {
627 LONG lP1, lP7, lP8, lP9, lP10;
628 LPSTR lP5;
629 LPRECT16 lP4,lP11;
630 WORD wP2, wP3, wP12;
631 INT16 iP6;
632 unsigned int nSize = -1;
633
634 if (pLPD->fn[FUNC_EXTTEXTOUT] == NULL)
635 {
636 WARN("Not supported by driver\n");
637 return 0;
638 }
639
640 lP1 = lpDestDev;
641 wP2 = wDestXOrg;
642 wP3 = wDestYOrg;
643
644 if (lpClipRect != NULL) {
645 lP4 = SEGPTR_NEW(RECT16);
646 TRACE("Adding lpClipRect\n");
647 memcpy(lP4,lpClipRect,sizeof(RECT16));
648 } else
649 lP4 = 0L;
650
651 if (lpString != NULL) {
652 nSize = strlen(lpString);
653 if (nSize>abs(wCount))
654 nSize = abs(wCount);
655 lP5 = SEGPTR_ALLOC(nSize+1);
656 TRACE("Adding lpString (nSize is %d)\n",nSize);
657 memcpy(lP5,lpString,nSize);
658 *((char *)lP5 + nSize) = '\0';
659 } else
660 lP5 = 0L;
661
662 iP6 = wCount;
663
664 /* This should be realized by the driver, so in 16bit data area */
665 lP7 = SEGPTR_GET( lpFontInfo );
666 lP8 = lpDrawMode;
667 lP9 = lpTextXForm;
668
669 if (lpCharWidths != NULL)
670 FIXME("Char widths not supported\n");
671 lP10 = 0;
672
673 if (lpOpaqueRect != NULL) {
674 lP11 = SEGPTR_NEW(RECT16);
675 TRACE("Adding lpOpaqueRect\n");
676 memcpy(lP11,lpOpaqueRect,sizeof(RECT16));
677 } else
678 lP11 = 0L;
679
680 wP12 = wOptions;
681 TRACE("Calling ExtTextOut 0x%lx 0x%x 0x%x %p\n",
682 lP1, wP2, wP3, lP4);
683 TRACE("%*s 0x%x 0x%lx 0x%lx\n",
684 nSize,lP5, iP6, lP7, lP8);
685 TRACE("0x%lx 0x%lx %p 0x%x\n",
686 lP9, lP10, lP11, wP12);
687 dwRet = PRTDRV_CallTo16_long_lwwllwlllllw(pLPD->fn[FUNC_EXTTEXTOUT],
688 lP1, wP2, wP3,
689 SEGPTR_GET(lP4),
690 SEGPTR_GET(lP5), iP6, lP7,
691 lP8, lP9, lP10,
692 SEGPTR_GET(lP11), wP12);
693 }
694 TRACE("return %lx\n", dwRet);
695 return dwRet;
696 }
697
698 /***********************************************************************
699 * dmEnumDFonts16
700 */
701 int WINAPI dmEnumDFonts16(LPPDEVICE lpDestDev, LPSTR lpFaceName, FARPROC16 lpCallbackFunc, LPVOID lpClientData)
702 {
703 /* Windows 3.1 just returns 1 */
704 return 1;
705 }
706
707 /***********************************************************************
708 * dmRealizeObject16
709 */
710 int WINAPI dmRealizeObject16(LPPDEVICE lpDestDev, INT16 wStyle, LPSTR lpInObj, LPSTR lpOutObj, SEGPTR lpTextXForm)
711 {
712 FIXME("(lpDestDev=%08x,wStyle=%04x,lpInObj=%08x,lpOutObj=%08x,lpTextXForm=%08x): stub\n",
713 (UINT)lpDestDev, wStyle, (UINT)lpInObj, (UINT)lpOutObj, (UINT)lpTextXForm);
714 if (wStyle < 0) { /* Free extra memory of given object's structure */
715 switch ( -wStyle ) {
716 case DRVOBJ_PEN: {
717 /* LPLOGPEN16 DeletePen = (LPLOGPEN16)lpInObj; */
718
719 TRACE("DRVOBJ_PEN_delete\n");
720 break;
721 }
722 case DRVOBJ_BRUSH: {
723 TRACE("DRVOBJ_BRUSH_delete\n");
724 break;
725 }
726 case DRVOBJ_FONT: {
727 /* LPTEXTXFORM16 TextXForm
728 = (LPTEXTXFORM16)lpTextXForm; */
729 TRACE("DRVOBJ_FONT_delete\n");
730 break;
731 }
732 case DRVOBJ_PBITMAP: TRACE("DRVOBJ_PBITMAP_delete\n");
733 break;
734 }
735 }
736 else { /* Realize given object */
737
738 switch (wStyle) {
739 case DRVOBJ_PEN: {
740 LPLOGPEN16 InPen = (LPLOGPEN16)lpInObj;
741
742 TRACE("DRVOBJ_PEN\n");
743 if (lpOutObj) {
744 if (InPen->lopnStyle == PS_NULL) {
745 *(DWORD *)lpOutObj = 0;
746 *(WORD *)(lpOutObj+4) = InPen->lopnStyle;
747 }
748 else
749 if ((InPen->lopnWidth.x > 1) || (InPen->lopnStyle > PS_NULL) ) {
750 *(DWORD *)lpOutObj = InPen->lopnColor;
751 *(WORD *)(lpOutObj+4) = 0;
752 }
753 else {
754 *(DWORD *)lpOutObj = InPen->lopnColor & 0xffff0000;
755 *(WORD *)(lpOutObj+4) = InPen->lopnStyle;
756 }
757 }
758 return sizeof(LOGPEN16);
759 }
760 case DRVOBJ_BRUSH: {
761 LPLOGBRUSH16 InBrush = (LPLOGBRUSH16)lpInObj;
762 LPLOGBRUSH16 OutBrush = (LPLOGBRUSH16)lpOutObj;
763 /* LPPOINT16 Point = (LPPOINT16)lpTextXForm; */
764
765 TRACE("DRVOBJ_BRUSH\n");
766 if (!lpOutObj) return sizeof(LOGBRUSH16);
767 else {
768 OutBrush->lbStyle = InBrush->lbStyle;
769 OutBrush->lbColor = InBrush->lbColor;
770 OutBrush->lbHatch = InBrush->lbHatch;
771 if (InBrush->lbStyle == BS_SOLID)
772 return 0x8002; /* FIXME: diff mono-color */
773 else return 0x8000;
774 }
775 }
776 case DRVOBJ_FONT: {
777 /* LPTEXTXFORM16 TextXForm
778 = (LPTEXTXFORM16)lpTextXForm; */
779 TRACE("DRVOBJ_FONT\n");
780 return 0;/* DISPLAY.DRV doesn't realize fonts */
781 }
782 case DRVOBJ_PBITMAP: TRACE("DRVOBJ_PBITMAP\n");
783 return 0; /* create memory bitmap */
784 }
785 }
786 return 1;
787 }
788
789
790 WORD PRTDRV_GetCharWidth(LPPDEVICE lpDestDev, LPINT lpBuffer,
791 WORD wFirstChar, WORD wLastChar, LPFONTINFO16 lpFontInfo,
792 SEGPTR lpDrawMode, SEGPTR lpTextXForm )
793 {
794
795 WORD wRet = 0;
796 LOADED_PRINTER_DRIVER *pLPD = NULL;
797
798 TRACE("(lots of params - fixme)\n");
799
800 if ((pLPD = FindPrinterDriverFromPDEVICE(lpDestDev)) != NULL)
801 {
802 LONG lP1, lP5, lP6, lP7;
803 LPWORD lP2;
804 WORD wP3, wP4, i;
805
806 if (pLPD->fn[FUNC_GETCHARWIDTH] == NULL)
807 {
808 WARN("Not supported by driver\n");
809 return 0;
810 }
811
812 lP1 = lpDestDev;
813 lP2 = SEGPTR_ALLOC( (wLastChar - wFirstChar + 1) * sizeof(WORD) );
814 wP3 = wFirstChar;
815 wP4 = wLastChar;
816 lP5 = SEGPTR_GET( lpFontInfo );
817 lP6 = lpDrawMode;
818 lP7 = lpTextXForm;
819
820 wRet = PRTDRV_CallTo16_word_llwwlll(pLPD->fn[FUNC_GETCHARWIDTH],
821 lP1, SEGPTR_GET(lP2), wP3,
822 wP4, lP5, lP6, lP7 );
823
824 for(i = 0; i <= wLastChar - wFirstChar; i++)
825 lpBuffer[i] = (INT) lP2[i];
826
827 SEGPTR_FREE(lP2);
828 }
829 return wRet;
830 }
831
832 /**************************************************************
833 *
834 * WIN16DRV_ExtDeviceMode
835 */
836 INT WIN16DRV_ExtDeviceMode(LPSTR lpszDriver, HWND hwnd, LPDEVMODEA lpdmOutput,
837 LPSTR lpszDevice, LPSTR lpszPort,
838 LPDEVMODEA lpdmInput, LPSTR lpszProfile,
839 DWORD dwMode)
840 {
841 LOADED_PRINTER_DRIVER *pLPD = LoadPrinterDriver(lpszDriver);
842 LPDEVMODEA lpSegOut = NULL, lpSegIn = NULL;
843 LPSTR lpSegDevice, lpSegPort, lpSegProfile;
844 INT16 wRet;
845 WORD wOutSize = 0, wInSize = 0;
846
847 if(!pLPD) return -1;
848
849 if(pLPD->fn[FUNC_EXTDEVICEMODE] == NULL) {
850 WARN("No EXTDEVICEMODE\n");
851 return -1;
852 }
853 lpSegDevice = SEGPTR_STRDUP(lpszDevice);
854 lpSegPort = SEGPTR_STRDUP(lpszPort);
855 lpSegProfile = SEGPTR_STRDUP(lpszProfile);
856 if(lpdmOutput) {
857 /* We don't know how big this will be so we call the driver's
858 ExtDeviceMode to find out */
859 wOutSize = PRTDRV_CallTo16_word_wwlllllw(
860 pLPD->fn[FUNC_EXTDEVICEMODE], hwnd, pLPD->hInst, 0,
861 SEGPTR_GET(lpSegDevice), SEGPTR_GET(lpSegPort), 0,
862 SEGPTR_GET(lpSegProfile), 0 );
863 lpSegOut = SEGPTR_ALLOC(wOutSize);
864 }
865 if(lpdmInput) {
866 /* This time we get the information from the fields */
867 wInSize = lpdmInput->dmSize + lpdmInput->dmDriverExtra;
868 lpSegIn = SEGPTR_ALLOC(wInSize);
869 memcpy(lpSegIn, lpdmInput, wInSize);
870 }
871 wRet = PRTDRV_CallTo16_word_wwlllllw( pLPD->fn[FUNC_EXTDEVICEMODE],
872 hwnd, pLPD->hInst,
873 SEGPTR_GET(lpSegOut),
874 SEGPTR_GET(lpSegDevice),
875 SEGPTR_GET(lpSegPort),
876 SEGPTR_GET(lpSegIn),
877 SEGPTR_GET(lpSegProfile),
878 dwMode );
879 if(lpSegOut) {
880 memcpy(lpdmOutput, lpSegOut, wOutSize);
881 SEGPTR_FREE(lpSegOut);
882 }
883 if(lpSegIn) {
884 SEGPTR_FREE(lpSegIn);
885 }
886 SEGPTR_FREE(lpSegDevice);
887 SEGPTR_FREE(lpSegPort);
888 SEGPTR_FREE(lpSegProfile);
889 return wRet;
890 }
891
892 /**************************************************************
893 *
894 * WIN16DRV_DeviceCapabilities
895 *
896 * This is a bit of a pain since we don't know the size of lpszOutput we have
897 * call the driver twice.
898 */
899 DWORD WIN16DRV_DeviceCapabilities(LPSTR lpszDriver, LPCSTR lpszDevice,
900 LPCSTR lpszPort, WORD fwCapability,
901 LPSTR lpszOutput, LPDEVMODEA lpDevMode)
902 {
903 LOADED_PRINTER_DRIVER *pLPD = LoadPrinterDriver(lpszDriver);
904 LPVOID lpSegdm = NULL, lpSegOut = NULL;
905 LPSTR lpSegDevice, lpSegPort;
906 DWORD dwRet;
907 INT OutputSize;
908
909 TRACE("%s,%s,%s,%d,%p,%p\n", lpszDriver, lpszDevice, lpszPort,
910 fwCapability, lpszOutput, lpDevMode);
911
912 if(!pLPD) return -1;
913
914 if(pLPD->fn[FUNC_DEVICECAPABILITIES] == NULL) {
915 WARN("No DEVICECAPABILITES\n");
916 return -1;
917 }
918 lpSegDevice = SEGPTR_STRDUP(lpszDevice);
919 lpSegPort = SEGPTR_STRDUP(lpszPort);
920
921 if(lpDevMode) {
922 lpSegdm = SEGPTR_ALLOC(lpDevMode->dmSize + lpDevMode->dmDriverExtra);
923 memcpy(lpSegdm, lpDevMode, lpDevMode->dmSize +
924 lpDevMode->dmDriverExtra);
925 }
926
927 dwRet = PRTDRV_CallTo16_long_llwll(
928 pLPD->fn[FUNC_DEVICECAPABILITIES],
929 SEGPTR_GET(lpSegDevice), SEGPTR_GET(lpSegPort),
930 fwCapability, 0, SEGPTR_GET(lpSegdm) );
931
932 if(dwRet == -1) return -1;
933
934 switch(fwCapability) {
935 case DC_BINADJUST:
936 case DC_COLLATE:
937 case DC_COLORDEVICE:
938 case DC_COPIES:
939 case DC_DRIVER:
940 case DC_DUPLEX:
941 case DC_EMF_COMPLIANT:
942 case DC_EXTRA:
943 case DC_FIELDS:
944 case DC_MANUFACTURER:
945 case DC_MAXEXTENT:
946 case DC_MINEXTENT:
947 case DC_MODEL:
948 case DC_ORIENTATION:
949 case DC_PRINTERMEM:
950 case DC_PRINTRATEUNIT:
951 case DC_SIZE:
952 case DC_TRUETYPE:
953 case DC_VERSION:
954 OutputSize = 0;
955 break;
956
957 case DC_BINNAMES:
958 OutputSize = 24 * dwRet;
959 break;
960
961 case DC_BINS:
962 case DC_PAPERS:
963 OutputSize = sizeof(WORD) * dwRet;
964 break;
965
966 case DC_DATATYPE_PRODUCED:
967 OutputSize = dwRet;
968 FIXME("%ld DataTypes supported. Don't know how long to make buffer!\n",
969 dwRet);
970 break;
971
972 case DC_ENUMRESOLUTIONS:
973 OutputSize = 2 * sizeof(LONG) * dwRet;
974 break;
975
976 case DC_FILEDEPENDENCIES:
977 case DC_MEDIAREADY:
978 case DC_PAPERNAMES:
979 OutputSize = 64 * dwRet;
980 break;
981
982 case DC_NUP:
983 OutputSize = sizeof(DWORD) * dwRet;
984 break;
985
986 case DC_PAPERSIZE:
987 OutputSize = sizeof(POINT16) * dwRet;
988 break;
989
990 case DC_PERSONALITY:
991 OutputSize = 32 * dwRet;
992 break;
993
994 default:
995 FIXME("Unsupported capability %d\n", fwCapability);
996 OutputSize = 0;
997 break;
998 }
999
1000 if(OutputSize && lpszOutput) {
1001 lpSegOut = SEGPTR_ALLOC(OutputSize);
1002 dwRet = PRTDRV_CallTo16_long_llwll(
1003 pLPD->fn[FUNC_DEVICECAPABILITIES],
1004 SEGPTR_GET(lpSegDevice),
1005 SEGPTR_GET(lpSegPort),
1006 fwCapability,
1007 SEGPTR_GET(lpSegOut),
1008 SEGPTR_GET(lpSegdm) );
1009 memcpy(lpszOutput, lpSegOut, OutputSize);
1010 SEGPTR_FREE(lpSegOut);
1011 }
1012
1013 if(lpSegdm) {
1014 memcpy(lpDevMode, lpSegdm, lpDevMode->dmSize +
1015 lpDevMode->dmDriverExtra);
1016 SEGPTR_FREE(lpSegdm);
1017 }
1018 SEGPTR_FREE(lpSegDevice);
1019 SEGPTR_FREE(lpSegPort);
1020 return dwRet;
1021 }
Maarten's multimedia branch