git.oblomov.eu Git - wine/blob - dlls/gdi32/printdrv16.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  *           QueryAbort   (GDI.155)
  62  *
  63  *  Calls the app's AbortProc function if avail.
  64  *
  65  * RETURNS
  66  * TRUE if no AbortProc avail or AbortProc wants to continue printing.
  67  * FALSE if AbortProc wants to abort printing.
  68  */
  69 BOOL16 WINAPI QueryAbort16(HDC16 hdc16, INT16 reserved)
  70 {
  71     BOOL ret = TRUE;
  72     HDC hdc = HDC_32( hdc16 );
  73     DC *dc = get_dc_ptr( hdc );
  74
  75     if(!dc) {
  76         ERR("Invalid hdc %p\n", hdc);
  77         return FALSE;
  78     }
  79     if (dc->pAbortProc) ret = dc->pAbortProc(hdc, 0);
  80     release_dc_ptr( dc );
  81     return ret;
  82 }
  83
  84
  85 /**********************************************************************
  86  *           call_abort_proc16
  87  */
  88 static BOOL CALLBACK call_abort_proc16( HDC hdc, INT code )
  89 {
  90     ABORTPROC16 proc16;
  91     DC *dc = get_dc_ptr( hdc );
  92
  93     if (!dc) return FALSE;
  94     proc16 = dc->pAbortProc16;
  95     release_dc_ptr( dc );
  96     if (proc16)
  97     {
  98         WORD args[2];
  99         DWORD ret;
 100
 101         args[1] = HDC_16(hdc);
 102         args[0] = code;
 103         WOWCallback16Ex( (DWORD)proc16, WCB16_PASCAL, sizeof(args), args, &ret );
 104         return LOWORD(ret);
 105     }
 106     return TRUE;
 107 }
 108
 109
 110 /**********************************************************************
 111  *           SetAbortProc   (GDI.381)
 112  */
 113 INT16 WINAPI SetAbortProc16(HDC16 hdc16, ABORTPROC16 abrtprc)
 114 {
 115     HDC hdc = HDC_32( hdc16 );
 116     DC *dc = get_dc_ptr( hdc );
 117
 118     if (!dc) return FALSE;
 119     dc->pAbortProc16 = abrtprc;
 120     dc->pAbortProc   = call_abort_proc16;
 121     release_dc_ptr( dc );
 122     return TRUE;
 123 }
 124
 125
 126 /****************** misc. printer related functions */
 127
 128 /*
 129  * The following function should implement a queing system
 130  */
 131 struct hpq
 132 {
 133     struct hpq  *next;
 134     int          tag;
 135     int          key;
 136 };
 137
 138 static struct hpq *hpqueue;
 139
 140 /**********************************************************************
 141  *           CreatePQ   (GDI.230)
 142  *
 143  */
 144 HPQ16 WINAPI CreatePQ16(INT16 size)
 145 {
 146 #if 0
 147     HGLOBAL16 hpq = 0;
 148     WORD tmp_size;
 149     LPWORD pPQ;
 150
 151     tmp_size = size << 2;
 152     if (!(hpq = GlobalAlloc16(GMEM_SHARE|GMEM_MOVEABLE, tmp_size + 8)))
 153        return 0xffff;
 154     pPQ = GlobalLock16(hpq);
 155     *pPQ++ = 0;
 156     *pPQ++ = tmp_size;
 157     *pPQ++ = 0;
 158     *pPQ++ = 0;
 159     GlobalUnlock16(hpq);
 160
 161     return (HPQ16)hpq;
 162 #else
 163     FIXME("(%d): stub\n",size);
 164     return 1;
 165 #endif
 166 }
 167
 168 /**********************************************************************
 169  *           DeletePQ   (GDI.235)
 170  *
 171  */
 172 INT16 WINAPI DeletePQ16(HPQ16 hPQ)
 173 {
 174     return GlobalFree16(hPQ);
 175 }
 176
 177 /**********************************************************************
 178  *           ExtractPQ   (GDI.232)
 179  *
 180  */
 181 INT16 WINAPI ExtractPQ16(HPQ16 hPQ)
 182 {
 183     struct hpq *queue, *prev, *current, *currentPrev;
 184     int key = 0, tag = -1;
 185     currentPrev = prev = NULL;
 186     queue = current = hpqueue;
 187     if (current)
 188         key = current->key;
 189
 190     while (current)
 191     {
 192         currentPrev = current;
 193         current = current->next;
 194         if (current)
 195         {
 196             if (current->key < key)
 197             {
 198                 queue = current;
 199                 prev = currentPrev;
 200             }
 201         }
 202     }
 203     if (queue)
 204     {
 205         tag = queue->tag;
 206
 207         if (prev)
 208             prev->next = queue->next;
 209         else
 210             hpqueue = queue->next;
 211         HeapFree(GetProcessHeap(), 0, queue);
 212     }
 213
 214     TRACE("%x got tag %d key %d\n", hPQ, tag, key);
 215
 216     return tag;
 217 }
 218
 219 /**********************************************************************
 220  *           InsertPQ   (GDI.233)
 221  *
 222  */
 223 INT16 WINAPI InsertPQ16(HPQ16 hPQ, INT16 tag, INT16 key)
 224 {
 225     struct hpq *queueItem = HeapAlloc(GetProcessHeap(), 0, sizeof(struct hpq));
 226     if(queueItem == NULL) {
 227         ERR("Memory exausted!\n");
 228         return FALSE;
 229     }
 230     queueItem->next = hpqueue;
 231     hpqueue = queueItem;
 232     queueItem->key = key;
 233     queueItem->tag = tag;
 234
 235     FIXME("(%x %d %d): stub???\n", hPQ, tag, key);
 236     return TRUE;
 237 }
 238
 239 /**********************************************************************
 240  *           MinPQ   (GDI.231)
 241  *
 242  */
 243 INT16 WINAPI MinPQ16(HPQ16 hPQ)
 244 {
 245     FIXME("(%x): stub\n", hPQ);
 246     return 0;
 247 }
 248
 249 /**********************************************************************
 250  *           SizePQ   (GDI.234)
 251  *
 252  */
 253 INT16 WINAPI SizePQ16(HPQ16 hPQ, INT16 sizechange)
 254 {
 255     FIXME("(%x %d): stub\n", hPQ, sizechange);
 256     return -1;
 257 }
 258
 259
 260
 261 /*
 262  * The following functions implement part of the spooling process to
 263  * print manager.  I would like to see wine have a version of print managers
 264  * that used LPR/LPD.  For simplicity print jobs will be sent to a file for
 265  * now.
 266  */
 267 typedef struct PRINTJOB
 268 {
 269     char        *pszOutput;
 270     char        *pszTitle;
 271     HDC16       hDC;
 272     HANDLE16    hHandle;
 273     int         nIndex;
 274     int         fd;
 275 } PRINTJOB, *PPRINTJOB;
 276
 277 #define MAX_PRINT_JOBS 1
 278 #define SP_OK 1
 279
 280 static PPRINTJOB gPrintJobsTable[MAX_PRINT_JOBS];
 281
 282
 283 static PPRINTJOB FindPrintJobFromHandle(HANDLE16 hHandle)
 284 {
 285     return gPrintJobsTable[0];
 286 }
 287
 288 static int CreateSpoolFile(LPCSTR pszOutput)
 289 {
 290     int fd=-1;
 291     char psCmd[1024];
 292     const char *psCmdP = psCmd;
 293     HKEY hkey;
 294
 295     /* TTD convert the 'output device' into a spool file name */
 296
 297     if (pszOutput == NULL || *pszOutput == '\0')
 298       return -1;
 299
 300     psCmd[0] = 0;
 301     /* @@ Wine registry key: HKCU\Software\Wine\Printing\Spooler */
 302     if(!RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Printing\\Spooler", &hkey))
 303     {
 304         DWORD type, count = sizeof(psCmd);
 305         RegQueryValueExA(hkey, pszOutput, 0, &type, (LPBYTE)psCmd, &count);
 306         RegCloseKey(hkey);
 307     }
 308     if (!psCmd[0] && !strncmp("LPR:",pszOutput,4))
 309         sprintf(psCmd,"|lpr -P'%s'",pszOutput+4);
 310
 311     TRACE("Got printerSpoolCommand '%s' for output device '%s'\n",
 312           psCmd, pszOutput);
 313     if (!*psCmd)
 314         psCmdP = pszOutput;
 315     else
 316     {
 317         while (*psCmdP && isspace(*psCmdP))
 318         {
 319             psCmdP++;
 320         }
 321         if (!*psCmdP)
 322             return -1;
 323     }
 324     TRACE("command: '%s'\n", psCmdP);
 325 #ifdef HAVE_FORK
 326     if (*psCmdP == '|')
 327     {
 328         int fds[2];
 329         if (pipe(fds)) {
 330             ERR("pipe() failed!\n");
 331             return -1;
 332         }
 333         if (fork() == 0)
 334         {
 335             psCmdP++;
 336
 337             TRACE("In child need to exec %s\n",psCmdP);
 338             close(0);
 339             dup2(fds[0],0);
 340             close (fds[1]);
 341
 342             /* reset signals that we previously set to SIG_IGN */
 343             signal( SIGPIPE, SIG_DFL );
 344             signal( SIGCHLD, SIG_DFL );
 345
 346             execl("/bin/sh", "/bin/sh", "-c", psCmdP, NULL);
 347             _exit(1);
 348
 349         }
 350         close (fds[0]);
 351         fd = fds[1];
 352         TRACE("Need to execute a cmnd and pipe the output to it\n");
 353     }
 354     else
 355 #endif
 356     {
 357         char *buffer;
 358         WCHAR psCmdPW[MAX_PATH];
 359
 360         TRACE("Just assume it's a file\n");
 361
 362         /**
 363          * The file name can be dos based, we have to find its
 364          * corresponding Unix file name.
 365          */
 366         MultiByteToWideChar(CP_ACP, 0, psCmdP, -1, psCmdPW, MAX_PATH);
 367         if ((buffer = wine_get_unix_file_name(psCmdPW)))
 368         {
 369             if ((fd = open(buffer, O_CREAT | O_TRUNC | O_WRONLY, 0666)) < 0)
 370             {
 371                 ERR("Failed to create spool file '%s' ('%s'). (error %s)\n",
 372                     buffer, psCmdP, strerror(errno));
 373             }
 374             HeapFree(GetProcessHeap(), 0, buffer);
 375         }
 376     }
 377     return fd;
 378 }
 379
 380 static int FreePrintJob(HANDLE16 hJob)
 381 {
 382     int nRet = SP_ERROR;
 383     PPRINTJOB pPrintJob;
 384
 385     pPrintJob = FindPrintJobFromHandle(hJob);
 386     if (pPrintJob != NULL)
 387     {
 388         gPrintJobsTable[pPrintJob->nIndex] = NULL;
 389         HeapFree(GetProcessHeap(), 0, pPrintJob->pszOutput);
 390         HeapFree(GetProcessHeap(), 0, pPrintJob->pszTitle);
 391         if (pPrintJob->fd >= 0) close(pPrintJob->fd);
 392         HeapFree(GetProcessHeap(), 0, pPrintJob);
 393         nRet = SP_OK;
 394     }
 395     return nRet;
 396 }
 397
 398 /**********************************************************************
 399  *           OpenJob   (GDI.240)
 400  *
 401  */
 402 HPJOB16 WINAPI OpenJob16(LPCSTR lpOutput, LPCSTR lpTitle, HDC16 hDC)
 403 {
 404     HPJOB16 hHandle = (HPJOB16)SP_ERROR;
 405     PPRINTJOB pPrintJob;
 406
 407     TRACE("'%s' '%s' %04x\n", lpOutput, lpTitle, hDC);
 408
 409     pPrintJob = gPrintJobsTable[0];
 410     if (pPrintJob == NULL)
 411     {
 412         int fd;
 413
 414         /* Try and create a spool file */
 415         fd = CreateSpoolFile(lpOutput);
 416         if (fd >= 0)
 417         {
 418             pPrintJob = HeapAlloc(GetProcessHeap(), 0, sizeof(PRINTJOB));
 419             if(pPrintJob == NULL) {
 420                 WARN("Memory exausted!\n");
 421                 return hHandle;
 422             }
 423
 424             hHandle = 1;
 425
 426             pPrintJob->pszOutput = HeapAlloc(GetProcessHeap(), 0, strlen(lpOutput)+1);
 427             strcpy( pPrintJob->pszOutput, lpOutput );
 428             if(lpTitle)
 429             {
 430                 pPrintJob->pszTitle = HeapAlloc(GetProcessHeap(), 0, strlen(lpTitle)+1);
 431                 strcpy( pPrintJob->pszTitle, lpTitle );
 432             }
 433             pPrintJob->hDC = hDC;
 434             pPrintJob->fd = fd;
 435             pPrintJob->nIndex = 0;
 436             pPrintJob->hHandle = hHandle;
 437             gPrintJobsTable[pPrintJob->nIndex] = pPrintJob;
 438         }
 439     }
 440     TRACE("return %04x\n", hHandle);
 441     return hHandle;
 442 }
 443
 444 /**********************************************************************
 445  *           CloseJob   (GDI.243)
 446  *
 447  */
 448 INT16 WINAPI CloseJob16(HPJOB16 hJob)
 449 {
 450     int nRet = SP_ERROR;
 451     PPRINTJOB pPrintJob = NULL;
 452
 453     TRACE("%04x\n", hJob);
 454
 455     pPrintJob = FindPrintJobFromHandle(hJob);
 456     if (pPrintJob != NULL)
 457     {
 458         /* Close the spool file */
 459         close(pPrintJob->fd);
 460         FreePrintJob(hJob);
 461         nRet  = 1;
 462     }
 463     return nRet;
 464 }
 465
 466 /**********************************************************************
 467  *           WriteSpool   (GDI.241)
 468  *
 469  */
 470 INT16 WINAPI WriteSpool16(HPJOB16 hJob, LPSTR lpData, INT16 cch)
 471 {
 472     int nRet = SP_ERROR;
 473     PPRINTJOB pPrintJob = NULL;
 474
 475     TRACE("%04x %p %04x\n", hJob, lpData, cch);
 476
 477     pPrintJob = FindPrintJobFromHandle(hJob);
 478     if (pPrintJob != NULL && pPrintJob->fd >= 0 && cch)
 479     {
 480         if (write(pPrintJob->fd, lpData, cch) != cch)
 481           nRet = SP_OUTOFDISK;
 482         else
 483           nRet = cch;
 484 #if 0
 485         /* FIXME: We just cannot call 16 bit functions from here, since we
 486          * have acquired several locks (DC). And we do not really need to.
 487          */
 488         if (pPrintJob->hDC == 0) {
 489             TRACE("hDC == 0 so no QueryAbort\n");
 490         }
 491         else if (!(QueryAbort16(pPrintJob->hDC, (nRet == SP_OUTOFDISK) ? nRet : 0 )))
 492         {
 493             CloseJob16(hJob); /* printing aborted */
 494             nRet = SP_APPABORT;
 495         }
 496 #endif
 497     }
 498     return nRet;
 499 }
 500
 501 typedef INT (WINAPI *MSGBOX_PROC)( HWND, LPCSTR, LPCSTR, UINT );
 502
 503 /**********************************************************************
 504  *           WriteDialog   (GDI.242)
 505  *
 506  */
 507 INT16 WINAPI WriteDialog16(HPJOB16 hJob, LPSTR lpMsg, INT16 cchMsg)
 508 {
 509     HMODULE mod;
 510     MSGBOX_PROC pMessageBoxA;
 511     INT16 ret = 0;
 512
 513     TRACE("%04x %04x '%s'\n", hJob,  cchMsg, lpMsg);
 514
 515     if ((mod = GetModuleHandleA("user32.dll")))
 516     {
 517         if ((pMessageBoxA = (MSGBOX_PROC)GetProcAddress( mod, "MessageBoxA" )))
 518             ret = pMessageBoxA(0, lpMsg, "Printing Error", MB_OKCANCEL);
 519     }
 520     return ret;
 521 }
 522
 523
 524 /**********************************************************************
 525  *           DeleteJob  (GDI.244)
 526  *
 527  */
 528 INT16 WINAPI DeleteJob16(HPJOB16 hJob, INT16 nNotUsed)
 529 {
 530     int nRet;
 531
 532     TRACE("%04x\n", hJob);
 533
 534     nRet = FreePrintJob(hJob);
 535     return nRet;
 536 }
 537
 538 /*
 539  * The following two function would allow a page to be sent to the printer
 540  * when it has been processed.  For simplicity they haven't been implemented.
 541  * This means a whole job has to be processed before it is sent to the printer.
 542  */
 543
 544 /**********************************************************************
 545  *           StartSpoolPage   (GDI.246)
 546  *
 547  */
 548 INT16 WINAPI StartSpoolPage16(HPJOB16 hJob)
 549 {
 550     FIXME("StartSpoolPage GDI.246 unimplemented\n");
 551     return 1;
 552
 553 }
 554
 555
 556 /**********************************************************************
 557  *           EndSpoolPage   (GDI.247)
 558  *
 559  */
 560 INT16 WINAPI EndSpoolPage16(HPJOB16 hJob)
 561 {
 562     FIXME("EndSpoolPage GDI.247 unimplemented\n");
 563     return 1;
 564 }
 565
 566
 567 /**********************************************************************
 568  *           GetSpoolJob   (GDI.245)
 569  *
 570  */
 571 DWORD WINAPI GetSpoolJob16(int nOption, LONG param)
 572 {
 573     DWORD retval = 0;
 574     TRACE("In GetSpoolJob param 0x%x noption %d\n",param, nOption);
 575     return retval;
 576 }
 577
 578
 579 /******************************************************************
 580  *                  DrvGetPrinterDataInternal
 581  *
 582  * Helper for DrvGetPrinterData
 583  */
 584 static DWORD DrvGetPrinterDataInternal(LPSTR RegStr_Printer,
 585 LPBYTE lpPrinterData, int cbData, int what)
 586 {
 587     DWORD res = -1;
 588     HKEY hkey;
 589     DWORD dwType, cbQueryData;
 590
 591     if (!(RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey))) {
 592         if (what == INT_PD_DEFAULT_DEVMODE) { /* "Default DevMode" */
 593             if (!(RegQueryValueExA(hkey, DefaultDevMode, 0, &dwType, 0, &cbQueryData))) {
 594                 if (!lpPrinterData)
 595                     res = cbQueryData;
 596                 else if ((cbQueryData) && (cbQueryData <= cbData)) {
 597                     cbQueryData = cbData;
 598                     if (RegQueryValueExA(hkey, DefaultDevMode, 0,
 599                                 &dwType, lpPrinterData, &cbQueryData))
 600                         res = cbQueryData;
 601                 }
 602             }
 603         } else { /* "Printer Driver" */
 604             cbQueryData = 32;
 605             RegQueryValueExA(hkey, "Printer Driver", 0,
 606                         &dwType, lpPrinterData, &cbQueryData);
 607             res = cbQueryData;
 608         }
 609     }
 610     if (hkey) RegCloseKey(hkey);
 611     return res;
 612 }
 613
 614 /******************************************************************
 615  *                DrvGetPrinterData     (GDI.282)
 616  *
 617  */
 618 DWORD WINAPI DrvGetPrinterData16(LPSTR lpPrinter, LPSTR lpProfile,
 619                                LPDWORD lpType, LPBYTE lpPrinterData,
 620                                int cbData, LPDWORD lpNeeded)
 621 {
 622     LPSTR RegStr_Printer;
 623     HKEY hkey = 0, hkey2 = 0;
 624     DWORD res = 0;
 625     DWORD dwType, PrinterAttr, cbPrinterAttr, SetData, size;
 626
 627     if (HIWORD(lpPrinter))
 628             TRACE("printer %s\n",lpPrinter);
 629     else
 630             TRACE("printer %p\n",lpPrinter);
 631     if (HIWORD(lpProfile))
 632             TRACE("profile %s\n",lpProfile);
 633     else
 634             TRACE("profile %p\n",lpProfile);
 635     TRACE("lpType %p\n",lpType);
 636
 637     if ((!lpPrinter) || (!lpProfile) || (!lpNeeded))
 638         return ERROR_INVALID_PARAMETER;
 639
 640     RegStr_Printer = HeapAlloc(GetProcessHeap(), 0,
 641                                strlen(Printers) + strlen(lpPrinter) + 2);
 642     strcpy(RegStr_Printer, Printers);
 643     strcat(RegStr_Printer, lpPrinter);
 644
 645     if ((PtrToUlong(lpProfile) == INT_PD_DEFAULT_DEVMODE) || (HIWORD(lpProfile) &&
 646     (!strcmp(lpProfile, DefaultDevMode)))) {
 647         size = DrvGetPrinterDataInternal(RegStr_Printer, lpPrinterData, cbData,
 648                                          INT_PD_DEFAULT_DEVMODE);
 649         if (size+1) {
 650             *lpNeeded = size;
 651             if ((lpPrinterData) && (*lpNeeded > cbData))
 652                 res = ERROR_MORE_DATA;
 653         }
 654         else res = ERROR_INVALID_PRINTER_NAME;
 655     }
 656     else
 657     if ((PtrToUlong(lpProfile) == INT_PD_DEFAULT_MODEL) || (HIWORD(lpProfile) &&
 658     (!strcmp(lpProfile, PrinterModel)))) {
 659         *lpNeeded = 32;
 660         if (!lpPrinterData) goto failed;
 661         if (cbData < 32) {
 662             res = ERROR_MORE_DATA;
 663             goto failed;
 664         }
 665         size = DrvGetPrinterDataInternal(RegStr_Printer, lpPrinterData, cbData,
 666                                          INT_PD_DEFAULT_MODEL);
 667         if ((size+1) && (lpType))
 668             *lpType = REG_SZ;
 669         else
 670             res = ERROR_INVALID_PRINTER_NAME;
 671     }
 672     else
 673     {
 674         if ((res = RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)))
 675             goto failed;
 676         cbPrinterAttr = 4;
 677         if ((res = RegQueryValueExA(hkey, "Attributes", 0,
 678                         &dwType, (LPBYTE)&PrinterAttr, &cbPrinterAttr)))
 679             goto failed;
 680         if ((res = RegOpenKeyA(hkey, PrinterDriverData, &hkey2)))
 681             goto failed;
 682         *lpNeeded = cbData;
 683         res = RegQueryValueExA(hkey2, lpProfile, 0,
 684                 lpType, lpPrinterData, lpNeeded);
 685         if ((res != ERROR_CANTREAD) &&
 686          ((PrinterAttr &
 687         (PRINTER_ATTRIBUTE_ENABLE_BIDI|PRINTER_ATTRIBUTE_NETWORK))
 688         == PRINTER_ATTRIBUTE_NETWORK))
 689         {
 690             if (!(res) && (*lpType == REG_DWORD) && (*(LPDWORD)lpPrinterData == -1))
 691                 res = ERROR_INVALID_DATA;
 692         }
 693         else
 694         {
 695             SetData = -1;
 696             RegSetValueExA(hkey2, lpProfile, 0, REG_DWORD, (LPBYTE)&SetData, 4); /* no result returned */
 697         }
 698     }
 699
 700 failed:
 701     if (hkey2) RegCloseKey(hkey2);
 702     if (hkey) RegCloseKey(hkey);
 703     HeapFree(GetProcessHeap(), 0, RegStr_Printer);
 704     return res;
 705 }
 706
 707
 708 /******************************************************************
 709  *                 DrvSetPrinterData     (GDI.281)
 710  *
 711  */
 712 DWORD WINAPI DrvSetPrinterData16(LPSTR lpPrinter, LPSTR lpProfile,
 713                                DWORD lpType, LPBYTE lpPrinterData,
 714                                DWORD dwSize)
 715 {
 716     LPSTR RegStr_Printer;
 717     HKEY hkey = 0;
 718     DWORD res = 0;
 719
 720     if (HIWORD(lpPrinter))
 721             TRACE("printer %s\n",lpPrinter);
 722     else
 723             TRACE("printer %p\n",lpPrinter);
 724     if (HIWORD(lpProfile))
 725             TRACE("profile %s\n",lpProfile);
 726     else
 727             TRACE("profile %p\n",lpProfile);
 728     TRACE("lpType %08x\n",lpType);
 729
 730     if ((!lpPrinter) || (!lpProfile) ||
 731     (PtrToUlong(lpProfile) == INT_PD_DEFAULT_MODEL) || (HIWORD(lpProfile) &&
 732     (!strcmp(lpProfile, PrinterModel))))
 733         return ERROR_INVALID_PARAMETER;
 734
 735     RegStr_Printer = HeapAlloc(GetProcessHeap(), 0,
 736                         strlen(Printers) + strlen(lpPrinter) + 2);
 737     strcpy(RegStr_Printer, Printers);
 738     strcat(RegStr_Printer, lpPrinter);
 739
 740     if ((PtrToUlong(lpProfile) == INT_PD_DEFAULT_DEVMODE) || (HIWORD(lpProfile) &&
 741     (!strcmp(lpProfile, DefaultDevMode)))) {
 742         if ( RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)
 743              != ERROR_SUCCESS ||
 744              RegSetValueExA(hkey, DefaultDevMode, 0, REG_BINARY,
 745                               lpPrinterData, dwSize) != ERROR_SUCCESS )
 746                 res = ERROR_INVALID_PRINTER_NAME;
 747     }
 748     else
 749     {
 750         strcat(RegStr_Printer, "\\");
 751
 752         if( (res = RegOpenKeyA(HKEY_LOCAL_MACHINE, RegStr_Printer, &hkey)) ==
 753             ERROR_SUCCESS ) {
 754
 755             if (!lpPrinterData)
 756                 res = RegDeleteValueA(hkey, lpProfile);
 757             else
 758                 res = RegSetValueExA(hkey, lpProfile, 0, lpType,
 759                                        lpPrinterData, dwSize);
 760         }
 761     }
 762
 763     if (hkey) RegCloseKey(hkey);
 764     HeapFree(GetProcessHeap(), 0, RegStr_Printer);
 765     return res;
 766 }