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 = 0;
  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 ))
  82     {
  83         release_dc_ptr( dc );
  84         return ret;
  85     }
  86
  87     if (dc->funcs->pStartDoc) ret = dc->funcs->pStartDoc( dc->physDev, doc );
  88     release_dc_ptr( dc );
  89     return ret;
  90 }
  91
  92 /*************************************************************************
  93  *                  StartDocA [GDI32.@]
  94  *
  95  */
  96 INT WINAPI StartDocA(HDC hdc, const DOCINFOA* doc)
  97 {
  98     LPWSTR szDocName = NULL, szOutput = NULL, szDatatype = NULL;
  99     DOCINFOW docW;
 100     INT ret, len;
 101
 102     docW.cbSize = doc->cbSize;
 103     if (doc->lpszDocName)
 104     {
 105         len = MultiByteToWideChar(CP_ACP,0,doc->lpszDocName,-1,NULL,0);
 106         szDocName = HeapAlloc(GetProcessHeap(),0,len*sizeof(WCHAR));
 107         MultiByteToWideChar(CP_ACP,0,doc->lpszDocName,-1,szDocName,len);
 108     }
 109     if (doc->lpszOutput)
 110     {
 111         len = MultiByteToWideChar(CP_ACP,0,doc->lpszOutput,-1,NULL,0);
 112         szOutput = HeapAlloc(GetProcessHeap(),0,len*sizeof(WCHAR));
 113         MultiByteToWideChar(CP_ACP,0,doc->lpszOutput,-1,szOutput,len);
 114     }
 115     if (doc->lpszDatatype)
 116     {
 117         len = MultiByteToWideChar(CP_ACP,0,doc->lpszDatatype,-1,NULL,0);
 118         szDatatype = HeapAlloc(GetProcessHeap(),0,len*sizeof(WCHAR));
 119         MultiByteToWideChar(CP_ACP,0,doc->lpszDatatype,-1,szDatatype,len);
 120     }
 121
 122     docW.lpszDocName = szDocName;
 123     docW.lpszOutput = szOutput;
 124     docW.lpszDatatype = szDatatype;
 125     docW.fwType = doc->fwType;
 126
 127     ret = StartDocW(hdc, &docW);
 128
 129     HeapFree( GetProcessHeap(), 0, szDocName );
 130     HeapFree( GetProcessHeap(), 0, szOutput );
 131     HeapFree( GetProcessHeap(), 0, szDatatype );
 132
 133     return ret;
 134 }
 135
 136
 137 /******************************************************************
 138  *                  EndDoc  [GDI32.@]
 139  *
 140  */
 141 INT WINAPI EndDoc(HDC hdc)
 142 {
 143     INT ret = 0;
 144     DC *dc = get_dc_ptr( hdc );
 145     if(!dc) return SP_ERROR;
 146
 147     if (dc->funcs->pEndDoc) ret = dc->funcs->pEndDoc( dc->physDev );
 148     release_dc_ptr( dc );
 149     return ret;
 150 }
 151
 152
 153 /******************************************************************
 154  *                  StartPage  [GDI32.@]
 155  *
 156  */
 157 INT WINAPI StartPage(HDC hdc)
 158 {
 159     INT ret = 1;
 160     DC *dc = get_dc_ptr( hdc );
 161     if(!dc) return SP_ERROR;
 162
 163     if(dc->funcs->pStartPage)
 164         ret = dc->funcs->pStartPage( dc->physDev );
 165     else
 166         FIXME("stub\n");
 167     release_dc_ptr( dc );
 168     return ret;
 169 }
 170
 171
 172 /******************************************************************
 173  *                  EndPage  [GDI32.@]
 174  *
 175  */
 176 INT WINAPI EndPage(HDC hdc)
 177 {
 178     INT ret = 0;
 179     DC *dc = get_dc_ptr( hdc );
 180     if(!dc) return SP_ERROR;
 181
 182     if (dc->funcs->pEndPage) ret = dc->funcs->pEndPage( dc->physDev );
 183     release_dc_ptr( dc );
 184     return ret;
 185 }
 186
 187
 188 /******************************************************************************
 189  *                 AbortDoc  [GDI32.@]
 190  */
 191 INT WINAPI AbortDoc(HDC hdc)
 192 {
 193     INT ret = 0;
 194     DC *dc = get_dc_ptr( hdc );
 195     if(!dc) return SP_ERROR;
 196
 197     if (dc->funcs->pAbortDoc) ret = dc->funcs->pAbortDoc( dc->physDev );
 198     release_dc_ptr( dc );
 199     return ret;
 200 }
 201
 202
 203 /**********************************************************************
 204  *           SetAbortProc   (GDI32.@)
 205  *
 206  */
 207 INT WINAPI SetAbortProc(HDC hdc, ABORTPROC abrtprc)
 208 {
 209     DC *dc = get_dc_ptr( hdc );
 210
 211     if (!dc) return FALSE;
 212     dc->pAbortProc = abrtprc;
 213     release_dc_ptr( dc );
 214     return TRUE;
 215 }