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 <stdarg.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29 #include "winspool.h"
  30 #include "winerror.h"
  31 #include "wine/debug.h"
  32 #include "gdi_private.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(print);
  35
  36 /******************************************************************
  37  * GdiGetSpoolMessage [GDI32.@]
  38  *
  39  */
  40 DWORD WINAPI GdiGetSpoolMessage(LPVOID ptr1, DWORD data2, LPVOID ptr3, DWORD data4)
  41 {
  42     TRACE("(%p 0x%x %p 0x%x) stub\n", ptr1, data2, ptr3, data4);
  43     /* avoid 100% cpu usage with spoolsv.exe from w2k
  44       (spoolsv.exe from xp does Sleep 1000/1500/2000 in a loop) */
  45     Sleep(500);
  46     return 0;
  47 }
  48
  49 /******************************************************************
  50  * GdiInitSpool [GDI32.@]
  51  *
  52  */
  53 DWORD WINAPI GdiInitSpool(void)
  54 {
  55     FIXME("stub\n");
  56     return TRUE;
  57 }
  58
  59 /******************************************************************
  60  *                  StartDocW  [GDI32.@]
  61  *
  62  * StartDoc calls the STARTDOC Escape with the input data pointing to DocName
  63  * and the output data (which is used as a second input parameter).pointing at
  64  * the whole docinfo structure.  This seems to be an undocumented feature of
  65  * the STARTDOC Escape.
  66  *
  67  * Note: we now do it the other way, with the STARTDOC Escape calling StartDoc.
  68  */
  69 INT WINAPI StartDocW(HDC hdc, const DOCINFOW* doc)
  70 {
  71     INT ret = 0;
  72     DC *dc = get_dc_ptr( hdc );
  73
  74     TRACE("DocName = %s Output = %s Datatype = %s\n",
  75           debugstr_w(doc->lpszDocName), debugstr_w(doc->lpszOutput),
  76           debugstr_w(doc->lpszDatatype));
  77
  78     if(!dc) return SP_ERROR;
  79
  80     if (dc->pAbortProc && !dc->pAbortProc( hdc, 0 ))
  81     {
  82         release_dc_ptr( dc );
  83         return ret;
  84     }
  85
  86     if (dc->funcs->pStartDoc) ret = dc->funcs->pStartDoc( dc->physDev, doc );
  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 = 0;
 143     DC *dc = get_dc_ptr( hdc );
 144     if(!dc) return SP_ERROR;
 145
 146     if (dc->funcs->pEndDoc) ret = dc->funcs->pEndDoc( dc->physDev );
 147     release_dc_ptr( dc );
 148     return ret;
 149 }
 150
 151
 152 /******************************************************************
 153  *                  StartPage  [GDI32.@]
 154  *
 155  */
 156 INT WINAPI StartPage(HDC hdc)
 157 {
 158     INT ret = 1;
 159     DC *dc = get_dc_ptr( hdc );
 160     if(!dc) return SP_ERROR;
 161
 162     if(dc->funcs->pStartPage)
 163         ret = dc->funcs->pStartPage( dc->physDev );
 164     else
 165         FIXME("stub\n");
 166     release_dc_ptr( dc );
 167     return ret;
 168 }
 169
 170
 171 /******************************************************************
 172  *                  EndPage  [GDI32.@]
 173  *
 174  */
 175 INT WINAPI EndPage(HDC hdc)
 176 {
 177     INT ret = 0;
 178     DC *dc = get_dc_ptr( hdc );
 179     if(!dc) return SP_ERROR;
 180
 181     if (dc->funcs->pEndPage) ret = dc->funcs->pEndPage( dc->physDev );
 182     release_dc_ptr( dc );
 183     return ret;
 184 }
 185
 186
 187 /******************************************************************************
 188  *                 AbortDoc  [GDI32.@]
 189  */
 190 INT WINAPI AbortDoc(HDC hdc)
 191 {
 192     INT ret = 0;
 193     DC *dc = get_dc_ptr( hdc );
 194     if(!dc) return SP_ERROR;
 195
 196     if (dc->funcs->pAbortDoc) ret = dc->funcs->pAbortDoc( dc->physDev );
 197     release_dc_ptr( dc );
 198     return ret;
 199 }
 200
 201
 202 /**********************************************************************
 203  *           SetAbortProc   (GDI32.@)
 204  *
 205  */
 206 INT WINAPI SetAbortProc(HDC hdc, ABORTPROC abrtprc)
 207 {
 208     DC *dc = get_dc_ptr( hdc );
 209
 210     if (!dc) return FALSE;
 211     dc->pAbortProc = abrtprc;
 212     release_dc_ptr( dc );
 213     return TRUE;
 214 }