graphics/win16drv/init.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 "module.h"
  15 #include "win16drv.h"
  16 #include "gdi.h"
  17 #include "bitmap.h"
  18 #include "heap.h"
  19 #include "color.h"
  20 #include "font.h"
  21 #include "callback.h"
  22 #include "stddebug.h"
  23 #include "debug.h"
  24
  25 #define SUPPORT_REALIZED_FONTS 1
  26 typedef SEGPTR LPPDEVICE;
  27
  28
  29 #if 0
  30 static BOOL16 windrvExtTextOut16( DC *dc, INT16 x, INT16 y, UINT16 flags, const RECT16 * lprect,
  31                                  LPCSTR str, UINT16 count, const INT16 *lpDx);
  32 #endif
  33
  34 DRAWMODE DrawMode;
  35 static BOOL32 WIN16DRV_CreateDC( DC *dc, LPCSTR driver, LPCSTR device,
  36                                  LPCSTR output, const DEVMODE16* initData );
  37 static INT32 WIN16DRV_Escape( DC *dc, INT32 nEscape, INT32 cbInput,
  38                               SEGPTR lpInData, SEGPTR lpOutData );
  39
  40 static const DC_FUNCTIONS WIN16DRV_Funcs =
  41 {
  42     NULL,                            /* pArc */
  43     NULL,                            /* pBitBlt */
  44     NULL,                            /* pChord */
  45     WIN16DRV_CreateDC,               /* pCreateDC */
  46     NULL,                            /* pDeleteDC */
  47     NULL,                            /* pDeleteObject */
  48     NULL,                            /* pEllipse */
  49     WIN16DRV_Escape,                 /* pEscape */
  50     NULL,                            /* pExcludeClipRect */
  51     NULL,                            /* pExcludeVisRect */
  52     NULL,                            /* pExtFloodFill */
  53     WIN16DRV_ExtTextOut,             /* pExtTextOut */
  54     NULL,                            /* pGetPixel */
  55     WIN16DRV_GetTextExtentPoint,     /* pGetTextExtentPoint */
  56     WIN16DRV_GetTextMetrics,         /* pGetTextMetrics */
  57     NULL,                            /* pIntersectClipRect */
  58     NULL,                            /* pIntersectVisRect */
  59     NULL,                            /* pLineTo */
  60     NULL,                            /* pMoveToEx */
  61     NULL,                            /* pOffsetClipRgn */
  62     NULL,                            /* pOffsetViewportOrgEx */
  63     NULL,                            /* pOffsetWindowOrgEx */
  64     NULL,                            /* pPaintRgn */
  65     NULL,                            /* pPatBlt */
  66     NULL,                            /* pPie */
  67     NULL,                            /* pPolyPolygon */
  68     NULL,                            /* pPolygon */
  69     NULL,                            /* pPolyline */
  70     NULL,                            /* pRealizePalette */
  71     NULL,                            /* pRectangle */
  72     NULL,                            /* pRestoreDC */
  73     NULL,                            /* pRoundRect */
  74     NULL,                            /* pSaveDC */
  75     NULL,                            /* pScaleViewportExtEx */
  76     NULL,                            /* pScaleWindowExtEx */
  77     NULL,                            /* pSelectClipRgn */
  78     WIN16DRV_SelectObject,           /* pSelectObject */
  79     NULL,                            /* pSelectPalette */
  80     NULL,                            /* pSetBkColor */
  81     NULL,                            /* pSetBkMode */
  82     NULL,                            /* pSetDeviceClipping */
  83     NULL,                            /* pSetDIBitsToDevice */
  84     NULL,                            /* pSetMapMode */
  85     NULL,                            /* pSetMapperFlags */
  86     NULL,                            /* pSetPixel */
  87     NULL,                            /* pSetPolyFillMode */
  88     NULL,                            /* pSetROP2 */
  89     NULL,                            /* pSetRelAbs */
  90     NULL,                            /* pSetStretchBltMode */
  91     NULL,                            /* pSetTextAlign */
  92     NULL,                            /* pSetTextCharacterExtra */
  93     NULL,                            /* pSetTextColor */
  94     NULL,                            /* pSetTextJustification */
  95     NULL,                            /* pSetViewportExtEx */
  96     NULL,                            /* pSetViewportOrgEx */
  97     NULL,                            /* pSetWindowExtEx */
  98     NULL,                            /* pSetWindowOrgEx */
  99     NULL,                            /* pStretchBlt */
 100     NULL                             /* pStretchDIBits */
 101 };
 102
 103
 104 #define MAX_PRINTER_DRIVERS     16
 105
 106 static LOADED_PRINTER_DRIVER *gapLoadedPrinterDrivers[MAX_PRINTER_DRIVERS];
 107
 108
 109 /**********************************************************************
 110  *           WIN16DRV_Init
 111  */
 112 BOOL32 WIN16DRV_Init(void)
 113 {
 114     return DRIVER_RegisterDriver( NULL /* generic driver */, &WIN16DRV_Funcs );
 115
 116 }
 117
 118 /* Tempory functions, for initialising structures */
 119 /* These values should be calculated, not hardcoded */
 120 void InitTextXForm(LPTEXTXFORM16 lpTextXForm)
 121 {
 122     lpTextXForm->txfHeight      = 0x0001;
 123     lpTextXForm->txfWidth       = 0x000c;
 124     lpTextXForm->txfEscapement  = 0x0000;
 125     lpTextXForm->txfOrientation = 0x0000;
 126     lpTextXForm->txfWeight      = 0x0190;
 127     lpTextXForm->txfItalic      = 0x00;
 128     lpTextXForm->txfUnderline   = 0x00;
 129     lpTextXForm->txfStrikeOut   = 0x00;
 130     lpTextXForm->txfOutPrecision = 0x02;
 131     lpTextXForm->txfClipPrecision = 0x01;
 132     lpTextXForm->txfAccelerator = 0x0001;
 133     lpTextXForm->txfOverhang    = 0x0000;
 134 }
 135
 136
 137 void InitDrawMode(LPDRAWMODE lpDrawMode)
 138 {
 139     lpDrawMode->Rop2            = 0x000d;
 140     lpDrawMode->bkMode          = 0x0001;
 141     lpDrawMode->bkColor         = 0x3fffffff;
 142     lpDrawMode->TextColor       = 0x20000000;
 143     lpDrawMode->TBreakExtra     = 0x0000;
 144     lpDrawMode->BreakExtra      = 0x0000;
 145     lpDrawMode->BreakErr        = 0x0000;
 146     lpDrawMode->BreakRem        = 0x0000;
 147     lpDrawMode->BreakCount      = 0x0000;
 148     lpDrawMode->CharExtra       = 0x0000;
 149     lpDrawMode->LbkColor        = 0x00ffffff;
 150     lpDrawMode->LTextColor      = 0x00000000;
 151 }
 152 /*
 153  * Thunking utility functions
 154  */
 155
 156 static BOOL32 AddData(SEGPTR *pSegPtr, const void *pData, int nSize, SEGPTR Limit)
 157 {
 158     BOOL32 bRet = FALSE;
 159     char *pBuffer = PTR_SEG_TO_LIN((*pSegPtr));
 160     char *pLimit = PTR_SEG_TO_LIN(Limit);
 161
 162
 163     if ((pBuffer + nSize) < pLimit)
 164     {
 165         DWORD *pdw = (DWORD *)pSegPtr;
 166         SEGPTR SegPtrOld = *pSegPtr;
 167         SEGPTR SegPtrNew;
 168
 169         dprintf_win16drv(stddeb, "AddData: Copying %d from %p to %p(0x%x)\n", nSize, pData, pBuffer, (UINT32)*pSegPtr);
 170         memcpy(pBuffer, pData, nSize);
 171         SegPtrNew = (SegPtrOld + nSize + 1);
 172         *pdw = (DWORD)SegPtrNew;
 173     }
 174     return bRet;
 175 }
 176
 177
 178 static BOOL32 GetParamData(SEGPTR SegPtrSrc,void *pDataDest, int nSize)
 179 {
 180     char *pSrc =  PTR_SEG_TO_LIN(SegPtrSrc);
 181     char *pDest = pDataDest;
 182
 183     dprintf_win16drv(stddeb, "GetParamData: Copying %d from %lx(%lx) to %lx\n", nSize, (DWORD)pSrc, (DWORD)SegPtrSrc, (DWORD)pDataDest);
 184     memcpy(pDest, pSrc, nSize);
 185     return TRUE;
 186 }
 187
 188
 189 static void GetPrinterDriverFunctions(HINSTANCE16 hInst, LOADED_PRINTER_DRIVER *pLPD)
 190 {
 191 #define LoadPrinterDrvFunc(A,B) pLPD->fn[A] = \
 192       GetProcAddress16(hInst, MAKEINTRESOURCE(B))
 193
 194       LoadPrinterDrvFunc(FUNC_CONTROL, ORD_CONTROL);            /* 3 */
 195       LoadPrinterDrvFunc(FUNC_ENABLE, ORD_ENABLE);              /* 5 */
 196       LoadPrinterDrvFunc(FUNC_ENUMDFONTS, ORD_ENUMDFONTS);      /* 6 */
 197       LoadPrinterDrvFunc(FUNC_REALIZEOBJECT, ORD_REALIZEOBJECT);/* 10 */
 198       LoadPrinterDrvFunc(FUNC_EXTTEXTOUT, ORD_EXTTEXTOUT);      /* 14 */
 199       dprintf_win16drv (stddeb,"got func CONTROL 0x%p enable 0x%p enumDfonts 0x%p realizeobject 0x%p extextout 0x%p\n",
 200               pLPD->fn[FUNC_CONTROL],
 201               pLPD->fn[FUNC_ENABLE],
 202               pLPD->fn[FUNC_ENUMDFONTS],
 203               pLPD->fn[FUNC_REALIZEOBJECT],
 204               pLPD->fn[FUNC_EXTTEXTOUT]);
 205
 206
 207 }
 208
 209 static LOADED_PRINTER_DRIVER *FindPrinterDriverFromPDEVICE(SEGPTR segptrPDEVICE)
 210 {
 211     LOADED_PRINTER_DRIVER *pLPD = NULL;
 212
 213     /* Find the printer driver associated with this PDEVICE */
 214     /* Each of the PDEVICE structures has a PDEVICE_HEADER structure */
 215     /* just before it */
 216     if (segptrPDEVICE != (SEGPTR)NULL)
 217     {
 218         PDEVICE_HEADER *pPDH = (PDEVICE_HEADER *)
 219           (PTR_SEG_TO_LIN(segptrPDEVICE) - sizeof(PDEVICE_HEADER));
 220         pLPD = pPDH->pLPD;
 221     }
 222     return pLPD;
 223 }
 224
 225 static LOADED_PRINTER_DRIVER *FindPrinterDriverFromName(const char *pszDriver)
 226 {
 227     LOADED_PRINTER_DRIVER *pLPD = NULL;
 228     int         nDriverSlot = 0;
 229
 230     /* Look to see if the printer driver is already loaded */
 231     while (pLPD == NULL && nDriverSlot < MAX_PRINTER_DRIVERS)
 232     {
 233         LOADED_PRINTER_DRIVER *ptmpLPD;
 234         ptmpLPD = gapLoadedPrinterDrivers[nDriverSlot++];
 235         if (ptmpLPD != NULL)
 236         {
 237             dprintf_win16drv(stddeb, "Comparing %s,%s\n",ptmpLPD->szDriver,pszDriver);
 238             /* Found driver store info, exit loop */
 239             if (lstrcmpi32A(ptmpLPD->szDriver, pszDriver) == 0)
 240               pLPD = ptmpLPD;
 241         }
 242     }
 243     if (pLPD == NULL) printf("Couldn't find driver %s\n", pszDriver);
 244     return pLPD;
 245 }
 246 /*
 247  * Load a printer driver, adding it self to the list of loaded drivers.
 248  */
 249
 250 static LOADED_PRINTER_DRIVER *LoadPrinterDriver(const char *pszDriver)
 251 {
 252     HINSTANCE16 hInst;
 253     LOADED_PRINTER_DRIVER *pLPD = NULL;
 254     int         nDriverSlot = 0;
 255     BOOL32      bSlotFound = FALSE;
 256
 257     /* First look to see if driver is loaded */
 258     pLPD = FindPrinterDriverFromName(pszDriver);
 259     if (pLPD != NULL)
 260     {
 261         /* Already loaded so increase usage count */
 262         pLPD->nUsageCount++;
 263         return pLPD;
 264     }
 265
 266     /* Not loaded so try and find an empty slot */
 267     while (!bSlotFound && nDriverSlot < MAX_PRINTER_DRIVERS)
 268     {
 269         if (gapLoadedPrinterDrivers[nDriverSlot] == NULL)
 270           bSlotFound = TRUE;
 271         else
 272           nDriverSlot++;
 273     }
 274     if (!bSlotFound)
 275     {
 276         printf("Too many printers drivers loaded\n");
 277         return NULL;
 278     }
 279
 280     {
 281         char *drvName = malloc(strlen(pszDriver)+5);
 282         strcpy(drvName, pszDriver);
 283         strcat(drvName, ".DRV");
 284         hInst = LoadLibrary16(drvName);
 285     }
 286     dprintf_win16drv(stddeb, "Loaded the library\n");
 287
 288
 289     if (hInst <= 32)
 290     {
 291         /* Failed to load driver */
 292         fprintf(stderr, "Failed to load printer driver %s\n", pszDriver);
 293     }
 294     else
 295     {
 296         HANDLE16 hHandle;
 297
 298         /* Allocate some memory for printer driver info */
 299         pLPD = malloc(sizeof(LOADED_PRINTER_DRIVER));
 300         memset(pLPD, 0 , sizeof(LOADED_PRINTER_DRIVER));
 301
 302         pLPD->hInst = hInst;
 303         strcpy(pLPD->szDriver,pszDriver);
 304
 305         /* Get DS for the printer module */
 306         pLPD->ds_reg = hInst;
 307
 308         dprintf_win16drv(stddeb, "DS for %s is %x\n", pszDriver, pLPD->ds_reg);
 309
 310         /* Get address of printer driver functions */
 311         GetPrinterDriverFunctions(hInst, pLPD);
 312
 313         /* Set initial usage count */
 314         pLPD->nUsageCount = 1;
 315
 316         /* Create a thunking buffer */
 317         hHandle = GlobalAlloc16(GHND, (1024 * 8));
 318         pLPD->hThunk = hHandle;
 319         pLPD->ThunkBufSegPtr = WIN16_GlobalLock16(hHandle);
 320         pLPD->ThunkBufLimit = pLPD->ThunkBufSegPtr + (1024*8);
 321
 322         /* Update table of loaded printer drivers */
 323         pLPD->nIndex = nDriverSlot;
 324         gapLoadedPrinterDrivers[nDriverSlot] = pLPD;
 325     }
 326
 327     return pLPD;
 328 }
 329 /*
 330  *  Control (ordinal 3)
 331  */
 332 INT16 PRTDRV_Control(LPPDEVICE lpDestDev, WORD wfunction, SEGPTR lpInData, SEGPTR lpOutData)
 333 {
 334     /* wfunction == Escape code */
 335     /* lpInData, lpOutData depend on code */
 336
 337     WORD wRet = 0;
 338     LOADED_PRINTER_DRIVER *pLPD = NULL;
 339
 340     dprintf_win16drv(stddeb, "PRTDRV_Control: %08x 0x%x %08lx %08lx\n", (unsigned int)lpDestDev, wfunction, lpInData, lpOutData);
 341
 342     if ((pLPD = FindPrinterDriverFromPDEVICE(lpDestDev)) != NULL)
 343     {
 344         LONG lP1, lP3, lP4;
 345         WORD wP2;
 346
 347         if (pLPD->fn[FUNC_CONTROL] == NULL)
 348         {
 349             dprintf_win16drv(stddeb, "PRTDRV_Control: Not supported by driver\n");
 350             return 0;
 351         }
 352
 353         lP1 = (SEGPTR)lpDestDev;
 354         wP2 = wfunction;
 355         lP3 = (SEGPTR)lpInData;
 356         lP4 = (SEGPTR)lpOutData;
 357
 358         wRet = CallTo16_word_lwll(pLPD->fn[FUNC_CONTROL],
 359                                   lP1, wP2, lP3, lP4);
 360     }
 361     dprintf_win16drv(stddeb, "PRTDRV_Control: return %x\n", wRet);
 362     return wRet;
 363
 364     return 0;
 365 }
 366
 367 /*
 368  *      Enable (ordinal 5)
 369  */
 370 static WORD PRTDRV_Enable(LPVOID lpDevInfo, WORD wStyle, LPCSTR  lpDestDevType,
 371                           LPCSTR lpDeviceName, LPCSTR lpOutputFile, LPVOID lpData)
 372 {
 373     WORD wRet = 0;
 374     LOADED_PRINTER_DRIVER *pLPD = NULL;
 375
 376     dprintf_win16drv(stddeb, "PRTDRV_Enable: %s %s\n",lpDestDevType, lpOutputFile);
 377
 378     /* Get the printer driver info */
 379     if (wStyle == INITPDEVICE)
 380     {
 381         pLPD = FindPrinterDriverFromPDEVICE((SEGPTR)lpDevInfo);
 382     }
 383     else
 384     {
 385         pLPD = FindPrinterDriverFromName((char *)lpDeviceName);
 386     }
 387     if (pLPD != NULL)
 388     {
 389         LONG lP1, lP3, lP4, lP5;
 390         WORD wP2;
 391         SEGPTR SegPtr = pLPD->ThunkBufSegPtr;
 392         SEGPTR Limit = pLPD->ThunkBufLimit;
 393         int   nSize;
 394
 395         if (pLPD->fn[FUNC_ENABLE] == NULL)
 396         {
 397             dprintf_win16drv(stddeb, "PRTDRV_Enable: Not supported by driver\n");
 398             return 0;
 399         }
 400
 401         if (wStyle == INITPDEVICE)
 402         {
 403             /* All ready a 16 address */
 404             lP1 = (SEGPTR)lpDevInfo;
 405         }
 406         else
 407         {
 408             /* 32 bit data */
 409             lP1 = SegPtr;
 410             nSize = sizeof(DeviceCaps);
 411             AddData(&SegPtr, lpDevInfo, nSize, Limit);
 412         }
 413
 414         wP2 = wStyle;
 415
 416         lP3 = SegPtr;
 417         nSize = strlen(lpDestDevType) + 1;
 418         AddData(&SegPtr, lpDestDevType, nSize, Limit);
 419
 420         lP4 = SegPtr;
 421         nSize = strlen(lpOutputFile) + 1;
 422         AddData(&SegPtr, lpOutputFile, nSize, Limit);
 423
 424         lP5 = (LONG)lpData;
 425
 426
 427         wRet = CallTo16_word_lwlll(pLPD->fn[FUNC_ENABLE],
 428                                    lP1, wP2, lP3, lP4, lP5);
 429
 430         /* Get the data back */
 431         if (lP1 != 0 && wStyle != INITPDEVICE)
 432         {
 433             nSize = sizeof(DeviceCaps);
 434             GetParamData(lP1, lpDevInfo, nSize);
 435         }
 436     }
 437     dprintf_win16drv(stddeb, "PRTDRV_Enable: return %x\n", wRet);
 438     return wRet;
 439 }
 440
 441
 442 /*
 443  * EnumCallback (GDI.158)
 444  *
 445  * This is the callback function used when EnumDFonts is called.
 446  * (The printer drivers uses it to pass info on available fonts).
 447  *
 448  * lpvClientData is the pointer passed to EnumDFonts, which points to a WEPFC
 449  * structure (WEPFC = WINE_ENUM_PRINTER_FONT_CALLBACK).  This structure
 450  * contains infomation on how to store the data passed .
 451  *
 452  * There are two modes:
 453  *      1) Just count the number of fonts available.
 454  *      2) Store all font data passed.
 455  */
 456 WORD WineEnumDFontCallback(LPLOGFONT16 lpLogFont, LPTEXTMETRIC16 lpTextMetrics,
 457                            WORD wFontType, LONG lpvClientData)
 458 {
 459     int wRet = 0;
 460     WEPFC *pWEPFC = (WEPFC *)lpvClientData;
 461
 462     /* Make sure we have the right structure */
 463     if (pWEPFC != NULL )
 464     {
 465         dprintf_win16drv(stddeb, "mode is 0x%x\n",pWEPFC->nMode);
 466
 467         switch (pWEPFC->nMode)
 468         {
 469             /* Count how many fonts */
 470           case 1:
 471             pWEPFC->nCount++;
 472             break;
 473
 474             /* Store the fonts in the printer driver structure */
 475           case 2:
 476           {
 477               PRINTER_FONTS_INFO *pPFI;
 478
 479               dprintf_win16drv(stddeb, "WineEnumDFontCallback: Found %s %x\n",
 480                      lpLogFont->lfFaceName, wFontType);
 481
 482               pPFI = &pWEPFC->pLPD->paPrinterFonts[pWEPFC->nCount];
 483               memcpy(&(pPFI->lf), lpLogFont, sizeof(LOGFONT16));
 484               memcpy(&(pPFI->tm), lpTextMetrics, sizeof(TEXTMETRIC16));
 485               pWEPFC->nCount++;
 486
 487           }
 488             break;
 489         }
 490         wRet = 1;
 491     }
 492     dprintf_win16drv(stddeb, "WineEnumDFontCallback: returnd %d\n", wRet);
 493     return wRet;
 494 }
 495
 496 /*
 497  *      EnumDFonts (ordinal 6)
 498  */
 499 WORD PRTDRV_EnumDFonts(LPPDEVICE lpDestDev, LPSTR lpFaceName,
 500                        FARPROC16 lpCallbackFunc, LPVOID lpClientData)
 501 {
 502     WORD wRet = 0;
 503     LOADED_PRINTER_DRIVER *pLPD = NULL;
 504
 505     dprintf_win16drv(stddeb, "PRTDRV_EnumDFonts:\n");
 506
 507     if ((pLPD = FindPrinterDriverFromPDEVICE(lpDestDev)) != NULL)
 508     {
 509         LONG lP1, lP2, lP3, lP4;
 510
 511         SEGPTR SegPtr = pLPD->ThunkBufSegPtr;
 512         SEGPTR Limit = pLPD->ThunkBufLimit;
 513         int   nSize;
 514
 515         if (pLPD->fn[FUNC_ENUMDFONTS] == NULL)
 516         {
 517             dprintf_win16drv(stddeb, "PRTDRV_EnumDFonts: Not supported by driver\n");
 518             return 0;
 519         }
 520
 521         lP1 = (SEGPTR)lpDestDev;
 522
 523         if (lpFaceName == NULL)
 524         {
 525             lP2 = 0;
 526         }
 527         else
 528         {
 529             lP2 = SegPtr;
 530             nSize = strlen(lpFaceName) + 1;
 531             AddData(&SegPtr, lpFaceName, nSize, Limit);
 532         }
 533
 534         lP3 = (LONG)lpCallbackFunc;
 535
 536         lP4 = (LONG)lpClientData;
 537
 538         wRet = CallTo16_word_llll(pLPD->fn[FUNC_ENUMDFONTS],
 539                                   lP1, lP2, lP3, lP4);
 540     }
 541     else
 542         printf("Failed to find device\n");
 543
 544     dprintf_win16drv(stddeb, "PRTDRV_EnumDFonts: return %x\n", wRet);
 545     return wRet;
 546 }
 547
 548 /*
 549  * RealizeObject (ordinal 10)
 550  */
 551 DWORD PRTDRV_RealizeObject(LPPDEVICE lpDestDev, WORD wStyle,
 552                     LPVOID lpInObj, LPVOID lpOutObj,
 553                     LPTEXTXFORM16 lpTextXForm)
 554 {
 555     WORD dwRet = 0;
 556     LOADED_PRINTER_DRIVER *pLPD = NULL;
 557
 558     dprintf_win16drv(stddeb, "PRTDRV_RealizeObject:\n");
 559
 560     if ((pLPD = FindPrinterDriverFromPDEVICE(lpDestDev)) != NULL)
 561     {
 562         LONG lP1, lP3, lP4, lP5;
 563         WORD wP2;
 564         SEGPTR SegPtr = pLPD->ThunkBufSegPtr;
 565         SEGPTR Limit = pLPD->ThunkBufLimit;
 566         int   nSize;
 567
 568         if (pLPD->fn[FUNC_REALIZEOBJECT] == NULL)
 569         {
 570             dprintf_win16drv(stddeb, "PRTDRV_RealizeObject: Not supported by driver\n");
 571             return 0;
 572         }
 573
 574         lP1 = lpDestDev;
 575         wP2 = wStyle;
 576
 577         lP3 = SegPtr;
 578         switch (wStyle)
 579         {
 580         case 3:
 581             nSize = sizeof(LOGFONT16);
 582             break;
 583         default:
 584             printf("PRTDRV_RealizeObject: Object type %d not supported\n", wStyle);
 585             nSize = 0;
 586
 587         }
 588         AddData(&SegPtr, lpInObj, nSize, Limit);
 589
 590         lP4 = (LONG)lpOutObj;
 591
 592         if (lpTextXForm != NULL)
 593         {
 594             lP5 = SegPtr;
 595             nSize = sizeof(TEXTXFORM16);
 596             AddData(&SegPtr, lpTextXForm, nSize, Limit);
 597         }
 598         else
 599           lP5 = 0L;
 600
 601         dwRet = CallTo16_long_lwlll(pLPD->fn[FUNC_REALIZEOBJECT],
 602                                     lP1, wP2, lP3, lP4, lP5);
 603
 604     }
 605     dprintf_win16drv(stddeb, "PRTDRV_RealizeObject: return %x\n", dwRet);
 606     return dwRet;
 607 }
 608
 609
 610 BOOL32 WIN16DRV_CreateDC( DC *dc, LPCSTR driver, LPCSTR device, LPCSTR output,
 611                           const DEVMODE16* initData )
 612 {
 613     LOADED_PRINTER_DRIVER *pLPD;
 614     WORD wRet;
 615     DeviceCaps *printerDevCaps;
 616     FARPROC16 pfnCallback;
 617     int nPDEVICEsize;
 618     PDEVICE_HEADER *pPDH;
 619     WIN16DRV_PDEVICE *physDev;
 620     LPDRAWMODE lpDrawMode = &DrawMode;
 621
 622     /* Realizing fonts */
 623     TEXTXFORM16 TextXForm;
 624     int nSize;
 625     char printerEnabled[20];
 626     PROFILE_GetWineIniString( "wine", "printer", "off",
 627                              printerEnabled, sizeof(printerEnabled) );
 628     if (strcmp(printerEnabled,"on"))
 629     {
 630         printf("WIN16DRV_CreateDC disabled in wine.conf file\n");
 631         return FALSE;
 632     }
 633
 634     dprintf_win16drv(stddeb, "In creatdc for (%s,%s,%s) initData 0x%p\n",driver, device, output, initData);
 635
 636     physDev = (WIN16DRV_PDEVICE *)HeapAlloc( SystemHeap, 0, sizeof(*physDev) );
 637     if (!physDev) return FALSE;
 638     dc->physDev = physDev;
 639
 640     pLPD = LoadPrinterDriver(driver);
 641     if (pLPD == NULL)
 642     {
 643         dprintf_win16drv(stddeb, "LPGDI_CreateDC: Failed to find printer driver\n");
 644         HeapFree( SystemHeap, 0, physDev );
 645         return FALSE;
 646     }
 647     dprintf_win16drv(stddeb, "windevCreateDC pLPD 0x%p\n", pLPD);
 648
 649     /* Now Get the device capabilities from the printer driver */
 650
 651     printerDevCaps = (DeviceCaps *) malloc(sizeof(DeviceCaps));
 652     memset(printerDevCaps, 0, sizeof(DeviceCaps));
 653
 654     /* Get GDIINFO which is the same as a DeviceCaps structure */
 655     wRet = PRTDRV_Enable(printerDevCaps, GETGDIINFO, device, driver, output,NULL);
 656
 657     /* Add this to the DC */
 658     dc->w.devCaps = printerDevCaps;
 659     dc->w.hVisRgn = CreateRectRgn32(0, 0, dc->w.devCaps->horzRes, dc->w.devCaps->vertRes);
 660     dc->w.bitsPerPixel = dc->w.devCaps->bitsPixel;
 661
 662     printf("Got devcaps width %d height %d bits %d planes %d\n",
 663            dc->w.devCaps->horzRes,
 664            dc->w.devCaps->vertRes,
 665            dc->w.devCaps->bitsPixel,
 666            dc->w.devCaps->planes);
 667
 668     /* Now we allocate enough memory for the PDEVICE structure */
 669     /* The size of this varies between printer drivers */
 670     /* This PDEVICE is used by the printer DRIVER not by the GDI so must */
 671     /* be accessable from 16 bit code */
 672     nPDEVICEsize = dc->w.devCaps->pdeviceSize + sizeof(PDEVICE_HEADER);
 673
 674     /* TTD Shouldn't really do pointer arithmetic on segment points */
 675     physDev->segptrPDEVICE = WIN16_GlobalLock16(GlobalAlloc16(GHND, nPDEVICEsize))+sizeof(PDEVICE_HEADER);
 676     *(BYTE *)(PTR_SEG_TO_LIN(physDev->segptrPDEVICE)+0) = 'N';
 677     *(BYTE *)(PTR_SEG_TO_LIN(physDev->segptrPDEVICE)+1) = 'B';
 678
 679     /* Set up the header */
 680     pPDH = (PDEVICE_HEADER *)(PTR_SEG_TO_LIN(physDev->segptrPDEVICE) - sizeof(PDEVICE_HEADER));
 681     pPDH->pLPD = pLPD;
 682
 683     dprintf_win16drv(stddeb, "PRTDRV_Enable: PDEVICE allocated %08lx\n",(DWORD)(physDev->segptrPDEVICE));
 684
 685     /* Now get the printer driver to initialise this data */
 686     wRet = PRTDRV_Enable((LPVOID)physDev->segptrPDEVICE, INITPDEVICE, device, driver, output, NULL);
 687
 688     /* Now enumerate the fonts supported by the printer driver*/
 689     /* GDI.158 is EnumCallback, which is called by the 16bit printer driver */
 690     /* passing information on the available fonts */
 691     if (pLPD->paPrinterFonts == NULL)
 692     {
 693         pfnCallback = MODULE_GetEntryPoint( GetModuleHandle16("GDI"), 158 );
 694
 695         if (pfnCallback != NULL)
 696         {
 697             WEPFC wepfc;
 698
 699             wepfc.nMode = 1;
 700             wepfc.nCount = 0;
 701             wepfc.pLPD = pLPD;
 702
 703             /* First count the number of fonts */
 704
 705             PRTDRV_EnumDFonts(physDev->segptrPDEVICE, NULL, pfnCallback,
 706                               (void *)&wepfc);
 707
 708             /* Allocate a buffer to store all of the fonts */
 709             pLPD->nPrinterFonts = wepfc.nCount;
 710             dprintf_win16drv(stddeb, "Got %d fonts\n",wepfc.nCount);
 711
 712             if (wepfc.nCount > 0)
 713             {
 714
 715                 pLPD->paPrinterFonts = malloc(sizeof(PRINTER_FONTS_INFO) * wepfc.nCount);
 716
 717                 /* Now get all of the fonts */
 718                 wepfc.nMode = 2;
 719                 wepfc.nCount = 0;
 720                 PRTDRV_EnumDFonts(physDev->segptrPDEVICE, NULL, pfnCallback,
 721                                   (void *)&wepfc);
 722             }
 723         }
 724     }
 725
 726     /* Select the first font into the DC */
 727     /* Set up the logfont */
 728     memcpy(&physDev->lf,
 729            &pLPD->paPrinterFonts[0].lf,
 730            sizeof(LOGFONT16));
 731
 732     /* Set up the textmetrics */
 733     memcpy(&physDev->tm,
 734            &pLPD->paPrinterFonts[0].tm,
 735            sizeof(TEXTMETRIC16));
 736
 737 #ifdef SUPPORT_REALIZED_FONTS
 738     /* TTD should calculate this */
 739     InitTextXForm(&TextXForm);
 740
 741     /* First get the size of the realized font */
 742     nSize = PRTDRV_RealizeObject(physDev->segptrPDEVICE, OBJ_FONT,
 743                                  &pLPD->paPrinterFonts[0], NULL,
 744                                  NULL);
 745
 746     physDev->segptrFontInfo = WIN16_GlobalLock16(GlobalAlloc16(GHND, nSize));
 747     /* Realize the font */
 748     PRTDRV_RealizeObject(physDev->segptrPDEVICE, OBJ_FONT,
 749                          &pLPD->paPrinterFonts[0],
 750                          (LPVOID)physDev->segptrFontInfo,
 751                          &TextXForm);
 752     /* Quick look at structure */
 753     if (physDev->segptrFontInfo)
 754     {
 755         FONTINFO16 *p = (FONTINFO16 *)PTR_SEG_TO_LIN(physDev->segptrFontInfo);
 756
 757         dprintf_win16drv(stddeb, "T:%d VR:%d HR:%d, F:%d L:%d\n",
 758                p->dfType,
 759                p->dfVertRes, p->dfHorizRes,
 760                p->dfFirstCHAR, p->dfLastCHAR
 761                );
 762     }
 763
 764 #endif
 765     /* TTD Lots more to do here */
 766     InitDrawMode(lpDrawMode);
 767
 768     return TRUE;
 769 }
 770
 771
 772 /*
 773  * Escape (GDI.38)
 774  */
 775 static INT32 WIN16DRV_Escape( DC *dc, INT32 nEscape, INT32 cbInput,
 776                               SEGPTR lpInData, SEGPTR lpOutData )
 777 {
 778     WIN16DRV_PDEVICE *physDev = (WIN16DRV_PDEVICE *)dc->physDev;
 779     int nRet = 0;
 780
 781     /* We should really process the nEscape parameter, but for now just
 782        pass it all to the driver */
 783     if (dc != NULL && physDev->segptrPDEVICE != 0)
 784     {
 785         switch(nEscape)
 786         {
 787           case 0x9:
 788             printf("Escape: SetAbortProc ignored\n");
 789             break;
 790
 791           default:
 792             nRet = PRTDRV_Control(physDev->segptrPDEVICE, nEscape,
 793                                   lpInData, lpOutData);
 794         }
 795     }
 796     else
 797         fprintf(stderr, "Escape(nEscape = %04x)\n", nEscape);
 798     return nRet;
 799 }
 800
 801 DWORD PRTDRV_ExtTextOut(LPPDEVICE lpDestDev, WORD wDestXOrg, WORD wDestYOrg,
 802                         RECT16 *lpClipRect, LPCSTR lpString, WORD wCount,
 803                         SEGPTR lpFontInfo, LPDRAWMODE lpDrawMode,
 804                         LPTEXTXFORM16 lpTextXForm, SHORT *lpCharWidths,
 805                         RECT16 *     lpOpaqueRect, WORD wOptions)
 806 {
 807     DWORD dwRet = 0;
 808     LOADED_PRINTER_DRIVER *pLPD = NULL;
 809
 810     dprintf_win16drv(stddeb, "PRTDRV_ExtTextOut:\n");
 811
 812     if ((pLPD = FindPrinterDriverFromPDEVICE(lpDestDev)) != NULL)
 813     {
 814         LONG lP1, lP4, lP5, lP7, lP8, lP9, lP10, lP11;
 815         WORD wP2, wP3, wP6, wP12;
 816         INT16 iP6;
 817
 818         SEGPTR SegPtr = pLPD->ThunkBufSegPtr;
 819         SEGPTR Limit = pLPD->ThunkBufLimit;
 820         int   nSize;
 821
 822         if (pLPD->fn[FUNC_EXTTEXTOUT] == NULL)
 823         {
 824             dprintf_win16drv(stddeb, "PRTDRV_ExtTextOut: Not supported by driver\n");
 825             return 0;
 826         }
 827
 828         lP1 = lpDestDev;
 829         wP2 = wDestXOrg;
 830         wP3 = wDestYOrg;
 831
 832         if (lpClipRect != NULL)
 833         {
 834             lP4 = SegPtr;
 835             nSize = sizeof(RECT16);
 836             dprintf_win16drv(stddeb, "Adding lpClipRect\n");
 837
 838             AddData(&SegPtr, lpClipRect, nSize, Limit);
 839         }
 840         else
 841           lP4 = 0L;
 842
 843         if (lpString != NULL)
 844         {
 845             /* TTD WARNING THIS STRING ISNT NULL TERMINATED */
 846             lP5 = SegPtr;
 847             nSize = strlen(lpString);
 848             nSize = abs(wCount);
 849             dprintf_win16drv(stddeb, "Adding string size %d\n",nSize);
 850
 851             AddData(&SegPtr, lpString, nSize, Limit);
 852         }
 853         else
 854           lP5 = 0L;
 855
 856         iP6 = wCount;
 857
 858         /* This should be realized by the driver, so in 16bit data area */
 859         lP7 = lpFontInfo;
 860
 861         if (lpDrawMode != NULL)
 862         {
 863             lP8 = SegPtr;
 864             nSize = sizeof(DRAWMODE);
 865             dprintf_win16drv(stddeb, "adding lpDrawMode\n");
 866
 867             AddData(&SegPtr, lpDrawMode, nSize, Limit);
 868         }
 869         else
 870           lP8 = 0L;
 871
 872         if (lpTextXForm != NULL)
 873         {
 874             lP9 = SegPtr;
 875             nSize = sizeof(TEXTXFORM16);
 876             dprintf_win16drv(stddeb, "Adding TextXForm\n");
 877             AddData(&SegPtr, lpTextXForm, nSize, Limit);
 878         }
 879         else
 880           lP9 = 0L;
 881
 882         if (lpCharWidths != NULL)
 883           dprintf_win16drv(stddeb, "PRTDRV_ExtTextOut: Char widths not supported\n");
 884         lP10 = 0;
 885
 886         if (lpOpaqueRect != NULL)
 887         {
 888             lP11 = SegPtr;
 889             nSize = sizeof(RECT16);
 890             dprintf_win16drv(stddeb, "Adding opaqueRect\n");
 891             AddData(&SegPtr, lpOpaqueRect, nSize, Limit);
 892         }
 893         else
 894           lP11 = 0L;
 895
 896         wP12 = wOptions;
 897         dprintf_win16drv(stddeb, "Calling exttextout 0x%lx 0x%x 0x%x 0x%lx\n0x%lx 0x%x 0x%lx 0x%lx\n"
 898                "0x%lx 0x%lx 0x%lx 0x%x\n",lP1, wP2, wP3, lP4,
 899                                            lP5, iP6, lP7, lP8, lP9, lP10,
 900                                            lP11, wP12);
 901         dwRet = CallTo16_long_lwwllwlllllw(pLPD->fn[FUNC_EXTTEXTOUT],
 902                                            lP1, wP2, wP3, lP4,
 903                                            lP5, iP6, lP7, lP8, lP9, lP10,
 904                                            lP11, wP12);
 905         if (lpDrawMode)
 906             GetParamData(lP8, lpDrawMode, sizeof(DRAWMODE));
 907     }
 908     dprintf_win16drv(stddeb, "PRTDRV_ExtTextOut: return %lx\n", dwRet);
 909     return dwRet;
 910 }
 911
 912
 913
 914 /****************** misc. printer releated functions */
 915
 916 /*
 917  * The following function should implement a queing system
 918  */
 919 #ifndef HPQ
 920 #define HPQ WORD
 921 #endif
 922 struct hpq
 923 {
 924     struct hpq  *next;
 925     int          tag;
 926     int          key;
 927 };
 928
 929 static struct hpq *hpqueue;
 930
 931 HPQ
 932 CreatePQ(int size)
 933 {
 934     printf("CreatePQ: %d\n",size);
 935     return 1;
 936 }
 937 int
 938 DeletePQ(HPQ hPQ)
 939 {
 940     printf("DeletePQ: %x\n", hPQ);
 941     return 0;
 942 }
 943 int
 944 ExtractPQ(HPQ hPQ)
 945 {
 946     struct hpq *queue, *prev, *current, *currentPrev;
 947     int key, tag = -1;
 948     currentPrev = prev = NULL;
 949     queue = current = hpqueue;
 950     if (current)
 951         key = current->key;
 952
 953     while (current)
 954     {
 955         currentPrev = current;
 956         current = current->next;
 957         if (current)
 958         {
 959             if (current->key < key)
 960             {
 961                 queue = current;
 962                 prev = currentPrev;
 963             }
 964         }
 965     }
 966     if (queue)
 967     {
 968         tag = queue->tag;
 969
 970         if (prev)
 971             prev->next = queue->next;
 972         else
 973             hpqueue = queue->next;
 974         free(queue);
 975     }
 976
 977     printf("ExtractPQ: %x got tag %d key %d\n", hPQ, tag, key);
 978
 979     return tag;
 980 }
 981
 982 int
 983 InsertPQ(HPQ hPQ, int tag, int key)
 984 {
 985     struct hpq *queueItem = malloc(sizeof(struct hpq));
 986     queueItem->next = hpqueue;
 987     hpqueue = queueItem;
 988     queueItem->key = key;
 989     queueItem->tag = tag;
 990
 991     printf("InsertPQ: %x %d %d\n", hPQ, tag, key);
 992     return TRUE;
 993 }
 994 int
 995 MinPQ(HPQ hPQ)
 996 {
 997     printf("MinPQ: %x\n", hPQ);
 998     return 0;
 999 }
