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