← Back to branch summary

~vcs-imports/samba/main

« back to all changes in this revision

Viewing changes to examples/printing/prtpub.c

  • Committer: jerry
  • Date: 2006-07-14 21:48:39 UTC
  • Revision ID: vcs-imports@canonical.com-20060714214839-586d8c489a8fcead
gutting trunk to move to svn:externals

Show diffs side-by-side

added added

removed removed

Lines of Context:
examples/printing/prtpub.c
1
 
/*
2
 
 *  Set printer capabilities in DsDriver Keys on remote printer
3
 
 *  Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2002.
4
 
 *
5
 
 *  This program is free software; you can redistribute it and/or modify
6
 
 *  it under the terms of the GNU General Public License as published by
7
 
 *  the Free Software Foundation; either version 2 of the License, or
8
 
 *  (at your option) any later version.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18
 
 */
19
 
 
20
 
/* This needs to be defined for certain compilers */
21
 
#define WINVER 0x0500
22
 
 
23
 
#include <tchar.h>
24
 
#include <windows.h>
25
 
#include <stdio.h>
26
 
 
27
 
#define SAMBA_PORT _T("Samba")
28
 
 
29
 
TCHAR *PrintLastError(void)
30
 
{
31
 
        static TCHAR msgtxt[1024*sizeof(TCHAR)];
32
 
 
33
 
        FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
34
 
                        NULL, GetLastError(), 
35
 
                        0, msgtxt, 0, NULL);
36
 
 
37
 
        return msgtxt;
38
 
}
39
 
 
40
 
void map_orientation(HANDLE ph, TCHAR *printer, TCHAR *port)
41
 
{
42
 
        DWORD rot;
43
 
        TCHAR portrait_only[] = _T("PORTRAIT\0");
44
 
        TCHAR both[] = _T("LANDSCAPE\0PORTRAIT\0");
45
 
 
46
 
        /* orentation of 90 or 270 indicates landscape supported, 0 means it isn't */
47
 
        rot = DeviceCapabilities(printer, port, DC_BINNAMES, NULL, NULL);
48
 
        
49
 
        printf("printOrientationsSupported:\n");
50
 
 
51
 
        if (rot) {
52
 
                printf("\tPORTRAIT\n\tLANDSCAPE\n");
53
 
                SetPrinterDataEx(ph, SPLDS_DRIVER_KEY, _T("printOrientationsSupported"), REG_MULTI_SZ,
54
 
                        both, sizeof(both));
55
 
        } else {
56
 
                printf("\tPORTRAIT\n");
57
 
                SetPrinterDataEx(ph, SPLDS_DRIVER_KEY, _T("printOrientationsSupported"), REG_MULTI_SZ,
58
 
                        portrait_only, sizeof(portrait_only));
59
 
        }
60
 
}
61
 
 
62
 
void map_resolution(HANDLE ph, TCHAR *printer, TCHAR *port)
63
 
{
64
 
        DWORD num, *res, maxres = 0, i;
65
 
 
66
 
        num = DeviceCapabilities(printer, port, DC_ENUMRESOLUTIONS, NULL, NULL);
67
 
        if ((DWORD) -1 == num)
68
 
                return;
69
 
        res = malloc(num*2*sizeof(DWORD));
70
 
        num = DeviceCapabilities(printer, port, DC_ENUMRESOLUTIONS, (BYTE *) res, NULL);
71
 
        for (i=0; i < num*2; i++) {
72
 
                maxres = (res[i] > maxres) ? res[i] : maxres;
73
 
        }
74
 
        printf("printMaxResolutionSupported: %d\n", maxres);
75
 
        SetPrinterDataEx(ph, SPLDS_DRIVER_KEY, _T("printMaxResolutionSupported"), REG_DWORD, 
76
 
                (BYTE *) &maxres, sizeof(maxres));
77
 
}
78
 
 
79
 
void map_extents(HANDLE ph, TCHAR *printer, TCHAR *port)
80
 
