dlls/gdi/printdrv.c

   1 /*
   2  * Implementation of some printer driver bits
   3  *
   4  * Copyright 1996 John Harvey
   5  * Copyright 1998 Huw Davies
   6  * Copyright 1998 Andreas Mohr
   7  * Copyright 1999 Klaas van Gend
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 #include "config.h"
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <ctype.h>
  30 #include <errno.h>
  31 #include <unistd.h>
  32 #include <fcntl.h>
  33 #include "winbase.h"
  34 #include "winuser.h"
  35 #include "wine/winbase16.h"
  36 #include "wine/wingdi16.h"
  37 #include "winspool.h"
  38 #include "winerror.h"
  39 #include "winreg.h"
  40 #include "wine/debug.h"
  41 #include "gdi.h"
  42 #include "heap.h"
  43 #include "file.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(print);
  46
  47 static char PrinterModel[]      = "Printer Model";
  48 static char DefaultDevMode[]    = "Default DevMode";
  49 static char PrinterDriverData[] = "PrinterDriverData";
  50 static char Printers[]          = "System\\CurrentControlSet\\Control\\Print\\Printers\\";
  51
  52 /******************************************************************
  53  *                  StartDoc  [GDI.377]
  54  *
  55  */
  56 INT16 WINAPI StartDoc16( HDC16 hdc, const DOCINFO16 *lpdoc )
  57 {
  58     DOCINFOA docA;
  59
  60     docA.cbSize = lpdoc->cbSize;
  61     docA.lpszDocName = MapSL(lpdoc->lpszDocName);
  62     docA.lpszOutput = MapSL(lpdoc->lpszOutput);
  63
  64     if(lpdoc->cbSize >= 14)
  65         docA.lpszDatatype = MapSL(lpdoc->lpszDatatype);
  66     else
  67         docA.lpszDatatype = NULL;
  68
  69     if(lpdoc->cbSize >= 18)
  70         docA.fwType = lpdoc->fwType;
  71     else
  72         docA.fwType = 0;
  73
  74     return StartDocA(hdc, &docA);
  75 }
  76
  77 /******************************************************************
  78  *                  StartDocA  [GDI32.@]
  79  *
  80  * StartDoc calls the STARTDOC Escape with the input data pointing to DocName
  81  * and the output data (which is used as a second input parameter).pointing at
  82  * the whole docinfo structure.  This seems to be an undocumented feature of
  83  * the STARTDOC Escape.
  84  *
  85  * Note: we now do it the other way, with the STARTDOC Escape calling StartDoc.
  86  */
  87 INT WINAPI StartDocA(HDC hdc, const DOCINFOA* doc)
  88 {
  89     INT ret = 0;
  90     DC *dc = DC_GetDCPtr( hdc );
  91
  92     TRACE("DocName = '%s' Output = '%s' Datatype = '%s'\n",
  93           doc->lpszDocName, doc->lpszOutput, doc->lpszDatatype);
  94
  95     if(!dc) return SP_ERROR;
  96
  97     if (dc->funcs->pStartDoc) ret = dc->funcs->pStartDoc( dc->physDev, doc );
  98     GDI_ReleaseObj( hdc );
  99     return ret;
 100 }
 101
 102 /*************************************************************************
 103  *                  StartDocW [GDI32.@]
 104  *
 105  */
 106 INT WINAPI StartDocW(HDC hdc, const DOCINFOW* doc)
 107 {
 108     DOCINFOA docA;
 109     INT ret;
 110
 111     docA.cbSize = doc->cbSize;
 112     docA.lpszDocName = doc->lpszDocName ?
 113       HEAP_strdupWtoA( GetProcessHeap(), 0, doc->lpszDocName ) : NULL;
 114     docA.lpszOutput = doc->lpszOutput ?
 115       HEAP_strdupWtoA( GetProcessHeap(), 0, doc->lpszOutput ) : NULL;
 116     docA.lpszDatatype = doc->lpszDatatype ?
 117       HEAP_strdupWtoA( GetProcessHeap(), 0, doc->lpszDatatype ) : NULL;
 118     docA.fwType = doc->fwType;
 119
 120     ret = StartDocA(hdc, &docA);
 121
 122     if(docA.lpszDocName)
 123         HeapFree( GetProcessHeap(), 0, (LPSTR)docA.lpszDocName );
 124     if(docA.lpszOutput)
 125         HeapFree( GetProcessHeap(), 0, (LPSTR)docA.lpszOutput );
 126     if(docA.lpszDatatype)
 127         HeapFree( GetProcessHeap(), 0, (LPSTR)docA.lpszDatatype );
 128
 129     return ret;
 130 }
 131
 132 /******************************************************************
 133  *                  EndDoc  [GDI.378]
 134  *
 135  */
 136 INT16 WINAPI EndDoc16(HDC16 hdc)
 137 {
 138     return EndDoc(hdc);
 139 }
 140
 141 /******************************************************************
 142  *                  EndDoc  [GDI32.@]
 143  *
 144  */
 145 INT WINAPI EndDoc(HDC hdc)
 146 {
 147     INT ret = 0;
 148     DC *dc = DC_GetDCPtr( hdc );
 149     if(!dc) return SP_ERROR;
 150
 151     if (dc->funcs->pEndDoc) ret = dc->funcs->pEndDoc( dc->physDev );
 152     GDI_ReleaseObj( hdc );
 153     return ret;
 154 }
 155
 156 /******************************************************************
 157  *                  StartPage  [GDI.379]
 158  *
 159  */
 160 INT16 WINAPI StartPage16(HDC16 hdc)
 161 {
 162     return StartPage(hdc);
 163 }
 164
 165 /******************************************************************
 166  *                  StartPage  [GDI32.@]
 167  *
 168  */
 169 INT WINAPI StartPage(HDC hdc)
 170 {
 171     INT ret = 1;
 172     DC *dc = DC_GetDCPtr( hdc );
 173     if(!dc) return SP_ERROR;
 174
 175     if(dc->funcs->pStartPage)
 176         ret = dc->funcs->pStartPage( dc->physDev );
 177     else
 178         FIXME("stub\n");
 179     GDI_ReleaseObj( hdc );
 180     return ret;
 181 }
 182
 183 /******************************************************************
 184  *                  EndPage  [GDI.380]
 185  *
 186  */
 187 INT16 WINAPI EndPage16( HDC16 hdc )
 188 {
 189     return EndPage(hdc);
 190 }
 191
 192 /******************************************************************
 193  *                  EndPage  [GDI32.@]
 194  *
 195  */
 196 INT WINAPI EndPage(HDC hdc)
 197 {
 198     INT ret = 0;
 199     DC *dc = DC_GetDCPtr( hdc );
 200     if(!dc) return SP_ERROR;
 201
 202     if (dc->funcs->pEndPage) ret = dc->funcs->pEndPage( dc->physDev );
 203     GDI_ReleaseObj( hdc );
 204     if (!QueryAbort16( hdc, 0 ))
 205     {
 206         EndDoc( hdc );
 207         ret = 0;
 208     }
 209     return ret;
 210 }
 211
 212 /******************************************************************************
 213  *                 AbortDoc  [GDI.382]
 214  */
 215 INT16 WINAPI AbortDoc16(HDC16 hdc)
 216 {
 217     return AbortDoc(hdc);
 218 }
 219
 220 /******************************************************************************
 221  *                 AbortDoc  [GDI32.@]
 222  */
 223 INT WINAPI AbortDoc(HDC hdc)
 224 {
 225     INT ret = 0;
 226     DC *dc = DC_GetDCPtr( hdc );
 227     if(!dc) return SP_ERROR;
 228
 229     if (dc->funcs->pAbortDoc) ret = dc->funcs->pAbortDoc( dc->physDev );
 230     GDI_ReleaseObj( hdc );
 231     return ret;
 232 }
 233
 234 /**********************************************************************
 235  *           QueryAbort   (GDI.155)
 236  *
 237  *  Calls the app's AbortProc function if avail.
 238  *
 239  * RETURNS
 240  * TRUE if no AbortProc avail or AbortProc wants to continue printing.
 241  * FALSE if AbortProc wants to abort printing.
 242  */
 243 BOOL16 WINAPI QueryAbort16(HDC16 hdc, INT16 reserved)
 244 {
 245     BOOL ret = TRUE;
 246     DC *dc = DC_GetDCPtr( hdc );
 247     ABORTPROC abproc;
 248
 249     if(!dc) {
 250         ERR("Invalid hdc %04x\n", hdc);
 251         return FALSE;
 252     }
 253
 254     abproc = dc->pAbortProc;
 255     GDI_ReleaseObj( hdc );
 256
 257     if (abproc)
 258         ret = abproc(hdc, 0);
 259     return ret;
 260 }
 261
 262 /* ### start build ### */
 263 extern WORD CALLBACK PRTDRV_CallTo16_word_ww(FARPROC16,WORD,WORD);
 264 /* ### stop build ### */
 265
 266 /**********************************************************************
 267  *           call_abort_proc16
 268  */
 269 static BOOL CALLBACK call_abort_proc16( HDC hdc, INT code )
 270 {
 271     ABORTPROC16 proc16;
 272     DC *dc = DC_GetDCPtr( hdc );
 273
 274     if (!dc) return FALSE;
 275     proc16 = dc->pAbortProc16;
 276     GDI_ReleaseObj( hdc );
 277     if (proc16) return PRTDRV_CallTo16_word_ww( (FARPROC16)proc16, hdc, code );
 278     return TRUE;
 279 }
 280
 281
 282 /**********************************************************************
 283  *           SetAbortProc   (GDI.381)
 284  */
 285 INT16 WINAPI SetAbortProc16(HDC16 hdc, ABORTPROC16 abrtprc)
 286 {
 287     DC *dc = DC_GetDCPtr( hdc );
 288
 289     if (!dc) return FALSE;
 290     dc->pAbortProc16 = abrtprc;
 291     GDI_ReleaseObj( hdc );
 292     return SetAbortProc( hdc, call_abort_proc16 );
 293 }
 294
 295 /**********************************************************************
 296  *           SetAbortProc   (GDI32.@)
 297  *
 298  */
 299 INT WINAPI SetAbortProc(HDC hdc, ABORTPROC abrtprc)
 300 {
 301     DC *dc = DC_GetDCPtr( hdc );
 302
 303     if (!dc) return FALSE;
 304     dc->pAbortProc = abrtprc;
 305     GDI_ReleaseObj( hdc );
 306     return TRUE;
 307 }
 308
 309
 310 /****************** misc. printer related functions */
 311
 312 /*
 313  * The following function should implement a queing system
 314  */
 315 struct hpq
 316 {
 317     struct hpq  *next;
 318     int          tag;
 319     int          key;
 320 };
 321
 322 static struct hpq *hpqueue;
 323
 324 /**********************************************************************
 325  *           CreatePQ   (GDI.230)
 326  *
 327  */
 328 HPQ16 WINAPI CreatePQ16(INT16 size)
 329 {
 330 #if 0
 331     HGLOBAL16 hpq = 0;
 332     WORD tmp_size;
 333     LPWORD pPQ;
 334
 335     tmp_size = size << 2;
 336     if (!(hpq = GlobalAlloc16(GMEM_SHARE|GMEM_MOVEABLE, tmp_size + 8)))
 337        return 0xffff;
 338     pPQ = GlobalLock16(hpq);
 339     *pPQ++ = 0;
 340     *pPQ++ = tmp_size;
 341     *pPQ++ = 0;
 342     *pPQ++ = 0;
 343     GlobalUnlock16(hpq);
 344
 345     return (HPQ16)hpq;
 346 #else
 347     FIXME("(%d): stub\n",size);
 348     return 1;
 349 #endif
 350 }
 351
 352 /**********************************************************************
 353  *           DeletePQ   (GDI.235)
 354  *
 355  */
 356 INT16 WINAPI DeletePQ16(HPQ16 hPQ)
 357 {
 358     return GlobalFree16((HGLOBAL16)hPQ);
 359 }
 360
 361 /**********************************************************************
 362  *           ExtractPQ   (GDI.232)
 363  *
 364  */
 365 INT16 WINAPI ExtractPQ16(HPQ16 hPQ)
 366 {
 367     struct hpq *queue, *prev, *current, *currentPrev;
 368     int key = 0, tag = -1;
 369     currentPrev = prev = NULL;
 370     queue = current = hpqueue;
 371     if (current)
 372         key = current->key;
 373
 374     while (current)
 375     {
 376         currentPrev = current;
 377         current = current->next;
 378         if (current)
 379         {
 380             if (current->key < key)
 381             {
 382                 queue = current;
 383                 prev = currentPrev;
 384             }
 385         }
 386     }
 387     if (queue)
 388     {
 389         tag = queue->tag;
 390
 391         if (prev)
 392             prev->next = queue->next;
 393         else
 394             hpqueue = queue->next;
 395         HeapFree(GetProcessHeap(), 0, queue);
 396     }
 397
 398     TRACE("%x got tag %d key %d\n", hPQ, tag, key);
 399
 400     return tag;
 401 }
 402
 403 /**********************************************************************
 404  *           InsertPQ   (GDI.233)
 405  *
 406  */
 407 INT16 WINAPI InsertPQ16(HPQ16 hPQ, INT16 tag, INT16 key)
 408 {
 409     struct hpq *queueItem = HeapAlloc(GetProcessHeap(), 0, sizeof(struct hpq));
 410     if(queueItem == NULL) {
 411         ERR("Memory exausted!\n");
 412         return FALSE;
 413     }
 414     queueItem->next = hpqueue;
 415     hpqueue = queueItem;
 416     queueItem->key = key;
 417     queueItem->tag = tag;
 418
 419     FIXME("(%x %d %d): stub???\n", hPQ, tag, key);
 420     return TRUE;
 421 }
 422
 423 /**********************************************************************
 424  *           MinPQ   (GDI.231)
 425  *
 426  */
 427 INT16 WINAPI MinPQ16(HPQ16 hPQ)
 428 {
 429     FIXME("(%x): stub\n", hPQ);
 430     return 0;
 431 }
 432
 433 /**********************************************************************
 434  *           SizePQ   (GDI.234)
 435  *
 436  */
 437 INT16 WINAPI SizePQ16(HPQ16 hPQ, INT16 sizechange)
 438 {
 439     FIXME("(%x %d): stub\n", hPQ, sizechange);
 440     return -1;
 441 }
 442
 443
 444
 445 /*
 446  * The following functions implement part of the spooling process to
 447  * print manager.  I would like to see wine have a version of print managers
 448  * that used LPR/LPD.  For simplicity print jobs will be sent to a file for
 449  * now.
 450  */
 451 typedef struct PRINTJOB
 452 {
 453     char        *pszOutput;
 454     char        *pszTitle;
 455     HDC16       hDC;
 456     HANDLE16    hHandle;
 457     int         nIndex;
 458     int         fd;
 459 } PRINTJOB, *PPRINTJOB;
 460
 461 #define MAX_PRINT_JOBS 1
 462 #define SP_OK 1
 463
 464 PPRINTJOB gPrintJobsTable[MAX_PRINT_JOBS];
 465
 466
 467 static PPRINTJOB FindPrintJobFromHandle(HANDLE16 hHandle)
 468 {
 469     return gPrintJobsTable[0];
 470 }
 471
 472 static int CreateSpoolFile(LPCSTR pszOutput)
 473 {
 474     int fd=-1;
 475     char psCmd[1024];
 476     char *psCmdP = psCmd;
 477
 478     /* TTD convert the 'output device' into a spool file name */
 479
 480     if (pszOutput == NULL || *pszOutput == '\0')
 481       return -1;
 482
 483     if (!strncmp("LPR:",pszOutput,4))
 484       sprintf(psCmd,"|lpr -P%s",pszOutput+4);
 485     else
 486     {
 487         HKEY hkey;
 488         /* default value */
 489         psCmd[0] = 0;
 490         if(!RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\spooler", &hkey))
 491         {
 492             DWORD type, count = sizeof(psCmd);
 493             RegQueryValueExA(hkey, pszOutput, 0, &type, psCmd, &count);
 494             RegCloseKey(hkey);
 495         }
 496     }
 497     TRACE("Got printerSpoolCommand '%s' for output device '%s'\n",
 498           psCmd, pszOutput);
 499     if (!*psCmd)
 500         psCmdP = (char *)pszOutput;
 501     else
 502     {
 503         while (*psCmdP && isspace(*psCmdP))
 504         {
 505             psCmdP++;
 506         };
 507         if (!*psCmdP)
 508             return -1;
 509     }
 510     if (*psCmdP == '|')
 511     {
 512         int fds[2];
 513         if (pipe(fds))
 514             return -1;
 515         if (fork() == 0)
 516         {
 517             psCmdP++;
 518
 519             TRACE("In child need to exec %s\n",psCmdP);
 520             close(0);
 521             dup2(fds[0],0);
 522             close (fds[1]);
 523             system(psCmdP);
 524             exit(0);
 525
 526         }
 527         close (fds[0]);
 528         fd = fds[1];
 529         TRACE("Need to execute a cmnd and pipe the output to it\n");
 530     }
 531     else
 532     {
 533         char buffer[MAX_PATH];
 534
 535         TRACE("Just assume it's a file\n");
 536
 537         /**
 538          * The file name can be dos based, we have to find its
 539          * Unix correspondant file name
 540          */
 541         wine_get_unix_file_name(psCmdP, buffer, sizeof(buffer));
 542
 543         if ((fd = open(buffer, O_CREAT | O_TRUNC | O_WRONLY , 0600)) < 0)
 544         {
 545             ERR("Failed to create spool file '%s' ('%s'). (error %s)\n",
 546                 buffer, psCmdP, strerror(errno));
 547         }
 548     }
 549     return fd;
 550 }
 551
 552 static int FreePrintJob(HANDLE16 hJob)
 553 {
 554     int nRet = SP_ERROR;
 555     PPRINTJOB pPrintJob;
 556
 557     pPrintJob = FindPrintJobFromHandle(hJob);
 558     if (pPrintJob != NULL)
 559     {
 560         gPrintJobsTable[pPrintJob->nIndex] = NULL;
 561         HeapFree(GetProcessHeap(), 0, pPrintJob->pszOutput);
 562         HeapFree(GetProcessHeap(), 0, pPrintJob->pszTitle);
 563         if (pPrintJob->fd >= 0) close(pPrintJob->fd);
 564         HeapFree(GetProcessHeap(), 0, pPrintJob);
 565         nRet = SP_OK;
 566     }
 567     return nRet;
 568 }
 569
 570 /**********************************************************************
 571  *           OpenJob   (GDI.240)
 572  *           OpenJob16 (GDI32.@)
 573  *
 574  */
 575 HPJOB16 WINAPI OpenJob16(LPCSTR lpOutput, LPCSTR lpTitle, HDC16 hDC)
 576 {
 577     HPJOB16 hHandle = (HPJOB16)SP_ERROR;
 578     PPRINTJOB pPrintJob;
 579
 580     TRACE("'%s' '%s' %04x\n", lpOutput, lpTitle, hDC);
 581
 582     pPrintJob = gPrintJobsTable[0];
 583     if (pPrintJob == NULL)
 584     {
 585         int fd;
 586
 587         /* Try and create a spool file */
 588         fd = CreateSpoolFile(lpOutput);
 589         if (fd >= 0)
 590         {
 591             pPrintJob = HeapAlloc(GetProcessHeap(), 0, sizeof(PRINTJOB));
 592             if(pPrintJob == NULL) {
 593                 WARN("Memory exausted!\n");
 594                 return hHandle;
 595             }
 596
 597             hHandle = 1;
 598
 599             pPrintJob->pszOutput = HeapAlloc(GetProcessHeap(), 0, strlen(lpOutput)+1);
 600             strcpy( pPrintJob->pszOutput, lpOutput );
 601             if(lpTitle)
 602             {
 603                 pPrintJob->pszTitle = HeapAlloc(GetProcessHeap(), 0, strlen(lpTitle)+1);
 604                 strcpy( pPrintJob->pszTitle, lpTitle );
 605             }
 606             pPrintJob->hDC = hDC;
 607             pPrintJob->fd = fd;
 608             pPrintJob->nIndex = 0;
 609             pPrintJob->hHandle = hHandle;
 610             gPrintJobsTable[pPrintJob->nIndex] = pPrintJob;
 611         }
 612     }
 613     TRACE("return %04x\n", hHandle);
 614     return hHandle;
 615 }
 616
 617 /**********************************************************************
 618  *           CloseJob   (GDI.243)
 619  *           CloseJob16 (GDI32.@)
 620  *
 621  */
 622 INT16 WINAPI CloseJob16(HPJOB16 hJob)
 623 {
 624     int nRet = SP_ERROR;
 625     PPRINTJOB pPrintJob = NULL;
 626
 627     TRACE("%04x\n", hJob);
 628
 629     pPrintJob = FindPrintJobFromHandle(hJob);
 630     if (pPrintJob != NULL)
 631     {
 632         /* Close the spool file */
 633         close(pPrintJob->fd);
 634         FreePrintJob(hJob);
 635         nRet  = 1;
 636     }
 637     return nRet;
 638 }
 639
 640 /**********************************************************************
 641  *           WriteSpool   (GDI.241)
 642  *           WriteSpool16 (GDI32.@)
 643  *
 644  */
 645 INT16 WINAPI WriteSpool16(HPJOB16 hJob, LPSTR lpData, INT16 cch)
 646 {
 647     int nRet = SP_ERROR;
 648     PPRINTJOB pPrintJob = NULL;
 649
 650     TRACE("%04x %08lx %04x\n", hJob, (DWORD)lpData, cch);
 651
 652     pPrintJob = FindPrintJobFromHandle(hJob);
 653     if (pPrintJob != NULL && pPrintJob->fd >= 0 && cch)
 654     {
 655         if (write(pPrintJob->fd, lpData, cch) != cch)
 656           nRet = SP_OUTOFDISK;
 657         else
 658           nRet = cch;
 659 #if 0
 660         /* FIXME: We just cannot call 16 bit functions from here, since we
 661          * have acquired several locks (DC). And we do not really need to.
 662          */
 663         if (pPrintJob->hDC == 0) {
 664             TRACE("hDC == 0 so no QueryAbort\n");
 665         }
 666         else if (!(QueryAbort16(pPrintJob->hDC, (nRet == SP_OUTOFDISK) ? nRet : 0 )))
 667         {
 668             CloseJob16(hJob); /* printing aborted */
 669             nRet = SP_APPABORT;
 670         }
 671 #endif
 672     }
 673     return nRet;
 674 }
 675
 676 typedef INT (WINAPI *MSGBOX_PROC)( HWND, LPCSTR, LPCSTR, UINT );
 677
 678 /**********************************************************************
 679  *           WriteDialog   (GDI.242)
 680  *
 681  */
 682 INT16 WINAPI WriteDialog16(HPJOB16 hJob, LPSTR lpMsg, INT16 cchMsg)
 683 {
 684     HMODULE mod;
 685     MSGBOX_PROC pMessageBoxA;
 686     INT16 ret = 0;
 687
 688     TRACE("%04x %04x '%s'\n", hJob,  cchMsg, lpMsg);
 689
 690     if ((mod = GetModuleHandleA("user32.dll")))
 691     {
 692         if ((pMessageBoxA = (MSGBOX_PROC)GetProcAddress( mod, "MessageBoxA" )))
 693             ret = pMessageBoxA(0, lpMsg, "Printing Error", MB_OKCANCEL);
 694     }
 695     return ret;
 696 }
 697
 698
 699 /**********************************************************************
 700  *           DeleteJob  (GDI.244)
 701  *
 702  */
 703 INT16 WINAPI DeleteJob16(HPJOB16 hJob, INT16 nNotUsed)
 704 {
 705     int nRet;
 706
 707     TRACE("%04x\n", hJob);
 708
 709     nRet = FreePrintJob(hJob);
 710     return nRet;
 711 }
 712
 713 /*
 714  * The following two function would allow a page to be sent to the printer
 715  * when it has been processed.  For simplicity they havn't been implemented.
 716  * This means a whole job has to be processed before it is sent to the printer.
 717  */
 718
 719 /**********************************************************************
 720  *           StartSpoolPage   (GDI.246)
 721  *
 722  */
 723 INT16 WINAPI StartSpoolPage16(HPJOB16 hJob)
 724 {
 725     FIXME("StartSpoolPage GDI.246 unimplemented\n");
 726     return 1;
 727
 728 }
 729
 730
 731 /**********************************************************************
 732  *           EndSpoolPage   (GDI.247)
 733  *
 734  */
 735 INT16 WINAPI EndSpoolPage16(HPJOB16 hJob)
 736 {
 737     FIXME("EndSpoolPage GDI.247 unimplemented\n");
 738     return 1;
 739 }
 740
 741
 742 /**********************************************************************
 743  *           GetSpoolJob   (GDI.245)
 744  *
 745  */
 746 DWORD WINAPI GetSpoolJob16(int nOption, LONG param)
 747 {
 748     DWORD retval = 0;
 749     TRACE("In GetSpoolJob param 0x%lx noption %d\n",param, nOption);
 750     return retval;
 751 }
 752
 753
 754 /******************************************************************
 755  *                  DrvGetPrinterDataInternal
 756  *
 757  * Helper for DrvGetPrinterData
 758  */
 759 static DWORD DrvGetPrinterDataInternal(LPSTR RegStr_Printer,
 760 LPBYTE lpPrinterData, int cbData, int what)
 761 {
 762     DWORD res = -1;
 763     HKEY hkey;
 764     DWORD dwType, cbQueryData;
 765
 766     if (!(RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey))) {
 767         if (what == INT_PD_DEFAULT_DEVMODE) { /* "Default DevMode" */
 768             if (!(RegQueryValueExA(hkey, DefaultDevMode, 0, &dwType, 0, &cbQueryData))) {
 769                 if (!lpPrinterData)
 770                     res = cbQueryData;
 771                 else if ((cbQueryData) && (cbQueryData <= cbData)) {
 772                     cbQueryData = cbData;
 773                     if (RegQueryValueExA(hkey, DefaultDevMode, 0,
 774                                 &dwType, lpPrinterData, &cbQueryData))
 775                         res = cbQueryData;
 776                 }
 777             }
 778         } else { /* "Printer Driver" */
 779             cbQueryData = 32;
 780             RegQueryValueExA(hkey, "Printer Driver", 0,
 781                         &dwType, lpPrinterData, &cbQueryData);
 782             res = cbQueryData;
 783         }
 784     }
 785     if (hkey) RegCloseKey(hkey);
 786     return res;
 787 }
 788
 789 /******************************************************************
 790  *                DrvGetPrinterData     (GDI.282)
 791  *                DrvGetPrinterData16   (GDI32.@)
 792  *
 793  */
 794 DWORD WINAPI DrvGetPrinterData16(LPSTR lpPrinter, LPSTR lpProfile,
 795                                LPDWORD lpType, LPBYTE lpPrinterData,
 796                                int cbData, LPDWORD lpNeeded)
 797 {
 798     LPSTR RegStr_Printer;
 799     HKEY hkey = 0, hkey2 = 0;
 800     DWORD res = 0;
 801     DWORD dwType, PrinterAttr, cbPrinterAttr, SetData, size;
 802
 803     if (HIWORD(lpPrinter))
 804             TRACE("printer %s\n",lpPrinter);
 805     else
 806             TRACE("printer %p\n",lpPrinter);
 807     if (HIWORD(lpProfile))
 808             TRACE("profile %s\n",lpProfile);
 809     else
 810             TRACE("profile %p\n",lpProfile);
 811     TRACE("lpType %p\n",lpType);
 812
 813     if ((!lpPrinter) || (!lpProfile) || (!lpNeeded))
 814         return ERROR_INVALID_PARAMETER;
 815
 816     RegStr_Printer = HeapAlloc(GetProcessHeap(), 0,
 817                                strlen(Printers) + strlen(lpPrinter) + 2);
 818     strcpy(RegStr_Printer, Printers);
 819     strcat(RegStr_Printer, lpPrinter);
 820
 821     if (((DWORD)lpProfile == INT_PD_DEFAULT_DEVMODE) || (HIWORD(lpProfile) &&
 822     (!strcmp(lpProfile, DefaultDevMode)))) {
 823         size = DrvGetPrinterDataInternal(RegStr_Printer, lpPrinterData, cbData,
 824                                          INT_PD_DEFAULT_DEVMODE);
 825         if (size+1) {
 826             *lpNeeded = size;
 827             if ((lpPrinterData) && (*lpNeeded > cbData))
 828                 res = ERROR_MORE_DATA;
 829         }
 830         else res = ERROR_INVALID_PRINTER_NAME;
 831     }
 832     else
 833     if (((DWORD)lpProfile == INT_PD_DEFAULT_MODEL) || (HIWORD(lpProfile) &&
 834     (!strcmp(lpProfile, PrinterModel)))) {
 835         *lpNeeded = 32;
 836         if (!lpPrinterData) goto failed;
 837         if (cbData < 32) {
 838             res = ERROR_MORE_DATA;
 839             goto failed;
 840         }
 841         size = DrvGetPrinterDataInternal(RegStr_Printer, lpPrinterData, cbData,
 842                                          INT_PD_DEFAULT_MODEL);
 843         if ((size+1) && (lpType))
 844             *lpType = REG_SZ;
 845         else
 846             res = ERROR_INVALID_PRINTER_NAME;
 847     }
 848     else
 849     {
 850         if ((res = RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)))
 851             goto failed;
 852         cbPrinterAttr = 4;
 853         if ((res = RegQueryValueExA(hkey, "Attributes", 0,
 854                         &dwType, (LPBYTE)&PrinterAttr, &cbPrinterAttr)))
 855             goto failed;
 856         if ((res = RegOpenKeyA(hkey, PrinterDriverData, &hkey2)))
 857             goto failed;
 858         *lpNeeded = cbData;
 859         res = RegQueryValueExA(hkey2, lpProfile, 0,
 860                 lpType, lpPrinterData, lpNeeded);
 861         if ((res != ERROR_CANTREAD) &&
 862          ((PrinterAttr &
 863         (PRINTER_ATTRIBUTE_ENABLE_BIDI|PRINTER_ATTRIBUTE_NETWORK))
 864         == PRINTER_ATTRIBUTE_NETWORK))
 865         {
 866             if (!(res) && (*lpType == REG_DWORD) && (*(LPDWORD)lpPrinterData == -1))
 867                 res = ERROR_INVALID_DATA;
 868         }
 869         else
 870         {
 871             SetData = -1;
 872             RegSetValueExA(hkey2, lpProfile, 0, REG_DWORD, (LPBYTE)&SetData, 4); /* no result returned */
 873         }
 874     }
 875
 876 failed:
 877     if (hkey2) RegCloseKey(hkey2);
 878     if (hkey) RegCloseKey(hkey);
 879     HeapFree(GetProcessHeap(), 0, RegStr_Printer);
 880     return res;
 881 }
 882
 883
 884 /******************************************************************
 885  *                 DrvSetPrinterData     (GDI.281)
 886  *                 DrvSetPrinterData16   (GDI32.@)
 887  *
 888  */
 889 DWORD WINAPI DrvSetPrinterData16(LPSTR lpPrinter, LPSTR lpProfile,
 890                                DWORD lpType, LPBYTE lpPrinterData,
 891                                DWORD dwSize)
 892 {
 893     LPSTR RegStr_Printer;
 894     HKEY hkey = 0;
 895     DWORD res = 0;
 896
 897     if (HIWORD(lpPrinter))
 898             TRACE("printer %s\n",lpPrinter);
 899     else
 900             TRACE("printer %p\n",lpPrinter);
 901     if (HIWORD(lpProfile))
 902             TRACE("profile %s\n",lpProfile);
 903     else
 904             TRACE("profile %p\n",lpProfile);
 905     TRACE("lpType %08lx\n",lpType);
 906
 907     if ((!lpPrinter) || (!lpProfile) ||
 908     ((DWORD)lpProfile == INT_PD_DEFAULT_MODEL) || (HIWORD(lpProfile) &&
 909     (!strcmp(lpProfile, PrinterModel))))
 910         return ERROR_INVALID_PARAMETER;
 911
 912     RegStr_Printer = HeapAlloc(GetProcessHeap(), 0,
 913                         strlen(Printers) + strlen(lpPrinter) + 2);
 914     strcpy(RegStr_Printer, Printers);
 915     strcat(RegStr_Printer, lpPrinter);
 916
 917     if (((DWORD)lpProfile == INT_PD_DEFAULT_DEVMODE) || (HIWORD(lpProfile) &&
 918     (!strcmp(lpProfile, DefaultDevMode)))) {
 919         if ( RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)
 920              != ERROR_SUCCESS ||
 921              RegSetValueExA(hkey, DefaultDevMode, 0, REG_BINARY,
 922                               lpPrinterData, dwSize) != ERROR_SUCCESS )
 923                 res = ERROR_INVALID_PRINTER_NAME;
 924     }
 925     else
 926     {
 927         strcat(RegStr_Printer, "\\");
 928
 929         if( (res = RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)) ==
 930             ERROR_SUCCESS ) {
 931
 932             if (!lpPrinterData)
 933                 res = RegDeleteValueA(hkey, lpProfile);
 934             else
 935                 res = RegSetValueExA(hkey, lpProfile, 0, lpType,
 936                                        lpPrinterData, dwSize);
 937         }
 938     }
 939
 940     if (hkey) RegCloseKey(hkey);
 941     HeapFree(GetProcessHeap(), 0, RegStr_Printer);
 942     return res;
 943 }