misc/spooler.c

   1 /*
   2  * Print spooler and PQ functions
   3  *
   4  * Copyright 1996 John Harvey
   5  *           1998 Huw Davies
   6  *
   7  */
   8
   9 #include <ctype.h>
  10 #include <errno.h>
  11 #include <fcntl.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <unistd.h>
  15 #include "callback.h"
  16 #include "dc.h"
  17 #include "debug.h"
  18 #include "gdi.h"
  19 #include "options.h"
  20 #include "wine/winuser16.h"
  21 #include "winerror.h"
  22 #include "xmalloc.h"
  23
  24 DEFAULT_DEBUG_CHANNEL(print)
  25
  26 /**********************************************************************
  27  *           QueryAbort   (GDI.155)
  28  *
  29  *  Calls the app's AbortProc function if avail.
  30  *
  31  * RETURNS
  32  * TRUE if no AbortProc avail or AbortProc wants to continue printing.
  33  * FALSE if AbortProc wants to abort printing.
  34  */
  35 BOOL16 WINAPI QueryAbort16(HDC16 hdc, INT16 reserved)
  36 {
  37     DC *dc = DC_GetDCPtr( hdc );
  38
  39     if ((!dc) || (!dc->w.lpfnPrint))
  40         return TRUE;
  41     return Callbacks->CallDrvAbortProc(dc->w.lpfnPrint, hdc, 0);
  42 }
  43
  44 /**********************************************************************
  45  *           SetAbortProc16   (GDI.381)
  46  *
  47  */
  48 INT16 WINAPI SetAbortProc16(HDC16 hdc, SEGPTR abrtprc)
  49 {
  50     return Escape16(hdc, SETABORTPROC, 0, abrtprc, (SEGPTR)0);
  51 }
  52
  53 /**********************************************************************
  54  *           SetAbortProc32   (GDI32.301)
  55  *
  56  */
  57 INT WINAPI SetAbortProc(HDC hdc, ABORTPROC abrtprc)
  58 {
  59     FIXME(print, "stub\n");
  60     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  61     return SP_ERROR;
  62 }
  63
  64
  65 /****************** misc. printer related functions */
  66
  67 /*
  68  * The following function should implement a queing system
  69  */
  70 #ifndef HPQ
  71 #define HPQ WORD
  72 #endif
  73 struct hpq
  74 {
  75     struct hpq  *next;
  76     int          tag;
  77     int          key;
  78 };
  79
  80 static struct hpq *hpqueue;
  81
  82 /**********************************************************************
  83  *           CreatePQ   (GDI.230)
  84  *
  85  */
  86 HPQ WINAPI CreatePQ16(int size)
  87 {
  88 #if 0
  89     HGLOBAL16 hpq = 0;
  90     WORD tmp_size;
  91     LPWORD pPQ;
  92
  93     tmp_size = size << 2;
  94     if (!(hpq = GlobalAlloc16(GMEM_SHARE|GMEM_MOVEABLE, tmp_size + 8)))
  95        return 0xffff;
  96     pPQ = GlobalLock16(hpq);
  97     *pPQ++ = 0;
  98     *pPQ++ = tmp_size;
  99     *pPQ++ = 0;
 100     *pPQ++ = 0;
 101     GlobalUnlock16(hpq);
 102
 103     return (HPQ)hpq;
 104 #else
 105     FIXME(print, "(%d): stub\n",size);
 106     return 1;
 107 #endif
 108 }
 109
 110 /**********************************************************************
 111  *           DeletePQ   (GDI.235)
 112  *
 113  */
 114 int WINAPI DeletePQ16(HPQ hPQ)
 115 {
 116     return GlobalFree16((HGLOBAL16)hPQ);
 117 }
 118
 119 /**********************************************************************
 120  *           ExtractPQ   (GDI.232)
 121  *
 122  */
 123 int WINAPI ExtractPQ16(HPQ hPQ)
 124 {
 125     struct hpq *queue, *prev, *current, *currentPrev;
 126     int key = 0, tag = -1;
 127     currentPrev = prev = NULL;
 128     queue = current = hpqueue;
 129     if (current)
 130         key = current->key;
 131
 132     while (current)
 133     {
 134         currentPrev = current;
 135         current = current->next;
 136         if (current)
 137         {
 138             if (current->key < key)
 139             {
 140                 queue = current;
 141                 prev = currentPrev;
 142             }
 143         }
 144     }
 145     if (queue)
 146     {
 147         tag = queue->tag;
 148
 149         if (prev)
 150             prev->next = queue->next;
 151         else
 152             hpqueue = queue->next;
 153         free(queue);
 154     }
 155
 156     TRACE(print, "%x got tag %d key %d\n", hPQ, tag, key);
 157
 158     return tag;
 159 }
 160
 161 /**********************************************************************
 162  *           InsertPQ   (GDI.233)
 163  *
 164  */
 165 int WINAPI InsertPQ16(HPQ hPQ, int tag, int key)
 166 {
 167     struct hpq *queueItem = xmalloc(sizeof(struct hpq));
 168     queueItem->next = hpqueue;
 169     hpqueue = queueItem;
 170     queueItem->key = key;
 171     queueItem->tag = tag;
 172
 173     FIXME(print, "(%x %d %d): stub???\n", hPQ, tag, key);
 174     return TRUE;
 175 }
 176
 177 /**********************************************************************
 178  *           MinPQ   (GDI.231)
 179  *
 180  */
 181 int WINAPI MinPQ16(HPQ hPQ)
 182 {
 183     FIXME(print, "(%x): stub\n", hPQ);
 184     return 0;
 185 }
 186
 187 /**********************************************************************
 188  *           SizePQ   (GDI.234)
 189  *
 190  */
 191 int WINAPI SizePQ16(HPQ hPQ, int sizechange)
 192 {
 193     FIXME(print, "(%x %d): stub\n", hPQ, sizechange);
 194     return -1;
 195 }
 196
 197
 198
 199 /*
 200  * The following functions implement part of the spooling process to
 201  * print manager.  I would like to see wine have a version of print managers
 202  * that used LPR/LPD.  For simplicity print jobs will be sent to a file for
 203  * now.
 204  */
 205 typedef struct PRINTJOB
 206 {
 207     char        *pszOutput;
 208     char        *pszTitle;
 209     HDC16       hDC;
 210     HANDLE16    hHandle;
 211     int         nIndex;
 212     int         fd;
 213 } PRINTJOB, *PPRINTJOB;
 214
 215 #define MAX_PRINT_JOBS 1
 216 #define SP_OK 1
 217
 218 PPRINTJOB gPrintJobsTable[MAX_PRINT_JOBS];
 219
 220
 221 static PPRINTJOB FindPrintJobFromHandle(HANDLE16 hHandle)
 222 {
 223     return gPrintJobsTable[0];
 224 }
 225
 226 /* TTD Need to do some DOS->UNIX file conversion here */
 227 static int CreateSpoolFile(LPSTR pszOutput)
 228 {
 229     int fd=-1;
 230     char psCmd[1024];
 231     char *psCmdP = psCmd;
 232
 233     /* TTD convert the 'output device' into a spool file name */
 234
 235     if (pszOutput == NULL || *pszOutput == '\0')
 236       return -1;
 237
 238     PROFILE_GetWineIniString( "spooler", pszOutput, "", psCmd, sizeof(psCmd) );
 239     TRACE(print, "Got printerSpoolCommand '%s' for output device '%s'\n",
 240           psCmd, pszOutput);
 241     if (!*psCmd)
 242         psCmdP = pszOutput;
 243     else
 244     {
 245         while (*psCmdP && isspace(*psCmdP))
 246         {
 247             psCmdP++;
 248         };
 249         if (!*psCmdP)
 250             return -1;
 251     }
 252     if (*psCmdP == '|')
 253     {
 254         int fds[2];
 255         if (pipe(fds))
 256             return -1;
 257         if (fork() == 0)
 258         {
 259             psCmdP++;
 260
 261             TRACE(print, "In child need to exec %s\n",psCmdP);
 262             close(0);
 263             dup2(fds[0],0);
 264             close (fds[1]);
 265             system(psCmdP);
 266             exit(0);
 267
 268         }
 269         close (fds[0]);
 270         fd = fds[1];
 271         TRACE(print,"Need to execute a cmnd and pipe the output to it\n");
 272     }
 273     else
 274     {
 275         TRACE(print, "Just assume its a file\n");
 276
 277         if ((fd = open(psCmdP, O_CREAT | O_TRUNC | O_WRONLY , 0600)) < 0)
 278         {
 279             ERR(print, "Failed to create spool file %s, errno = %d\n",
 280                 psCmdP, errno);
 281         }
 282     }
 283     return fd;
 284 }
 285
 286 static int FreePrintJob(HANDLE16 hJob)
 287 {
 288     int nRet = SP_ERROR;
 289     PPRINTJOB pPrintJob;
 290
 291     pPrintJob = FindPrintJobFromHandle(hJob);
 292     if (pPrintJob != NULL)
 293     {
 294         gPrintJobsTable[pPrintJob->nIndex] = NULL;
 295         free(pPrintJob->pszOutput);
 296         free(pPrintJob->pszTitle);
 297         if (pPrintJob->fd >= 0) close(pPrintJob->fd);
 298         free(pPrintJob);
 299         nRet = SP_OK;
 300     }
 301     return nRet;
 302 }
 303
 304 /**********************************************************************
 305  *           OpenJob   (GDI.240)
 306  *
 307  */
 308 HANDLE16 WINAPI OpenJob16(LPSTR lpOutput, LPSTR lpTitle, HDC16 hDC)
 309 {
 310     HANDLE16 hHandle = (HANDLE16)SP_ERROR;
 311     PPRINTJOB pPrintJob;
 312
 313     TRACE(print, "'%s' '%s' %04x\n", lpOutput, lpTitle, hDC);
 314
 315     pPrintJob = gPrintJobsTable[0];
 316     if (pPrintJob == NULL)
 317     {
 318         int fd;
 319
 320         /* Try an create a spool file */
 321         fd = CreateSpoolFile(lpOutput);
 322         if (fd >= 0)
 323         {
 324             hHandle = 1;
 325
 326             pPrintJob = xmalloc(sizeof(PRINTJOB));
 327             memset(pPrintJob, 0, sizeof(PRINTJOB));
 328
 329             pPrintJob->pszOutput = strdup(lpOutput);
 330             if(lpTitle)
 331                 pPrintJob->pszTitle = strdup(lpTitle);
 332             pPrintJob->hDC = hDC;
 333             pPrintJob->fd = fd;
 334             pPrintJob->nIndex = 0;
 335             pPrintJob->hHandle = hHandle;
 336             gPrintJobsTable[pPrintJob->nIndex] = pPrintJob;
 337         }
 338     }
 339     TRACE(print, "return %04x\n", hHandle);
 340     return hHandle;
 341 }
 342
 343 /**********************************************************************
 344  *           CloseJob   (GDI.243)
 345  *
 346  */
 347 int WINAPI CloseJob16(HANDLE16 hJob)
 348 {
 349     int nRet = SP_ERROR;
 350     PPRINTJOB pPrintJob = NULL;
 351
 352     TRACE(print, "%04x\n", hJob);
 353
 354     pPrintJob = FindPrintJobFromHandle(hJob);
 355     if (pPrintJob != NULL)
 356     {
 357         /* Close the spool file */
 358         close(pPrintJob->fd);
 359         FreePrintJob(hJob);
 360         nRet  = 1;
 361     }
 362     return nRet;
 363 }
 364
 365 /**********************************************************************
 366  *           WriteSpool   (GDI.241)
 367  *
 368  */
 369 int WINAPI WriteSpool16(HANDLE16 hJob, LPSTR lpData, WORD cch)
 370 {
 371     int nRet = SP_ERROR;
 372     PPRINTJOB pPrintJob = NULL;
 373
 374     TRACE(print, "%04x %08lx %04x\n", hJob, (DWORD)lpData, cch);
 375
 376     pPrintJob = FindPrintJobFromHandle(hJob);
 377     if (pPrintJob != NULL && pPrintJob->fd >= 0 && cch)
 378     {
 379         if (write(pPrintJob->fd, lpData, cch) != cch)
 380           nRet = SP_OUTOFDISK;
 381         else
 382           nRet = cch;
 383         if (pPrintJob->hDC == 0) {
 384             TRACE(print, "hDC == 0 so no QueryAbort\n");
 385         }
 386         else if (!(QueryAbort16(pPrintJob->hDC, (nRet == SP_OUTOFDISK) ? nRet : 0 )))
 387         {
 388             CloseJob16(hJob); /* printing aborted */
 389             nRet = SP_APPABORT;
 390         }
 391     }
 392     return nRet;
 393 }
 394
 395 /**********************************************************************
 396  *           WriteDialog   (GDI.242)
 397  *
 398  */
 399 int WINAPI WriteDialog16(HANDLE16 hJob, LPSTR lpMsg, WORD cchMsg)
 400 {
 401     int nRet = 0;
 402
 403     TRACE(print, "%04x %04x '%s'\n", hJob,  cchMsg, lpMsg);
 404
 405     nRet = MessageBox16(0, lpMsg, "Printing Error", MB_OKCANCEL);
 406     return nRet;
 407 }
 408
 409
 410 /**********************************************************************
 411  *           DeleteJob  (GDI.244)
 412  *
 413  */
 414 int WINAPI DeleteJob16(HANDLE16 hJob, WORD wNotUsed)
 415 {
 416     int nRet;
 417
 418     TRACE(print, "%04x\n", hJob);
 419
 420     nRet = FreePrintJob(hJob);
 421     return nRet;
 422 }
 423
 424 /*
 425  * The following two function would allow a page to be sent to the printer
 426  * when it has been processed.  For simplicity they havn't been implemented.
 427  * This means a whole job has to be processed before it is sent to the printer.
 428  */
 429
 430 /**********************************************************************
 431  *           StartSpoolPage   (GDI.246)
 432  *
 433  */
 434 int WINAPI StartSpoolPage16(HANDLE16 hJob)
 435 {
 436     FIXME(print, "StartSpoolPage GDI.246 unimplemented\n");
 437     return 1;
 438
 439 }
 440
 441
 442 /**********************************************************************
 443  *           EndSpoolPage   (GDI.247)
 444  *
 445  */
 446 int WINAPI EndSpoolPage16(HANDLE16 hJob)
 447 {
 448     FIXME(print, "EndSpoolPage GDI.247 unimplemented\n");
 449     return 1;
 450 }
 451
 452
 453 /**********************************************************************
 454  *           GetSpoolJob   (GDI.245)
 455  *
 456  */
 457 DWORD WINAPI GetSpoolJob16(int nOption, LONG param)
 458 {
 459     DWORD retval = 0;
 460     TRACE(print, "In GetSpoolJob param 0x%lx noption %d\n",param, nOption);
 461     return retval;
 462 }