graphics/win16drv/prtdrv.c

   1 /*
   2  * Windows Device Context initialisation functions
   3  *
   4  * Copyright 1996 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 "windows.h"
  14 #include "win16drv.h"
  15
  16 #include "callback.h"
  17 #include "stddebug.h"
  18 #include "debug.h"
  19
  20 #define MAX_PRINTER_DRIVERS     16
  21 static LOADED_PRINTER_DRIVER *gapLoadedPrinterDrivers[MAX_PRINTER_DRIVERS];
  22
  23
  24 static void GetPrinterDriverFunctions(HINSTANCE16 hInst, LOADED_PRINTER_DRIVER *pLPD)
  25 {
  26 #define LoadPrinterDrvFunc(A) pLPD->fn[FUNC_##A] = \
  27       GetProcAddress16(hInst, MAKEINTRESOURCE(ORD_##A))
  28
  29       LoadPrinterDrvFunc(BITBLT);
  30       LoadPrinterDrvFunc(COLORINFO);
  31       LoadPrinterDrvFunc(CONTROL);
  32       LoadPrinterDrvFunc(DISABLE);
  33       LoadPrinterDrvFunc(ENABLE);
  34       LoadPrinterDrvFunc(ENUMDFONTS);
  35       LoadPrinterDrvFunc(ENUMOBJ);
  36       LoadPrinterDrvFunc(OUTPUT);
  37       LoadPrinterDrvFunc(PIXEL);
  38       LoadPrinterDrvFunc(REALIZEOBJECT);
  39       LoadPrinterDrvFunc(STRBLT);
  40       LoadPrinterDrvFunc(SCANLR);
  41       LoadPrinterDrvFunc(DEVICEMODE);
  42       LoadPrinterDrvFunc(EXTTEXTOUT);
  43       LoadPrinterDrvFunc(GETCHARWIDTH);
  44       LoadPrinterDrvFunc(DEVICEBITMAP);
  45       LoadPrinterDrvFunc(FASTBORDER);
  46       LoadPrinterDrvFunc(SETATTRIBUTE);
  47       LoadPrinterDrvFunc(STRETCHBLT);
  48       LoadPrinterDrvFunc(STRETCHDIBITS);
  49       LoadPrinterDrvFunc(SELECTBITMAP);
  50       LoadPrinterDrvFunc(BITMAPBITS);
  51       LoadPrinterDrvFunc(EXTDEVICEMODE);
  52       LoadPrinterDrvFunc(DEVICECAPABILITIES);
  53       LoadPrinterDrvFunc(ADVANCEDSETUPDIALOG);
  54       LoadPrinterDrvFunc(DIALOGFN);
  55       LoadPrinterDrvFunc(PSEUDOEDIT);
  56       dprintf_win16drv (stddeb,"got func CONTROL 0x%p enable 0x%p enumDfonts 0x%p realizeobject 0x%p extextout 0x%p\n",
  57               pLPD->fn[FUNC_CONTROL],
  58               pLPD->fn[FUNC_ENABLE],
  59               pLPD->fn[FUNC_ENUMDFONTS],
  60               pLPD->fn[FUNC_REALIZEOBJECT],
  61               pLPD->fn[FUNC_EXTTEXTOUT]);
  62
  63
  64 }
  65
  66
  67 static LOADED_PRINTER_DRIVER *FindPrinterDriverFromName(const char *pszDriver)
  68 {
  69     LOADED_PRINTER_DRIVER *pLPD = NULL;
  70     int         nDriverSlot = 0;
  71
  72     /* Look to see if the printer driver is already loaded */
  73     while (pLPD == NULL && nDriverSlot < MAX_PRINTER_DRIVERS)
  74     {
  75         LOADED_PRINTER_DRIVER *ptmpLPD;
  76         ptmpLPD = gapLoadedPrinterDrivers[nDriverSlot++];
  77         if (ptmpLPD != NULL)
  78         {
  79             dprintf_win16drv(stddeb, "Comparing %s,%s\n",ptmpLPD->szDriver,pszDriver);
  80             /* Found driver store info, exit loop */
  81             if (lstrcmpi32A(ptmpLPD->szDriver, pszDriver) == 0)
  82               pLPD = ptmpLPD;
  83         }
  84     }
  85     if (pLPD == NULL) printf("Couldn't find driver %s\n", pszDriver);
  86     return pLPD;
  87 }
  88
  89 static LOADED_PRINTER_DRIVER *FindPrinterDriverFromPDEVICE(SEGPTR segptrPDEVICE)
  90 {
  91     LOADED_PRINTER_DRIVER *pLPD = NULL;
  92
  93     /* Find the printer driver associated with this PDEVICE */
  94     /* Each of the PDEVICE structures has a PDEVICE_HEADER structure */
  95     /* just before it */
  96     if (segptrPDEVICE != (SEGPTR)NULL)
  97     {
  98         PDEVICE_HEADER *pPDH = (PDEVICE_HEADER *)
  99           (PTR_SEG_TO_LIN(segptrPDEVICE) - sizeof(PDEVICE_HEADER));
 100         pLPD = pPDH->pLPD;
 101     }
 102     return pLPD;
 103 }
 104
 105 /*
 106  * Load a printer driver, adding it self to the list of loaded drivers.
 107  */
 108
 109 LOADED_PRINTER_DRIVER *LoadPrinterDriver(const char *pszDriver)
 110 {
 111     HINSTANCE16 hInst;
 112     LOADED_PRINTER_DRIVER *pLPD = NULL;
 113     int         nDriverSlot = 0;
 114     BOOL32      bSlotFound = FALSE;
 115
 116     /* First look to see if driver is loaded */
 117     pLPD = FindPrinterDriverFromName(pszDriver);
 118     if (pLPD != NULL)
 119     {
 120         /* Already loaded so increase usage count */
 121         pLPD->nUsageCount++;
 122         return pLPD;
 123     }
 124
 125     /* Not loaded so try and find an empty slot */
 126     while (!bSlotFound && nDriverSlot < MAX_PRINTER_DRIVERS)
 127     {
 128         if (gapLoadedPrinterDrivers[nDriverSlot] == NULL)
 129           bSlotFound = TRUE;
 130         else
 131           nDriverSlot++;
 132     }
 133     if (!bSlotFound)
 134     {
 135         printf("Too many printers drivers loaded\n");
 136         return NULL;
 137     }
 138
 139     {
 140         char *drvName = malloc(strlen(pszDriver)+5);
 141         strcpy(drvName, pszDriver);
 142         strcat(drvName, ".DRV");
 143         hInst = LoadLibrary16(drvName);
 144     }
 145     dprintf_win16drv(stddeb, "Loaded the library\n");
 146
 147
 148     if (hInst <= 32)
 149     {
 150         /* Failed to load driver */
 151         fprintf(stderr, "Failed to load printer driver %s\n", pszDriver);
 152     }
 153     else
 154     {
 155         HANDLE16 hHandle;
 156
 157         /* Allocate some memory for printer driver info */
 158         pLPD = malloc(sizeof(LOADED_PRINTER_DRIVER));
 159         memset(pLPD, 0 , sizeof(LOADED_PRINTER_DRIVER));
 160
 161         pLPD->hInst = hInst;
 162         strcpy(pLPD->szDriver,pszDriver);
 163
 164         /* Get DS for the printer module */
 165         pLPD->ds_reg = hInst;
 166
 167         dprintf_win16drv(stddeb, "DS for %s is %x\n", pszDriver, pLPD->ds_reg);
 168
 169         /* Get address of printer driver functions */
 170         GetPrinterDriverFunctions(hInst, pLPD);
 171
 172         /* Set initial usage count */
 173         pLPD->nUsageCount = 1;
 174
 175         /* Create a thunking buffer */
 176         hHandle = GlobalAlloc16(GHND, (1024 * 8));
 177         pLPD->hThunk = hHandle;
 178         pLPD->ThunkBufSegPtr = WIN16_GlobalLock16(hHandle);
 179         pLPD->ThunkBufLimit = pLPD->ThunkBufSegPtr + (1024*8);
 180
 181         /* Update table of loaded printer drivers */
 182         pLPD->nIndex = nDriverSlot;
 183         gapLoadedPrinterDrivers[nDriverSlot] = pLPD;
 184     }
 185
 186     return pLPD;
 187 }
 188
 189 /*
 190  * Thunking utility functions
 191  */
 192
 193 static BOOL32 AddData(SEGPTR *pSegPtr, const void *pData, int nSize, SEGPTR Limit)
 194 {
 195     BOOL32 bRet = FALSE;
 196     char *pBuffer = PTR_SEG_TO_LIN((*pSegPtr));
 197     char *pLimit = PTR_SEG_TO_LIN(Limit);
 198
 199
 200     if ((pBuffer + nSize) < pLimit)
 201     {
 202         DWORD *pdw = (DWORD *)pSegPtr;
 203         SEGPTR SegPtrOld = *pSegPtr;
 204         SEGPTR SegPtrNew;
 205
 206         dprintf_win16drv(stddeb, "AddData: Copying %d from %p to %p(0x%x)\n", nSize, pData, pBuffer, (UINT32)*pSegPtr);
 207         memcpy(pBuffer, pData, nSize);
 208         SegPtrNew = (SegPtrOld + nSize + 1);
 209         *pdw = (DWORD)SegPtrNew;
 210     }
 211     return bRet;
 212 }
 213
 214
 215 static BOOL32 GetParamData(SEGPTR SegPtrSrc,void *pDataDest, int nSize)
 216 {
 217     char *pSrc =  PTR_SEG_TO_LIN(SegPtrSrc);
 218     char *pDest = pDataDest;
 219
 220     dprintf_win16drv(stddeb, "GetParamData: Copying %d from %lx(%lx) to %lx\n", nSize, (DWORD)pSrc, (DWORD)SegPtrSrc, (DWORD)pDataDest);
 221     memcpy(pDest, pSrc, nSize);
 222     return TRUE;
 223 }
 224
 225 /*
 226  *  Control (ordinal 3)
 227  */
 228 INT16 PRTDRV_Control(LPPDEVICE lpDestDev, WORD wfunction, SEGPTR lpInData, SEGPTR lpOutData)
 229 {
 230     /* wfunction == Escape code */
 231     /* lpInData, lpOutData depend on code */
 232
 233     WORD wRet = 0;
 234     LOADED_PRINTER_DRIVER *pLPD = NULL;
 235
 236     dprintf_win16drv(stddeb, "PRTDRV_Control: %08x 0x%x %08lx %08lx\n", (unsigned int)lpDestDev, wfunction, lpInData, lpOutData);
 237
 238     if ((pLPD = FindPrinterDriverFromPDEVICE(lpDestDev)) != NULL)
 239     {
 240         LONG lP1, lP3, lP4;
 241         WORD wP2;
 242
 243         if (pLPD->fn[FUNC_CONTROL] == NULL)
 244         {
 245             dprintf_win16drv(stddeb, "PRTDRV_Control: Not supported by driver\n");
 246             return 0;
 247         }
 248
 249         lP1 = (SEGPTR)lpDestDev;
 250         wP2 = wfunction;
 251         lP3 = (SEGPTR)lpInData;
 252         lP4 = (SEGPTR)lpOutData;
 253
 254         wRet = CallTo16_word_lwll(pLPD->fn[FUNC_CONTROL],
 255                                   lP1, wP2, lP3, lP4);
 256     }
 257     dprintf_win16drv(stddeb, "PRTDRV_Control: return %x\n", wRet);
 258     return wRet;
 259
 260     return 0;
 261 }
 262
 263 /*
 264  *      Enable (ordinal 5)
 265  */
 266 WORD PRTDRV_Enable(LPVOID lpDevInfo, WORD wStyle, LPCSTR  lpDestDevType,
 267                           LPCSTR lpDeviceName, LPCSTR lpOutputFile, LPVOID lpData)
 268 {
 269     WORD wRet = 0;
 270     LOADED_PRINTER_DRIVER *pLPD = NULL;
 271
 272     dprintf_win16drv(stddeb, "PRTDRV_Enable: %s %s\n",lpDestDevType, lpOutputFile);
 273
 274     /* Get the printer driver info */
 275     if (wStyle == INITPDEVICE)
 276     {
 277         pLPD = FindPrinterDriverFromPDEVICE((SEGPTR)lpDevInfo);
 278     }
 279     else
 280     {
 281         pLPD = FindPrinterDriverFromName((char *)lpDeviceName);
 282     }
 283     if (pLPD != NULL)
 284     {
 285         LONG lP1, lP3, lP4, lP5;
 286         WORD wP2;
 287         SEGPTR SegPtr = pLPD->ThunkBufSegPtr;
 288         SEGPTR Limit = pLPD->ThunkBufLimit;
 289         int   nSize;
 290
 291         if (pLPD->fn[FUNC_ENABLE] == NULL)
 292         {
 293             dprintf_win16drv(stddeb, "PRTDRV_Enable: Not supported by driver\n");
 294             return 0;
 295         }
 296
 297         if (wStyle == INITPDEVICE)
 298         {
 299             /* All ready a 16 address */
 300             lP1 = (SEGPTR)lpDevInfo;
 301         }
 302         else
 303         {
 304             /* 32 bit data */
 305             lP1 = SegPtr;
 306             nSize = sizeof(DeviceCaps);
 307             AddData(&SegPtr, lpDevInfo, nSize, Limit);
 308         }
 309
 310         wP2 = wStyle;
 311
 312         lP3 = SegPtr;
 313         nSize = strlen(lpDestDevType) + 1;
 314         AddData(&SegPtr, lpDestDevType, nSize, Limit);
 315
 316         lP4 = SegPtr;
 317         nSize = strlen(lpOutputFile) + 1;
 318         AddData(&SegPtr, lpOutputFile, nSize, Limit);
 319
 320         lP5 = (LONG)lpData;
 321
 322
 323         wRet = CallTo16_word_lwlll(pLPD->fn[FUNC_ENABLE],
 324                                    lP1, wP2, lP3, lP4, lP5);
 325
 326         /* Get the data back */
 327         if (lP1 != 0 && wStyle != INITPDEVICE)
 328         {
 329             nSize = sizeof(DeviceCaps);
 330             GetParamData(lP1, lpDevInfo, nSize);
 331         }
 332     }
 333     dprintf_win16drv(stddeb, "PRTDRV_Enable: return %x\n", wRet);
 334     return wRet;
 335 }
 336
 337
 338 /*
 339  *      EnumDFonts (ordinal 6)
 340  */
 341 WORD PRTDRV_EnumDFonts(LPPDEVICE lpDestDev, LPSTR lpFaceName,
 342                        FARPROC16 lpCallbackFunc, LPVOID lpClientData)
 343 {
 344     WORD wRet = 0;
 345     LOADED_PRINTER_DRIVER *pLPD = NULL;
 346
 347     dprintf_win16drv(stddeb, "PRTDRV_EnumDFonts:\n");
 348
 349     if ((pLPD = FindPrinterDriverFromPDEVICE(lpDestDev)) != NULL)
 350     {
 351         LONG lP1, lP2, lP3, lP4;
 352
 353         SEGPTR SegPtr = pLPD->ThunkBufSegPtr;
 354         SEGPTR Limit = pLPD->ThunkBufLimit;
 355         int   nSize;
 356
 357         if (pLPD->fn[FUNC_ENUMDFONTS] == NULL)
 358         {
 359             dprintf_win16drv(stddeb, "PRTDRV_EnumDFonts: Not supported by driver\n");
 360             return 0;
 361         }
 362
 363         lP1 = (SEGPTR)lpDestDev;
 364
 365         if (lpFaceName == NULL)
 366         {
 367             lP2 = 0;
 368         }
 369         else
 370         {
 371             lP2 = SegPtr;
 372             nSize = strlen(lpFaceName) + 1;
 373             AddData(&SegPtr, lpFaceName, nSize, Limit);
 374         }
 375
 376         lP3 = (LONG)lpCallbackFunc;
 377
 378         lP4 = (LONG)lpClientData;
 379
 380         wRet = CallTo16_word_llll(pLPD->fn[FUNC_ENUMDFONTS],
 381                                   lP1, lP2, lP3, lP4);
 382     }
 383     else
 384         printf("Failed to find device\n");
 385
 386     dprintf_win16drv(stddeb, "PRTDRV_EnumDFonts: return %x\n", wRet);
 387     return wRet;
 388 }
 389 /*
 390  *      EnumObj (ordinal 7)
 391  */
 392 BOOL16 PRTDRV_EnumObj(LPPDEVICE lpDestDev, WORD iStyle,
 393                        FARPROC16 lpCallbackFunc, LPVOID lpClientData)
 394 {
 395     WORD wRet = 0;
 396     LOADED_PRINTER_DRIVER *pLPD = NULL;
 397
 398     dprintf_win16drv(stddeb, "PRTDRV_EnumDFonts:\n");
 399
 400     if ((pLPD = FindPrinterDriverFromPDEVICE(lpDestDev)) != NULL)
 401     {
 402         LONG lP1, lP3, lP4;
 403         WORD wP2;
 404
 405         if (pLPD->fn[FUNC_ENUMDFONTS] == NULL)
 406         {
 407             dprintf_win16drv(stddeb, "PRTDRV_EnumDFonts: Not supported by driver\n");
 408             return 0;
 409         }
 410
 411         lP1 = (SEGPTR)lpDestDev;
 412
 413         wP2 = iStyle;
 414
 415         /*
 416          * Need to pass addres of function conversion function that will switch back to 32 bit code if necessary
 417          */
 418         lP3 = (LONG)lpCallbackFunc;
 419
 420         lP4 = (LONG)lpClientData;
 421
 422         wRet = CallTo16_word_lwll(pLPD->fn[FUNC_ENUMOBJ],
 423                                   lP1, wP2, lP3, lP4);
 424     }
 425     else
 426         printf("Failed to find device\n");
 427
 428     dprintf_win16drv(stddeb, "PRTDRV_EnumDFonts: return %x\n", wRet);
 429     return wRet;
 430 }
 431
 432 /*
 433  * RealizeObject (ordinal 10)
 434  */
 435 DWORD PRTDRV_RealizeObject(LPPDEVICE lpDestDev, WORD wStyle,
 436                     LPVOID lpInObj, LPVOID lpOutObj,
 437                     LPTEXTXFORM16 lpTextXForm)
 438 {
 439     WORD dwRet = 0;
 440     LOADED_PRINTER_DRIVER *pLPD = NULL;
 441
 442     dprintf_win16drv(stddeb, "PRTDRV_RealizeObject:\n");
 443
 444     if ((pLPD = FindPrinterDriverFromPDEVICE(lpDestDev)) != NULL)
 445     {
 446         LONG lP1, lP3, lP4, lP5;
 447         WORD wP2;
 448         SEGPTR SegPtr = pLPD->ThunkBufSegPtr;
 449         SEGPTR Limit = pLPD->ThunkBufLimit;
 450         int   nSize;
 451
 452         if (pLPD->fn[FUNC_REALIZEOBJECT] == NULL)
 453         {
 454             dprintf_win16drv(stddeb, "PRTDRV_RealizeObject: Not supported by driver\n");
 455             return 0;
 456         }
 457
 458         lP1 = lpDestDev;
 459         wP2 = wStyle;
 460
 461         lP3 = SegPtr;
 462         switch (wStyle)
 463         {
 464         case 3:
 465             nSize = sizeof(LOGFONT16);
 466             break;
 467         default:
 468             printf("PRTDRV_RealizeObject: Object type %d not supported\n", wStyle);
 469             nSize = 0;
 470
 471         }
 472         AddData(&SegPtr, lpInObj, nSize, Limit);
 473
 474         lP4 = (LONG)lpOutObj;
 475
 476         if (lpTextXForm != NULL)
 477         {
 478             lP5 = SegPtr;
 479             nSize = sizeof(TEXTXFORM16);
 480             AddData(&SegPtr, lpTextXForm, nSize, Limit);
 481         }
 482         else
 483           lP5 = 0L;
 484
 485         dwRet = CallTo16_long_lwlll(pLPD->fn[FUNC_REALIZEOBJECT],
 486                                     lP1, wP2, lP3, lP4, lP5);
 487
 488     }
 489     dprintf_win16drv(stddeb, "PRTDRV_RealizeObject: return %x\n", dwRet);
 490     return dwRet;
 491 }
 492
 493
 494 DWORD PRTDRV_ExtTextOut(LPPDEVICE lpDestDev, WORD wDestXOrg, WORD wDestYOrg,
 495                         RECT16 *lpClipRect, LPCSTR lpString, WORD wCount,
 496                         SEGPTR lpFontInfo, LPDRAWMODE lpDrawMode,
 497                         LPTEXTXFORM16 lpTextXForm, SHORT *lpCharWidths,
 498                         RECT16 *     lpOpaqueRect, WORD wOptions)
 499 {
 500     DWORD dwRet = 0;
 501     LOADED_PRINTER_DRIVER *pLPD = NULL;
 502
 503     dprintf_win16drv(stddeb, "PRTDRV_ExtTextOut:\n");
 504
 505     if ((pLPD = FindPrinterDriverFromPDEVICE(lpDestDev)) != NULL)
 506     {
 507         LONG lP1, lP4, lP5, lP7, lP8, lP9, lP10, lP11;
 508         WORD wP2, wP3, wP12;
 509         INT16 iP6;
 510
 511         SEGPTR SegPtr = pLPD->ThunkBufSegPtr;
 512         SEGPTR Limit = pLPD->ThunkBufLimit;
 513         int   nSize;
 514
 515         if (pLPD->fn[FUNC_EXTTEXTOUT] == NULL)
 516         {
 517             dprintf_win16drv(stddeb, "PRTDRV_ExtTextOut: Not supported by driver\n");
 518             return 0;
 519         }
 520
 521         lP1 = lpDestDev;
 522         wP2 = wDestXOrg;
 523         wP3 = wDestYOrg;
 524
 525         if (lpClipRect != NULL)
 526         {
 527             lP4 = SegPtr;
 528             nSize = sizeof(RECT16);
 529             dprintf_win16drv(stddeb, "Adding lpClipRect\n");
 530
 531             AddData(&SegPtr, lpClipRect, nSize, Limit);
 532         }
 533         else
 534           lP4 = 0L;
 535
 536         if (lpString != NULL)
 537         {
 538             /* TTD WARNING THIS STRING ISNT NULL TERMINATED */
 539             lP5 = SegPtr;
 540             nSize = strlen(lpString);
 541             nSize = abs(wCount);
 542             dprintf_win16drv(stddeb, "Adding string size %d\n",nSize);
 543
 544             AddData(&SegPtr, lpString, nSize, Limit);
 545         }
 546         else
 547           lP5 = 0L;
 548
 549         iP6 = wCount;
 550
 551         /* This should be realized by the driver, so in 16bit data area */
 552         lP7 = lpFontInfo;
 553
 554         if (lpDrawMode != NULL)
 555         {
 556             lP8 = SegPtr;
 557             nSize = sizeof(DRAWMODE);
 558             dprintf_win16drv(stddeb, "adding lpDrawMode\n");
 559
 560             AddData(&SegPtr, lpDrawMode, nSize, Limit);
 561         }
 562         else
 563           lP8 = 0L;
 564
 565         if (lpTextXForm != NULL)
 566         {
 567             lP9 = SegPtr;
 568             nSize = sizeof(TEXTXFORM16);
 569             dprintf_win16drv(stddeb, "Adding TextXForm\n");
 570             AddData(&SegPtr, lpTextXForm, nSize, Limit);
 571         }
 572         else
 573           lP9 = 0L;
 574
 575         if (lpCharWidths != NULL)
 576           dprintf_win16drv(stddeb, "PRTDRV_ExtTextOut: Char widths not supported\n");
 577         lP10 = 0;
 578
 579         if (lpOpaqueRect != NULL)
 580         {
 581             lP11 = SegPtr;
 582             nSize = sizeof(RECT16);
 583             dprintf_win16drv(stddeb, "Adding opaqueRect\n");
 584             AddData(&SegPtr, lpOpaqueRect, nSize, Limit);
 585         }
 586         else
 587           lP11 = 0L;
 588
 589         wP12 = wOptions;
 590         dprintf_win16drv(stddeb, "Calling exttextout 0x%lx 0x%x 0x%x 0x%lx\n0x%lx 0x%x 0x%lx 0x%lx\n"
 591                "0x%lx 0x%lx 0x%lx 0x%x\n",lP1, wP2, wP3, lP4,
 592                                            lP5, iP6, lP7, lP8, lP9, lP10,
 593                                            lP11, wP12);
 594         dwRet = CallTo16_long_lwwllwlllllw(pLPD->fn[FUNC_EXTTEXTOUT],
 595                                            lP1, wP2, wP3, lP4,
 596                                            lP5, iP6, lP7, lP8, lP9, lP10,
 597                                            lP11, wP12);
 598         if (lpDrawMode)
 599             GetParamData(lP8, lpDrawMode, sizeof(DRAWMODE));
 600     }
 601     dprintf_win16drv(stddeb, "PRTDRV_ExtTextOut: return %lx\n", dwRet);
 602     return dwRet;
 603 }