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 <stdarg.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29 #include "winnls.h"
  30 #include "winspool.h"
  31 #include "winerror.h"
  32 #include "wine/debug.h"
  33 #include "gdi_private.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(print);
  36
  37 /******************************************************************
  38  * GdiGetSpoolMessage [GDI32.@]
  39  *
  40  */
  41 DWORD WINAPI GdiGetSpoolMessage(LPVOID ptr1, DWORD data2, LPVOID ptr3, DWORD data4)
  42 {
  43     TRACE("(%p 0x%x %p 0x%x) stub\n", ptr1, data2, ptr3, data4);
  44     /* avoid 100% cpu usage with spoolsv.exe from w2k
  45       (spoolsv.exe from xp does Sleep 1000/1500/2000 in a loop) */
  46     Sleep(500);
  47     return 0;
  48 }
  49
  50 /******************************************************************
  51  * GdiInitSpool [GDI32.@]
  52  *
  53  */
  54 DWORD WINAPI GdiInitSpool(void)
  55 {
  56     FIXME("stub\n");
  57     return TRUE;
  58 }
  59
  60 /******************************************************************
  61  *                  StartDocW  [GDI32.@]
  62  *
  63  * StartDoc calls the STARTDOC Escape with the input data pointing to DocName
  64  * and the output data (which is used as a second input parameter).pointing at
  65  * the whole docinfo structure.  This seems to be an undocumented feature of
  66  * the STARTDOC Escape.
  67  *
  68  * Note: we now do it the other way, with the STARTDOC Escape calling StartDoc.
  69  */
  70 INT WINAPI StartDocW(HDC hdc, const DOCINFOW* doc)
  71 {
  72     INT ret;
  73     DC *dc = get_dc_ptr( hdc );
  74
  75     TRACE("DocName = %s Output = %s Datatype = %s\n",
  76           debugstr_w(doc->lpszDocName), debugstr_w(doc->lpszOutput),
  77           debugstr_w(doc->lpszDatatype));
  78
  79     if(!dc) return SP_ERROR;
  80
  81     if (dc->pAbortProc && !dc->pAbortProc( hdc, 0 )) ret = 0;
  82     else
  83     {
  84         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pStartDoc );
  85         ret = physdev->funcs->pStartDoc( physdev, doc );
  86     }
  87     release_dc_ptr( dc );
  88     return ret;
  89 }
  90
  91 /*************************************************************************
  92  *                  StartDocA [GDI32.@]
  93  *
  94  */
  95 INT WINAPI StartDocA(HDC hdc, const DOCINFOA* doc)
  96 {
  97     LPWSTR szDocName = NULL, szOutput = NULL, szDatatype = NULL;
  98     DOCINFOW docW;
  99     INT ret, len;
 100
 101     docW.cbSize = doc->cbSize;
 102     if (doc->lpszDocName)
 103     {
 104         len = MultiByteToWideChar(CP_ACP,0,doc->lpszDocName,-1,NULL,0);
 105         szDocName = HeapAlloc(GetProcessHeap(),0,len*sizeof(WCHAR));
 106         MultiByteToWideChar(CP_ACP,0,doc->lpszDocName,-1,szDocName,len);
 107     }
 108     if (doc->lpszOutput)
 109     {
 110         len = MultiByteToWideChar(CP_ACP,0,doc->lpszOutput,-1,NULL,0);
 111         szOutput = HeapAlloc(GetProcessHeap(),0,len*sizeof(WCHAR));
 112         MultiByteToWideChar(CP_ACP,0,doc->lpszOutput,-1,szOutput,len);
 113     }
 114     if (doc->lpszDatatype)
 115     {
 116         len = MultiByteToWideChar(CP_ACP,0,doc->lpszDatatype,-1,NULL,0);
 117         szDatatype = HeapAlloc(GetProcessHeap(),0,len*sizeof(WCHAR));
 118         MultiByteToWideChar(CP_ACP,0,doc->lpszDatatype,-1,szDatatype,len);
 119     }
 120
 121     docW.lpszDocName = szDocName;
 122     docW.lpszOutput = szOutput;
 123     docW.lpszDatatype = szDatatype;
 124     docW.fwType = doc->fwType;
 125
 126     ret = StartDocW(hdc, &docW);
 127
 128     HeapFree( GetProcessHeap(), 0, szDocName );
 129     HeapFree( GetProcessHeap(), 0, szOutput );
 130     HeapFree( GetProcessHeap(), 0, szDatatype );
 131
 132     return ret;
 133 }
 134
 135
 136 /******************************************************************
 137  *                  EndDoc  [GDI32.@]
 138  *
 139  */
 140 INT WINAPI EndDoc(HDC hdc)
 141 {
 142     INT ret = SP_ERROR;
 143     DC *dc = get_dc_ptr( hdc );
 144
 145     if (dc)
 146     {
 147         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pEndDoc );
 148         ret = physdev->funcs->pEndDoc( physdev );
 149         release_dc_ptr( dc );
 150     }
 151     return ret;
 152 }
 153
 154
 155 /******************************************************************
 156  *                  StartPage  [GDI32.@]
 157  *
 158  */
 159 INT WINAPI StartPage(HDC hdc)
 160 {
 161     INT ret = SP_ERROR;
 162     DC *dc = get_dc_ptr( hdc );
 163
 164     if (dc)
 165     {
 166         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pStartPage );
 167         ret = physdev->funcs->pStartPage( physdev );
 168         release_dc_ptr( dc );
 169     }
 170     return ret;
 171 }
 172
 173
 174 /******************************************************************
 175  *                  EndPage  [GDI32.@]
 176  *
 177  */
 178 INT WINAPI EndPage(HDC hdc)
 179 {
 180     INT ret = SP_ERROR;
 181     DC *dc = get_dc_ptr( hdc );
 182
 183     if (dc)
 184     {
 185         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pEndPage );
 186         ret = physdev->funcs->pEndPage( physdev );
 187         release_dc_ptr( dc );
 188     }
 189     return ret;
 190 }
 191
 192
 193 /******************************************************************************
 194  *                 AbortDoc  [GDI32.@]
 195  */
 196 INT WINAPI AbortDoc(HDC hdc)
 197 {
 198     INT ret = SP_ERROR;
 199     DC *dc = get_dc_ptr( hdc );
 200
 201     if (dc)
 202     {
 203         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pAbortDoc );
 204         ret = physdev->funcs->pAbortDoc( physdev );
 205         release_dc_ptr( dc );
 206     }
 207     return ret;
 208 }
 209
 210
 211 /**********************************************************************
 212  *           SetAbortProc   (GDI32.@)
 213  *
 214  */
 215 INT WINAPI SetAbortProc(HDC hdc, ABORTPROC abrtprc)
 216 {
 217     DC *dc = get_dc_ptr( hdc );
 218
 219     if (!dc) return FALSE;
 220     dc->pAbortProc = abrtprc;
 221     release_dc_ptr( dc );
 222     return TRUE;
 223 }