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