{
81
 
        DWORD extentval, xval, yval;
82
 
 
83
 
        extentval = DeviceCapabilities(printer, port, DC_MINEXTENT, NULL, NULL);
84
 
        xval = (DWORD) (LOWORD(extentval));
85
 
        yval = (DWORD) (HIWORD(extentval));
86
 
        printf("printMinXExtent: %d\n", xval);
87
 
        printf("printMinYExtent: %d\n", yval);
88
 
        SetPrinterDataEx(ph, SPLDS_DRIVER_KEY, _T("printMinXExtent"), REG_DWORD, (BYTE *) &xval, sizeof(xval));
89
 
        SetPrinterDataEx(ph, SPLDS_DRIVER_KEY, _T("printMinYExtent"), REG_DWORD, (BYTE *) &yval, sizeof(yval));
90
 
        extentval = DeviceCapabilities(printer, port, DC_MAXEXTENT, NULL, NULL);
91
 
        xval = (DWORD) (LOWORD(extentval));
92
 
        yval = (DWORD) (HIWORD(extentval));
93
 
        printf("printMaxXExtent: %d\n", xval);
94
 
        printf("printMaxYExtent: %d\n", yval);
95
 
        SetPrinterDataEx(ph, SPLDS_DRIVER_KEY, _T("printMaxXExtent"), REG_DWORD, (BYTE *) &xval, sizeof(xval));
96
 
        SetPrinterDataEx(ph, SPLDS_DRIVER_KEY, _T("printMaxYExtent"), REG_DWORD, (BYTE *) &yval, sizeof(yval));
97
 
}
98
 
 
99
 
void map_printrateunit(HANDLE ph, TCHAR *printer, TCHAR *port)
100
 
{
101
 
        DWORD unit;
102
 
        TCHAR ppm[] = _T("PagesPerMinute");
103
 
        TCHAR ipm[] = _T("InchesPerMinute");
104
 
        TCHAR lpm[] = _T("LinesPerMinute");
105
 
        TCHAR cps[] = _T("CharactersPerSecond");
106
 
 
107
 
        unit = DeviceCapabilities(printer, port, DC_PRINTRATEUNIT, NULL, NULL);
108
 
        switch(unit) {
109
 
        case PRINTRATEUNIT_PPM:
110
 
                printf("printRateUnit: %s\n", ppm);
111
 
                SetPrinterDataEx(ph, SPLDS_DRIVER_KEY, _T("printRateUnit"), REG_SZ, ppm, sizeof(ppm));
112
 
                break;
113
 
        case PRINTRATEUNIT_IPM:
114
 
                printf("printRateUnit: %s\n", ipm);
115
 
                SetPrinterDataEx(ph, SPLDS_DRIVER_KEY, _T("printRateUnit"), REG_SZ, ipm, sizeof(ipm));
116
 
                break;
117
 
        case PRINTRATEUNIT_LPM:
118
 
                printf("printRateUnit: %s\n", lpm);
119
 
                SetPrinterDataEx(ph, SPLDS_DRIVER_KEY, _T("printRateUnit"), REG_SZ, lpm, sizeof(lpm));
120
 
                break;
121
 
        case PRINTRATEUNIT_CPS:
122
 
                printf("printRateUnit: %s\n", cps);
123
 
                SetPrinterDataEx(ph, SPLDS_DRIVER_KEY, _T("printRateUnit"), REG_SZ, cps, sizeof(cps));
124
 
                break;
125
 
        default:
126
 
                printf("printRateUnit: unknown value %d\n", unit);
127
 
        }
128
 
}
129
 
 
130
 
void map_generic_boolean(HANDLE ph, TCHAR *printer, TCHAR *port, WORD cap, TCHAR *key)
131
 
{
132
 
        BYTE boolval;
133
 
        /* DeviceCapabilities doesn't always return 1 for true...just nonzero */
134
 
        boolval = (BYTE) (DeviceCapabilities(printer, port, cap, NULL, NULL) ? 1 : 0);
135
 
        printf("%s: %s\n", key, boolval ? "TRUE" : "FALSE");
136
 
        SetPrinterDataEx(ph, SPLDS_DRIVER_KEY, key, REG_BINARY, &boolval, sizeof(boolval));
137
 
}
138
 
 
139
 
void map_generic_dword(HANDLE ph, TCHAR *printer, TCHAR *port, WORD cap, TCHAR *key)
140
 
{
141
 
        DWORD dword;
142
 
 
143
 
        dword = DeviceCapabilities(printer, port, cap, NULL, NULL);
144
 
        if ((DWORD) -1 == dword)
145
 
                return;
146
 
 
147
 
        printf("%s: %d\n", key, dword);
148
 
        SetPrinterDataEx(ph, SPLDS_DRIVER_KEY, key, REG_DWORD, (BYTE *) &dword, sizeof(dword));
149
 
}
150
 
 
151
 
void map_generic_multi_sz(HANDLE ph, TCHAR *printer, TCHAR *port, WORD cap, TCHAR *key, int size)
152
 