1000 int
1001 SizePQ(HPQ hPQ, int sizechange)
1002 {
1003     printf("SizePQ: %x %d\n", hPQ, sizechange);
1004     return -1;
1005 }
1006
1007 /*
1008  * The following functions implement part of the spooling process to
1009  * print manager.  I would like to see wine have a version of print managers
1010  * that used LPR/LPD.  For simplicity print jobs will be sent to a file for
1011  * now.
1012  */
1013 typedef struct PRINTJOB
1014 {
1015     char        *pszOutput;
1016     char        *pszTitle;
1017     HDC16       hDC;
1018     HANDLE16    hHandle;
1019     int         nIndex;
1020     int         fd;
1021 } PRINTJOB, *PPRINTJOB;
1022
1023 #define MAX_PRINT_JOBS 1
1024 #define SP_OK 1
1025
1026 PPRINTJOB gPrintJobsTable[MAX_PRINT_JOBS];
1027
1028
1029 static PPRINTJOB FindPrintJobFromHandle(HANDLE16 hHandle)
1030 {
1031     return gPrintJobsTable[0];
1032 }
1033
1034 /* TTD Need to do some DOS->UNIX file conversion here */
1035 static int CreateSpoolFile(LPSTR pszOutput)
1036 {
1037     int fd;
1038     char szSpoolFile[32];
1039
1040     /* TTD convert the 'output device' into a spool file name */
1041
1042     if (pszOutput == NULL || *pszOutput == '\0')
1043         strcpy(szSpoolFile,"lp.out");
1044     else
1045         strcpy(szSpoolFile, pszOutput);
1046
1047     if ((fd = open(szSpoolFile, O_CREAT | O_TRUNC | O_WRONLY , 0600)) < 0)
1048     {
1049         printf("Failed to create spool file %s, errno = %d\n", szSpoolFile, errno);
1050     }
1051     return fd;
1052 }
1053
1054 static int FreePrintJob(HANDLE16 hJob)
1055 {
1056     int nRet = SP_ERROR;
1057     PPRINTJOB pPrintJob;
1058
1059     pPrintJob = FindPrintJobFromHandle(hJob);
1060     if (pPrintJob != NULL)
1061     {
1062         gPrintJobsTable[pPrintJob->nIndex] = NULL;
1063         free(pPrintJob->pszOutput);
1064         free(pPrintJob->pszTitle);
1065         if (pPrintJob->fd >= 0) close(pPrintJob->fd);
1066         free(pPrintJob);
1067         nRet = SP_OK;
1068     }
1069     return nRet;
1070 }
1071
1072 HANDLE16 OpenJob(LPSTR lpOutput, LPSTR lpTitle, HDC16 hDC)
1073 {
1074     HANDLE16 hHandle = SP_ERROR;
1075     PPRINTJOB pPrintJob;
1076
1077     dprintf_win16drv(stddeb, "OpenJob: \"%s\" \"%s\" %04x\n", lpOutput, lpTitle, hDC);
1078
1079     pPrintJob = gPrintJobsTable[0];
1080     if (pPrintJob == NULL)
1081     {
1082         int fd;
1083
1084         /* Try an create a spool file */
1085         fd = CreateSpoolFile(lpOutput);
1086         if (fd >= 0)
1087         {
1088             hHandle = 1;
1089
1090             pPrintJob = malloc(sizeof(PRINTJOB));
1091             memset(pPrintJob, 0, sizeof(PRINTJOB));
1092
1093             pPrintJob->pszOutput = strdup(lpOutput);
1094             pPrintJob->pszTitle = strdup(lpTitle);
1095             pPrintJob->hDC = hDC;
1096             pPrintJob->fd = fd;
1097             pPrintJob->nIndex = 0;
1098             pPrintJob->hHandle = hHandle;
1099             gPrintJobsTable[pPrintJob->nIndex] = pPrintJob;
1100         }
1101     }
1102     dprintf_win16drv(stddeb, "OpenJob: return %04x\n", hHandle);
1103     return hHandle;
1104 }
1105
1106 int CloseJob(HANDLE16 hJob)
1107 {
1108     int nRet = SP_ERROR;
1109     PPRINTJOB pPrintJob = NULL;
1110
1111     dprintf_win16drv(stddeb, "CloseJob: %04x\n", hJob);
1112
1113     pPrintJob = FindPrintJobFromHandle(hJob);
1114     if (pPrintJob != NULL)
1115     {
1116         /* Close the spool file */
1117         close(pPrintJob->fd);
1118         FreePrintJob(hJob);
1119         nRet  = 1;
1120     }
1121     return nRet;
1122 }
1123
1124 int WriteSpool(HANDLE16 hJob, LPSTR lpData, WORD cch)
1125 {
1126     int nRet = SP_ERROR;
1127     PPRINTJOB pPrintJob = NULL;
1128
1129     dprintf_win16drv(stddeb, "WriteSpool: %04x %08lx %04x\n", hJob, (DWORD)lpData, cch);
1130
1131     pPrintJob = FindPrintJobFromHandle(hJob);
1132     if (pPrintJob != NULL && pPrintJob->fd >= 0 && cch)
1133     {
1134         if (write(pPrintJob->fd, lpData, cch) != cch)
1135           nRet = SP_OUTOFDISK;
1136         else
1137           nRet = cch;
1138     }
1139     return nRet;
1140 }
1141
1142 int WriteDialog(HANDLE16 hJob, LPSTR lpMsg, WORD cchMsg)
1143 {
1144     int nRet = 0;
1145
1146     dprintf_win16drv(stddeb, "WriteDialog: %04x %04x \"%s\"\n", hJob,  cchMsg, lpMsg);
1147
1148     nRet = MessageBox16(NULL, lpMsg, "Printing Error", MB_OKCANCEL);
1149     return nRet;
1150 }
1151
1152 int DeleteJob(HANDLE16 hJob, WORD wNotUsed)
1153 {
1154     int nRet;
1155
1156     dprintf_win16drv(stddeb, "DeleteJob: %04x\n", hJob);
1157
1158     nRet = FreePrintJob(hJob);
1159     return nRet;
1160 }
1161
1162 /*
1163  * The following two function would allow a page to be sent to the printer
1164  * when it has been processed.  For simplicity they havn't been implemented.
1165  * This means a whole job has to be processed before it is sent to the printer.
1166  */
1167 int StartSpoolPage(HANDLE16 hJob)
1168 {
1169     dprintf_win16drv(stddeb, "StartSpoolPage GDI.246 unimplemented\n");
1170     return 1;
1171
1172 }
1173 int EndSpoolPage(HANDLE16 hJob)
1174 {
1175     dprintf_win16drv(stddeb, "EndSpoolPage GDI.247 unimplemented\n");
1176     return 1;
1177 }
1178
1179
1180 DWORD GetSpoolJob(int nOption, LONG param)
1181 {
1182     DWORD retval = 0;
1183     dprintf_win16drv(stddeb, "In GetSpoolJob param 0x%lx noption %d\n",param, nOption);
1184     return retval;
1185 }