« back to all changes in this revision
Viewing changes to gprintersettings.cpp
- browse files at revision 3
- compare with another revision
- download diff
- download tarball
- view history from revision 3
- Committer: Bazaar Package Importer
- Author(s): Milan Zamazal
- Date: 2007-05-01 16:32:13 UTC
- mfrom: (1.1.1 upstream)
- Revision ID: james.westby@ubuntu.com-20070501163213-ni1933khtg9fdvn5
Tags: 0.3.5-2
Move to unstable.
- files added:
- ABOUT-NLS
- effects
- m4
- po
- files removed:
- Makefile
- files modified:
- Makefile.am
- support/searchpath.cpp *
added
removed
gprintersettings.cpp
1
/*
2
* gprintersettings.cpp - Bridges GutenPrint's stp_vars_t and the configuration file.
3
* A subclass of ConfigSectionHandler.
4
*
5
* Copyright (c) 2004 by Alastair M. Robinson
6
* Distributed under the terms of the GNU General Public License -
7
* see the file named "COPYING" for more details.
8
*
9
*/
10
11
#include <iostream>
12
13
#include <string.h>
14
#include <glib.h>
15
#include <glib/gprintf.h>
16
17
#include "stpui_widgets/stputil.h"
18
#include "gprintersettings.h"
19
20
using namespace std;
21
22
23
static void dumpstrings(const stp_parameter_t *desc)
24
{
25
int j,strcount;
26
stp_string_list_t *strlist=desc->bounds.str;
27
if(strlist)
28
{
29
strcount=stp_string_list_count(strlist);
30
for(j=0;j<strcount;++j)
31
{
32
stp_param_string_t *p=stp_string_list_param(strlist,j);
33
fprintf(stderr," %s (%s)\n",p->text,p->name);
34
}
35
}
36
else
37
fprintf(stderr," No string list!\n");
38
}
39
40
41
static void dumpvars(stp_vars_t *v)
42
{
43
stp_parameter_list_t params = stp_get_parameter_list(v);
44
45
int count = stp_parameter_list_count(params);
46
47
for (int i = 0; i < count; i++)
48
{
49
const stp_parameter_t *p = stp_parameter_list_param(params, i);
50
// if((p->p_level<=STP_PARAMETER_LEVEL_ADVANCED4)
51
// && ((p->p_class==STP_PARAMETER_CLASS_FEATURE) || (p->p_class==STP_PARAMETER_CLASS_OUTPUT)))
52
{
53
stp_parameter_t desc;
54
stp_describe_parameter(v,p->name,&desc);
55
const char *str;
56
int ival;
57
double fval;
58
59
fprintf(stderr,"%s, %d, %d, %d, %d ",desc.name,desc.p_type,p->p_type,desc.p_class,desc.p_level);
60
61
if(desc.is_active)
62
{
63
fprintf(stderr,", Active");
64
}
65
else
66
{
67
fprintf(stderr,", Inactive");
68
}
69
switch(desc.p_type)
70
{
71
case STP_PARAMETER_TYPE_STRING_LIST:
72
str=stp_get_string_parameter(v,desc.name);
73
fprintf(stderr,", StringList\n");
74
dumpstrings(&desc);
75
if(str)
76
fprintf(stderr," Currently set to: %s\n",str);
77
break;
78
79
case STP_PARAMETER_TYPE_INT:
80
ival=stp_get_int_parameter(v,desc.name);
81
fprintf(stderr,", Int\n");
82
fprintf(stderr," Currently set to: %d\n",ival);
83
break;
84
85
case STP_PARAMETER_TYPE_BOOLEAN:
86
ival=stp_get_boolean_parameter(v,desc.name);
87
fprintf(stderr,", Boolean\n");
88
fprintf(stderr," Currently set to: %d\n",ival);
89
break;
90
91
case STP_PARAMETER_TYPE_DOUBLE:
92
fval=stp_get_float_parameter(v,desc.name);
93
fprintf(stderr,", Double\n");
94
fprintf(stderr," Currently set to: %f\n",fval);
95
break;
96
97
default:
98
fprintf(stderr,", Other\n");
99
break;
100
}
101
}
102
}
103
stp_parameter_list_destroy(params);
104
}
105
106
107
void GPrinterSettings::Dump()
108
{
109
dumpvars(stpvars);
110
}
111
112
113
GPrinterSettings::GPrinterSettings(PrintOutput &output,ConfigFile *inf,const char *section)
114
: ConfigSectionHandler(inf,section), stpvars(NULL), output(output), initialised(false)
115
{
116
cerr << "In GPrinterSetting constructor - about to call stp_init()" << endl;
117
stp_init();
118
cerr << "Done" << endl;
119
stpvars=stp_vars_create();
120
}
121
122
123
GPrinterSettings::~GPrinterSettings()
124
{
125
if(stpvars)
126
stp_vars_destroy(stpvars);
127
}
128
129
130
void GPrinterSettings::SelectSection()
131
{
132
/* Slight hack here: The printer driver is stored in the [Output] section
133
which is prior to the [Print] section. Clearing this forces the driver
134
to be set before the printer options are set */
135
136
initialised=false;
137
}
138
139
140
void GPrinterSettings::ParseString(const char *string)
141
{
142
if(!initialised)
143
{
144
const char *driver=output.FindString("Driver");
145
if(!SetDriver(driver))
146
output.SetString("Driver",DEFAULT_PRINTER_DRIVER);
147
initialised=true;
148
}
149
150
while(*string==' ')
151
++string;
152
153
char *value;
154
char *token;
155
value=token=strdup(string);
156
int l=strlen(token)-1;
157
while((l>0) && ((token[l]=='\n') || (token[l]=='\r')))
158
--l;
159
token[l+1]=0;
160
161
while(1)
162
{
163
switch (*value)
164
{
165
case '\0':
166
free(token);
167
return;
168
break;
169
case '=':
170
*value='\0';
171
++value;
172
if(*value)
173
{
174
stp_parameter_t param;
175
stp_describe_parameter(stpvars,token,¶m);
176
switch(param.p_type)
177
{
178
case STP_PARAMETER_TYPE_STRING_LIST:
179
// cerr << "Setting " << token << " to " << value << endl;
180
stp_set_string_parameter(stpvars,token,value);
181
break;
182
183
case STP_PARAMETER_TYPE_INT:
184
// cerr << "Setting " << token << " to " << value << endl;
185
stp_set_int_parameter(stpvars,token,atoi(value));
186
break;
187
188
case STP_PARAMETER_TYPE_BOOLEAN:
189
// cerr << "Setting " << token << " to " << value << endl;
190
stp_set_boolean_parameter(stpvars,token,atoi(value));
191
break;
192
193
case STP_PARAMETER_TYPE_DOUBLE:
194
// cerr << "Setting " << token << " to " << value << endl;
195
stp_set_float_parameter(stpvars,token,atof(value));
196
break;
197
198
default:
199
break;
200
}
201
stp_parameter_description_destroy(¶m);
202
}
203
free(token);
204
return;
205
break;
206
}
207
++value;
208
}
209
}
210
211
212
void GPrinterSettings::SaveSection(FILE *file)
213
{
214
stp_parameter_list_t params = stp_get_parameter_list(stpvars);
215
216
int count = stp_parameter_list_count(params);
217
218
for (int i = 0; i < count; i++)
219
{
220
const stp_parameter_t *p = stp_parameter_list_param(params, i);
221
if((p->p_level<=STP_PARAMETER_LEVEL_ADVANCED4))
222
{
223
stp_parameter_t desc;
224
stp_describe_parameter(stpvars,p->name,&desc);
225
if(desc.is_active)
226
{
227
switch(desc.p_type)
228
{
229
case STP_PARAMETER_TYPE_STRING_LIST:
230
{
231
if(stp_check_string_parameter(stpvars,desc.name,STP_PARAMETER_DEFAULTED))
232
{
233
const char *str=stp_get_string_parameter(stpvars,desc.name);
234
// if(!desc.is_mandatory || strcmp(str,desc.deflt.str)!=0)
235
fprintf(file,"%s=%s\n",desc.name,str);
236
}
237
}
238
break;
239
240
case STP_PARAMETER_TYPE_INT:
241
{
242
if(stp_check_int_parameter(stpvars,desc.name,STP_PARAMETER_DEFAULTED))
243
{
244
int val=stp_get_int_parameter(stpvars,desc.name);
245
// if(!desc.is_mandatory || val!=desc.deflt.integer)
246
fprintf(file,"%s=%d\n",desc.name,val);
247
}
248
}
249
break;
250
251
case STP_PARAMETER_TYPE_BOOLEAN:
252
{
253
if(stp_check_boolean_parameter(stpvars,desc.name,STP_PARAMETER_DEFAULTED))
254
{
255
int val=stp_get_boolean_parameter(stpvars,desc.name);
256
// if(!desc.is_mandatory || val!=desc.deflt.boolean)
257
fprintf(file,"%s=%d\n",desc.name,val);
258
}
259
}
260
break;
261
262
case STP_PARAMETER_TYPE_DOUBLE:
263
{
264
if(stp_check_float_parameter(stpvars,desc.name,STP_PARAMETER_DEFAULTED))
265
{
266
double val=stp_get_float_parameter(stpvars,desc.name);
267
// if(!desc.is_mandatory || val!=desc.deflt.dbl)
268
fprintf(file,"%s=%f\n",desc.name,val);
269
}
270
}
271
break;
272
273
default:
274
break;
275
}
276
}
277
stp_parameter_description_destroy(&desc);
278
}
279
}
280
stp_parameter_list_destroy(params);
281
}
282
283
284
// SetDriver
285
// Returns false if the driver isn't recognised, true otherwise.
286
287
bool GPrinterSettings::SetDriver(const char *driver)
288
{
289
bool result=true;
290
if(stpvars)
291
{
292
const char *olddriver=stp_get_driver(stpvars);
293
if(!olddriver)
294
olddriver="None";
295
if(!driver)
296
driver=DEFAULT_PRINTER_DRIVER;
297
if(strcmp(driver,olddriver))
298
{
299
cerr << "SetDriver(): Setting driver to " << driver << endl;
300
301
// Work around the non-defaulting of inactive settings...
302
const stp_vars_t *defaults=stp_default_settings();
303
stp_vars_copy(stpvars,defaults);
304
305
stp_set_driver(stpvars,driver);
306
output.SetString("Driver",driver);
307
308
const stp_printer_t *printer=stp_get_printer(stpvars);
309
if(printer)
310
{
311
cerr << "Setting defaults" << endl;
312
stp_set_printer_defaults(stpvars,printer);
313
}
314
else
315
{
316
cerr << "Unable to get printer - reverting to default driver" << endl;
317
output.SetString("Driver",DEFAULT_PRINTER_DRIVER);
318
stp_set_driver(stpvars,DEFAULT_PRINTER_DRIVER);
319
if((printer=stp_get_printer(stpvars)))
320
stp_set_printer_defaults(stpvars,printer);
321
else
322
cerr << "Still can't get printer!" << endl;
323
result=false;
324
}
325
}
326
}
327
else
328
cerr << "No stp vars!" << endl;
329
return(result);
330
}
331
332
333
void GPrinterSettings::SetPageSize(const char *pagesize)
334
{
335
if(stpvars)
336
{
337
stp_set_string_parameter(stpvars,"MediaSize",pagesize);
338
}
339
}
340
341
342
void GPrinterSettings::Validate()
343
{
344
stputil_validate_parameters(stpvars);
345
}
346
347
348
void GPrinterSettings::Reset()
349
{
350
stp_vars_destroy(stpvars);
351
stpvars=stp_vars_create();
352
cerr << "Created fresh stp_vars" << endl;
353
initialised=false;
354
}
1
/*
2
* gprintersettings.cpp - Bridges GutenPrint's stp_vars_t and the configuration file.
3
* A subclass of ConfigSectionHandler.
4
*
5
* Copyright (c) 2004 by Alastair M. Robinson
6
* Distributed under the terms of the GNU General Public License -
7
* see the file named "COPYING" for more details.
8
*
9
*/
10
11
#include <iostream>
12
13
#include <string.h>
14
#include <glib.h>
15
#include <glib/gprintf.h>
16
17
#include "stpui_widgets/stputil.h"
18
#include "gprintersettings.h"
19
#include "util.h"
20
21
#include "support/generaldialogs.h"
22
23
#define DEFAULT_PPD_STRING "<Default Queue PPD>"
24
25
using namespace std;
26
27
28
static void dumpstrings(const stp_parameter_t *desc)
29
{
30
int j,strcount;
31
stp_string_list_t *strlist=desc->bounds.str;
32
if(strlist)
33
{
34
strcount=stp_string_list_count(strlist);
35
for(j=0;j<strcount;++j)
36
{
37
stp_param_string_t *p=stp_string_list_param(strlist,j);
38
fprintf(stderr," %s (%s)\n",p->text,p->name);
39
}
40
}
41
else
42
fprintf(stderr," No string list!\n");
43
}
44
45
46
static void dumpvars(stp_vars_t *v)
47
{
48
stp_parameter_list_t params = stp_get_parameter_list(v);
49
50
int count = stp_parameter_list_count(params);
51
52
for (int i = 0; i < count; i++)
53
{
54
const stp_parameter_t *p = stp_parameter_list_param(params, i);
55
// if((p->p_level<=STP_PARAMETER_LEVEL_ADVANCED4)
56
// && ((p->p_class==STP_PARAMETER_CLASS_FEATURE) || (p->p_class==STP_PARAMETER_CLASS_OUTPUT)))
57
{
58
stp_parameter_t desc;
59
stp_describe_parameter(v,p->name,&desc);
60
const char *str;
61
int ival;
62
double fval;
63
64
fprintf(stderr,"%s, %d, %d, %d, %d ",desc.name,desc.p_type,p->p_type,desc.p_class,desc.p_level);
65
66
if(desc.is_active)
67
{
68
fprintf(stderr,", Active");
69
}
70
else
71
{
72
fprintf(stderr,", Inactive");
73
}
74
switch(desc.p_type)
75
{
76
case STP_PARAMETER_TYPE_STRING_LIST:
77
str=stp_get_string_parameter(v,desc.name);
78
fprintf(stderr,", StringList\n");
79
dumpstrings(&desc);
80
if(str)
81
fprintf(stderr," Currently set to: %s\n",str);
82
break;
83
84
case STP_PARAMETER_TYPE_INT:
85
ival=stp_get_int_parameter(v,desc.name);
86
fprintf(stderr,", Int\n");
87
fprintf(stderr," Currently set to: %d\n",ival);
88
break;
89
90
case STP_PARAMETER_TYPE_BOOLEAN:
91
ival=stp_get_boolean_parameter(v,desc.name);
92
fprintf(stderr,", Boolean\n");
93
fprintf(stderr," Currently set to: %d\n",ival);
94
break;
95
96
case STP_PARAMETER_TYPE_DOUBLE:
97
fval=stp_get_float_parameter(v,desc.name);
98
fprintf(stderr,", Double\n");
99
fprintf(stderr," Currently set to: %f\n",fval);
100
break;
101
102
default:
103
fprintf(stderr,", Other\n");
104
break;
105
}
106
}
107
}
108
stp_parameter_list_destroy(params);
109
}
110
111
112
void GPrinterSettings::Dump()
113
{
114
dumpvars(stpvars);
115
}
116
117
118
GPrinterSettings::GPrinterSettings(PrintOutput &output,ConfigFile *inf,const char *section)
119
: ConfigSectionHandler(inf,section), PageExtent(), stpvars(NULL), output(output), initialised(false)
120
{
121
#if 0
122
cerr << "In GPrinterSetting constructor - about to call stp_init()" << endl;
123
stp_init();
124
cerr << "Done" << endl;
125
#endif
126
stpvars=stp_vars_create();
127
}
128
129
130
GPrinterSettings::~GPrinterSettings()
131
{
132
if(stpvars)
133
stp_vars_destroy(stpvars);
134
}
135
136
137
void GPrinterSettings::SelectSection()
138
{
139
/* Slight hack here: The printer driver is stored in the [Output] section
140
which is prior to the [Print] section. Clearing this forces the driver
141
to be set before the printer options are set */
142
143
initialised=false;
144
}
145
146
147
void GPrinterSettings::ParseString(const char *string)
148
{
149
if(!initialised)
150
{
151
const char *driver=output.FindString("Driver");
152
if(!SetDriver(driver))
153
output.SetString("Driver",DEFAULT_PRINTER_DRIVER);
154
initialised=true;
155
}
156
157
while(*string==' ')
158
++string;
159
160
char *value;
161
char *token;
162
value=token=strdup(string);
163
int l=strlen(token)-1;
164
while((l>0) && ((token[l]=='\n') || (token[l]=='\r')))
165
--l;
166
token[l+1]=0;
167
168
while(1)
169
{
170
switch (*value)
171
{
172
case '\0':
173
free(token);
174
return;
175
break;
176
case '=':
177
*value='\0';
178
++value;
179
if(*value)
180
{
181
if(strcmp("CustomWidth",token)==0)
182
{
183
cerr << "Setting custom width to: " << value << endl;
184
stp_set_page_width(stpvars,pagewidth=atoi(value));
185
}
186
else if(strcmp("CustomHeight",token)==0)
187
{
188
cerr << "Setting custom height to: " << value << endl;
189
stp_set_page_height(stpvars,pageheight=atoi(value));
190
}
191
else
192
{
193
stp_parameter_t param;
194
stp_describe_parameter(stpvars,token,¶m);
195
switch(param.p_type)
196
{
197
case STP_PARAMETER_TYPE_STRING_LIST:
198
stp_set_string_parameter(stpvars,token,value);
199
break;
200
201
case STP_PARAMETER_TYPE_FILE:
202
// Because the queue PPD filenames returned by CUPS
203
// aren't persistent between sessions, we have to
204
// save an escape string, and substitute the current
205
// filename at preset loading time.
206
if(strcmp(value,DEFAULT_PPD_STRING)==0)
207
{
208
cerr << "*** Fetching default PPD filename" << endl;
209
char *defppd=output.GetPPD();
210
if(defppd)
211
{
212
cerr << "Got default PPD filename: " << defppd << endl;
213
stp_set_file_parameter(stpvars,token,defppd);
214
free(defppd);
215
216
stp_parameter_t desc2;
217
stp_describe_parameter(stpvars,"PageSize",&desc2);
218
cerr << "After setting PPD Default page size is now: " << desc2.deflt.str << endl;
219
stp_set_string_parameter(stpvars,"PageSize",desc2.deflt.str);
220
stp_parameter_description_destroy(&desc2);
221
ppdsizes_workaround_done=true;
222
}
223
else
224
cerr << "Couldn't get default PPD." << endl;
225
}
226
else
227
stp_set_file_parameter(stpvars,token,value);
228
break;
229
230
case STP_PARAMETER_TYPE_INT:
231
// cerr << "Setting " << token << " to " << value << endl;
232
stp_set_int_parameter(stpvars,token,atoi(value));
233
break;
234
235
case STP_PARAMETER_TYPE_BOOLEAN:
236
// cerr << "Setting " << token << " to " << value << endl;
237
stp_set_boolean_parameter(stpvars,token,atoi(value));
238
break;
239
240
case STP_PARAMETER_TYPE_DOUBLE:
241
// cerr << "Setting " << token << " to " << value << endl;
242
stp_set_float_parameter(stpvars,token,atof(value));
243
break;
244
245
default:
246
break;
247
}
248
stp_parameter_description_destroy(¶m);
249
}
250
}
251
free(token);
252
return;
253
break;
254
}
255
++value;
256
}
257
}
258
259
260
void GPrinterSettings::SaveSection(FILE *file)
261
{
262
stp_parameter_list_t params = stp_get_parameter_list(stpvars);
263
stp_parameter_t desc;
264
265
int count = stp_parameter_list_count(params);
266
267
// PPDFile parameter must be saved first, because it must be restored
268
// before other parameters upon loading.
269
// Because CUPS returns a local temporary filename for a queue's PPD
270
// which is not persistent between sessions, we must save an escape
271
// string to indicate that the queue's default should be used.
272
273
stp_describe_parameter(stpvars,"PPDFile",&desc);
274
if(desc.is_active)
275
{
276
cerr << "Saving PPDFile parameter..." << endl;
277
const char *ppd=stp_get_file_parameter(stpvars,"PPDFile");
278
char *defppd=output.GetPPD();
279
cerr << "Current PPD: " << ppd << endl;
280
cerr << "Default PPD: " << defppd << endl;
281
if(defppd && CompareFiles(defppd,ppd))
282
ppd=DEFAULT_PPD_STRING;
283
if(defppd)
284
free(defppd);
285
fprintf(file,"PPDFile=%s\n",ppd);
286
}
287
288
for (int i = 0; i < count; i++)
289
{
290
const stp_parameter_t *p = stp_parameter_list_param(params, i);
291
if((p->p_level<=STP_PARAMETER_LEVEL_ADVANCED4))
292
{
293
stp_parameter_t desc;
294
stp_describe_parameter(stpvars,p->name,&desc);
295
if(desc.is_active)
296
{
297
switch(desc.p_type)
298
{
299
case STP_PARAMETER_TYPE_STRING_LIST:
300
{
301
if(stp_check_string_parameter(stpvars,desc.name,STP_PARAMETER_DEFAULTED))
302
{
303
const char *str=stp_get_string_parameter(stpvars,desc.name);
304
// if(!desc.is_mandatory || strcmp(str,desc.deflt.str)!=0)
305
fprintf(file,"%s=%s\n",desc.name,str);
306
}
307
}
308
break;
309
310
case STP_PARAMETER_TYPE_INT:
311
{
312
if(stp_check_int_parameter(stpvars,desc.name,STP_PARAMETER_DEFAULTED))
313
{
314
int val=stp_get_int_parameter(stpvars,desc.name);
315
// if(!desc.is_mandatory || val!=desc.deflt.integer)
316
fprintf(file,"%s=%d\n",desc.name,val);
317
}
318
}
319
break;
320
321
case STP_PARAMETER_TYPE_BOOLEAN:
322
{
323
if(stp_check_boolean_parameter(stpvars,desc.name,STP_PARAMETER_DEFAULTED))
324
{
325
int val=stp_get_boolean_parameter(stpvars,desc.name);
326
// if(!desc.is_mandatory || val!=desc.deflt.boolean)
327
fprintf(file,"%s=%d\n",desc.name,val);
328
}
329
}
330
break;
331
332
case STP_PARAMETER_TYPE_DOUBLE:
333
{
334
if(stp_check_float_parameter(stpvars,desc.name,STP_PARAMETER_DEFAULTED))
335
{
336
double val=stp_get_float_parameter(stpvars,desc.name);
337
// if(!desc.is_mandatory || val!=desc.deflt.dbl)
338
fprintf(file,"%s=%f\n",desc.name,val);
339
}
340
}
341
break;
342
343
default:
344
break;
345
}
346
}
347
stp_parameter_description_destroy(&desc);
348
}
349
}
350
351
fprintf(file,"CustomWidth=%d\n",pagewidth);
352
fprintf(file,"CustomHeight=%d\n",pageheight);
353
354
stp_parameter_list_destroy(params);
355
}
356
357
358
// SetDriver
359
// Returns false if the driver isn't recognised, true otherwise.
360
361
bool GPrinterSettings::SetDriver(const char *driver)
362
{
363
bool result=true;
364
if(stpvars)
365
{
366
const char *olddriver=stp_get_driver(stpvars);
367
if(!olddriver)
368
olddriver="None";
369
if(!driver)
370
driver=DEFAULT_PRINTER_DRIVER;
371
if(strcmp(driver,olddriver))
372
{
373
cerr << "SetDriver(): Setting driver to " << driver << endl;
374
375
// Work around the non-defaulting of inactive settings...
376
const stp_vars_t *defaults=stp_default_settings();
377
stp_vars_copy(stpvars,defaults);
378
379
stp_set_driver(stpvars,driver);
380
output.SetString("Driver",driver);
381
382
const stp_printer_t *printer=stp_get_printer(stpvars);
383
if(printer)
384
{
385
cerr << "Setting defaults" << endl;
386
stp_set_printer_defaults(stpvars,printer);
387
}
388
else
389
{
390
cerr << "Unable to get printer - reverting to default driver" << endl;
391
output.SetString("Driver",DEFAULT_PRINTER_DRIVER);
392
stp_set_driver(stpvars,DEFAULT_PRINTER_DRIVER);
393
if((printer=stp_get_printer(stpvars)))
394
stp_set_printer_defaults(stpvars,printer);
395
else
396
cerr << "Still can't get printer!" << endl;
397
result=false;
398
}
399
}
400
stp_set_page_width(stpvars,pagewidth);
401
stp_set_page_height(stpvars,pageheight);
402
403
404
stp_parameter_t desc;
405
stp_describe_parameter(stpvars,"PPDFile",&desc);
406
if(desc.is_active)
407
{
408
cerr << "Getting default PPD..." << endl;
409
char *defppd=output.GetPPD();
410
if(defppd)
411
{
412
cerr << "Setting PPDFile to " << defppd << endl;
413
stp_set_file_parameter(stpvars,"PPDFile",defppd);
414
free(defppd);
415
416
if(!ppdsizes_workaround_done)
417
{
418
stp_parameter_t desc2;
419
stp_describe_parameter(stpvars,"PageSize",&desc2);
420
cerr << "After setting PPD Default page size is now: " << desc2.deflt.str << endl;
421
stp_set_string_parameter(stpvars,"PageSize",desc2.deflt.str);
422
stp_parameter_description_destroy(&desc2);
423
ppdsizes_workaround_done=true;
424
}
425
}
426
}
427
stp_parameter_description_destroy(&desc);
428
}
429
else
430
cerr << "No stp vars!" << endl;
431
return(result);
432
}
433
434
435
void GPrinterSettings::Validate()
436
{
437
stputil_validate_parameters(stpvars);
438
cerr << "After stputil_validate_parameters(): " << setlocale(LC_ALL,"") << endl;
439
}
440
441
442
void GPrinterSettings::Reset()
443
{
444
stp_vars_destroy(stpvars);
445
stpvars=stp_vars_create();
446
cerr << "Created fresh stp_vars" << endl;
447
initialised=false;
448
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1