fusion: Allow spaces between attribute-value pairs in an assembly name.
[wine] / 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 }