summaryrefslogtreecommitdiff
path: root/print/OEM Printer Customization Plug-in Samples/C++/bitmap/intrface.h
blob: 7c9920556abc9011b65b2bf3c8e0cb498b7947aa (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
//  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
//  ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
//  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//  PARTICULAR PURPOSE.
//
//  Copyright  1997 - 2003  Microsoft Corporation.  All Rights Reserved.
//
//  FILE:   Intrface.H
//
//
//  PURPOSE:    Define COM interface for User Mode Printer Customization DLL.
//


#pragma once

/////////////////////////////////////////////////////////
//      String Literals
/////////////////////////////////////////////////////////


CONST CHAR NAME_CommandCallback[]       = "CommandCallback";
CONST CHAR NAME_FilterGraphics[]            = "FilterGraphics";
CONST CHAR NAME_ImageProcessing[]           = "ImageProcessing";


////////////////////////////////////////////////////////////////////////////////
//
//  COemUni2
//
//  Interface for Unidrv OEM sample rendering module
//
class COemUni2 : public IPrintOemUni2
{
public:
    // *** IUnknown methods ***
    STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj);

    STDMETHOD_(ULONG,AddRef)  (THIS);

    // the _At_ tag here tells prefast that once release 
    // is called, the memory should not be considered leaked
    _At_(this, __drv_freesMem(object)) 
    STDMETHOD_(ULONG,Release)(THIS);

    //
    // Method for publishing Driver interface.
    //
    STDMETHOD(PublishDriverInterface)(THIS_ IUnknown    *pIUnknown);

    //
    // Method for getting the implemented methods.
    // Returns S_OK if the given method is implemneted.
    // Returns S_FALSE if the given method is notimplemneted.
    //

    STDMETHOD(GetImplementedMethod)(THIS_ _In_ PSTR  pMethodName);

    //
    // Method for OEM to specify DDIs that have been hooked
    //

    STDMETHOD(EnableDriver) (THIS_ DWORD            DriverVersion,
                                DWORD               cbSize,
                                PDRVENABLEDATA      pded);

    //
    // Method to notify OEM plugin that it is no longer required
    //

    STDMETHOD(DisableDriver) (THIS);

    //
    // Method for OEM plugin to contruct its own PDEV
    //

    STDMETHOD(EnablePDEV)(THIS_ PDEVOBJ     pdevobj,
                            _In_ PWSTR          pPrinterName,
                            ULONG               cPatterns,
                            HSURF               *phsurfPatterns,
                            ULONG               cjGdiInfo,
                            GDIINFO             *pGdiInfo,
                            ULONG               cjDevInfo,
                            DEVINFO             *pDevInfo,
                            DRVENABLEDATA       *pded,
                            OUT PDEVOEM     *pDevOem);

    //
    // Method for OEM to free any resource associated with its PDEV
    //

    STDMETHOD(DisablePDEV)(THIS_ PDEVOBJ    pdevobj);

    //
    // Method for OEM to transfer from old PDEV to new PDEV
    //

    STDMETHOD(ResetPDEV)(THIS_ PDEVOBJ      pdevobjOld,
                            PDEVOBJ             pdevobjNew);

    //
    // Get OEM dll related information
    //

    STDMETHOD(GetInfo)(THIS_ DWORD      dwMode,
                        PVOID               pBuffer,
                        DWORD               cbSize,
                        PDWORD              pcbNeeded);

    //
    // OEMDriverDMS - UNIDRV only, return E_NOTIMPL on Pscript
    //

    STDMETHOD(DriverDMS)(THIS_ PVOID        pDevObj,
                            PVOID           pBuffer,
                            DWORD           cbSize,
                            PDWORD          pcbNeeded);

    //
    // OEMDevMode
    //

    STDMETHOD(DevMode)(THIS_ DWORD      dwMode,
                        POEMDMPARAM     pOemDMParam);

    //
    // OEMCommandCallback - UNIDRV only, return E_NOTIMPL on Pscript
    //

    STDMETHOD(CommandCallback)(THIS_ PDEVOBJ        pdevobj,
                                    DWORD               dwCallbackID,
                                    DWORD               dwCount,
                                    PDWORD              pdwParams,
                                    OUT INT             *piResult);

    //
    // OEMImageProcessing - UNIDRV only, return E_NOTIMPL on Pscript
    //

    STDMETHOD(ImageProcessing)(THIS_ PDEVOBJ            pdevobj,
                                    PBYTE                   pSrcBitmap,
                                    PBITMAPINFOHEADER       pBitmapInfoHeader,
                                    PBYTE                   pColorTable,
                                    DWORD                   dwCallbackID,
                                    PIPPARAMS               pIPParams,
                                    OUT PBYTE               *ppbResult);

    //
    // OEMFilterGraphics - UNIDRV only, return E_NOTIMPL on Pscript
    //

    STDMETHOD(FilterGraphics)(THIS_ PDEVOBJ pdevobj,
                                PBYTE           pBuf,
                                DWORD           dwLen);
    //
    // OEMCompression - UNIDRV only, return E_NOTIMPL on Pscript
    //

    STDMETHOD(Compression)(THIS_ PDEVOBJ        pdevobj,
                                PBYTE               pInBuf,
                                PBYTE               pOutBuf,
                                DWORD               dwInLen,
                                DWORD               dwOutLen,
                                OUT INT             *piResult);

    //
    // OEMHalftone - UNIDRV only, return E_NOTIMPL on Pscript
    //

    STDMETHOD(HalftonePattern)(THIS_ PDEVOBJ        pdevobj,
                                PBYTE               pHTPattern,
                                DWORD               dwHTPatternX,
                                DWORD               dwHTPatternY,
                                DWORD               dwHTNumPatterns,
                                DWORD               dwCallbackID,
                                PBYTE               pResource,
                                DWORD               dwResourceSize);

    //
    // OEMMemoryUsage - UNIDRV only, return E_NOTIMPL on Pscript
    //

    STDMETHOD(MemoryUsage)(THIS_ PDEVOBJ        pdevobj,
                                POEMMEMORYUSAGE pMemoryUsage);

    //
    // OEMTTYGetInfo - UNIDRV only, return E_NOTIMPL on Pscript
    //

    STDMETHOD(TTYGetInfo)(THIS_ PDEVOBJ     pdevobj,
                            DWORD               dwInfoIndex,
                            PVOID               pOutputBuf,
                            DWORD               dwSize,
                            DWORD               *pcbcNeeded);

    //
    // OEMDownloadFontheader - UNIDRV only
    //

    STDMETHOD(DownloadFontHeader)(THIS_ PDEVOBJ pdevobj,
                                        PUNIFONTOBJ     pUFObj,
                                        OUT DWORD       *pdwResult);

    //
    // OEMDownloadCharGlyph - UNIDRV only
    //

    STDMETHOD(DownloadCharGlyph)(THIS_ PDEVOBJ  pdevobj,
                                    PUNIFONTOBJ         pUFObj,
                                    HGLYPH              hGlyph,
                                    PDWORD              pdwWidth,
                                    OUT DWORD           *pdwResult);

    //
    // OEMTTDownloadMethod - UNIDRV only
    //

    STDMETHOD(TTDownloadMethod)(THIS_ PDEVOBJ   pdevobj,
                                    PUNIFONTOBJ         pUFObj,
                                    OUT DWORD           *pdwResult);

    //
    // OEMOutputCharStr - UNIDRV only
    //

    STDMETHOD(OutputCharStr)(THIS_ PDEVOBJ      pdevobj,
                                PUNIFONTOBJ         pUFObj,
                                DWORD               dwType,
                                DWORD               dwCount,
                                PVOID               pGlyph);

    //
    // OEMSendFontCmd - UNIDRV only
    //


    STDMETHOD(SendFontCmd)(THIS_ PDEVOBJ        pdevobj,
                                PUNIFONTOBJ         pUFObj,
                                PFINVOCATION        pFInv);

    //
    // OEMTextOutAsBitmap - UNIDRV only
    //

    STDMETHOD(TextOutAsBitmap)(THIS_ SURFOBJ        *pso,
                                    STROBJ              *pstro,
                                    FONTOBJ             *pfo,
                                    CLIPOBJ             *pco,
                                    RECTL               *prclExtra,
                                    RECTL               *prclOpaque,
                                    BRUSHOBJ            *pboFore,
                                    BRUSHOBJ            *pboOpaque,
                                    POINTL              *pptlOrg,
                                    MIX                 mix);

    //
    // IPrintOemUni2 methods
    //

    //
    // Method for plugin to hook out spooler's WritePrinter API so it
    // can get access to output data Universal driver is generating
    //
    // At DrvEnablePDEV time, Universal driver will call this function with
    // pdevobj = NULL, pBuf = NULL, cbBuffer = 0 to detect if the plugin
    // implements this function. Plugin should return S_OK to indicate it is
    // implementing this function, or return E_NOTIMPL otherwise.
    //
    // In pcbWritten, plugins should return the number of bytes written to the
    // spooler's WritePrinter function. Zero doesn't carry a special meaning,
    // errors must be reported through the returned HRESULT.
    //

    STDMETHOD(WritePrinter)(THIS_ PDEVOBJ       pdevobj,
                            PVOID               pBuf,
                            DWORD               cbBuffer,
                            PDWORD              pcbWritten);


    COemUni2();
    ~COemUni2();

protected:
    LONG                m_cRef;
    IPrintOemDriverUni* m_pOEMHelp;
};