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 }
199
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.