{
153
 
        TCHAR *strings_in;
154
 
        TCHAR *strings_out, *strings_cur;
155
 
        DWORD num_items, i;
156
 
 
157
 
        num_items = DeviceCapabilities(printer, port, cap, NULL, NULL);
158
 
        if ((DWORD) -1 == num_items)
159
 
                return;
160
 
        strings_in = malloc(num_items * size);
161
 
        strings_out = calloc(num_items, size);
162
 
        num_items = DeviceCapabilities(printer, port, cap, strings_in, NULL);
163
 
        printf("%s:\n", key);
164
 
        for (i=0, strings_cur = strings_out; i < num_items; i++) {
165
 
                _tcsncpy(strings_cur, &strings_in[i*size], size);
166
 
                printf("\t%s\n", strings_cur);
167
 
                strings_cur += _tcslen(strings_cur) + 1;
168
 
        }
169
 
                
170
 
        SetPrinterDataEx(ph, SPLDS_DRIVER_KEY, key, REG_MULTI_SZ, strings_out, 
171
 
                (strings_cur - strings_out + 1) * sizeof(TCHAR));
172
 
 
173
 
        free(strings_in);
174
 
        free(strings_out);
175
 
}
176
 
 
177
 
int main(int argc, char *argv[])
178
 
{
179
 
        HANDLE ph;
180
 
        BYTE *driver_info;
181
 
        DWORD needed;
182
 
        TCHAR *printer;
183
 
        TCHAR *port = SAMBA_PORT;
184
 
        PRINTER_DEFAULTS admin_access = {NULL, NULL, PRINTER_ACCESS_ADMINISTER};
185
 
        PRINTER_INFO_7 publish = {NULL, DSPRINT_PUBLISH};
186
 
        
187
 
        if (argc < 2) {
188
 
                printf("Usage: %s <printername>\n", argv[0]);
189
 
                return -1;
190
 
        }
191
 
 
192
 
        printer = argv[1];
193
 
 
194
 
        if (!(OpenPrinter(printer, &ph, &admin_access))) {
195
 
                printf("OpenPrinter failed, error = %s\n", PrintLastError());
196
 
                return -1;
197
 
        }
198
 
 
199
 
        GetPrinterDriver(ph, NULL, 1, NULL, 0, &needed);
200
 
        if (!needed) {
201
 
                printf("GetPrinterDriver failed, error = %s\n", PrintLastError());
202
 
                ClosePrinter(ph);
203
 
                return -1;
204
 
        }
205
 
        driver_info = malloc(needed);
206
 
        if (!(GetPrinterDriver(ph, NULL, 1, driver_info, needed, &needed))) {
207
 
                printf("GetPrinterDriver failed, error = %s\n", PrintLastError());
208
 
                ClosePrinter(ph);
209
 
                return -1;
210
 
        }
211
 
 
212
 
        map_generic_multi_sz(ph, printer, port, DC_BINNAMES, _T("printBinNames"), 24);
213
 
        map_generic_boolean(ph, printer, port, DC_COLLATE, _T("printCollate"));
214
 
        map_generic_dword(ph, printer, port, DC_COPIES, _T("printMaxCopies"));
215
 
        map_generic_dword(ph, printer, port, DC_DRIVER, _T("driverVersion"));
216
 
        map_generic_boolean(ph, printer, port, DC_DUPLEX, _T("printDuplexSupported"));
217
 
        map_extents(ph, printer, port);
218
 
        map_resolution(ph, printer, port);
219
 
        map_orientation(ph, printer, port);
220
 
        map_generic_multi_sz(ph, printer, port, DC_PAPERNAMES, _T("printMediaSupported"), 64);
221
 
#if (WINVER >= 0x0500)
222
 
        map_generic_boolean(ph, printer, port, DC_COLORDEVICE, _T("printColor"));
223
 
        map_generic_multi_sz(ph, printer, port, DC_PERSONALITY, _T("printLanguage"), 64);
224
 
        map_generic_multi_sz(ph, printer, port, DC_MEDIAREADY, _T("printMediaReady"),64);
225
 
        map_generic_dword(ph, printer, port, DC_PRINTERMEM, _T("printMemory"));
226
 
        map_generic_dword(ph, printer, port, DC_PRINTRATE, _T("printRate"));
227
 
        map_printrateunit(ph, printer, port);
228
 
#ifdef DC_STAPLE
229
 
        map_generic_boolean(ph, printer, port, DC_STAPLE, _T("printStaplingSupported"));
230
 
#endif
231
 
#ifdef DC_PRINTRATEPPM
232
 
        map_generic_dword(ph, printer, port, DC_PRINTRATEPPM, _T("printPagesPerMinute"));
233
 
#endif
234
 
#endif
235
 
        SetPrinter(ph, 7, (BYTE *) &publish, 0);
236
 
        ClosePrinter(ph);
237
 
        return 0;
238
 
}