summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--meta/recipes-extended/ghostscript/ghostscript/CVE-2024-33871-0001.patch4863
-rw-r--r--meta/recipes-extended/ghostscript/ghostscript/CVE-2024-33871-0002.patch43
-rw-r--r--meta/recipes-extended/ghostscript/ghostscript_9.55.0.bb2
3 files changed, 4908 insertions, 0 deletions
diff --git a/meta/recipes-extended/ghostscript/ghostscript/CVE-2024-33871-0001.patch b/meta/recipes-extended/ghostscript/ghostscript/CVE-2024-33871-0001.patch
new file mode 100644
index 0000000000..008f588bff
--- /dev/null
+++ b/meta/recipes-extended/ghostscript/ghostscript/CVE-2024-33871-0001.patch
@@ -0,0 +1,4863 @@
1From 8b47f269b83b172b22606806fe5ec272d974e797 Mon Sep 17 00:00:00 2001
2From: Michael Vrhel <michael.vrhel@artifex.com>
3Date: Mon, 22 Nov 2021 12:13:10 -0800
4Subject: [PATCH 6/7] Removal of globals in opvp device
5
6Thanks to Robin for suggesting the structure form
7to get the globals at a common offset for the
8raster and vector forms of the device. That coupled
9with pushing the device through all the methods and
10doing initialization was the biggest effort.
11
12Thanks also to Chris for his help in providing
13understanding as to what this device was actually doing.
14
15This commit includes a test harness for the opvp
16device, which uses the device client API to write
17out the commands it receives to a text file for
18comparison. To build the driver use ./build_opv_harness.sh
19To use the driver use a command line like
20-sDEVICE=opvp -sDriver=libopv.so -o output.txt -f ./examples/tiger.eps
21The command lines are always dumped to the same
22file which is opvp_command_dump.txt. Note that the
23harness itself has to rely upon globals due to our
24inability to change the client API.
25
26CVE: CVE-2024-33871
27
28Upstream-Status: Backport [https://github.com/ArtifexSoftware/ghostpdl/commit/8b47f269b83b172b22606]
29
30Signed-off-by: Archana Polampalli <archana.polampalli@windriver.com>
31---
32 contrib/opvp/README.txt | 18 +
33 contrib/opvp/build_opv_harness.sh | 4 +
34 contrib/opvp/gdevopvp.c | 1879 +++++++++++++++++------------
35 contrib/opvp/opvp.h | 9 +-
36 contrib/opvp/opvp_0_2_0.h | 4 +-
37 contrib/opvp/opvpharness.c | 947 +++++++++++++++
38 6 files changed, 2070 insertions(+), 791 deletions(-)
39 create mode 100644 contrib/opvp/README.txt
40 create mode 100755 contrib/opvp/build_opv_harness.sh
41 create mode 100644 contrib/opvp/opvpharness.c
42
43diff --git a/contrib/opvp/README.txt b/contrib/opvp/README.txt
44new file mode 100644
45index 0000000..fd2250e
46--- /dev/null
47+++ b/contrib/opvp/README.txt
48@@ -0,0 +1,18 @@
49+In an effort to remove globals in devices
50+that ship with Ghostscript, the opvp device was updated
51+to place it's global values into the device structure.
52+
53+As part of that commit, a harness was added to enable
54+testing of the opvp device client API to test for any
55+issues. To build the harness use ./build_opv_harness.sh
56+This will create a debug version of the shared object
57+libopv.so. The command line
58+gs -sDEVICE=opvp -sDriver=./contrib/opvp/libopv.so -o output.txt -f ./examples/tiger.eps
59+can then be used.
60+
61+This command should create a file called
62+opvp_command_dump.txt that contains the calls and
63+the parameters made to the client API. Note that the
64+harness itself has to rely upon globals. To do otherwise
65+would require a to change the client API, which we
66+do not own.
67\ No newline at end of file
68diff --git a/contrib/opvp/build_opv_harness.sh b/contrib/opvp/build_opv_harness.sh
69new file mode 100755
70index 0000000..8d10f05
71--- /dev/null
72+++ b/contrib/opvp/build_opv_harness.sh
73@@ -0,0 +1,4 @@
74+#!/bin/bash
75+
76+gcc -Werror -Wall -c -fpic -g opvpharness.c
77+gcc -shared -o libopv.so opvpharness.o
78\ No newline at end of file
79diff --git a/contrib/opvp/gdevopvp.c b/contrib/opvp/gdevopvp.c
80index 844b46c..64afbfe 100644
81--- a/contrib/opvp/gdevopvp.c
82+++ b/contrib/opvp/gdevopvp.c
83@@ -115,14 +115,62 @@ typedef struct {
84
85 #define MAX_PATH_POINTS 1000
86
87-/* driver */
88-typedef struct gx_device_opvp_s {
89+/* To remove the existing globals from this device,
90+ we place the current globals into a structure
91+ and place them at the same offset location
92+ for the opvp and oprp devices, allowing easy
93+ access regardless of the device type. */
94+
95+typedef struct opXp_globals_s {
96+ bool vector;
97+ bool inkjet;
98+ bool zoomAuto;
99+ bool zooming;
100+ bool beginPage;
101+ float margins[4];
102+ float zoom[2];
103+ float shift[2];
104+ opvp_int_t outputFD;
105+ opvp_int_t nApiEntry;
106+ opvp_dc_t printerContext;
107+ opvp_cspace_t colorSpace;
108+ opvp_cspace_t savedColorSpace;
109+ char* vectorDriver;
110+ char* printerModel;
111+ void* handle;
112+ opvp_brush_t* vectorFillColor;
113+ opvp_int_t* ErrorNo;
114+ opvp_api_procs_t* apiEntry;
115+ OPVP_api_procs* apiEntry_0_2;
116+ char* jobInfo;
117+ char* docInfo;
118+ opvp_dc_t(*OpenPrinter)(opvp_int_t, const opvp_char_t*,
119+ const opvp_int_t[2], opvp_api_procs_t**);
120+ int (*OpenPrinter_0_2)(int, char*, int*,
121+ OPVP_api_procs**);
122+ int (*GetLastError)(gx_device*);
123+} opXp_globals;
124+
125+typedef struct base_opvp_s {
126 gx_device_vector_common;
127+} base_opvp;
128+
129+typedef struct base_oprp_s {
130+ gx_device_common;
131+ gx_prn_device_common;
132+} base_oprp;
133+
134+typedef struct gx_device_opvp_s {
135+ gx_device_vector_common;
136+ char padding[1 + (sizeof(base_oprp) > sizeof(base_opvp) ? sizeof(base_oprp) - sizeof(base_opvp) : 0)];
137+ opXp_globals globals;
138 } gx_device_opvp;
139
140-typedef struct gx_device_oprp_s {
141+typedef struct gx_device_oprp_s {
142 gx_device_common;
143 gx_prn_device_common;
144+ char padding[1 + (sizeof(base_opvp) > sizeof(base_oprp) ? sizeof(base_opvp) - sizeof(base_oprp) : 0)];
145+ opXp_globals globals;
146 } gx_device_oprp;
147
148 /* point (internal) */
149@@ -135,15 +183,16 @@ typedef struct {
150
151 /* Utilities */
152 static int opvp_startpage(gx_device *);
153-static int opvp_endpage(void);
154+static int opvp_endpage(gx_device*);
155 static char *opvp_alloc_string(char **, const char *);
156 static char *opvp_cat_string(char **, const char *);
157 static char *opvp_adjust_num_string(char *);
158-static char **opvp_gen_dynamic_lib_name(void);
159+static char **opvp_gen_dynamic_lib_name(gx_device*);
160 static char *opvp_to_utf8(char *);
161-#define opvp_check_in_page(pdev) \
162- ((beginPage) || (inkjet) ? 0 \
163- : (*vdev_proc(pdev, beginpage))((gx_device_vector*)pdev))
164+#define opvp_check_in_page(opdev) \
165+ ((((gx_device_opvp*)(opdev))->globals.beginPage) || \
166+ (((gx_device_opvp*)(opdev))->globals.inkjet) ? 0 \
167+ : (*vdev_proc(opdev, beginpage))((gx_device_vector*)opdev))
168 static int opvp_get_papertable_index(gx_device *);
169 static char *opvp_get_sizestring(float, float);
170 /* not used static const char *opvp_get_papersize_region(gx_device *);*/
171@@ -160,8 +209,8 @@ static int opvp_draw_image(gx_device_opvp *, int,
172 int, int, int, int, int, int, const byte *);
173
174 /* load/unload vector driver */
175-static int opvp_load_vector_driver(void);
176-static int opvp_unload_vector_driver(void);
177+static int opvp_load_vector_driver(gx_device*);
178+static int opvp_unload_vector_driver(gx_device*);
179 static int prepare_open(gx_device *);
180
181 /* driver procs */
182@@ -177,10 +226,10 @@ static int opvp_copy_mono(gx_device *, const byte *, int, int,
183 gx_color_index, gx_color_index);
184 static int opvp_copy_color(gx_device *, const byte *, int, int,
185 gx_bitmap_id, int, int, int, int);
186-static int _get_params(gs_param_list *);
187+static int _get_params(gx_device*, gs_param_list *);
188 static int opvp_get_params(gx_device *, gs_param_list *);
189 static int oprp_get_params(gx_device *, gs_param_list *);
190-static int _put_params(gs_param_list *);
191+static int _put_params(gx_device*, gs_param_list *);
192 static int opvp_put_params(gx_device *, gs_param_list *);
193 static int oprp_put_params(gx_device *, gs_param_list *);
194 static int opvp_fill_path(gx_device *, const gs_gstate *, gx_path *,
195@@ -295,6 +344,53 @@ gs_public_st_suffix_add0_final(
196 NULL, /* *jobInfo */\
197 NULL /* *docInfo */
198
199+
200+static int
201+GetLastError_1_0(gx_device* dev)
202+{
203+ gx_device_opvp* pdev = (gx_device_opvp*)dev;
204+
205+ return *(pdev->globals.ErrorNo);
206+}
207+
208+/* Initialize the globals */
209+static void
210+InitGlobals(gx_device* dev)
211+{
212+ gx_device_opvp* opdev = (gx_device_opvp*)dev;
213+
214+ opdev->globals.vector = true;
215+ opdev->globals.inkjet = false;
216+ opdev->globals.zoomAuto = false;
217+ opdev->globals.zooming = false;
218+ opdev->globals.beginPage = false;
219+ opdev->globals.margins[0] = 0;
220+ opdev->globals.margins[1] = 0;
221+ opdev->globals.margins[2] = 0;
222+ opdev->globals.margins[3] = 0;
223+ opdev->globals.zoom[0] = 1;
224+ opdev->globals.zoom[1] = 1;
225+ opdev->globals.shift[0] = 0;
226+ opdev->globals.shift[1] = 0;
227+ opdev->globals.outputFD = -1;
228+ opdev->globals.nApiEntry = 0;
229+ opdev->globals.printerContext = -1;
230+ opdev->globals.colorSpace = OPVP_CSPACE_STANDARDRGB;
231+ opdev->globals.savedColorSpace = OPVP_CSPACE_STANDARDRGB;
232+ opdev->globals.vectorDriver = NULL;
233+ opdev->globals.printerModel = NULL;
234+ opdev->globals.handle = NULL;
235+ opdev->globals.vectorFillColor = NULL;
236+ opdev->globals.ErrorNo = NULL;
237+ opdev->globals.apiEntry = NULL;
238+ opdev->globals.apiEntry_0_2 = NULL;
239+ opdev->globals.jobInfo = NULL;
240+ opdev->globals.docInfo = NULL;
241+ opdev->globals.OpenPrinter = NULL;
242+ opdev->globals.OpenPrinter_0_2 = NULL;
243+ opdev->globals.GetLastError = GetLastError_1_0;
244+}
245+
246 /* device procs */
247 static void
248 opvp_initialize_device_procs(gx_device *dev)
249@@ -325,6 +421,9 @@ opvp_initialize_device_procs(gx_device *dev)
250 * by the system to the default. For compatibility we do the same. */
251 set_dev_proc(dev, encode_color, NULL);
252 set_dev_proc(dev, decode_color, NULL);
253+
254+ /* And the device globals */
255+ InitGlobals(dev);
256 }
257
258 /* vector procs */
259@@ -394,6 +493,9 @@ oprp_initialize_device_procs(gx_device *dev)
260 * by the system to the default. For compatibility we do the same. */
261 set_dev_proc(dev, encode_color, NULL);
262 set_dev_proc(dev, decode_color, NULL);
263+
264+ /* And the device globals */
265+ InitGlobals(dev);
266 }
267
268 const gx_device_oprp gs_oprp_device =
269@@ -412,43 +514,6 @@ const gx_device_oprp gs_oprp_device =
270 )
271 };
272
273-/* driver mode */
274-static bool vector = true;
275-static bool inkjet = false;
276-static char *vectorDriver = NULL;
277-static char *printerModel = NULL;
278-static void *handle = NULL;
279-static opvp_dc_t (*OpenPrinter)(opvp_int_t,const opvp_char_t*,
280- const opvp_int_t[2],
281- opvp_api_procs_t**) = NULL;
282-static int (*OpenPrinter_0_2)(int,char*,int*,
283- OPVP_api_procs**) = NULL;
284-static opvp_int_t *ErrorNo = NULL;
285-static opvp_int_t outputFD = -1;
286-static opvp_int_t nApiEntry = 0;
287-static opvp_api_procs_t *apiEntry = NULL;
288-static OPVP_api_procs *apiEntry_0_2 = NULL;
289-static opvp_dc_t printerContext = -1;
290-static char *jobInfo = NULL;
291-static char *docInfo = NULL;
292-static opvp_cspace_t colorSpace = OPVP_CSPACE_STANDARDRGB;
293-static opvp_cspace_t savedColorSpace;
294-static opvp_brush_t *vectorFillColor = NULL;
295-static float margins[4] = {0, 0, 0, 0};
296-static float zoom[2] = {1, 1};
297-static float shift[2] = {0, 0};
298-static bool zoomAuto = false;
299-static bool zooming = false;
300-static bool beginPage = false;
301-
302-static int
303-GetLastError_1_0(void)
304-{
305- return *ErrorNo;
306-}
307-
308-static int (*GetLastError)(void) = GetLastError_1_0;
309-
310 /* Wrapper functions that keep compatible with 0.2 */
311
312 /* color space mapping 0.2 to 1.0 */
313@@ -496,9 +561,11 @@ static int colorDepth_0_2[] = {
314
315 /* translate error code */
316 static int
317-GetLastError_0_2(void)
318+GetLastError_0_2(gx_device* dev)
319 {
320- switch(*ErrorNo) {
321+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
322+
323+ switch(*(opdev->globals.ErrorNo)) {
324 case OPVP_FATALERROR_0_2:
325 return OPVP_FATALERROR;
326 break;
327@@ -526,48 +593,51 @@ GetLastError_0_2(void)
328 }
329
330 static opvp_result_t
331-StartPageWrapper(opvp_dc_t printerContext, const opvp_char_t *pageInfo)
332+StartPageWrapper(gx_device *dev, opvp_dc_t printerContext, const opvp_char_t *pageInfo)
333 {
334 int r;
335+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
336
337- if ((r = apiEntry_0_2->StartPage(printerContext,
338+ if ((r = opdev->globals.apiEntry_0_2->StartPage(printerContext,
339 /* discard const */(char *)pageInfo)) != OPVP_OK) {
340 /* error */
341 return r;
342 }
343 /* initialize ROP */
344- if (apiEntry_0_2->SetROP != NULL) {
345- apiEntry_0_2->SetROP(printerContext,
346+ if (opdev->globals.apiEntry_0_2->SetROP != NULL) {
347+ opdev->globals.apiEntry_0_2->SetROP(printerContext,
348 OPVP_0_2_ROP_P);
349 }
350 return OPVP_OK;
351 }
352
353 static opvp_result_t
354-InitGSWrapper(opvp_dc_t printerContext)
355+InitGSWrapper(gx_device *dev, opvp_dc_t printerContext)
356 {
357 int r;
358+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
359
360- if ((r = apiEntry_0_2->InitGS(printerContext)) != OPVP_OK) {
361+ if ((r = opdev->globals.apiEntry_0_2->InitGS(printerContext)) != OPVP_OK) {
362 /* error */
363 return r;
364 }
365 /* initialize ROP */
366- if (apiEntry_0_2->SetROP != NULL) {
367- apiEntry_0_2->SetROP(printerContext,
368+ if (opdev->globals.apiEntry_0_2->SetROP != NULL) {
369+ opdev->globals.apiEntry_0_2->SetROP(printerContext,
370 OPVP_0_2_ROP_P);
371 }
372 return OPVP_OK;
373 }
374
375 static opvp_result_t
376-QueryColorSpaceWrapper( opvp_dc_t printerContext, opvp_int_t *pnum,
377+QueryColorSpaceWrapper(gx_device *dev, opvp_dc_t printerContext, opvp_int_t *pnum,
378 opvp_cspace_t *pcspace)
379 {
380 int r;
381 int i;
382+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
383
384- if ((r = apiEntry_0_2->QueryColorSpace(printerContext,
385+ if ((r = opdev->globals.apiEntry_0_2->QueryColorSpace(printerContext,
386 (OPVP_ColorSpace *)pcspace,pnum)) != OPVP_OK) {
387 /* error */
388 return r;
389@@ -587,51 +657,54 @@ QueryColorSpaceWrapper( opvp_dc_t printerContext, opvp_int_t *pnum,
390 }
391
392 static opvp_result_t
393-SetColorSpaceWrapper(opvp_dc_t printerContext, opvp_cspace_t cspace)
394+SetColorSpaceWrapper(gx_device *dev, opvp_dc_t printerContext, opvp_cspace_t cspace)
395 {
396+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
397+
398 if (cspace == OPVP_CSPACE_DEVICEKRGB) {
399 /* 0.2 doesn't have OPVP_CSPACE_DEVICEKRGB */
400- *ErrorNo = OPVP_NOTSUPPORTED_0_2;
401+ *(opdev->globals.ErrorNo) = OPVP_NOTSUPPORTED_0_2;
402 return -1;
403 }
404 if ((int)cspace
405 >= sizeof(cspace_1_0_to_0_2)/sizeof(OPVP_ColorSpace)) {
406 /* unknown color space */
407- *ErrorNo = OPVP_PARAMERROR_0_2;
408+ *(opdev->globals.ErrorNo) = OPVP_PARAMERROR_0_2;
409 return -1;
410 }
411- return apiEntry_0_2->SetColorSpace(printerContext,
412+ return opdev->globals.apiEntry_0_2->SetColorSpace(printerContext,
413 cspace_1_0_to_0_2[cspace]);
414 }
415
416+/* Not used
417 static opvp_result_t
418-GetColorSpaceWrapper(opvp_dc_t printerContext, opvp_cspace_t *pcspace)
419+GetColorSpaceWrapper(gx_device *dev, opvp_dc_t printerContext, opvp_cspace_t *pcspace)
420 {
421 int r;
422+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
423
424- if ((r = apiEntry_0_2->GetColorSpace(printerContext,
425+ if ((r = opdev->globals.apiEntry_0_2->GetColorSpace(printerContext,
426 (OPVP_ColorSpace *)pcspace)) != OPVP_OK) {
427- /* error */
428 return r;
429 }
430 if (*pcspace
431 >= sizeof(cspace_0_2_to_1_0)/sizeof(opvp_cspace_t)) {
432- /* unknown color space */
433- /* set DEVICERGB instead */
434 *pcspace = OPVP_CSPACE_DEVICERGB;
435 } else {
436 *pcspace = cspace_0_2_to_1_0[*pcspace];
437 }
438 return r;
439 }
440+*/
441
442 static opvp_result_t
443-SetStrokeColorWrapper(opvp_dc_t printerContext, const opvp_brush_t *brush)
444+SetStrokeColorWrapper(gx_device *dev, opvp_dc_t printerContext, const opvp_brush_t *brush)
445 {
446 OPVP_Brush brush_0_2;
447+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
448
449 if (brush == NULL) {
450- *ErrorNo = OPVP_PARAMERROR_0_2;
451+ *(opdev->globals.ErrorNo) = OPVP_PARAMERROR_0_2;
452 return -1;
453 }
454 if (brush->colorSpace == OPVP_CSPACE_DEVICEKRGB) {
455@@ -641,7 +714,7 @@ SetStrokeColorWrapper(opvp_dc_t printerContext, const opvp_brush_t *brush)
456 if ((int)brush->colorSpace
457 >= sizeof(cspace_1_0_to_0_2)/sizeof(OPVP_ColorSpace)) {
458 /* unknown color space */
459- *ErrorNo = OPVP_PARAMERROR_0_2;
460+ *(opdev->globals.ErrorNo) = OPVP_PARAMERROR_0_2;
461 return -1;
462 }
463 brush_0_2.colorSpace = cspace_1_0_to_0_2[brush->colorSpace];
464@@ -649,16 +722,17 @@ SetStrokeColorWrapper(opvp_dc_t printerContext, const opvp_brush_t *brush)
465 brush_0_2.yorg = brush->yorg;
466 brush_0_2.pbrush = (OPVP_BrushData *)brush->pbrush;
467 memcpy(brush_0_2.color,brush->color,sizeof(brush_0_2.color));
468- return apiEntry_0_2->SetStrokeColor(printerContext,&brush_0_2);
469+ return opdev->globals.apiEntry_0_2->SetStrokeColor(printerContext, &brush_0_2);
470 }
471
472 static opvp_result_t
473-SetFillColorWrapper(opvp_dc_t printerContext, const opvp_brush_t *brush)
474+SetFillColorWrapper(gx_device *dev, opvp_dc_t printerContext, const opvp_brush_t *brush)
475 {
476 OPVP_Brush brush_0_2;
477+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
478
479 if (brush == NULL) {
480- *ErrorNo = OPVP_PARAMERROR_0_2;
481+ *(opdev->globals.ErrorNo) = OPVP_PARAMERROR_0_2;
482 return -1;
483 }
484 if (brush->colorSpace == OPVP_CSPACE_DEVICEKRGB) {
485@@ -668,7 +742,7 @@ SetFillColorWrapper(opvp_dc_t printerContext, const opvp_brush_t *brush)
486 if ((int)brush->colorSpace
487 >= sizeof(cspace_1_0_to_0_2)/sizeof(OPVP_ColorSpace)) {
488 /* unknown color space */
489- *ErrorNo = OPVP_PARAMERROR_0_2;
490+ *(opdev->globals.ErrorNo) = OPVP_PARAMERROR_0_2;
491 return -1;
492 }
493 brush_0_2.colorSpace = cspace_1_0_to_0_2[brush->colorSpace];
494@@ -676,27 +750,28 @@ SetFillColorWrapper(opvp_dc_t printerContext, const opvp_brush_t *brush)
495 brush_0_2.yorg = brush->yorg;
496 brush_0_2.pbrush = (OPVP_BrushData *)brush->pbrush;
497 memcpy(brush_0_2.color,brush->color,sizeof(brush_0_2.color));
498- return apiEntry_0_2->SetFillColor(printerContext,&brush_0_2);
499+ return opdev->globals.apiEntry_0_2->SetFillColor(printerContext, &brush_0_2);
500 }
501
502 static opvp_result_t
503-SetBgColorWrapper(opvp_dc_t printerContext, const opvp_brush_t *brush)
504+SetBgColorWrapper(gx_device *dev, opvp_dc_t printerContext, const opvp_brush_t *brush)
505 {
506 OPVP_Brush brush_0_2;
507+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
508
509 if (brush == NULL) {
510- *ErrorNo = OPVP_PARAMERROR_0_2;
511+ *(opdev->globals.ErrorNo) = OPVP_PARAMERROR_0_2;
512 return -1;
513 }
514 if (brush->colorSpace == OPVP_CSPACE_DEVICEKRGB) {
515 /* 0.2 doesn't have OPVP_CSPACE_DEVICEKRGB */
516- *ErrorNo = OPVP_NOTSUPPORTED_0_2;
517+ *(opdev->globals.ErrorNo) = OPVP_NOTSUPPORTED_0_2;
518 return -1;
519 }
520 if ((int)brush->colorSpace
521 >= sizeof(cspace_1_0_to_0_2)/sizeof(OPVP_ColorSpace)) {
522 /* unknown color space */
523- *ErrorNo = OPVP_PARAMERROR_0_2;
524+ *(opdev->globals.ErrorNo) = OPVP_PARAMERROR_0_2;
525 return -1;
526 }
527 brush_0_2.colorSpace = cspace_1_0_to_0_2[brush->colorSpace];
528@@ -704,11 +779,12 @@ SetBgColorWrapper(opvp_dc_t printerContext, const opvp_brush_t *brush)
529 brush_0_2.yorg = brush->yorg;
530 brush_0_2.pbrush = (OPVP_BrushData *)brush->pbrush;
531 memcpy(brush_0_2.color,brush->color,sizeof(brush_0_2.color));
532- return apiEntry_0_2->SetBgColor(printerContext,&brush_0_2);
533+ return opdev->globals.apiEntry_0_2->SetBgColor(printerContext, &brush_0_2);
534 }
535
536 static opvp_result_t
537 DrawImageWrapper(
538+ gx_device *dev,
539 opvp_dc_t printerContext,
540 opvp_int_t sourceWidth,
541 opvp_int_t sourceHeight,
542@@ -723,30 +799,31 @@ DrawImageWrapper(
543 OPVP_ImageFormat iformat_0_2;
544 OPVP_PaintMode paintmode_0_2 = OPVP_paintModeTransparent;
545 int depth;
546+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
547
548 if (imageFormat == OPVP_IFORMAT_MASK) {
549- if (apiEntry_0_2->GetPaintMode != NULL) {
550- apiEntry_0_2->GetPaintMode(printerContext,
551+ if (opdev->globals.apiEntry_0_2->GetPaintMode != NULL) {
552+ opdev->globals.apiEntry_0_2->GetPaintMode(printerContext,
553 &paintmode_0_2);
554 }
555 if (paintmode_0_2 != OPVP_paintModeTransparent) {
556- if (apiEntry_0_2->SetROP != NULL) {
557- apiEntry_0_2->SetROP(printerContext,
558+ if (opdev->globals.apiEntry_0_2->SetROP != NULL) {
559+ opdev->globals.apiEntry_0_2->SetROP(printerContext,
560 OPVP_0_2_ROP_S);
561 }
562 }
563 else {
564- if (apiEntry_0_2->SetROP != NULL) {
565- apiEntry_0_2->SetROP(printerContext,
566+ if (opdev->globals.apiEntry_0_2->SetROP != NULL) {
567+ opdev->globals.apiEntry_0_2->SetROP(printerContext,
568 OPVP_0_2_ROP_OR);
569 }
570 }
571 depth = 1;
572 } else {
573- if (apiEntry_0_2->SetROP != NULL) {
574- apiEntry_0_2->SetROP(printerContext,OPVP_0_2_ROP_S);
575+ if (opdev->globals.apiEntry_0_2->SetROP != NULL) {
576+ opdev->globals.apiEntry_0_2->SetROP(printerContext,OPVP_0_2_ROP_S);
577 }
578- depth = colorDepth_0_2[colorSpace];
579+ depth = colorDepth_0_2[opdev->globals.colorSpace];
580 }
581
582 OPVP_I2FIX(0,rect.p0.x);
583@@ -755,17 +832,17 @@ DrawImageWrapper(
584 OPVP_I2FIX(destinationHeight,rect.p1.y);
585 if (imageFormat >= sizeof(iformat_1_0_to_0_2)/sizeof(OPVP_ImageFormat)) {
586 /* illegal image format */
587- *ErrorNo = OPVP_PARAMERROR_0_2;
588+ *(opdev->globals.ErrorNo) = OPVP_PARAMERROR_0_2;
589 return -1;
590 }
591 iformat_0_2 = iformat_1_0_to_0_2[imageFormat];
592- r = apiEntry_0_2->DrawImage(printerContext,sourceWidth,sourceHeight,
593+ r = opdev->globals.apiEntry_0_2->DrawImage(printerContext,sourceWidth,sourceHeight,
594 depth,iformat_0_2,rect,
595 sourcePitch*sourceHeight,
596 /* remove const */ (void *)imagedata);
597
598- if (apiEntry_0_2->SetROP != NULL) {
599- apiEntry_0_2->SetROP(printerContext,OPVP_0_2_ROP_P);
600+ if (opdev->globals.apiEntry_0_2->SetROP != NULL) {
601+ opdev->globals.apiEntry_0_2->SetROP(printerContext,OPVP_0_2_ROP_P);
602 }
603
604 return r;
605@@ -773,6 +850,7 @@ DrawImageWrapper(
606
607 static opvp_result_t
608 StartDrawImageWrapper(
609+ gx_device *dev,
610 opvp_dc_t printerContext,
611 opvp_int_t sourceWidth,
612 opvp_int_t sourceHeight,
613@@ -786,28 +864,29 @@ StartDrawImageWrapper(
614 OPVP_ImageFormat iformat_0_2;
615 OPVP_PaintMode paintmode_0_2 = OPVP_paintModeTransparent;
616 int depth;
617+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
618
619 if (imageFormat == OPVP_IFORMAT_MASK) {
620- if (apiEntry_0_2->GetPaintMode != NULL) {
621- apiEntry_0_2->GetPaintMode(printerContext,
622+ if (opdev->globals.apiEntry_0_2->GetPaintMode != NULL) {
623+ opdev->globals.apiEntry_0_2->GetPaintMode(printerContext,
624 &paintmode_0_2);
625 }
626 if (paintmode_0_2 != OPVP_paintModeTransparent) {
627- if (apiEntry_0_2->SetROP != NULL) {
628- apiEntry_0_2->SetROP(printerContext,OPVP_0_2_ROP_S);
629+ if (opdev->globals.apiEntry_0_2->SetROP != NULL) {
630+ opdev->globals.apiEntry_0_2->SetROP(printerContext,OPVP_0_2_ROP_S);
631 }
632 }
633 else {
634- if (apiEntry_0_2->SetROP != NULL) {
635- apiEntry_0_2->SetROP(printerContext,OPVP_0_2_ROP_OR);
636+ if (opdev->globals.apiEntry_0_2->SetROP != NULL) {
637+ opdev->globals.apiEntry_0_2->SetROP(printerContext,OPVP_0_2_ROP_OR);
638 }
639 }
640 depth = 1;
641 } else {
642- if (apiEntry_0_2->SetROP != NULL) {
643- apiEntry_0_2->SetROP(printerContext,OPVP_0_2_ROP_S);
644+ if (opdev->globals.apiEntry_0_2->SetROP != NULL) {
645+ opdev->globals.apiEntry_0_2->SetROP(printerContext,OPVP_0_2_ROP_S);
646 }
647- depth = colorDepth_0_2[colorSpace];
648+ depth = colorDepth_0_2[opdev->globals.colorSpace];
649 }
650
651 OPVP_I2FIX(0,rect.p0.x);
652@@ -816,310 +895,518 @@ StartDrawImageWrapper(
653 OPVP_I2FIX(destinationHeight,rect.p1.y);
654 if (imageFormat >= sizeof(iformat_1_0_to_0_2)/sizeof(OPVP_ImageFormat)) {
655 /* illegal image format */
656- *ErrorNo = OPVP_PARAMERROR_0_2;
657+ *(opdev->globals.ErrorNo) = OPVP_PARAMERROR_0_2;
658 return -1;
659 }
660 iformat_0_2 = iformat_1_0_to_0_2[imageFormat];
661- r = apiEntry_0_2->StartDrawImage(printerContext,
662- sourceWidth,sourceHeight,
663- depth,iformat_0_2,rect);
664+ r = opdev->globals.apiEntry_0_2->StartDrawImage(printerContext,
665+ sourceWidth, sourceHeight,
666+ depth, iformat_0_2, rect);
667
668 return r;
669 }
670
671 static opvp_result_t
672-EndDrawImageWrapper(opvp_dc_t printerContext)
673+EndDrawImageWrapper(gx_device *dev, opvp_dc_t printerContext)
674 {
675 int r;
676+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
677
678- r = apiEntry_0_2->EndDrawImage(printerContext);
679+ r = opdev->globals.apiEntry_0_2->EndDrawImage(printerContext);
680
681 /* make sure rop is pattern copy */
682- if (apiEntry_0_2->SetROP != NULL) {
683- apiEntry_0_2->SetROP(printerContext,OPVP_0_2_ROP_P);
684+ if (opdev->globals.apiEntry_0_2->SetROP != NULL) {
685+ opdev->globals.apiEntry_0_2->SetROP(printerContext,OPVP_0_2_ROP_P);
686 }
687
688 return r;
689 }
690
691+/* Not used
692 static opvp_result_t
693 QueryDeviceCapabilityWrapper(
694+ gx_device *dev,
695 opvp_dc_t printerContext,
696 opvp_queryinfoflags_t queryflag,
697 opvp_int_t *buflen,
698 opvp_char_t *infoBuf)
699 {
700- return apiEntry_0_2->QueryDeviceCapability(printerContext,queryflag,
701+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
702+
703+ return opdev->globals.apiEntry_0_2->QueryDeviceCapability(printerContext,queryflag,
704 *buflen,(char *)infoBuf);
705 }
706
707 static opvp_result_t
708 QueryDeviceInfoWrapper(
709+ gx_device *dev,
710 opvp_dc_t printerContext,
711 opvp_queryinfoflags_t queryflag,
712 opvp_int_t *buflen,
713 opvp_char_t *infoBuf)
714 {
715+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
716+
717 if (queryflag & OPVP_QF_MEDIACOPY) {
718- *ErrorNo = OPVP_NOTSUPPORTED;
719+ *(opdev->globals.ErrorNo) = OPVP_NOTSUPPORTED;
720 return -1;
721 }
722 if (queryflag & OPVP_QF_PRINTREGION) {
723 queryflag &= ~OPVP_QF_PRINTREGION;
724 queryflag |= 0x0020000;
725 }
726- return apiEntry_0_2->QueryDeviceInfo(printerContext,queryflag,
727- *buflen,(char *)infoBuf);
728+ return opdev->globals.apiEntry_0_2->QueryDeviceInfo(printerContext, queryflag,
729+ *buflen, (char *)infoBuf);
730 }
731+*/
732
733 static opvp_result_t
734-SetLineDashWrapper(opvp_dc_t printerContext, opvp_int_t num,
735+SetLineDashWrapper(gx_device *dev, opvp_dc_t printerContext, opvp_int_t num,
736 const opvp_fix_t *pdash)
737 {
738- return apiEntry_0_2->SetLineDash(printerContext,
739- /* remove const */ (OPVP_Fix *)pdash,num);
740+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
741+
742+ return opdev->globals.apiEntry_0_2->SetLineDash(printerContext, num,
743+ /* remove const */ (OPVP_Fix *)pdash);
744 }
745
746+/* Not used
747 static opvp_result_t
748-GetLineDashWrapper(opvp_dc_t printerContext, opvp_int_t *pnum,
749+GetLineDashWrapper(gx_device* dev, opvp_dc_t printerContext, opvp_int_t *pnum,
750 opvp_fix_t *pdash)
751 {
752- return apiEntry_0_2->GetLineDash(printerContext,
753+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
754+
755+ return opdev->globals.apiEntry_0_2->GetLineDash(printerContext,
756 pdash,pnum);
757 }
758+*/
759
760 static opvp_dc_t
761 OpenPrinterWrapper(
762+ gx_device *dev,
763 opvp_int_t outputFD,
764 const opvp_char_t *printerModel,
765 const opvp_int_t apiVersion[2],
766 opvp_api_procs_t **apiProcs)
767 {
768+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
769+
770 opvp_dc_t dc = -1;
771
772- if (OpenPrinter != NULL) {
773- dc = (*OpenPrinter)(outputFD,printerModel,apiVersion,apiProcs);
774+ if (opdev->globals.OpenPrinter != NULL) {
775+ dc = (*(opdev->globals.OpenPrinter))(outputFD, printerModel, apiVersion, apiProcs);
776 } else {
777 /* try version 0.2 */
778
779- if (OpenPrinter_0_2 != NULL) {
780+ if (opdev->globals.OpenPrinter_0_2 != NULL) {
781 static opvp_api_procs_t tEntry;
782- int nApiEntry;
783+ int nApiEntry; /* Alias with prior global. Kept as is */
784
785- dc = (*OpenPrinter_0_2)(outputFD,
786+ dc = (*(opdev->globals.OpenPrinter_0_2))(outputFD,
787 /* remove const */
788 (char *)printerModel,
789- &nApiEntry,&apiEntry_0_2);
790+ &nApiEntry,
791+ &(opdev->globals.apiEntry_0_2));
792 /* setting functions */
793 tEntry.opvpClosePrinter
794- = apiEntry_0_2->ClosePrinter;
795+ = opdev->globals.apiEntry_0_2->ClosePrinter;
796 tEntry.opvpStartJob
797 = (opvp_result_t (*)(opvp_int_t,
798 const opvp_char_t*))
799- apiEntry_0_2->StartJob;
800- tEntry.opvpEndJob = apiEntry_0_2->EndJob;
801+ opdev->globals.apiEntry_0_2->StartJob;
802+ tEntry.opvpEndJob = opdev->globals.apiEntry_0_2->EndJob;
803 tEntry.opvpAbortJob = NULL;
804 tEntry.opvpStartDoc
805 = (opvp_result_t (*)(opvp_dc_t,
806 const opvp_char_t*))
807- apiEntry_0_2->StartDoc;
808- tEntry.opvpEndDoc = apiEntry_0_2->EndDoc;
809- if (apiEntry_0_2->StartPage != NULL) {
810- tEntry.opvpStartPage = StartPageWrapper;
811- } else {
812- tEntry.opvpStartPage = NULL;
813- }
814- tEntry.opvpEndPage = apiEntry_0_2->EndPage;
815-
816- if (apiEntry_0_2->QueryDeviceCapability != NULL) {
817- tEntry.opvpQueryDeviceCapability
818- = QueryDeviceCapabilityWrapper;
819- } else {
820- tEntry.opvpQueryDeviceCapability = NULL;
821- }
822-
823- if (apiEntry_0_2->QueryDeviceInfo != NULL) {
824- tEntry.opvpQueryDeviceInfo = QueryDeviceInfoWrapper;
825- } else {
826- tEntry.opvpQueryDeviceInfo = NULL;
827- }
828-
829- tEntry.opvpResetCTM = apiEntry_0_2->ResetCTM;
830+ opdev->globals.apiEntry_0_2->StartDoc;
831+ tEntry.opvpEndDoc = opdev->globals.apiEntry_0_2->EndDoc;
832+ tEntry.opvpStartPage = NULL;
833+ tEntry.opvpEndPage = opdev->globals.apiEntry_0_2->EndPage;
834+ tEntry.opvpQueryDeviceCapability = NULL;
835+ tEntry.opvpQueryDeviceInfo = NULL;
836+ tEntry.opvpResetCTM = opdev->globals.apiEntry_0_2->ResetCTM;
837 tEntry.opvpSetCTM = (opvp_result_t (*)(opvp_dc_t,
838 const opvp_ctm_t*))
839- apiEntry_0_2->SetCTM;
840+ opdev->globals.apiEntry_0_2->SetCTM;
841 tEntry.opvpGetCTM = (opvp_result_t (*)(opvp_dc_t,opvp_ctm_t*))
842- apiEntry_0_2->GetCTM;
843- if (apiEntry_0_2->InitGS != NULL) {
844- tEntry.opvpInitGS = InitGSWrapper;
845- } else {
846- tEntry.opvpInitGS = NULL;
847- }
848- tEntry.opvpSaveGS = apiEntry_0_2->SaveGS;
849- tEntry.opvpRestoreGS = apiEntry_0_2->RestoreGS;
850- if (apiEntry_0_2->QueryColorSpace != NULL) {
851- tEntry.opvpQueryColorSpace = QueryColorSpaceWrapper;
852- } else {
853- tEntry.opvpQueryColorSpace = NULL;
854- }
855- if (apiEntry_0_2->SetColorSpace != NULL) {
856- tEntry.opvpSetColorSpace = SetColorSpaceWrapper;
857- } else {
858- tEntry.opvpSetColorSpace = NULL;
859- }
860- if (apiEntry_0_2->GetColorSpace != NULL) {
861- tEntry.opvpGetColorSpace = GetColorSpaceWrapper;
862- } else {
863- tEntry.opvpGetColorSpace = NULL;
864- }
865+ opdev->globals.apiEntry_0_2->GetCTM;
866+ tEntry.opvpInitGS = NULL;
867+ tEntry.opvpSaveGS = opdev->globals.apiEntry_0_2->SaveGS;
868+ tEntry.opvpRestoreGS = opdev->globals.apiEntry_0_2->RestoreGS;
869+ tEntry.opvpQueryColorSpace = NULL;
870+ tEntry.opvpSetColorSpace = NULL;
871+ tEntry.opvpGetColorSpace = NULL;
872+
873 tEntry.opvpSetFillMode
874 = (opvp_result_t (*)(opvp_dc_t,opvp_fillmode_t))
875- apiEntry_0_2->SetFillMode;
876+ opdev->globals.apiEntry_0_2->SetFillMode;
877 tEntry.opvpGetFillMode
878 = (opvp_result_t (*)(opvp_dc_t,opvp_fillmode_t*))
879- apiEntry_0_2->GetFillMode;
880- tEntry.opvpSetAlphaConstant = apiEntry_0_2->SetAlphaConstant;
881- tEntry.opvpGetAlphaConstant = apiEntry_0_2->GetAlphaConstant;
882- tEntry.opvpSetLineWidth = apiEntry_0_2->SetLineWidth;
883- tEntry.opvpGetLineWidth = apiEntry_0_2->GetLineWidth;
884- if (apiEntry_0_2->SetLineDash != NULL) {
885- tEntry.opvpSetLineDash = SetLineDashWrapper;
886- } else {
887- tEntry.opvpSetLineDash = NULL;
888- }
889- if (apiEntry_0_2->GetLineDash != NULL) {
890- tEntry.opvpGetLineDash = GetLineDashWrapper;
891- } else {
892- tEntry.opvpGetLineDash = NULL;
893- }
894+ opdev->globals.apiEntry_0_2->GetFillMode;
895+ tEntry.opvpSetAlphaConstant = opdev->globals.apiEntry_0_2->SetAlphaConstant;
896+ tEntry.opvpGetAlphaConstant = opdev->globals.apiEntry_0_2->GetAlphaConstant;
897+ tEntry.opvpSetLineWidth = opdev->globals.apiEntry_0_2->SetLineWidth;
898+ tEntry.opvpGetLineWidth = opdev->globals.apiEntry_0_2->GetLineWidth;
899+ tEntry.opvpSetLineDash = NULL;
900+ tEntry.opvpGetLineDash = NULL;
901+
902 tEntry.opvpSetLineDashOffset
903- = apiEntry_0_2->SetLineDashOffset;
904+ = opdev->globals.apiEntry_0_2->SetLineDashOffset;
905 tEntry.opvpGetLineDashOffset
906- = apiEntry_0_2->GetLineDashOffset;
907+ = opdev->globals.apiEntry_0_2->GetLineDashOffset;
908 tEntry.opvpSetLineStyle
909 = (opvp_result_t (*)(opvp_dc_t,opvp_linestyle_t))
910- apiEntry_0_2->SetLineStyle;
911+ opdev->globals.apiEntry_0_2->SetLineStyle;
912 tEntry.opvpGetLineStyle
913 = (opvp_result_t (*)(opvp_dc_t,opvp_linestyle_t*))
914- apiEntry_0_2->GetLineStyle;
915+ opdev->globals.apiEntry_0_2->GetLineStyle;
916 tEntry.opvpSetLineCap
917 = (opvp_result_t (*)(opvp_dc_t,opvp_linecap_t))
918- apiEntry_0_2->SetLineCap;
919+ opdev->globals.apiEntry_0_2->SetLineCap;
920 tEntry.opvpGetLineCap
921 = (opvp_result_t (*)(opvp_dc_t,opvp_linecap_t*))
922- apiEntry_0_2->GetLineCap;
923+ opdev->globals.apiEntry_0_2->GetLineCap;
924 tEntry.opvpSetLineJoin
925 = (opvp_result_t (*)(opvp_dc_t,opvp_linejoin_t))
926- apiEntry_0_2->SetLineJoin;
927+ opdev->globals.apiEntry_0_2->SetLineJoin;
928 tEntry.opvpGetLineJoin
929 = (opvp_result_t (*)(opvp_dc_t,opvp_linejoin_t*))
930- apiEntry_0_2->GetLineJoin;
931- tEntry.opvpSetMiterLimit = apiEntry_0_2->SetMiterLimit;
932- tEntry.opvpGetMiterLimit = apiEntry_0_2->GetMiterLimit;
933+ opdev->globals.apiEntry_0_2->GetLineJoin;
934+ tEntry.opvpSetMiterLimit = opdev->globals.apiEntry_0_2->SetMiterLimit;
935+ tEntry.opvpGetMiterLimit = opdev->globals.apiEntry_0_2->GetMiterLimit;
936 tEntry.opvpSetPaintMode
937 = (opvp_result_t (*)(opvp_dc_t,opvp_paintmode_t))
938- apiEntry_0_2->SetPaintMode;
939+ opdev->globals.apiEntry_0_2->SetPaintMode;
940 tEntry.opvpGetPaintMode
941 = (opvp_result_t (*)(opvp_dc_t,opvp_paintmode_t*))
942- apiEntry_0_2->GetPaintMode;
943- if (apiEntry_0_2->SetStrokeColor != NULL) {
944- tEntry.opvpSetStrokeColor = SetStrokeColorWrapper;
945- } else {
946- tEntry.opvpSetStrokeColor = NULL;
947- }
948- if (apiEntry_0_2->SetFillColor != NULL) {
949- tEntry.opvpSetFillColor = SetFillColorWrapper;
950- } else {
951- tEntry.opvpSetFillColor = NULL;
952- }
953- if (apiEntry_0_2->SetBgColor != NULL) {
954- tEntry.opvpSetBgColor = SetBgColorWrapper;
955- } else {
956- tEntry.opvpSetBgColor = NULL;
957- }
958- tEntry.opvpNewPath = apiEntry_0_2->NewPath;
959- tEntry.opvpEndPath = apiEntry_0_2->EndPath;
960- tEntry.opvpStrokePath = apiEntry_0_2->StrokePath;
961- tEntry.opvpFillPath = apiEntry_0_2->FillPath;
962- tEntry.opvpStrokeFillPath = apiEntry_0_2->StrokeFillPath;
963+ opdev->globals.apiEntry_0_2->GetPaintMode;
964+ tEntry.opvpSetStrokeColor = NULL;
965+ tEntry.opvpSetFillColor = NULL;
966+ tEntry.opvpSetBgColor = NULL;
967+ tEntry.opvpNewPath = opdev->globals.apiEntry_0_2->NewPath;
968+ tEntry.opvpEndPath = opdev->globals.apiEntry_0_2->EndPath;
969+ tEntry.opvpStrokePath = opdev->globals.apiEntry_0_2->StrokePath;
970+ tEntry.opvpFillPath = opdev->globals.apiEntry_0_2->FillPath;
971+ tEntry.opvpStrokeFillPath = opdev->globals.apiEntry_0_2->StrokeFillPath;
972 tEntry.opvpSetClipPath
973 = (opvp_result_t (*)(opvp_dc_t,opvp_cliprule_t))
974- apiEntry_0_2->SetClipPath;
975- tEntry.opvpResetClipPath = apiEntry_0_2->ResetClipPath;
976- tEntry.opvpSetCurrentPoint = apiEntry_0_2->SetCurrentPoint;
977+ opdev->globals.apiEntry_0_2->SetClipPath;
978+ tEntry.opvpResetClipPath = opdev->globals.apiEntry_0_2->ResetClipPath;
979+ tEntry.opvpSetCurrentPoint = opdev->globals.apiEntry_0_2->SetCurrentPoint;
980 tEntry.opvpLinePath
981 = (opvp_result_t (*)(opvp_dc_t,
982 opvp_pathmode_t,opvp_int_t,
983 const opvp_point_t*))
984- apiEntry_0_2->LinePath;
985+ opdev->globals.apiEntry_0_2->LinePath;
986 tEntry.opvpPolygonPath
987 = (opvp_result_t (*)(opvp_dc_t,opvp_int_t,
988 const opvp_int_t*,
989 const opvp_point_t*))
990- apiEntry_0_2->PolygonPath;
991+ opdev->globals.apiEntry_0_2->PolygonPath;
992 tEntry.opvpRectanglePath
993 = (opvp_result_t (*)(opvp_dc_t,opvp_int_t,
994 const opvp_rectangle_t*))
995- apiEntry_0_2->RectanglePath;
996+ opdev->globals.apiEntry_0_2->RectanglePath;
997 tEntry.opvpRoundRectanglePath
998 = (opvp_result_t (*)(opvp_dc_t,opvp_int_t,
999 const opvp_roundrectangle_t*))
1000- apiEntry_0_2->RoundRectanglePath;
1001+ opdev->globals.apiEntry_0_2->RoundRectanglePath;
1002 tEntry.opvpBezierPath
1003 = (opvp_result_t (*)(opvp_dc_t,opvp_int_t,
1004 const opvp_point_t*))
1005- apiEntry_0_2->BezierPath;
1006+ opdev->globals.apiEntry_0_2->BezierPath;
1007 tEntry.opvpArcPath
1008 = (opvp_result_t (*)(opvp_dc_t,opvp_arcmode_t,
1009 opvp_arcdir_t,opvp_fix_t,opvp_fix_t,opvp_fix_t,
1010 opvp_fix_t,opvp_fix_t,opvp_fix_t,opvp_fix_t,
1011- opvp_fix_t))apiEntry_0_2->ArcPath;
1012- if (apiEntry_0_2->DrawImage != NULL) {
1013- tEntry.opvpDrawImage = DrawImageWrapper;
1014- } else {
1015- tEntry.opvpDrawImage = NULL;
1016- }
1017- if (apiEntry_0_2->StartDrawImage != NULL) {
1018- tEntry.opvpStartDrawImage = StartDrawImageWrapper;
1019- } else {
1020- tEntry.opvpStartDrawImage = NULL;
1021- }
1022+ opvp_fix_t))opdev->globals.apiEntry_0_2->ArcPath;
1023+ tEntry.opvpDrawImage = NULL;
1024+ tEntry.opvpStartDrawImage = NULL;
1025 tEntry.opvpTransferDrawImage =
1026 (opvp_result_t (*)(opvp_dc_t,opvp_int_t,const void*))
1027- apiEntry_0_2->TransferDrawImage;
1028- if (apiEntry_0_2->EndDrawImage != NULL) {
1029- tEntry.opvpEndDrawImage = EndDrawImageWrapper;
1030- } else {
1031- tEntry.opvpEndDrawImage = NULL;
1032- }
1033- tEntry.opvpStartScanline = apiEntry_0_2->StartScanline;
1034+ opdev->globals.apiEntry_0_2->TransferDrawImage;
1035+ tEntry.opvpEndDrawImage = NULL;
1036+ tEntry.opvpStartScanline = opdev->globals.apiEntry_0_2->StartScanline;
1037 tEntry.opvpScanline
1038 = (opvp_result_t (*)(opvp_dc_t,opvp_int_t,
1039 const opvp_int_t*))
1040- apiEntry_0_2->Scanline;
1041- tEntry.opvpEndScanline = apiEntry_0_2->EndScanline;
1042- tEntry.opvpStartRaster = apiEntry_0_2->StartRaster;
1043+ opdev->globals.apiEntry_0_2->Scanline;
1044+ tEntry.opvpEndScanline = opdev->globals.apiEntry_0_2->EndScanline;
1045+ tEntry.opvpStartRaster = opdev->globals.apiEntry_0_2->StartRaster;
1046 tEntry.opvpTransferRasterData
1047 = (opvp_result_t (*)(opvp_dc_t,opvp_int_t,
1048 const opvp_byte_t*))
1049- apiEntry_0_2->TransferRasterData;
1050- tEntry.opvpSkipRaster = apiEntry_0_2->SkipRaster;
1051- tEntry.opvpEndRaster = apiEntry_0_2->EndRaster;
1052- tEntry.opvpStartStream = apiEntry_0_2->StartStream;
1053+ opdev->globals.apiEntry_0_2->TransferRasterData;
1054+ tEntry.opvpSkipRaster = opdev->globals.apiEntry_0_2->SkipRaster;
1055+ tEntry.opvpEndRaster = opdev->globals.apiEntry_0_2->EndRaster;
1056+ tEntry.opvpStartStream = opdev->globals.apiEntry_0_2->StartStream;
1057 tEntry.opvpTransferStreamData
1058 = (opvp_result_t (*)(opvp_dc_t,opvp_int_t,
1059 const void *))
1060- apiEntry_0_2->TransferStreamData;
1061- tEntry.opvpEndStream = apiEntry_0_2->EndStream;
1062+ opdev->globals.apiEntry_0_2->TransferStreamData;
1063+ tEntry.opvpEndStream = opdev->globals.apiEntry_0_2->EndStream;
1064
1065 *apiProcs = &tEntry;
1066
1067- GetLastError = GetLastError_0_2;
1068+ opdev->globals.GetLastError = GetLastError_0_2;
1069 }
1070 }
1071 return dc;
1072 }
1073
1074+/* Set of methods to separate the 0.2 and 1.0 calls AND deal with the prior use of globals */
1075+static opvp_result_t
1076+gsopvpStartPage(gx_device* dev, opvp_dc_t printerContext, const opvp_char_t* pageInfo)
1077+{
1078+ gx_device_opvp* opdev = (gx_device_opvp*)dev;
1079+
1080+ if (opdev->globals.apiEntry_0_2 != NULL &&
1081+ opdev->globals.apiEntry_0_2->StartPage) {
1082+ return StartPageWrapper(dev, printerContext, pageInfo);
1083+ } else if (opdev->globals.apiEntry->opvpStartPage) {
1084+ return opdev->globals.apiEntry->opvpStartPage(printerContext, pageInfo);
1085+ } else
1086+ return OPVP_FATALERROR;
1087+}
1088+
1089+/* Not used
1090+static opvp_result_t
1091+gsopvpQueryDeviceCapability(
1092+ gx_device* dev,
1093+ opvp_dc_t printerContext,
1094+ opvp_queryinfoflags_t queryflag,
1095+ opvp_int_t* buflen,
1096+ opvp_char_t* infoBuf)
1097+{
1098+ gx_device_opvp* opdev = (gx_device_opvp*)dev;
1099+
1100+ if (opdev->globals.apiEntry_0_2 != NULL &&
1101+ opdev->globals.apiEntry_0_2->QueryDeviceCapability) {
1102+ return QueryDeviceCapabilityWrapper(dev, printerContext, queryflag, buflen, infoBuf);
1103+ } else if (opdev->globals.apiEntry->opvpQueryDeviceCapability) {
1104+ return opdev->globals.apiEntry->opvpQueryDeviceCapability(printerContext, queryflag, buflen, infoBuf);
1105+ } else
1106+ return OPVP_FATALERROR;
1107+}
1108+
1109+static opvp_result_t
1110+gsopvpQueryDeviceInfo(
1111+ gx_device* dev,
1112+ opvp_dc_t printerContext,
1113+ opvp_queryinfoflags_t queryflag,
1114+ opvp_int_t* buflen,
1115+ opvp_char_t* infoBuf)
1116+{
1117+ gx_device_opvp* opdev = (gx_device_opvp*)dev;
1118+
1119+ if (opdev->globals.apiEntry_0_2 != NULL &&
1120+ opdev->globals.apiEntry_0_2->QueryDeviceCapability) {
1121+ return QueryDeviceInfoWrapper(dev, printerContext, queryflag, buflen, infoBuf);
1122+ } else if (opdev->globals.apiEntry->opvpQueryDeviceCapability) {
1123+ return opdev->globals.apiEntry->opvpQueryDeviceInfo(printerContext, queryflag, buflen, infoBuf);
1124+ } else
1125+ return OPVP_FATALERROR;
1126+}
1127+*/
1128+
1129+static opvp_result_t
1130+gsopvpInitGS(gx_device* dev, opvp_dc_t printerContext)
1131+{
1132+ gx_device_opvp* opdev = (gx_device_opvp*)dev;
1133+
1134+ if (opdev->globals.apiEntry_0_2 != NULL &&
1135+ opdev->globals.apiEntry_0_2->InitGS) {
1136+ return InitGSWrapper(dev, printerContext);
1137+ } else if (opdev->globals.apiEntry->opvpInitGS) {
1138+ return opdev->globals.apiEntry->opvpInitGS(printerContext);
1139+ } else
1140+ return OPVP_FATALERROR;
1141+}
1142+
1143+static opvp_result_t
1144+gsopvpQueryColorSpace(gx_device* dev, opvp_dc_t printerContext, opvp_int_t* pnum,
1145+ opvp_cspace_t* pcspace)
1146+{
1147+ gx_device_opvp* opdev = (gx_device_opvp*)dev;
1148+
1149+ if (opdev->globals.apiEntry_0_2 != NULL &&
1150+ opdev->globals.apiEntry_0_2->QueryColorSpace) {
1151+ return QueryColorSpaceWrapper(dev, printerContext, pnum, pcspace);
1152+ } else if (opdev->globals.apiEntry->opvpQueryColorSpace) {
1153+ return opdev->globals.apiEntry->opvpQueryColorSpace(printerContext, pnum, pcspace);
1154+ } else
1155+ return OPVP_FATALERROR;
1156+}
1157+
1158+static opvp_result_t
1159+gsopvpSetColorSpace(gx_device* dev, opvp_dc_t printerContext, opvp_cspace_t cspace)
1160+{
1161+ gx_device_opvp* opdev = (gx_device_opvp*)dev;
1162+
1163+ if (opdev->globals.apiEntry_0_2 != NULL &&
1164+ opdev->globals.apiEntry_0_2->SetColorSpace) {
1165+ return SetColorSpaceWrapper(dev, printerContext, cspace);
1166+ } else if (opdev->globals.apiEntry->opvpQueryColorSpace) {
1167+ return opdev->globals.apiEntry->opvpSetColorSpace(printerContext, cspace);
1168+ } else
1169+ return OPVP_FATALERROR;
1170+}
1171+
1172+/* Not used
1173+static opvp_result_t
1174+gsopvpGetColorSpace(gx_device* dev, opvp_dc_t printerContext, opvp_cspace_t* pcspace)
1175+{
1176+ gx_device_opvp* opdev = (gx_device_opvp*)dev;
1177+
1178+ if (opdev->globals.apiEntry_0_2 != NULL &&
1179+ opdev->globals.apiEntry_0_2->GetColorSpace) {
1180+ return GetColorSpaceWrapper(dev, printerContext, pcspace);
1181+ } else if (opdev->globals.apiEntry->opvpGetColorSpace) {
1182+ return opdev->globals.apiEntry->opvpGetColorSpace(printerContext, pcspace);
1183+ } else
1184+ return OPVP_FATALERROR;
1185+}
1186+*/
1187+
1188+static opvp_result_t
1189+gsopvpSetLineDash(gx_device* dev, opvp_dc_t printerContext, opvp_int_t num,
1190+ const opvp_fix_t* pdash)
1191+{
1192+ gx_device_opvp* opdev = (gx_device_opvp*)dev;
1193+
1194+ if (opdev->globals.apiEntry_0_2 != NULL &&
1195+ opdev->globals.apiEntry_0_2->SetLineDash) {
1196+ return SetLineDashWrapper(dev, printerContext, num, pdash);
1197+ } else if (opdev->globals.apiEntry->opvpSetLineDash) {
1198+ return opdev->globals.apiEntry->opvpSetLineDash(printerContext, num, pdash);
1199+ } else
1200+ return OPVP_FATALERROR;
1201+}
1202+
1203+/* Not used
1204+static opvp_result_t
1205+gsopvpGetLineDash(gx_device* dev, opvp_dc_t printerContext, opvp_int_t* pnum,
1206+ opvp_fix_t* pdash)
1207+{
1208+ gx_device_opvp* opdev = (gx_device_opvp*)dev;
1209+
1210+ if (opdev->globals.apiEntry_0_2 != NULL &&
1211+ opdev->globals.apiEntry_0_2->GetLineDash) {
1212+ return GetLineDashWrapper(dev, printerContext, pnum, pdash);
1213+ } else if (opdev->globals.apiEntry->opvpGetLineDash) {
1214+ return opdev->globals.apiEntry->opvpGetLineDash(printerContext, pnum, pdash);
1215+ } else
1216+ return OPVP_FATALERROR;
1217+}
1218+*/
1219+
1220+static opvp_result_t
1221+gsopvpSetStrokeColor(gx_device* dev, opvp_dc_t printerContext, const opvp_brush_t* brush)
1222+{
1223+ gx_device_opvp* opdev = (gx_device_opvp*)dev;
1224+
1225+ if (opdev->globals.apiEntry_0_2 != NULL &&
1226+ opdev->globals.apiEntry_0_2->SetStrokeColor) {
1227+ return SetStrokeColorWrapper(dev, printerContext, brush);
1228+ } else if (opdev->globals.apiEntry->opvpSetStrokeColor) {
1229+ return opdev->globals.apiEntry->opvpSetStrokeColor(printerContext, brush);
1230+ } else
1231+ return OPVP_FATALERROR;
1232+}
1233+
1234+static opvp_result_t
1235+gsopvpSetFillColor(gx_device* dev, opvp_dc_t printerContext, const opvp_brush_t* brush)
1236+{
1237+ gx_device_opvp* opdev = (gx_device_opvp*)dev;
1238+
1239+ if (opdev->globals.apiEntry_0_2 != NULL &&
1240+ opdev->globals.apiEntry_0_2->SetFillColor) {
1241+ return SetFillColorWrapper(dev, printerContext, brush);
1242+ } else if (opdev->globals.apiEntry->opvpSetFillColor) {
1243+ return opdev->globals.apiEntry->opvpSetFillColor(printerContext, brush);
1244+ } else
1245+ return OPVP_FATALERROR;
1246+}
1247+
1248+static opvp_result_t
1249+gsopvpSetBgColor(gx_device* dev, opvp_dc_t printerContext, const opvp_brush_t* brush)
1250+{
1251+ gx_device_opvp* opdev = (gx_device_opvp*)dev;
1252+
1253+ if (opdev->globals.apiEntry_0_2 != NULL &&
1254+ opdev->globals.apiEntry_0_2->SetBgColor) {
1255+ return SetBgColorWrapper(dev, printerContext, brush);
1256+ } else if (opdev->globals.apiEntry->opvpSetBgColor) {
1257+ return opdev->globals.apiEntry->opvpSetBgColor(printerContext, brush);
1258+ } else
1259+ return OPVP_FATALERROR;
1260+}
1261+
1262+static opvp_result_t
1263+gsopvpDrawImage(
1264+ gx_device* dev,
1265+ opvp_dc_t printerContext,
1266+ opvp_int_t sourceWidth,
1267+ opvp_int_t sourceHeight,
1268+ opvp_int_t sourcePitch,
1269+ opvp_imageformat_t imageFormat,
1270+ opvp_int_t destinationWidth,
1271+ opvp_int_t destinationHeight,
1272+ const void* imagedata)
1273+{
1274+ gx_device_opvp* opdev = (gx_device_opvp*)dev;
1275+
1276+ if (opdev->globals.apiEntry_0_2 != NULL &&
1277+ opdev->globals.apiEntry_0_2->DrawImage) {
1278+ return DrawImageWrapper(dev, printerContext, sourceWidth, sourceHeight,
1279+ sourcePitch, imageFormat, destinationWidth, destinationHeight, imagedata);
1280+ } else if (opdev->globals.apiEntry->opvpDrawImage) {
1281+ return opdev->globals.apiEntry->opvpDrawImage(printerContext, sourceWidth, sourceHeight,
1282+ sourcePitch, imageFormat, destinationWidth, destinationHeight, imagedata);
1283+ } else
1284+ return OPVP_FATALERROR;
1285+}
1286+
1287+static opvp_result_t
1288+gsopvpStartDrawImage(
1289+ gx_device* dev,
1290+ opvp_dc_t printerContext,
1291+ opvp_int_t sourceWidth,
1292+ opvp_int_t sourceHeight,
1293+ opvp_int_t sourcePitch,
1294+ opvp_imageformat_t imageFormat,
1295+ opvp_int_t destinationWidth,
1296+ opvp_int_t destinationHeight)
1297+{
1298+ gx_device_opvp* opdev = (gx_device_opvp*)dev;
1299+
1300+ if (opdev->globals.apiEntry_0_2 != NULL &&
1301+ opdev->globals.apiEntry_0_2->StartDrawImage) {
1302+ return StartDrawImageWrapper(dev, printerContext, sourceWidth, sourceHeight,
1303+ sourcePitch, imageFormat, destinationWidth, destinationHeight);
1304+ } else if (opdev->globals.apiEntry->opvpStartDrawImage) {
1305+ return opdev->globals.apiEntry->opvpStartDrawImage(printerContext, sourceWidth, sourceHeight,
1306+ sourcePitch, imageFormat, destinationWidth, destinationHeight);
1307+ } else
1308+ return OPVP_FATALERROR;
1309+}
1310+
1311+static opvp_result_t
1312+gsopvpEndDrawImage(gx_device* dev, opvp_dc_t printerContext)
1313+{
1314+ gx_device_opvp* opdev = (gx_device_opvp*)dev;
1315+
1316+ if (opdev->globals.apiEntry_0_2 != NULL &&
1317+ opdev->globals.apiEntry_0_2->EndDrawImage) {
1318+ return EndDrawImageWrapper(dev, printerContext);
1319+ } else if (opdev->globals.apiEntry->opvpEndDrawImage) {
1320+ return opdev->globals.apiEntry->opvpEndDrawImage(printerContext);
1321+ } else
1322+ return OPVP_FATALERROR;
1323+}
1324+
1325 /* for image */
1326 static const
1327 gx_image_enum_procs_t opvp_image_enum_procs =
1328@@ -1167,27 +1454,28 @@ typedef struct bbox_image_enum_s {
1329 /* initialize Graphic State */
1330 /* No defaults in OPVP 1.0 */
1331 static int
1332-InitGS(void)
1333+InitGS(gx_device* dev)
1334 {
1335- if (apiEntry->opvpInitGS != NULL) {
1336- if (apiEntry->opvpInitGS(printerContext) != OPVP_OK) {
1337- return -1;
1338- }
1339+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
1340+
1341+ if (gsopvpInitGS(dev, opdev->globals.printerContext) != OPVP_OK) {
1342+ return -1;
1343 }
1344- if (apiEntry->opvpSetColorSpace != NULL) {
1345- if (apiEntry->opvpSetColorSpace(printerContext,colorSpace)
1346- != OPVP_OK) {
1347+
1348+ if (opdev->globals.apiEntry->opvpSetColorSpace != NULL) {
1349+ if (opdev->globals.apiEntry->opvpSetColorSpace(opdev->globals.printerContext,
1350+ opdev->globals.colorSpace) != OPVP_OK){
1351 return -1;
1352 }
1353 }
1354- if (apiEntry->opvpSetPaintMode != NULL) {
1355- if (apiEntry->opvpSetPaintMode(printerContext,
1356+ if (opdev->globals.apiEntry->opvpSetPaintMode != NULL) {
1357+ if (opdev->globals.apiEntry->opvpSetPaintMode(opdev->globals.printerContext,
1358 OPVP_PAINTMODE_TRANSPARENT) != OPVP_OK) {
1359 return -1;
1360 }
1361 }
1362- if (apiEntry->opvpSetAlphaConstant != NULL) {
1363- if (apiEntry->opvpSetAlphaConstant(printerContext,1.0)
1364+ if (opdev->globals.apiEntry->opvpSetAlphaConstant != NULL) {
1365+ if (opdev->globals.apiEntry->opvpSetAlphaConstant(opdev->globals.printerContext,1.0)
1366 != OPVP_OK) {
1367 return -1;
1368 }
1369@@ -1203,20 +1491,20 @@ opvp_startpage(gx_device *dev)
1370 int ecode = 0;
1371 opvp_result_t r = -1;
1372 static char *page_info = NULL;
1373+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
1374
1375 /* page info */
1376 page_info = opvp_alloc_string(&page_info, OPVP_INFO_PREFIX);
1377 page_info = opvp_cat_string(&page_info, opvp_gen_page_info(dev));
1378
1379 /* call StartPage */
1380- if (printerContext != -1) {
1381- if (apiEntry->opvpStartPage)
1382- r = apiEntry->opvpStartPage(printerContext,
1383- (opvp_char_t *)opvp_to_utf8(page_info));
1384+ if (opdev->globals.printerContext != -1) {
1385+ r = gsopvpStartPage(dev, opdev->globals.printerContext,
1386+ (opvp_char_t*)opvp_to_utf8(page_info));
1387 if (r != OPVP_OK) {
1388 ecode = -1;
1389 } else {
1390- ecode = InitGS();
1391+ ecode = InitGS(dev);
1392 }
1393 }
1394
1395@@ -1224,15 +1512,16 @@ opvp_startpage(gx_device *dev)
1396 }
1397
1398 static int
1399-opvp_endpage(void)
1400+opvp_endpage(gx_device* dev)
1401 {
1402 int ecode = 0;
1403 opvp_result_t r = -1;
1404+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
1405
1406 /* call EndPage */
1407- if (printerContext != -1) {
1408- if (apiEntry->opvpEndPage)
1409- r = apiEntry->opvpEndPage(printerContext);
1410+ if (opdev->globals.printerContext != -1) {
1411+ if (opdev->globals.apiEntry->opvpEndPage)
1412+ r = opdev->globals.apiEntry->opvpEndPage(opdev->globals.printerContext);
1413 if (r != OPVP_OK) {
1414 ecode = -1;
1415 }
1416@@ -1304,32 +1593,33 @@ opvp_adjust_num_string(char *num_string)
1417 }
1418
1419 static char **
1420-opvp_gen_dynamic_lib_name(void)
1421+opvp_gen_dynamic_lib_name(gx_device* dev)
1422 {
1423 static char *buff[5] = {NULL,NULL,NULL,NULL,NULL};
1424 char tbuff[OPVP_BUFF_SIZE];
1425+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
1426
1427- if (!vectorDriver) {
1428+ if (!(opdev->globals.vectorDriver)) {
1429 return NULL;
1430 }
1431
1432 memset((void*)tbuff, 0, OPVP_BUFF_SIZE);
1433- strncpy(tbuff, vectorDriver, OPVP_BUFF_SIZE - 1);
1434+ strncpy(tbuff, opdev->globals.vectorDriver, OPVP_BUFF_SIZE - 1);
1435 opvp_alloc_string(&(buff[0]), tbuff);
1436
1437 memset((void*)tbuff, 0, OPVP_BUFF_SIZE);
1438- strncpy(tbuff, vectorDriver, OPVP_BUFF_SIZE - 4);
1439+ strncpy(tbuff, opdev->globals.vectorDriver, OPVP_BUFF_SIZE - 4);
1440 strcat(tbuff, ".so");
1441 opvp_alloc_string(&(buff[1]), tbuff);
1442
1443 memset((void*)tbuff, 0, OPVP_BUFF_SIZE);
1444- strncpy(tbuff, vectorDriver, OPVP_BUFF_SIZE - 5);
1445+ strncpy(tbuff, opdev->globals.vectorDriver, OPVP_BUFF_SIZE - 5);
1446 strcat(tbuff, ".dll");
1447 opvp_alloc_string(&(buff[2]), tbuff);
1448
1449 memset((void*)tbuff, 0, OPVP_BUFF_SIZE);
1450 strcpy(tbuff, "lib");
1451- strncat(tbuff, vectorDriver, OPVP_BUFF_SIZE - 7);
1452+ strncat(tbuff, opdev->globals.vectorDriver, OPVP_BUFF_SIZE - 7);
1453 strcat(tbuff, ".so");
1454 opvp_alloc_string(&(buff[3]), tbuff);
1455
1456@@ -1387,7 +1677,7 @@ opvp_to_utf8(char *string)
1457 }
1458
1459 static float
1460-opvp_fabsf(float f)
1461+opvp_fabsf(gx_device* dev, float f)
1462 {
1463 return (float)fabs((double)f);
1464 }
1465@@ -1429,7 +1719,7 @@ opvp_get_papertable_index(gx_device *pdev)
1466 paper = i;
1467 match = true;
1468 break;
1469- } else if ((f = opvp_fabsf(height - paper_h)) < TOLERANCE) {
1470+ } else if ((f = opvp_fabsf(pdev, height - paper_h)) < TOLERANCE) {
1471 if (f < h_delta) {
1472 h_delta = f;
1473 candidate = i;
1474@@ -1442,14 +1732,14 @@ opvp_get_papertable_index(gx_device *pdev)
1475 } else if (prev != paper_w) {
1476 prev = paper_w;
1477 if (paper_w < width) {
1478- if ((f = opvp_fabsf(width - paper_w)) < TOLERANCE) {
1479+ if ((f = opvp_fabsf(pdev, width - paper_w)) < TOLERANCE) {
1480 if (f < sw_delta) {
1481 sw_delta = f;
1482 smaller = i;
1483 }
1484 }
1485 } else {
1486- if ((f = opvp_fabsf(width - paper_w)) < TOLERANCE) {
1487+ if ((f = opvp_fabsf(pdev, width - paper_w)) < TOLERANCE) {
1488 if (f < lw_delta) {
1489 lw_delta = f;
1490 larger = i;
1491@@ -1468,7 +1758,7 @@ opvp_get_papertable_index(gx_device *pdev)
1492 sh_delta = 0;
1493 s_candi = i;
1494 break;
1495- } else if ((f = opvp_fabsf(height - paper_h)) < TOLERANCE) {
1496+ } else if ((f = opvp_fabsf(pdev, height - paper_h)) < TOLERANCE) {
1497 if (f < sh_delta) {
1498 sh_delta = f;
1499 s_candi = i;
1500@@ -1484,7 +1774,7 @@ opvp_get_papertable_index(gx_device *pdev)
1501 lh_delta = 0;
1502 l_candi = i;
1503 break;
1504- } else if ((f = opvp_fabsf(height - paper_h)) < TOLERANCE) {
1505+ } else if ((f = opvp_fabsf(pdev, height - paper_h)) < TOLERANCE) {
1506 if (f < lh_delta) {
1507 lh_delta = f;
1508 l_candi = i;
1509@@ -1560,8 +1850,8 @@ opvp_get_mediasize(gx_device *pdev)
1510 (strcmp(region, "oe" ) == 0)) {
1511 unit = "in";
1512 } else {
1513- width *= MMPI;
1514- height *= MMPI;
1515+ width *= (float) MMPI;
1516+ height *= (float) MMPI;
1517 unit = "mm";
1518 }
1519 } else {
1520@@ -1591,9 +1881,10 @@ opvp_gen_page_info(gx_device *dev)
1521 int num_copies = 1;
1522 bool landscape;
1523 char tbuff[OPVP_BUFF_SIZE];
1524+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
1525
1526 /* copies */
1527- if (!inkjet) {
1528+ if (!(opdev->globals.inkjet)) {
1529 if (dev->IgnoreNumCopies) {
1530 num_copies = 1;
1531 } else if (dev->NumCopies_set > 0) {
1532@@ -1642,14 +1933,13 @@ opvp_set_brush_color(gx_device_opvp *pdev, gx_color_index color,
1533 ecode = -1;
1534 } else {
1535 #if ENABLE_SIMPLE_MODE
1536- brush->colorSpace = colorSpace;
1537+ brush->colorSpace = pdev->globals.colorSpace;
1538 #else
1539 opvp_result_t r = -1;
1540 /* call GetColorSpace */
1541- if (apiEntry->opvpGetColorSpace) {
1542- r = apiEntry->opvpGetColorSpace(printerContext,
1543- &(brush->colorSpace));
1544- }
1545+
1546+ r = gsopvpGetColorSpace((gx_device*)pdev, printerContext,
1547+ &(brush->colorSpace));
1548 if (r != OPVP_OK) {
1549 brush->colorSpace = OPVP_CSPACE_DEVICEKRGB;
1550 }
1551@@ -1667,7 +1957,7 @@ opvp_set_brush_color(gx_device_opvp *pdev, gx_color_index color,
1552
1553 static int
1554 opvp_draw_image(
1555- gx_device_opvp *pdev,
1556+ gx_device_opvp *opdev,
1557 int depth,
1558 int sw,
1559 int sh,
1560@@ -1682,35 +1972,36 @@ opvp_draw_image(
1561 int count;
1562
1563 /* check page-in */
1564- if (opvp_check_in_page(pdev)) return -1;
1565+ if (opvp_check_in_page(opdev))
1566+ return -1;
1567
1568 /* image size */
1569 count = raster * sh;
1570
1571 /* call DrawImage */
1572- if (apiEntry->opvpDrawImage) {
1573- r = apiEntry->opvpDrawImage(printerContext,
1574- sw,sh,
1575- raster,
1576- mask ? OPVP_IFORMAT_MASK : OPVP_IFORMAT_RAW,
1577- dw,dh,
1578- /* discard 'const' qualifier */
1579- (void *)data);
1580- }
1581+ r = gsopvpDrawImage((gx_device*) opdev,
1582+ opdev->globals.printerContext,
1583+ sw,sh,
1584+ raster,
1585+ mask ? OPVP_IFORMAT_MASK : OPVP_IFORMAT_RAW,
1586+ dw,dh,
1587+ /* discard 'const' qualifier */
1588+ (void *)data);
1589+
1590 if (r != OPVP_OK) {
1591 /* call StartDrawImage */
1592- if (apiEntry->opvpStartDrawImage) {
1593- r = apiEntry->opvpStartDrawImage(printerContext,
1594- sw,sh,
1595- raster,
1596- mask ? OPVP_IFORMAT_MASK : OPVP_IFORMAT_RAW,
1597- dw,dh);
1598- }
1599+ r = gsopvpStartDrawImage((gx_device*)opdev,
1600+ opdev->globals.printerContext,
1601+ sw,sh,
1602+ raster,
1603+ mask ? OPVP_IFORMAT_MASK : OPVP_IFORMAT_RAW,
1604+ dw,dh);
1605+
1606 if (r == OPVP_OK) {
1607 /* call TansferDrawImage */
1608- if (apiEntry->opvpTransferDrawImage) {
1609- r = apiEntry->opvpTransferDrawImage(
1610- printerContext,
1611+ if (opdev->globals.apiEntry->opvpTransferDrawImage) {
1612+ r = opdev->globals.apiEntry->opvpTransferDrawImage(
1613+ opdev->globals.printerContext,
1614 count,
1615 /* discard 'const' qualifier */
1616 (void *)data);
1617@@ -1718,9 +2009,8 @@ opvp_draw_image(
1618 if (r != OPVP_OK) ecode = -1;
1619
1620 /* call EndDrawImage */
1621- if (apiEntry->opvpEndDrawImage) {
1622- apiEntry->opvpEndDrawImage(printerContext);
1623- }
1624+ gsopvpEndDrawImage((gx_device*)opdev, opdev->globals.printerContext);
1625+
1626 } else {
1627 ecode = 0; /* continue... */
1628 }
1629@@ -1735,48 +2025,49 @@ opvp_draw_image(
1630 * load vector-driver
1631 */
1632 static int
1633-opvp_load_vector_driver(void)
1634+opvp_load_vector_driver(gx_device* dev)
1635 {
1636 char **list = NULL;
1637 int i;
1638 void *h;
1639+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
1640
1641- if (handle) {
1642- opvp_unload_vector_driver();
1643+ if (opdev->globals.handle) {
1644+ opvp_unload_vector_driver(dev);
1645 }
1646
1647- if (vectorDriver) {
1648- list = opvp_gen_dynamic_lib_name();
1649+ if (opdev->globals.vectorDriver) {
1650+ list = opvp_gen_dynamic_lib_name(dev);
1651 }
1652
1653 if (list) {
1654 i = 0;
1655 while (list[i]) {
1656 if ((h = dlopen(list[i],RTLD_NOW))) {
1657- OpenPrinter = dlsym(h,"opvpOpenPrinter");
1658- ErrorNo = dlsym(h,"opvpErrorNo");
1659- if (OpenPrinter && ErrorNo) {
1660- handle = h;
1661+ opdev->globals.OpenPrinter = dlsym(h,"opvpOpenPrinter");
1662+ opdev->globals.ErrorNo = dlsym(h,"opvpErrorNo");
1663+ if (opdev->globals.OpenPrinter && opdev->globals.ErrorNo) {
1664+ opdev->globals.handle = h;
1665 break;
1666 }
1667- OpenPrinter = NULL;
1668- ErrorNo = NULL;
1669+ opdev->globals.OpenPrinter = NULL;
1670+ opdev->globals.ErrorNo = NULL;
1671 /* try version 0.2 driver */
1672- OpenPrinter_0_2 = dlsym(h,"OpenPrinter");
1673- ErrorNo = dlsym(h,"errorno");
1674- if (OpenPrinter_0_2 && ErrorNo) {
1675- handle = h;
1676+ opdev->globals.OpenPrinter_0_2 = dlsym(h,"OpenPrinter");
1677+ opdev->globals.ErrorNo = dlsym(h,"errorno");
1678+ if (opdev->globals.OpenPrinter_0_2 && opdev->globals.ErrorNo) {
1679+ opdev->globals.handle = h;
1680 break;
1681 }
1682- OpenPrinter_0_2 = NULL;
1683- ErrorNo = NULL;
1684+ opdev->globals.OpenPrinter_0_2 = NULL;
1685+ opdev->globals.ErrorNo = NULL;
1686 dlclose(h);
1687 }
1688 i++;
1689 }
1690 }
1691
1692- if (handle) {
1693+ if (opdev->globals.handle) {
1694 return 0;
1695 } else {
1696 return -1;
1697@@ -1787,13 +2078,15 @@ opvp_load_vector_driver(void)
1698 * unload vector-driver
1699 */
1700 static int
1701-opvp_unload_vector_driver(void)
1702+opvp_unload_vector_driver(gx_device* dev)
1703 {
1704- if (handle) {
1705- dlclose(handle);
1706- handle = NULL;
1707- OpenPrinter = NULL;
1708- ErrorNo = NULL;
1709+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
1710+
1711+ if (opdev->globals.handle) {
1712+ dlclose(opdev->globals.handle);
1713+ opdev->globals.handle = NULL;
1714+ opdev->globals.OpenPrinter = NULL;
1715+ opdev->globals.ErrorNo = NULL;
1716 }
1717 return 0;
1718 }
1719@@ -1810,6 +2103,7 @@ prepare_open(gx_device *dev)
1720 int dumFD = -1;
1721 opvp_dc_t dumContext = -1;
1722 opvp_cspace_t cspace = OPVP_CSPACE_STANDARDRGB;
1723+ gx_device_opvp *opdev = (gx_device_opvp*) dev;
1724
1725 /* open dummy device */
1726 code = open("/dev/null", O_RDWR);
1727@@ -1818,19 +2112,19 @@ prepare_open(gx_device *dev)
1728
1729 /* load vector driver */
1730 if (!ecode) {
1731- if ((code = opvp_load_vector_driver())) {
1732+ if ((code = opvp_load_vector_driver(dev))) {
1733 ecode = code;
1734 }
1735 }
1736
1737 /* prepare array of function pointer for PDAPI */
1738 if (!ecode) {
1739- if (!apiEntry) {
1740- if (!(apiEntry = calloc(sizeof(opvp_api_procs_t), 1))) {
1741+ if (!(opdev->globals.apiEntry)) {
1742+ if (!(opdev->globals.apiEntry = calloc(sizeof(opvp_api_procs_t), 1))) {
1743 ecode = -1;
1744 }
1745 } else {
1746- memset(apiEntry, 0, sizeof(opvp_api_procs_t));
1747+ memset(opdev->globals.apiEntry, 0, sizeof(opvp_api_procs_t));
1748 }
1749 }
1750
1751@@ -1842,8 +2136,8 @@ prepare_open(gx_device *dev)
1752 /* require version 1.0 */
1753 apiVersion[0] = 1;
1754 apiVersion[1] = 0;
1755- dc = OpenPrinterWrapper(dumFD, (opvp_char_t *)printerModel,
1756- apiVersion,&api_entry);
1757+ dc = OpenPrinterWrapper(dev, dumFD, (opvp_char_t *)(opdev->globals.printerModel),
1758+ apiVersion, &api_entry);
1759 if (dc == -1) {
1760 ecode = -1;
1761 } else {
1762@@ -1853,33 +2147,33 @@ prepare_open(gx_device *dev)
1763
1764 /* set apiEntry */
1765 if (!ecode) {
1766- nApiEntry = sizeof(opvp_api_procs_t)/sizeof(void *);
1767- memcpy(apiEntry, api_entry, nApiEntry*sizeof(void *));
1768+ opdev->globals.nApiEntry = sizeof(opvp_api_procs_t)/sizeof(void *);
1769+ memcpy(opdev->globals.apiEntry, api_entry, opdev->globals.nApiEntry*sizeof(void *));
1770 } else {
1771- if (apiEntry) free(apiEntry);
1772- apiEntry = NULL;
1773+ if (opdev->globals.apiEntry) free(opdev->globals.apiEntry);
1774+ opdev->globals.apiEntry = NULL;
1775 }
1776
1777 /* check vector fucntion */
1778- if (apiEntry) {
1779- if (!inkjet) {
1780- if (!(apiEntry->opvpNewPath) ||
1781- !(apiEntry->opvpEndPath) ||
1782- !(apiEntry->opvpStrokePath) ||
1783- !(apiEntry->opvpSetCurrentPoint) ||
1784- !(apiEntry->opvpLinePath) ||
1785- !(apiEntry->opvpBezierPath)) {
1786+ if (opdev->globals.apiEntry) {
1787+ if (!(opdev->globals.inkjet)) {
1788+ if (!(opdev->globals.apiEntry->opvpNewPath) ||
1789+ !(opdev->globals.apiEntry->opvpEndPath) ||
1790+ !(opdev->globals.apiEntry->opvpStrokePath) ||
1791+ !(opdev->globals.apiEntry->opvpSetCurrentPoint) ||
1792+ !(opdev->globals.apiEntry->opvpLinePath) ||
1793+ !(opdev->globals.apiEntry->opvpBezierPath)) {
1794 /* NOT avail vector drawing mode */
1795- vector = false;
1796+ opdev->globals.vector = false;
1797 }
1798 }
1799 /* call GetColorSpace */
1800- if (apiEntry->opvpGetColorSpace) {
1801- (void)apiEntry->opvpGetColorSpace(dumContext, &cspace);
1802+ if (opdev->globals.apiEntry->opvpGetColorSpace) {
1803+ (void)(opdev->globals.apiEntry->opvpGetColorSpace)(dumContext, &cspace);
1804 }
1805 if (cspace == OPVP_CSPACE_BW) {
1806 /* mono-color */
1807- colorSpace = cspace;
1808+ opdev->globals.colorSpace = cspace;
1809 dev->color_info.num_components = 1;
1810 dev->color_info.depth = 1;
1811 dev->color_info.max_gray = 0;
1812@@ -1888,7 +2182,7 @@ prepare_open(gx_device *dev)
1813 dev->color_info.dither_colors = 1;
1814 } else if (cspace == OPVP_CSPACE_DEVICEGRAY) {
1815 /* gray-scale */
1816- colorSpace = cspace;
1817+ opdev->globals.colorSpace = cspace;
1818 dev->color_info.num_components = 1;
1819 dev->color_info.depth = 8;
1820 dev->color_info.max_gray = 255;
1821@@ -1897,7 +2191,7 @@ prepare_open(gx_device *dev)
1822 dev->color_info.dither_colors = 256;
1823 } else {
1824 /* rgb color */
1825- colorSpace = OPVP_CSPACE_STANDARDRGB;
1826+ opdev->globals.colorSpace = OPVP_CSPACE_STANDARDRGB;
1827 dev->color_info.num_components = 3;
1828 dev->color_info.depth = 24;
1829 dev->color_info.max_gray = 255;
1830@@ -1913,8 +2207,8 @@ prepare_open(gx_device *dev)
1831 /* call Closerinter as dummy */
1832 if (dumContext != -1) {
1833 /* call ClosePrinter */
1834- if (apiEntry->opvpClosePrinter) {
1835- apiEntry->opvpClosePrinter(dumContext);
1836+ if (opdev->globals.apiEntry->opvpClosePrinter) {
1837+ opdev->globals.apiEntry->opvpClosePrinter(dumContext);
1838 }
1839 dumContext = -1;
1840 }
1841@@ -1926,7 +2220,7 @@ prepare_open(gx_device *dev)
1842 }
1843
1844 /* un-load vector driver */
1845- opvp_unload_vector_driver();
1846+ opvp_unload_vector_driver(dev);
1847
1848 return ecode;
1849 }
1850@@ -1961,51 +2255,52 @@ opvp_open(gx_device *dev)
1851 }
1852
1853 /* set margins */
1854- if (zoomAuto) {
1855- margin_width = (margins[0] + margins[2])
1856+ if (pdev->globals.zoomAuto) {
1857+ margin_width = (pdev->globals.margins[0] + pdev->globals.margins[2])
1858 * dev->HWResolution[0];
1859- margin_height = (margins[1] + margins[3])
1860+ margin_height = (pdev->globals.margins[1] + pdev->globals.margins[3])
1861 * dev->HWResolution[1];
1862- zoom[0] = (dev->width - margin_width) / dev->width;
1863- zoom[1] = (dev->height - margin_height) / dev->height;
1864- if (zoom[0] < zoom[1]) {
1865- zoom[1] = zoom[0];
1866+ pdev->globals.zoom[0] = (dev->width - margin_width) / dev->width;
1867+ pdev->globals.zoom[1] = (dev->height - margin_height) / dev->height;
1868+ if (pdev->globals.zoom[0] < pdev->globals.zoom[1]) {
1869+ pdev->globals.zoom[1] = pdev->globals.zoom[0];
1870 } else {
1871- zoom[0] = zoom[1];
1872+ pdev->globals.zoom[0] = pdev->globals.zoom[1];
1873 }
1874 }
1875- if (inkjet) {
1876- if ((margins[0] != 0) ||
1877- (margins[1] != 0) || (margins[3] != 0)) {
1878- shift[0] = margins[0] * dev->HWResolution[0];
1879- shift[1] = (margins[1] + margins[3])
1880+ if (pdev->globals.inkjet) {
1881+ if ((pdev->globals.margins[0] != 0) ||
1882+ (pdev->globals.margins[1] != 0) || (pdev->globals.margins[3] != 0)) {
1883+ pdev->globals.shift[0] = pdev->globals.margins[0] * dev->HWResolution[0];
1884+ pdev->globals.shift[1] = (pdev->globals.margins[1] + pdev->globals.margins[3])
1885 * dev->HWResolution[1];
1886- zooming = true;
1887+ pdev->globals.zooming = true;
1888 }
1889- dev->width -= margins[2] * dev->HWResolution[0];
1890- dev->height -= margins[1] * dev->HWResolution[1];
1891+ dev->width -= (int) (pdev->globals.margins[2] * dev->HWResolution[0]);
1892+ dev->height -= (int) (pdev->globals.margins[1] * dev->HWResolution[1]);
1893 } else {
1894- if ((margins[0] != 0) || (margins[1] != 0)) {
1895- shift[0] = margins[0] * dev->HWResolution[0];
1896- shift[1] = margins[3] * dev->HWResolution[1];
1897- zooming = true;
1898+ if ((pdev->globals.margins[0] != 0) || (pdev->globals.margins[1] != 0)) {
1899+ pdev->globals.shift[0] = pdev->globals.margins[0] * dev->HWResolution[0];
1900+ pdev->globals.shift[1] = pdev->globals.margins[3] * dev->HWResolution[1];
1901+ pdev->globals.zooming = true;
1902 }
1903 adj_margins[0] = 0;
1904 adj_margins[3] = 0;
1905- adj_margins[1] = dev->height * zoom[1] / dev->HWResolution[1]
1906+ adj_margins[1] = dev->height * pdev->globals.zoom[1] / dev->HWResolution[1]
1907 - (dev->MediaSize[1] / PS_DPI
1908- - (margins[1] + margins[3]));
1909+ - (pdev->globals.margins[1] + pdev->globals.margins[3]));
1910 if (adj_margins[1] < 0) adj_margins[0] = 0;
1911- adj_margins[2] = dev->width * zoom[0] / dev->HWResolution[0]
1912+ adj_margins[2] = dev->width * pdev->globals.zoom[0] / dev->HWResolution[0]
1913 - (dev->MediaSize[0] / PS_DPI
1914- - (margins[0] + margins[2]));
1915+ - (pdev->globals.margins[0] + pdev->globals.margins[2]));
1916 if (adj_margins[2] < 0) adj_margins[2] = 0;
1917 gx_device_set_margins(dev, adj_margins, true);
1918 }
1919- if ((zoom[0] != 1) || (zoom[1] != 1)) zooming = true;
1920+ if ((pdev->globals.zoom[0] != 1) || (pdev->globals.zoom[1] != 1))
1921+ pdev->globals.zooming = true;
1922
1923 /* open file for output device */
1924- if (!inkjet) {
1925+ if (!(pdev->globals.inkjet)) {
1926 pdev->v_memory = gs_memory_stable(pdev->memory);
1927 /* open output stream */
1928 code = gdev_vector_open_file_options((gx_device_vector*)dev,
1929@@ -2027,7 +2322,7 @@ opvp_open(gx_device *dev)
1930 pdev->bbox_device->memory = gs_memory_stable(dev->memory);
1931 }
1932 }
1933- outputFD = fileno(gp_get_file(pdev->file));
1934+ pdev->globals.outputFD = fileno(gp_get_file(pdev->file));
1935 } else {
1936 /* open printer device */
1937 code = gdev_prn_open(dev);
1938@@ -2044,13 +2339,13 @@ opvp_open(gx_device *dev)
1939 if (code < 0) {
1940 return code;
1941 }
1942- outputFD = fileno(gp_get_file(rdev->file));
1943+ pdev->globals.outputFD = fileno(gp_get_file(rdev->file));
1944 }
1945- if (outputFD < 0)
1946- return outputFD;
1947+ if (pdev->globals.outputFD < 0)
1948+ return pdev->globals.outputFD;
1949
1950 /* RE-load vector driver */
1951- if ((code = opvp_load_vector_driver())) {
1952+ if ((code = opvp_load_vector_driver(dev))) {
1953 return code;
1954 }
1955
1956@@ -2058,44 +2353,48 @@ opvp_open(gx_device *dev)
1957 /* require version 1.0 */
1958 apiVersion[0] = 1;
1959 apiVersion[1] = 0;
1960- dc = OpenPrinterWrapper(outputFD,(opvp_char_t *)printerModel,
1961+ dc = OpenPrinterWrapper(dev, pdev->globals.outputFD, (opvp_char_t *)pdev->globals.printerModel,
1962 apiVersion,&api_entry);
1963- if (!apiEntry) {
1964- if (!(apiEntry = calloc(sizeof(opvp_api_procs_t), 1))) {
1965+ if (!(pdev->globals.apiEntry)) {
1966+ if (!(pdev->globals.apiEntry = calloc(sizeof(opvp_api_procs_t), 1))) {
1967 ecode = -1;
1968 }
1969 } else {
1970- memset(apiEntry, 0, sizeof(opvp_api_procs_t));
1971+ memset(pdev->globals.apiEntry, 0, sizeof(opvp_api_procs_t));
1972 }
1973 if (dc == -1) {
1974 ecode = -1;
1975- if (apiEntry) free(apiEntry);
1976- apiEntry = NULL;
1977- opvp_unload_vector_driver();
1978- if (inkjet) gdev_prn_close(dev);
1979+ if (pdev->globals.apiEntry)
1980+ free(pdev->globals.apiEntry);
1981+ pdev->globals.apiEntry = NULL;
1982+ opvp_unload_vector_driver(dev);
1983+ if (pdev->globals.inkjet)
1984+ gdev_prn_close(dev);
1985 else gdev_vector_close_file((gx_device_vector *)pdev);
1986 return ecode;
1987 }
1988- printerContext = dc;
1989- nApiEntry = sizeof(opvp_api_procs_t)/sizeof(void *);
1990- memcpy(apiEntry, api_entry, nApiEntry*sizeof(void *));
1991+ pdev->globals.printerContext = dc;
1992+ pdev->globals.nApiEntry = sizeof(opvp_api_procs_t)/sizeof(void *);
1993+ memcpy(pdev->globals.apiEntry, api_entry, pdev->globals.nApiEntry*sizeof(void *));
1994
1995 /* initialize */
1996- if ((!ecode) && (!inkjet)) {
1997+ if ((!ecode) && (!(pdev->globals.inkjet))) {
1998 pdev->vec_procs = &opvp_vector_procs;
1999- if (vector) gdev_vector_init((gx_device_vector *)pdev);
2000+ if (pdev->globals.vector)
2001+ gdev_vector_init((gx_device_vector *)pdev);
2002 }
2003
2004- if (apiEntry->opvpQueryColorSpace) {
2005+ if (pdev->globals.apiEntry->opvpQueryColorSpace ||
2006+ pdev->globals.apiEntry_0_2->QueryColorSpace) {
2007 int n = sizeof(cspace_available);
2008 int nn = n;
2009 opvp_cspace_t *p = malloc(n*sizeof(opvp_cspace_t));
2010
2011- if ((r = apiEntry->opvpQueryColorSpace(printerContext,&nn,p))
2012+ if ((r = gsopvpQueryColorSpace(dev, pdev->globals.printerContext,&nn,p))
2013 == OPVP_PARAMERROR && nn > n) {
2014 /* realloc buffer and retry */
2015 p = realloc(p,nn*sizeof(opvp_cspace_t));
2016- r = apiEntry->opvpQueryColorSpace(printerContext,&nn,p);
2017+ r = gsopvpQueryColorSpace(dev, pdev->globals.printerContext,&nn,p);
2018 }
2019 if (r == OPVP_OK) {
2020 int i;
2021@@ -2111,12 +2410,12 @@ opvp_open(gx_device *dev)
2022 /* start job */
2023 if (!ecode) {
2024 /* job info */
2025- if (jobInfo) {
2026- if (strlen(jobInfo) > 0) {
2027- job_info = opvp_alloc_string(&job_info,jobInfo);
2028+ if (pdev->globals.jobInfo) {
2029+ if (strlen(pdev->globals.jobInfo) > 0) {
2030+ job_info = opvp_alloc_string(&job_info, pdev->globals.jobInfo);
2031 }
2032 }
2033- tmp_info = opvp_alloc_string(&tmp_info,opvp_gen_job_info(dev));
2034+ tmp_info = opvp_alloc_string(&tmp_info, opvp_gen_job_info(dev));
2035 if (tmp_info) {
2036 if (strlen(tmp_info) > 0) {
2037 if (job_info) {
2038@@ -2130,8 +2429,8 @@ opvp_open(gx_device *dev)
2039 }
2040
2041 /* call StartJob */
2042- if (apiEntry->opvpStartJob) {
2043- r = apiEntry->opvpStartJob(printerContext,
2044+ if (pdev->globals.apiEntry->opvpStartJob) {
2045+ r = pdev->globals.apiEntry->opvpStartJob(pdev->globals.printerContext,
2046 (opvp_char_t *)opvp_to_utf8(job_info));
2047 }
2048 if (r != OPVP_OK) {
2049@@ -2142,9 +2441,9 @@ opvp_open(gx_device *dev)
2050 /* start doc */
2051 if (!ecode) {
2052 /* doc info */
2053- if (docInfo) {
2054- if (strlen(docInfo) > 0) {
2055- doc_info = opvp_alloc_string(&doc_info,docInfo);
2056+ if (pdev->globals.docInfo) {
2057+ if (strlen(pdev->globals.docInfo) > 0) {
2058+ doc_info = opvp_alloc_string(&doc_info, pdev->globals.docInfo);
2059 }
2060 }
2061 tmp_info = opvp_alloc_string(&tmp_info, opvp_gen_doc_info(dev));
2062@@ -2161,8 +2460,8 @@ opvp_open(gx_device *dev)
2063 }
2064
2065 /* call StartDoc */
2066- if (apiEntry->opvpStartDoc) {
2067- r = apiEntry->opvpStartDoc(printerContext,
2068+ if (pdev->globals.apiEntry->opvpStartDoc) {
2069+ r = pdev->globals.apiEntry->opvpStartDoc(pdev->globals.printerContext,
2070 (opvp_char_t *)opvp_to_utf8(doc_info));
2071 }
2072 if (r != OPVP_OK) {
2073@@ -2183,9 +2482,11 @@ opvp_open(gx_device *dev)
2074 static int
2075 oprp_open(gx_device *dev)
2076 {
2077+ gx_device_opvp *opdev = (gx_device_opvp*) dev;
2078+
2079 /* set inkjet mode */
2080- vector = false;
2081- inkjet = true;
2082+ opdev->globals.vector = false;
2083+ opdev->globals.inkjet = true;
2084
2085 /* matrix */
2086 dev->procs.get_initial_matrix = opvp_get_initial_matrix;
2087@@ -2198,24 +2499,24 @@ oprp_open(gx_device *dev)
2088 static void
2089 opvp_get_initial_matrix(gx_device *dev, gs_matrix *pmat)
2090 {
2091- gx_device_opvp *pdev = (gx_device_opvp *)dev;
2092+ gx_device_opvp * opdev = (gx_device_opvp *)dev;
2093 opvp_ctm_t omat;
2094
2095 gx_default_get_initial_matrix(dev,pmat);
2096- if (zooming) {
2097+ if (opdev->globals.zooming) {
2098 /* gs matrix */
2099- pmat->xx *= zoom[0];
2100- pmat->xy *= zoom[1];
2101- pmat->yx *= zoom[0];
2102- pmat->yy *= zoom[1];
2103- pmat->tx = pmat->tx * zoom[0] + shift[0];
2104- pmat->ty = pmat->ty * zoom[1] + shift[1];
2105+ pmat->xx *= opdev->globals.zoom[0];
2106+ pmat->xy *= opdev->globals.zoom[1];
2107+ pmat->yx *= opdev->globals.zoom[0];
2108+ pmat->yy *= opdev->globals.zoom[1];
2109+ pmat->tx = pmat->tx * opdev->globals.zoom[0] + opdev->globals.shift[0];
2110+ pmat->ty = pmat->ty * opdev->globals.zoom[1] + opdev->globals.shift[1];
2111 }
2112
2113- if (pdev->is_open) {
2114+ if (opdev->is_open) {
2115 /* call ResetCTM */
2116- if (apiEntry->opvpResetCTM) {
2117- apiEntry->opvpResetCTM(printerContext);
2118+ if (opdev->globals.apiEntry->opvpResetCTM) {
2119+ opdev->globals.apiEntry->opvpResetCTM(opdev->globals.printerContext);
2120 } else {
2121 /* call SetCTM */
2122 omat.a = 1;
2123@@ -2224,8 +2525,8 @@ opvp_get_initial_matrix(gx_device *dev, gs_matrix *pmat)
2124 omat.d = 1;
2125 omat.e = 0;
2126 omat.f = 0;
2127- if (apiEntry->opvpSetCTM) {
2128- apiEntry->opvpSetCTM(printerContext, &omat);
2129+ if (opdev->globals.apiEntry->opvpSetCTM) {
2130+ opdev->globals.apiEntry->opvpSetCTM(opdev->globals.printerContext, &omat);
2131 }
2132 }
2133 }
2134@@ -2239,30 +2540,32 @@ opvp_get_initial_matrix(gx_device *dev, gs_matrix *pmat)
2135 static int
2136 opvp_output_page(gx_device *dev, int num_copies, int flush)
2137 {
2138- gx_device_opvp *pdev = (gx_device_opvp *)dev;
2139+ gx_device_opvp *opdev = (gx_device_opvp *)dev;
2140 int ecode = 0;
2141 int code = -1;
2142
2143- if (inkjet) return gdev_prn_output_page(dev, num_copies, flush);
2144+ if (opdev->globals.inkjet)
2145+ return gdev_prn_output_page(dev, num_copies, flush);
2146
2147 #ifdef OPVP_IGNORE_BLANK_PAGE
2148 if (pdev->in_page) {
2149 #else
2150 /* check page-in */
2151- if (opvp_check_in_page(pdev)) return -1;
2152+ if (opvp_check_in_page(opdev))
2153+ return -1;
2154 #endif
2155 /* end page */
2156- code = opvp_endpage();
2157+ code = opvp_endpage(dev);
2158 if (code) ecode = code;
2159
2160- pdev->in_page = false;
2161- beginPage = false;
2162+ opdev->in_page = false;
2163+ opdev->globals.beginPage = false;
2164 #ifdef OPVP_IGNORE_BLANK_PAGE
2165 }
2166 #endif
2167
2168- if (vector) {
2169- gdev_vector_reset((gx_device_vector *)pdev);
2170+ if (opdev->globals.vector) {
2171+ gdev_vector_reset((gx_device_vector *)dev);
2172 }
2173
2174 code = gx_finish_output_page(dev, num_copies, flush);
2175@@ -2289,6 +2592,7 @@ oprp_print_page(gx_device_printer *pdev, gp_file *prn_stream)
2176 int rasterWidth;
2177 bool start_page = false;
2178 bool start_raster = false;
2179+ gx_device_opvp *opdev = (gx_device_opvp*)pdev;
2180 #if ENABLE_SKIP_RASTER
2181 int i;
2182 byte check;
2183@@ -2317,8 +2621,8 @@ oprp_print_page(gx_device_printer *pdev, gp_file *prn_stream)
2184
2185 /* call StartRaster */
2186 if (!ecode) {
2187- if (apiEntry->opvpStartRaster) {
2188- r = apiEntry->opvpStartRaster(printerContext,rasterWidth);
2189+ if (opdev->globals.apiEntry->opvpStartRaster) {
2190+ r = opdev->globals.apiEntry->opvpStartRaster(opdev->globals.printerContext,rasterWidth);
2191 }
2192 if (r != OPVP_OK) {
2193 ecode = r;
2194@@ -2339,7 +2643,7 @@ oprp_print_page(gx_device_printer *pdev, gp_file *prn_stream)
2195 }
2196 #if ENABLE_SKIP_RASTER
2197 /* check support SkipRaster */
2198- if (apiEntry->opvpSkipRaster) {
2199+ if (opdev->globals.apiEntry->opvpSkipRaster) {
2200 /* check all white */
2201 if (pdev->color_info.depth > 8) {
2202 for (check = 0xff, i = 0; i < raster_size; i++)
2203@@ -2349,7 +2653,7 @@ oprp_print_page(gx_device_printer *pdev, gp_file *prn_stream)
2204 }
2205 /* if all white call SkipRaster */
2206 if (check == 0xff) {
2207- r = apiEntry->opvpSkipRaster(printerContext, 1);
2208+ r = opdev->globals.apiEntry->opvpSkipRaster(opdev->globals.printerContext, 1);
2209 if (r == OPVP_OK) continue;
2210 }
2211 } else {
2212@@ -2359,27 +2663,29 @@ oprp_print_page(gx_device_printer *pdev, gp_file *prn_stream)
2213 }
2214 /* if all zero call SkipRaster */
2215 if (check) {
2216- r = apiEntry->opvpSkipRaster(printerContext, 1);
2217- if (r == OPVP_OK) continue;
2218+ r = opdev->globals.apiEntry->opvpSkipRaster(opdev->globals.printerContext, 1);
2219+ if (r == OPVP_OK)
2220+ continue;
2221 }
2222 }
2223 }
2224 #endif
2225 /* call TransferRasterData */
2226 if (!ecode) {
2227- if (apiEntry->opvpTransferRasterData) {
2228- r = apiEntry->opvpTransferRasterData(printerContext,
2229+ if (opdev->globals.apiEntry->opvpTransferRasterData) {
2230+ r = opdev->globals.apiEntry->opvpTransferRasterData(opdev->globals.printerContext,
2231 raster_size,
2232 data);
2233 }
2234- if (r != OPVP_OK) ecode = r;
2235+ if (r != OPVP_OK)
2236+ ecode = r;
2237 }
2238 }
2239
2240 /* call EndRaster */
2241 if (start_raster) {
2242- if (apiEntry->opvpEndRaster) {
2243- r = apiEntry->opvpEndRaster(printerContext);
2244+ if (opdev->globals.apiEntry->opvpEndRaster) {
2245+ r = opdev->globals.apiEntry->opvpEndRaster(opdev->globals.printerContext);
2246 }
2247 if (r != OPVP_OK) ecode = r;
2248 start_raster = false;
2249@@ -2387,7 +2693,7 @@ oprp_print_page(gx_device_printer *pdev, gp_file *prn_stream)
2250
2251 /* end page */
2252 if (start_page) {
2253- code = opvp_endpage();
2254+ code = opvp_endpage((gx_device*) pdev);
2255 if (code) ecode = code;
2256 start_page = false;
2257 }
2258@@ -2411,37 +2717,38 @@ opvp_close(gx_device *dev)
2259 int ecode = 0;
2260
2261 /* finalize */
2262- if (printerContext != -1) {
2263+ if (pdev->globals.printerContext != -1) {
2264 /* call EndDoc */
2265- if (apiEntry->opvpEndDoc) {
2266- apiEntry->opvpEndDoc(printerContext);
2267+ if (pdev->globals.apiEntry->opvpEndDoc) {
2268+ pdev->globals.apiEntry->opvpEndDoc(pdev->globals.printerContext);
2269 }
2270
2271 /* call EndJob */
2272- if (apiEntry->opvpEndJob) {
2273- apiEntry->opvpEndJob(printerContext);
2274+ if (pdev->globals.apiEntry->opvpEndJob) {
2275+ pdev->globals.apiEntry->opvpEndJob(pdev->globals.printerContext);
2276 }
2277
2278 /* call ClosePrinter */
2279- if (apiEntry->opvpClosePrinter) {
2280- apiEntry->opvpClosePrinter(printerContext);
2281+ if (pdev->globals.apiEntry->opvpClosePrinter) {
2282+ pdev->globals.apiEntry->opvpClosePrinter(pdev->globals.printerContext);
2283 }
2284- printerContext = -1;
2285+ pdev->globals.printerContext = -1;
2286 }
2287
2288 /* unload vector driver */
2289- if (apiEntry) free(apiEntry);
2290- apiEntry = NULL;
2291- opvp_unload_vector_driver();
2292+ if (pdev->globals.apiEntry)
2293+ free(pdev->globals.apiEntry);
2294+ pdev->globals.apiEntry = NULL;
2295+ opvp_unload_vector_driver(dev);
2296
2297- if (inkjet) {
2298+ if (pdev->globals.inkjet) {
2299 /* close printer */
2300 gdev_prn_close(dev);
2301 } else {
2302 /* close output stream */
2303 gdev_vector_close_file((gx_device_vector *)pdev);
2304 }
2305- outputFD = -1;
2306+ pdev->globals.outputFD = -1;
2307
2308 return ecode;
2309 }
2310@@ -2455,6 +2762,7 @@ opvp_map_rgb_color(gx_device *dev,
2311 {
2312 opvp_cspace_t cs;
2313 uint c, m, y, k;
2314+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
2315
2316 #if !(ENABLE_SIMPLE_MODE)
2317 gx_device_opvp *pdev;
2318@@ -2467,16 +2775,15 @@ opvp_map_rgb_color(gx_device *dev,
2319 b = prgb[2];
2320
2321 #if ENABLE_SIMPLE_MODE
2322- cs = colorSpace;
2323+ cs = opdev->globals.colorSpace;
2324 #else
2325 pdev = (gx_device_opvp *)dev;
2326 r = -1;
2327 cs = OPVP_CSPACE_STANDARDRGB;
2328 if (pdev->is_open) {
2329 /* call GetColorSpace */
2330- if (apiEntry->opvpGetColorSpace) {
2331- r = apiEntry->opvpGetColorSpace(printerContext, &cs);
2332- }
2333+
2334+ r = gsopvpGetColorSpace(dev, opdev->globals.printerContext, &cs);
2335 if (r != OPVP_OK) {
2336 if (pdev->color_info.depth > 32) {
2337 cs = OPVP_CSPACE_STANDARDRGB64;
2338@@ -2555,15 +2862,14 @@ opvp_map_color_rgb(gx_device *dev, gx_color_index color,
2339 #endif
2340 opvp_cspace_t cs = OPVP_CSPACE_STANDARDRGB;
2341 uint c, m, y, k;
2342+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
2343
2344 #if ENABLE_SIMPLE_MODE
2345- cs = colorSpace;
2346+ cs = opdev->globals.colorSpace;
2347 #else
2348 /* call GetColorSpace */
2349 if (pdev->is_open) {
2350- if (apiEntry->opvpGetColorSpace) {
2351- r = apiEntry->opvpGetColorSpace(printerContext, &cs);
2352- }
2353+ r = gsopvpGetColorSpace(dev, opdev->globals.printerContext, &cs);
2354 if (r != OPVP_OK) {
2355 if (pdev->color_info.depth > 32) {
2356 cs = OPVP_CSPACE_STANDARDRGB64;
2357@@ -2635,44 +2941,44 @@ opvp_fill_rectangle(
2358 int h,
2359 gx_color_index color)
2360 {
2361- gx_device_opvp *pdev = (gx_device_opvp *)dev;
2362+ gx_device_opvp *opdev = (gx_device_opvp *)dev;
2363 byte data[8] = {0xC0, 0, 0, 0, 0xC0, 0, 0, 0};
2364 int code = -1;
2365 int ecode = 0;
2366 opvp_brush_t brush;
2367 opvp_point_t point;
2368
2369- if (vector) {
2370- return gdev_vector_fill_rectangle( dev, x, y, w, h, color);
2371+ if (opdev->globals.vector) {
2372+ return gdev_vector_fill_rectangle(dev, x, y, w, h, color);
2373 }
2374
2375 /* check page-in */
2376- if (opvp_check_in_page(pdev)) return -1;
2377+ if (opvp_check_in_page(opdev))
2378+ return -1;
2379
2380 #if !(ENABLE_SIMPLE_MODE)
2381 /* call SaveGS */
2382- if (apiEntry->opvpSaveGS) {
2383- apiEntry->opvpSaveGS(printerContext);
2384+ if (pdev->globals.apiEntry->opvpSaveGS) {
2385+ pdev->globals.apiEntry->opvpSaveGS(printerContext);
2386 }
2387 #endif
2388
2389 /* one-color */
2390- opvp_set_brush_color(pdev, color, &brush);
2391+ opvp_set_brush_color(opdev, color, &brush);
2392
2393 /* call SetFillColor */
2394- if (apiEntry->opvpSetFillColor) {
2395- apiEntry->opvpSetFillColor(printerContext, &brush);
2396- }
2397+ gsopvpSetFillColor(dev, opdev->globals.printerContext, &brush);
2398+
2399
2400 /* call SetCurrentPoint */
2401 OPVP_I2FIX(x, point.x);
2402 OPVP_I2FIX(y, point.y);
2403- if (apiEntry->opvpSetCurrentPoint) {
2404- apiEntry->opvpSetCurrentPoint(printerContext,point.x, point.y);
2405+ if (opdev->globals.apiEntry->opvpSetCurrentPoint) {
2406+ opdev->globals.apiEntry->opvpSetCurrentPoint(opdev->globals.printerContext,point.x, point.y);
2407 }
2408
2409 /* draw image */
2410- code = opvp_draw_image(pdev,
2411+ code = opvp_draw_image(opdev,
2412 1,
2413 2, 2,
2414 w, h,
2415@@ -2684,17 +2990,15 @@ opvp_fill_rectangle(
2416 }
2417
2418 /* restore fill color */
2419- if (vectorFillColor) {
2420+ if (opdev->globals.vectorFillColor) {
2421 /* call SetFillColor */
2422- if (apiEntry->opvpSetFillColor) {
2423- apiEntry->opvpSetFillColor(printerContext,vectorFillColor);
2424- }
2425+ gsopvpSetFillColor(dev, opdev->globals.printerContext,opdev->globals.vectorFillColor);
2426 }
2427
2428 #if !(ENABLE_SIMPLE_MODE)
2429 /* call RestoreGS */
2430- if (apiEntry->opvpRestoreGS) {
2431- apiEntry->opvpRestoreGS(printerContext);
2432+ if (pdev->globals.apiEntry->opvpRestoreGS) {
2433+ pdev->globals.opdev->globals.apiEntry->opvpRestoreGS(printerContext);
2434 }
2435 #endif
2436
2437@@ -2718,7 +3022,7 @@ opvp_copy_mono(
2438 gx_color_index zero,
2439 gx_color_index one)
2440 {
2441- gx_device_opvp *pdev = (gx_device_opvp *)dev;
2442+ gx_device_opvp *opdev = (gx_device_opvp *)dev;
2443 int code = -1;
2444 int ecode = 0;
2445 opvp_brush_t brush;
2446@@ -2736,7 +3040,8 @@ opvp_copy_mono(
2447 bool reverse = false;
2448
2449 /* check page-in */
2450- if (opvp_check_in_page(pdev)) return -1;
2451+ if (opvp_check_in_page(opdev))
2452+ return -1;
2453
2454 /* data offset */
2455 if (data_x) {
2456@@ -2773,8 +3078,8 @@ opvp_copy_mono(
2457
2458 #if !(ENABLE_SIMPLE_MODE)
2459 /* call SaveGS */
2460- if (apiEntry->opvpSaveGS) {
2461- apiEntry->opvpSaveGS(printerContext);
2462+ if (opdev->globals.apiEntry->opvpSaveGS) {
2463+ opdev->globals.apiEntry->opvpSaveGS(printerContext);
2464 }
2465 #endif
2466 if (one == gx_no_color_index) {
2467@@ -2789,25 +3094,22 @@ opvp_copy_mono(
2468 if (zero != gx_no_color_index) {
2469 /* not mask */
2470 /* Set PaintMode */
2471- if (apiEntry->opvpSetPaintMode) {
2472- apiEntry->opvpSetPaintMode(printerContext,OPVP_PAINTMODE_OPAQUE);
2473+ if (opdev->globals.apiEntry->opvpSetPaintMode) {
2474+ opdev->globals.apiEntry->opvpSetPaintMode(opdev->globals.printerContext, OPVP_PAINTMODE_OPAQUE);
2475 }
2476 /* zero-color */
2477- opvp_set_brush_color(pdev, zero, &brush);
2478+ opvp_set_brush_color(opdev, zero, &brush);
2479
2480 /* call SetBgColor */
2481- if (apiEntry->opvpSetBgColor) {
2482- apiEntry->opvpSetBgColor(printerContext, &brush);
2483- }
2484+ gsopvpSetBgColor(dev, opdev->globals.printerContext, &brush);
2485+
2486 }
2487
2488 /* one-color */
2489- opvp_set_brush_color(pdev, one, &brush);
2490+ opvp_set_brush_color(opdev, one, &brush);
2491
2492 /* call SetFillColor */
2493- if (apiEntry->opvpSetFillColor) {
2494- apiEntry->opvpSetFillColor(printerContext, &brush);
2495- }
2496+ gsopvpSetFillColor(dev, opdev->globals.printerContext, &brush);
2497
2498 if (reverse) {
2499 /* 0/1 reverse image */
2500@@ -2826,12 +3128,12 @@ opvp_copy_mono(
2501 /* call SetCurrentPoint */
2502 OPVP_I2FIX(x, point.x);
2503 OPVP_I2FIX(y, point.y);
2504- if (apiEntry->opvpSetCurrentPoint) {
2505- apiEntry->opvpSetCurrentPoint(printerContext,point.x, point.y);
2506+ if (opdev->globals.apiEntry->opvpSetCurrentPoint) {
2507+ opdev->globals.apiEntry->opvpSetCurrentPoint(opdev->globals.printerContext,point.x, point.y);
2508 }
2509
2510 /* draw image */
2511- code = opvp_draw_image(pdev,
2512+ code = opvp_draw_image(opdev,
2513 1,
2514 w, h,
2515 w, h,
2516@@ -2844,23 +3146,21 @@ opvp_copy_mono(
2517
2518 if (zero != gx_no_color_index) {
2519 /* restore PaintMode */
2520- if (apiEntry->opvpSetPaintMode) {
2521- apiEntry->opvpSetPaintMode(printerContext,
2522+ if (opdev->globals.apiEntry->opvpSetPaintMode) {
2523+ opdev->globals.apiEntry->opvpSetPaintMode(opdev->globals.printerContext,
2524 OPVP_PAINTMODE_TRANSPARENT);
2525 }
2526 }
2527 /* restore fill color */
2528- if (vectorFillColor) {
2529+ if (opdev->globals.vectorFillColor) {
2530 /* call SetFillColor */
2531- if (apiEntry->opvpSetFillColor) {
2532- apiEntry->opvpSetFillColor(printerContext,vectorFillColor);
2533- }
2534+ gsopvpSetFillColor(dev, opdev->globals.printerContext,opdev->globals.vectorFillColor);
2535 }
2536
2537 #if !(ENABLE_SIMPLE_MODE)
2538 /* call RestoreGS */
2539- if (apiEntry->opvpRestoreGS) {
2540- apiEntry->opvpRestoreGS(printerContext);
2541+ if (opdev->globals.apiEntry->opvpRestoreGS) {
2542+ opdev->globals.apiEntry->opvpRestoreGS(opdev->globals.printerContext);
2543 }
2544 #endif
2545
2546@@ -2887,7 +3187,7 @@ opvp_copy_color(
2547 int w,
2548 int h)
2549 {
2550- gx_device_opvp *pdev = (gx_device_opvp *)dev;
2551+ gx_device_opvp *opdev = (gx_device_opvp *)dev;
2552 int code = -1;
2553 int ecode = 0;
2554 opvp_point_t point;
2555@@ -2902,11 +3202,12 @@ opvp_copy_color(
2556 int adj_raster = raster;
2557
2558 /* check page-in */
2559- if (opvp_check_in_page(pdev)) return -1;
2560+ if (opvp_check_in_page(opdev))
2561+ return -1;
2562
2563 /* data offset */
2564 if (data_x) {
2565- depth = pdev->color_info.depth;
2566+ depth = opdev->color_info.depth;
2567 pixel = (depth + 7) >> 3;
2568 byte_length = pixel * w;
2569 adj_raster = ((byte_length + 3) >> 2) << 2;
2570@@ -2926,21 +3227,21 @@ opvp_copy_color(
2571
2572 #if !(ENABLE_SIMPLE_MODE)
2573 /* call SaveGS */
2574- if (apiEntry->opvpSaveGS) {
2575- apiEntry->opvpSaveGS(printerContext);
2576+ if (opdev->globals.apiEntry->opvpSaveGS) {
2577+ opdev->globals.apiEntry->opvpSaveGS(opdev->globals.printerContext);
2578 }
2579 #endif
2580
2581 /* call SetCurrentPoint */
2582 OPVP_I2FIX(x, point.x);
2583 OPVP_I2FIX(y, point.y);
2584- if (apiEntry->opvpSetCurrentPoint) {
2585- apiEntry->opvpSetCurrentPoint(printerContext, point.x, point.y);
2586+ if (opdev->globals.apiEntry->opvpSetCurrentPoint) {
2587+ opdev->globals.apiEntry->opvpSetCurrentPoint(opdev->globals.printerContext, point.x, point.y);
2588 }
2589
2590 /* draw image */
2591- code = opvp_draw_image(pdev,
2592- pdev->color_info.depth,
2593+ code = opvp_draw_image(opdev,
2594+ opdev->color_info.depth,
2595 w, h,
2596 w, h,
2597 adj_raster,
2598@@ -2952,8 +3253,8 @@ opvp_copy_color(
2599
2600 #if !(ENABLE_SIMPLE_MODE)
2601 /* call RestoreGS */
2602- if (apiEntry->opvpRestoreGS) {
2603- apiEntry->opvpRestoreGS(printerContext);
2604+ if (opdev->globals.apiEntry->opvpRestoreGS) {
2605+ opdev->globals.apiEntry->opvpRestoreGS(opdev->globals.printerContext);
2606 }
2607 #endif
2608
2609@@ -2969,7 +3270,7 @@ opvp_copy_color(
2610 * get params
2611 */
2612 static int
2613-_get_params(gs_param_list *plist)
2614+_get_params(gx_device* dev, gs_param_list *plist)
2615 {
2616 int code;
2617 int ecode = 0;
2618@@ -2985,37 +3286,38 @@ _get_params(gs_param_list *plist)
2619 gs_param_string mbps;
2620 gs_param_string zmps;
2621 char buff[OPVP_BUFF_SIZE];
2622+ gx_device_opvp* opdev = (gx_device_opvp*)dev;
2623
2624 /* get params */
2625
2626 /* vector driver name */
2627 pname = "Driver";
2628- vdps.data = (byte *)vectorDriver;
2629- vdps.size = (vectorDriver ? strlen(vectorDriver) + 1 : 0);
2630+ vdps.data = (byte *)opdev->globals.vectorDriver;
2631+ vdps.size = (opdev->globals.vectorDriver ? strlen(opdev->globals.vectorDriver) + 1 : 0);
2632 vdps.persistent = false;
2633 code = param_write_string(plist, pname, &vdps);
2634 if (code) ecode = code;
2635
2636 /* printer model name */
2637 pname = "Model";
2638- pmps.data = (byte *)printerModel;
2639- pmps.size = (printerModel ? strlen(printerModel) + 1 : 0);
2640+ pmps.data = (byte *)opdev->globals.printerModel;
2641+ pmps.size = (opdev->globals.printerModel ? strlen(opdev->globals.printerModel) + 1 : 0);
2642 pmps.persistent = false;
2643 code = param_write_string(plist, pname, &pmps);
2644 if (code) ecode = code;
2645
2646 /* job info */
2647 pname = "JobInfo";
2648- jips.data = (byte *)jobInfo;
2649- jips.size = (jobInfo ? strlen(jobInfo) + 1 : 0);
2650+ jips.data = (byte *)opdev->globals.jobInfo;
2651+ jips.size = (opdev->globals.jobInfo ? strlen(opdev->globals.jobInfo) + 1 : 0);
2652 jips.persistent = false;
2653 code = param_write_string(plist, pname, &jips);
2654 if (code) ecode = code;
2655
2656 /* doc info */
2657 pname = "DocInfo";
2658- dips.data = (byte *)docInfo;
2659- dips.size = (docInfo ? strlen(docInfo) + 1 : 0);
2660+ dips.data = (byte *)opdev->globals.docInfo;
2661+ dips.size = (opdev->globals.docInfo ? strlen(opdev->globals.docInfo) + 1 : 0);
2662 dips.persistent = false;
2663 code = param_write_string(plist, pname, &dips);
2664 if (code) ecode = code;
2665@@ -3052,28 +3354,28 @@ _get_params(gs_param_list *plist)
2666 /* margins */
2667 memset((void*)buff, 0, OPVP_BUFF_SIZE);
2668 pname = "MarginLeft";
2669- snprintf(buff, OPVP_BUFF_SIZE - 1, "%f",margins[0]);
2670+ snprintf(buff, OPVP_BUFF_SIZE - 1, "%f",opdev->globals.margins[0]);
2671 mlps.data = (byte *)buff;
2672 mlps.size = strlen(buff) + 1;
2673 mlps.persistent = false;
2674 code = param_write_string(plist, pname, &mlps);
2675 if (code) ecode = code;
2676 pname = "MarginTop";
2677- snprintf(buff, OPVP_BUFF_SIZE - 1, "%f",margins[3]);
2678+ snprintf(buff, OPVP_BUFF_SIZE - 1, "%f",opdev->globals.margins[3]);
2679 mtps.data = (byte *)buff;
2680 mtps.size = strlen(buff) + 1;
2681 mtps.persistent = false;
2682 code = param_write_string(plist, pname, &mtps);
2683 if (code) ecode = code;
2684 pname = "MarginRight";
2685- snprintf(buff, OPVP_BUFF_SIZE - 1, "%f",margins[2]);
2686+ snprintf(buff, OPVP_BUFF_SIZE - 1, "%f",opdev->globals.margins[2]);
2687 mrps.data = (byte *)buff;
2688 mrps.size = strlen(buff) + 1;
2689 mrps.persistent = false;
2690 code = param_write_string(plist, pname, &mrps);
2691 if (code) ecode = code;
2692 pname = "MarginBottom";
2693- snprintf(buff, OPVP_BUFF_SIZE - 1, "%f",margins[1]);
2694+ snprintf(buff, OPVP_BUFF_SIZE - 1, "%f",opdev->globals.margins[1]);
2695 mbps.data = (byte *)buff;
2696 mbps.size = strlen(buff) + 1;
2697 mbps.persistent = false;
2698@@ -3082,7 +3384,7 @@ _get_params(gs_param_list *plist)
2699
2700 /* zoom */
2701 pname = "Zoom";
2702- snprintf(buff, OPVP_BUFF_SIZE - 1, "%f",zoom[0]);
2703+ snprintf(buff, OPVP_BUFF_SIZE - 1, "%f",opdev->globals.zoom[0]);
2704 zmps.data = (byte *)buff;
2705 zmps.size = strlen(buff) + 1;
2706 zmps.persistent = false;
2707@@ -3105,7 +3407,7 @@ opvp_get_params(gx_device *dev, gs_param_list *plist)
2708 if (code) return code;
2709
2710 /* get params */
2711- return _get_params(plist);
2712+ return _get_params(dev, plist);
2713 }
2714
2715 /*
2716@@ -3121,14 +3423,14 @@ oprp_get_params(gx_device *dev, gs_param_list *plist)
2717 if (code) return code;
2718
2719 /* get params */
2720- return _get_params(plist);
2721+ return _get_params(dev, plist);
2722 }
2723
2724 /*
2725 * put params
2726 */
2727 static int
2728-_put_params(gs_param_list *plist)
2729+_put_params(gx_device *dev, gs_param_list *plist)
2730 {
2731 int code;
2732 int ecode = 0;
2733@@ -3144,6 +3446,7 @@ _put_params(gs_param_list *plist)
2734 gs_param_string mrps;
2735 gs_param_string mbps;
2736 gs_param_string zmps;
2737+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
2738
2739 /* vector driver name */
2740 pname = "Driver";
2741@@ -3153,10 +3456,10 @@ _put_params(gs_param_list *plist)
2742 buff = realloc(buff, vdps.size + 1);
2743 memcpy(buff, vdps.data, vdps.size);
2744 buff[vdps.size] = 0;
2745- opvp_alloc_string(&vectorDriver, buff);
2746+ opvp_alloc_string(&(opdev->globals.vectorDriver), buff);
2747 break;
2748 case 1:
2749- /* opvp_alloc_string(&vectorDriver, NULL);*/
2750+ /* opvp_alloc_string(&(opdev->globals.vectorDriver), NULL);*/
2751 break;
2752 default:
2753 ecode = code;
2754@@ -3171,10 +3474,10 @@ _put_params(gs_param_list *plist)
2755 buff = realloc(buff, pmps.size + 1);
2756 memcpy(buff, pmps.data, pmps.size);
2757 buff[pmps.size] = 0;
2758- opvp_alloc_string(&printerModel, buff);
2759+ opvp_alloc_string(&(opdev->globals.printerModel), buff);
2760 break;
2761 case 1:
2762- /*opvp_alloc_string(&printerModel, NULL);*/
2763+ /*opvp_alloc_string(&(opdev->globals.printerModel), NULL);*/
2764 break;
2765 default:
2766 ecode = code;
2767@@ -3189,10 +3492,10 @@ _put_params(gs_param_list *plist)
2768 buff = realloc(buff, jips.size + 1);
2769 memcpy(buff, jips.data, jips.size);
2770 buff[jips.size] = 0;
2771- opvp_alloc_string(&jobInfo, buff);
2772+ opvp_alloc_string(&(opdev->globals.jobInfo), buff);
2773 break;
2774 case 1:
2775- /*opvp_alloc_string(&jobInfo, NULL);*/
2776+ /*opvp_alloc_string(&(opdev->globals.jobInfo), NULL);*/
2777 break;
2778 default:
2779 ecode = code;
2780@@ -3207,10 +3510,10 @@ _put_params(gs_param_list *plist)
2781 buff = realloc(buff, dips.size + 1);
2782 memcpy(buff, dips.data, dips.size);
2783 buff[dips.size] = 0;
2784- opvp_alloc_string(&docInfo, buff);
2785+ opvp_alloc_string(&(opdev->globals.docInfo), buff);
2786 break;
2787 case 1:
2788- /*opvp_alloc_string(&docInfo, NULL);*/
2789+ /*opvp_alloc_string(&(opdev->globals.docInfo), NULL);*/
2790 break;
2791 default:
2792 ecode = code;
2793@@ -3256,7 +3559,7 @@ _put_params(gs_param_list *plist)
2794 buff = realloc(buff, mlps.size + 1);
2795 memcpy(buff, mlps.data, mlps.size);
2796 buff[mlps.size] = 0;
2797- margins[0] = atof(buff);
2798+ opdev->globals.margins[0] = atof(buff);
2799 break;
2800 case 1:
2801 break;
2802@@ -3271,7 +3574,7 @@ _put_params(gs_param_list *plist)
2803 buff = realloc(buff, mtps.size + 1);
2804 memcpy(buff, mtps.data, mtps.size);
2805 buff[mtps.size] = 0;
2806- margins[3] = atof(buff);
2807+ opdev->globals.margins[3] = atof(buff);
2808 break;
2809 case 1:
2810 break;
2811@@ -3286,7 +3589,7 @@ _put_params(gs_param_list *plist)
2812 buff = realloc(buff, mrps.size + 1);
2813 memcpy(buff, mrps.data, mrps.size);
2814 buff[mrps.size] = 0;
2815- margins[2] = atof(buff);
2816+ opdev->globals.margins[2] = atof(buff);
2817 break;
2818 case 1:
2819 break;
2820@@ -3301,7 +3604,7 @@ _put_params(gs_param_list *plist)
2821 buff = realloc(buff, mbps.size + 1);
2822 memcpy(buff, mbps.data, mbps.size);
2823 buff[mbps.size] = 0;
2824- margins[1] = atof(buff);
2825+ opdev->globals.margins[1] = atof(buff);
2826 break;
2827 case 1:
2828 break;
2829@@ -3319,15 +3622,15 @@ _put_params(gs_param_list *plist)
2830 memcpy(buff, zmps.data, zmps.size);
2831 buff[zmps.size] = 0;
2832 if (strncasecmp(buff, "Auto", 4)) {
2833- zoom[0] = atof(buff);
2834- if (zoom[0] > 0) {
2835- zoom[1] = zoom[0];
2836+ opdev->globals.zoom[0] = atof(buff);
2837+ if (opdev->globals.zoom[0] > 0) {
2838+ opdev->globals.zoom[1] = opdev->globals.zoom[0];
2839 } else {
2840- zoom[0] = zoom[1] = 1;
2841+ opdev->globals.zoom[0] = opdev->globals.zoom[1] = 1;
2842 }
2843 } else {
2844- zoom[0] = zoom[1] = 1;
2845- zoomAuto = true;
2846+ opdev->globals.zoom[0] = opdev->globals.zoom[1] = 1;
2847+ opdev->globals.zoomAuto = true;
2848 }
2849 break;
2850 case 1:
2851@@ -3351,7 +3654,7 @@ opvp_put_params(gx_device *dev, gs_param_list *plist)
2852 int code;
2853
2854 /* put params */
2855- code = _put_params(plist);
2856+ code = _put_params(dev, plist);
2857 if (code) return code;
2858
2859 /* put default params */
2860@@ -3367,7 +3670,7 @@ oprp_put_params(gx_device *dev, gs_param_list *plist)
2861 int code;
2862
2863 /* put params */
2864- code = _put_params(plist);
2865+ code = _put_params(dev, plist);
2866 if (code) return code;
2867
2868 /* put default params */
2869@@ -3444,13 +3747,14 @@ opvp_fill_path(
2870 {
2871 bool draw_image = false;
2872 gs_fixed_rect inner, outer;
2873+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
2874
2875 /* check if paths are too complex */
2876 if (!checkPath(ppath) || !checkCPath(pxpath)) {
2877 return gx_default_fill_path(dev, pgs, ppath, params, pdevc, pxpath);
2878 }
2879 /* check clippath support */
2880- if (!(apiEntry->opvpSetClipPath)) {
2881+ if (!(opdev->globals.apiEntry->opvpSetClipPath)) {
2882 /* get clipping box area */
2883 gx_cpath_inner_box(pxpath,&inner);
2884 gx_cpath_outer_box(pxpath,&outer);
2885@@ -3462,7 +3766,7 @@ opvp_fill_path(
2886 }
2887 }
2888
2889- if (!vector || draw_image) {
2890+ if (!(opdev->globals.vector) || draw_image) {
2891 return gx_default_fill_path(dev, pgs, ppath, params, pdevc, pxpath);
2892 }
2893
2894@@ -3483,6 +3787,7 @@ opvp_stroke_path(
2895 {
2896 bool draw_image = false;
2897 gs_fixed_rect inner, outer;
2898+ gx_device_opvp *opdev = (gx_device_opvp *) dev;
2899
2900 /* check if paths are too complex */
2901 if (!checkPath(ppath) || !checkCPath(pxpath)) {
2902@@ -3490,7 +3795,7 @@ opvp_stroke_path(
2903 params, pdcolor, pxpath);
2904 }
2905 /* check clippath support */
2906- if (!(apiEntry->opvpSetClipPath)) {
2907+ if (!(opdev->globals.apiEntry->opvpSetClipPath)) {
2908 /* get clipping box area */
2909 gx_cpath_inner_box(pxpath,&inner);
2910 gx_cpath_outer_box(pxpath,&outer);
2911@@ -3502,7 +3807,7 @@ opvp_stroke_path(
2912 }
2913 }
2914
2915- if (!vector || draw_image) {
2916+ if (!(opdev->globals.vector) || draw_image) {
2917 return gx_default_stroke_path(dev, pgs, ppath,
2918 params, pdcolor, pxpath);
2919 }
2920@@ -3530,7 +3835,9 @@ opvp_fill_mask(
2921 gs_logical_operation_t lop,
2922 const gx_clip_path *pcpath)
2923 {
2924- if (vector) {
2925+ gx_device_opvp *opdev = (gx_device_opvp*) dev;
2926+
2927+ if (opdev->globals.vector) {
2928 int code;
2929 code = gdev_vector_update_fill_color((gx_device_vector *)dev, NULL, pdcolor);
2930 if (code < 0) return code;
2931@@ -3574,6 +3881,7 @@ opvp_begin_typed_image(
2932 int p;
2933 float mag[2] = {1, 1};
2934 const gs_color_space *pcs;
2935+ gx_device_opvp *opdev = (gx_device_opvp *)dev;
2936
2937 /* check if paths are too complex */
2938 if (pic->type->index != 1 || !checkCPath(pcpath))
2939@@ -3757,7 +4065,7 @@ opvp_begin_typed_image(
2940 * 3 planes 24 bits color image
2941 * (8 bits per plane)
2942 */
2943- if (apiEntry->opvpStartDrawImage) {
2944+ if (opdev->globals.apiEntry->opvpStartDrawImage) {
2945 draw_image = true;
2946 }
2947 }
2948@@ -3768,54 +4076,51 @@ opvp_begin_typed_image(
2949 *pinfo = (gx_image_enum_common_t *)vinfo;
2950
2951 if (!ecode) {
2952+ opvp_cspace_t ncspace;
2953+
2954 if (!pim->ImageMask) {
2955 /* call SetPaintMode */
2956- if (apiEntry->opvpSetPaintMode) {
2957- apiEntry->opvpSetPaintMode(printerContext,
2958+ if (opdev->globals.apiEntry->opvpSetPaintMode) {
2959+ opdev->globals.apiEntry->opvpSetPaintMode(opdev->globals.printerContext,
2960 OPVP_PAINTMODE_OPAQUE);
2961 change_paint_mode = true;
2962 }
2963 /* set color space */
2964- if (apiEntry->opvpSetColorSpace != NULL) {
2965- opvp_cspace_t ncspace;
2966-
2967- savedColorSpace = colorSpace;
2968- switch (bits_per_pixel) {
2969- case 1:
2970- ncspace = OPVP_CSPACE_DEVICEGRAY;
2971- bits_per_pixel = 8;
2972- if (!cspace_available[ncspace]) {
2973- ncspace = OPVP_CSPACE_STANDARDRGB;
2974- bits_per_pixel = 24;
2975- }
2976- break;
2977- case 8:
2978- ncspace = OPVP_CSPACE_DEVICEGRAY;
2979- if (!cspace_available[ncspace]) {
2980- ncspace = OPVP_CSPACE_STANDARDRGB;
2981- bits_per_pixel = 24;
2982- }
2983- break;
2984- case 24:
2985- ncspace = OPVP_CSPACE_DEVICERGB;
2986- if (!cspace_available[ncspace]) {
2987- ncspace = OPVP_CSPACE_STANDARDRGB;
2988- }
2989- break;
2990- default:
2991+ opdev->globals.savedColorSpace = opdev->globals.colorSpace;
2992+ switch (bits_per_pixel) {
2993+ case 1:
2994+ ncspace = OPVP_CSPACE_DEVICEGRAY;
2995+ bits_per_pixel = 8;
2996+ if (!cspace_available[ncspace]) {
2997+ ncspace = OPVP_CSPACE_STANDARDRGB;
2998+ bits_per_pixel = 24;
2999+ }
3000+ break;
3001+ case 8:
3002+ ncspace = OPVP_CSPACE_DEVICEGRAY;
3003+ if (!cspace_available[ncspace]) {
3004+ ncspace = OPVP_CSPACE_STANDARDRGB;
3005+ bits_per_pixel = 24;
3006+ }
3007+ break;
3008+ case 24:
3009+ ncspace = OPVP_CSPACE_DEVICERGB;
3010+ if (!cspace_available[ncspace]) {
3011+ ncspace = OPVP_CSPACE_STANDARDRGB;
3012+ }
3013+ break;
3014+ default:
3015+ r = -1;
3016+ goto fallthrough;
3017+ break;
3018+ }
3019+ if (ncspace != opdev->globals.colorSpace) {
3020+ if (gsopvpSetColorSpace(dev, opdev->globals.printerContext, ncspace) != OPVP_OK) {
3021 r = -1;
3022 goto fallthrough;
3023- break;
3024- }
3025- if (ncspace != colorSpace) {
3026- if (apiEntry->opvpSetColorSpace(printerContext,ncspace)
3027- != OPVP_OK) {
3028- r = -1;
3029- goto fallthrough;
3030- }
3031- colorSpace = ncspace;
3032- change_cspace = true;
3033 }
3034+ opdev->globals.colorSpace = ncspace;
3035+ change_cspace = true;
3036 }
3037 }
3038 }
3039@@ -3832,8 +4137,8 @@ opvp_begin_typed_image(
3040 ctm.d = mtx.yy;
3041 ctm.e = mtx.tx;
3042 ctm.f = mtx.ty;
3043- if (apiEntry->opvpSetCTM) {
3044- r = apiEntry->opvpSetCTM(printerContext, &ctm);
3045+ if (opdev->globals.apiEntry->opvpSetCTM) {
3046+ r = opdev->globals.apiEntry->opvpSetCTM(opdev->globals.printerContext, &ctm);
3047 }
3048 else r = -1;
3049 if (r != OPVP_OK) ecode = r;
3050@@ -3841,38 +4146,33 @@ opvp_begin_typed_image(
3051 }
3052 if (!ecode) {
3053 int dw,dh;
3054+ opvp_int_t adj_raster;
3055
3056 /* image size */
3057 if (mag[0] != 1) {
3058- dw = floor(vinfo->width * mag[0]+0.5);
3059+ dw = (int) floor(vinfo->width * mag[0]+0.5);
3060 } else {
3061 dw = vinfo->width;
3062 }
3063 if (mag[1] != 1) {
3064- dh = floor(vinfo->height * mag[1]+0.5);
3065+ dh = (int) floor(vinfo->height * mag[1]+0.5);
3066 } else {
3067 dh = vinfo->height;
3068 }
3069 /* call StartDrawImage */
3070- if (apiEntry->opvpStartDrawImage) {
3071- opvp_int_t adj_raster;
3072-
3073- adj_raster = bits_per_pixel*vinfo->width;
3074- adj_raster = ((adj_raster+31) >> 5) << 2;
3075- r = apiEntry->opvpStartDrawImage(
3076- printerContext,
3077- vinfo->width,
3078- vinfo->height,
3079- adj_raster,
3080- pim->ImageMask ?
3081- OPVP_IFORMAT_MASK:
3082- OPVP_IFORMAT_RAW,
3083- dw,dh);
3084- if(r != OPVP_OK) {
3085- if (apiEntry->opvpEndDrawImage) {
3086- apiEntry->opvpEndDrawImage(printerContext);
3087- }
3088- }
3089+ adj_raster = bits_per_pixel*vinfo->width;
3090+ adj_raster = ((adj_raster+31) >> 5) << 2;
3091+ r = gsopvpStartDrawImage(dev,
3092+ opdev->globals.printerContext,
3093+ vinfo->width,
3094+ vinfo->height,
3095+ adj_raster,
3096+ pim->ImageMask ?
3097+ OPVP_IFORMAT_MASK:
3098+ OPVP_IFORMAT_RAW,
3099+ dw,dh);
3100+ if(r != OPVP_OK) {
3101+ gsopvpEndDrawImage(dev, opdev->globals.printerContext);
3102 }
3103
3104 /* bugfix for 32bit CMYK image print error */
3105@@ -3880,23 +4180,20 @@ fallthrough:
3106 if(r != OPVP_OK) {
3107 if (change_paint_mode) {
3108 /* restore paint mode */
3109- if (apiEntry->opvpSetPaintMode) {
3110- apiEntry->opvpSetPaintMode(printerContext,
3111+ if (opdev->globals.apiEntry->opvpSetPaintMode) {
3112+ opdev->globals.apiEntry->opvpSetPaintMode(opdev->globals.printerContext,
3113 OPVP_PAINTMODE_TRANSPARENT);
3114 }
3115 change_paint_mode = false;
3116 }
3117 if (change_cspace) {
3118 /* restore color space */
3119- colorSpace = savedColorSpace;
3120- if (apiEntry->opvpSetColorSpace) {
3121- apiEntry->opvpSetColorSpace(printerContext,
3122- colorSpace);
3123- }
3124+ opdev->globals.colorSpace = opdev->globals.savedColorSpace;
3125+ gsopvpSetColorSpace(dev, opdev->globals.printerContext, opdev->globals.colorSpace);
3126 change_cspace = false;
3127 }
3128- if(apiEntry->opvpResetCTM) {
3129- apiEntry->opvpResetCTM(printerContext); /* reset CTM */
3130+ if(opdev->globals.apiEntry->opvpResetCTM) {
3131+ opdev->globals.apiEntry->opvpResetCTM(opdev->globals.printerContext); /* reset CTM */
3132 }
3133 goto fallback;
3134 }
3135@@ -3942,6 +4239,7 @@ opvp_image_plane_data(
3136 bbox_image_enum *pbe;
3137 gx_image_enum *tinfo;
3138 const gs_gstate *pgs;
3139+ gx_device_opvp *opdev = (gx_device_opvp*)(info->dev);
3140
3141 vinfo = (gdev_vector_image_enum_t *)info;
3142
3143@@ -4037,7 +4335,7 @@ opvp_image_plane_data(
3144 if(color_index == gs_color_space_index_Indexed) {
3145 if (base_color_index == gs_color_space_index_DeviceGray ||
3146 base_color_index == gs_color_space_index_CIEA) {
3147- if (colorSpace == OPVP_CSPACE_DEVICEGRAY) {
3148+ if (opdev->globals.colorSpace == OPVP_CSPACE_DEVICEGRAY) {
3149 /* Convert indexed gray color -> Gray */
3150 if (bits_per_pixel == 8) { /* 8bit image */
3151 dst_bytes = data_bytes;
3152@@ -4193,8 +4491,8 @@ opvp_image_plane_data(
3153 /* Convert Gray */
3154 if(color_index == gs_color_space_index_DeviceGray ||
3155 color_index == gs_color_space_index_CIEA) {
3156- if (colorSpace == OPVP_CSPACE_STANDARDRGB
3157- || colorSpace == OPVP_CSPACE_DEVICERGB) {
3158+ if (opdev->globals.colorSpace == OPVP_CSPACE_STANDARDRGB
3159+ || opdev->globals.colorSpace == OPVP_CSPACE_DEVICERGB) {
3160 /* convert to RGB */
3161 if (bits_per_pixel == 8) { /* 8bit image */
3162 dst_bytes = data_bytes * 3;
3163@@ -4206,7 +4504,7 @@ opvp_image_plane_data(
3164 src_ptr = buf + raster_length * i;
3165 dst_ptr = tmp_buf + dst_length * i;
3166 for (j = 0; j < data_bytes; j++) {
3167- unsigned char d = floor(
3168+ unsigned char d = (unsigned char) floor(
3169 imageDecode[0]*255 + src_ptr[j]*
3170 (imageDecode[1]-imageDecode[0])+0.5);
3171
3172@@ -4234,7 +4532,7 @@ opvp_image_plane_data(
3173 for (j = 0; j < vinfo->width; j++) {
3174 int o = ((src_ptr[j/8] & (1 << (7 - (j & 7))))
3175 != 0);
3176- unsigned char d = floor(
3177+ unsigned char d = (unsigned char) floor(
3178 imageDecode[0]*255 + o*
3179 (imageDecode[1]-imageDecode[0])*255+0.5);
3180 dst_ptr[j*3] = d; /* R */
3181@@ -4250,7 +4548,7 @@ opvp_image_plane_data(
3182 vinfo->bits_per_pixel = 24;
3183 }
3184 }
3185- } else if (colorSpace == OPVP_CSPACE_DEVICEGRAY) {
3186+ } else if (opdev->globals.colorSpace == OPVP_CSPACE_DEVICEGRAY) {
3187 if (bits_per_pixel == 1) { /* 1bit image */
3188 dst_bytes = vinfo->width;
3189 dst_length = ((dst_bytes + 3) >> 2) << 2;
3190@@ -4263,7 +4561,7 @@ opvp_image_plane_data(
3191 for (j = 0; j < vinfo->width; j++) {
3192 int o = ((src_ptr[j/8] & (1 << (7 - (j & 7))))
3193 != 0);
3194- unsigned char d = floor(
3195+ unsigned char d = (unsigned char) floor(
3196 imageDecode[0]*255 + o*
3197 (imageDecode[1]-imageDecode[0])*255+0.5);
3198 dst_ptr[j] = d; /* R */
3199@@ -4299,8 +4597,8 @@ opvp_image_plane_data(
3200 }
3201
3202 /* call TansferDrawImage */
3203- if (apiEntry->opvpTransferDrawImage) {
3204- apiEntry->opvpTransferDrawImage(printerContext,
3205+ if (opdev->globals.apiEntry->opvpTransferDrawImage) {
3206+ opdev->globals.apiEntry->opvpTransferDrawImage(opdev->globals.printerContext,
3207 raster_length * height, (void *)buf);
3208 }
3209 }
3210@@ -4325,21 +4623,20 @@ opvp_image_end_image(gx_image_enum_common_t *info, bool draw_last)
3211 gx_device_vector *vdev = (gx_device_vector *)dev;
3212 gdev_vector_image_enum_t *vinfo;
3213 opvp_ctm_t ctm;
3214+ gx_device_opvp *opdev = (gx_device_opvp*)dev;
3215
3216 vinfo = (gdev_vector_image_enum_t *)info;
3217
3218 if (begin_image) {
3219 /* call EndDrawImage */
3220- if (apiEntry->opvpEndDrawImage) {
3221- apiEntry->opvpEndDrawImage(printerContext);
3222- }
3223+ gsopvpEndDrawImage(dev, opdev->globals.printerContext);
3224
3225 begin_image = false;
3226
3227 if (FastImageMode != FastImageNoCTM) {
3228 /* call ResetCTM */
3229- if (apiEntry->opvpResetCTM) {
3230- apiEntry->opvpResetCTM(printerContext);
3231+ if (opdev->globals.apiEntry->opvpResetCTM) {
3232+ opdev->globals.apiEntry->opvpResetCTM(opdev->globals.printerContext);
3233 } else {
3234 /* call SetCTM */
3235 ctm.a = 1;
3236@@ -4348,25 +4645,24 @@ opvp_image_end_image(gx_image_enum_common_t *info, bool draw_last)
3237 ctm.d = 1;
3238 ctm.e = 0;
3239 ctm.f = 0;
3240- if (apiEntry->opvpSetCTM) {
3241- apiEntry->opvpSetCTM(printerContext, &ctm);
3242+ if (opdev->globals.apiEntry->opvpSetCTM) {
3243+ opdev->globals.apiEntry->opvpSetCTM(opdev->globals.printerContext, &ctm);
3244 }
3245 }
3246 }
3247 if (change_paint_mode) {
3248 /* restore paint mode */
3249- if (apiEntry->opvpSetPaintMode) {
3250- apiEntry->opvpSetPaintMode(printerContext,
3251+ if (opdev->globals.apiEntry->opvpSetPaintMode) {
3252+ opdev->globals.apiEntry->opvpSetPaintMode(opdev->globals.printerContext,
3253 OPVP_PAINTMODE_TRANSPARENT);
3254 }
3255 change_paint_mode = false;
3256 }
3257 if (change_cspace) {
3258 /* restore color space */
3259- colorSpace = savedColorSpace;
3260- if (apiEntry->opvpSetColorSpace) {
3261- apiEntry->opvpSetColorSpace(printerContext,
3262- colorSpace);
3263+ opdev->globals.colorSpace = opdev->globals.savedColorSpace;
3264+ if (gsopvpSetColorSpace(dev, opdev->globals.printerContext, opdev->globals.colorSpace) != OPVP_OK) {
3265+ return -1;
3266 }
3267 change_cspace = false;
3268 }
3269@@ -4382,20 +4678,20 @@ opvp_image_end_image(gx_image_enum_common_t *info, bool draw_last)
3270 static int
3271 opvp_beginpage(gx_device_vector *vdev)
3272 {
3273- gx_device_opvp *pdev = (gx_device_opvp *)vdev;
3274+ gx_device_opvp *opdev = (gx_device_opvp *)vdev;
3275 int code = -1;
3276 int ecode = 0;
3277
3278 #ifdef OPVP_IGNORE_BLANK_PAGE
3279- if (pdev->in_page) return 0;
3280+ if (opdev->in_page) return 0;
3281 #endif
3282 /* start page */
3283- code = opvp_startpage((gx_device *)pdev);
3284+ code = opvp_startpage((gx_device *)opdev);
3285 if (code) {
3286 ecode = code;
3287 } else {
3288- pdev->in_page = true; /* added '05.12.07 */
3289- beginPage = true;
3290+ opdev->in_page = true; /* added '05.12.07 */
3291+ opdev->globals.beginPage = true;
3292 }
3293
3294 return ecode;
3295@@ -4407,18 +4703,19 @@ opvp_beginpage(gx_device_vector *vdev)
3296 static int
3297 opvp_setlinewidth(gx_device_vector *vdev, double width)
3298 {
3299- gx_device_opvp *pdev = (gx_device_opvp *)vdev;
3300+ gx_device_opvp *opdev = (gx_device_opvp *)vdev;
3301 opvp_result_t r = -1;
3302 int ecode = 0;
3303 opvp_fix_t w;
3304
3305 /* check page-in */
3306- if (opvp_check_in_page(pdev)) return -1;
3307+ if (opvp_check_in_page(opdev))
3308+ return -1;
3309
3310 /* call SetLineWidth */
3311 OPVP_F2FIX(width, w);
3312- if (apiEntry->opvpSetLineWidth) {
3313- r = apiEntry->opvpSetLineWidth(printerContext, w);
3314+ if (opdev->globals.apiEntry->opvpSetLineWidth) {
3315+ r = opdev->globals.apiEntry->opvpSetLineWidth(opdev->globals.printerContext, w);
3316 }
3317 if (r != OPVP_OK) {
3318 ecode = -1;
3319@@ -4433,13 +4730,14 @@ opvp_setlinewidth(gx_device_vector *vdev, double width)
3320 static int
3321 opvp_setlinecap(gx_device_vector *vdev, gs_line_cap cap)
3322 {
3323- gx_device_opvp *pdev = (gx_device_opvp *)vdev;
3324+ gx_device_opvp *opdev = (gx_device_opvp *)vdev;
3325 opvp_result_t r = -1;
3326 int ecode = 0;
3327 opvp_linecap_t linecap;
3328
3329 /* check page-in */
3330- if (opvp_check_in_page(pdev)) return -1;
3331+ if (opvp_check_in_page(opdev))
3332+ return -1;
3333
3334 switch (cap) {
3335 case gs_cap_butt:
3336@@ -4458,8 +4756,8 @@ opvp_setlinecap(gx_device_vector *vdev, gs_line_cap cap)
3337 }
3338
3339 /* call SetLineCap */
3340- if (apiEntry->opvpSetLineCap) {
3341- r = apiEntry->opvpSetLineCap(printerContext, linecap);
3342+ if (opdev->globals.apiEntry->opvpSetLineCap) {
3343+ r = opdev->globals.apiEntry->opvpSetLineCap(opdev->globals.printerContext, linecap);
3344 }
3345 if (r != OPVP_OK) {
3346 ecode = -1;
3347@@ -4474,13 +4772,14 @@ opvp_setlinecap(gx_device_vector *vdev, gs_line_cap cap)
3348 static int
3349 opvp_setlinejoin(gx_device_vector *vdev, gs_line_join join)
3350 {
3351- gx_device_opvp *pdev = (gx_device_opvp *)vdev;
3352+ gx_device_opvp *opdev = (gx_device_opvp *)vdev;
3353 opvp_result_t r = -1;
3354 int ecode = 0;
3355 opvp_linejoin_t linejoin;
3356
3357 /* check page-in */
3358- if (opvp_check_in_page(pdev)) return -1;
3359+ if (opvp_check_in_page(opdev))
3360+ return -1;
3361
3362 switch (join) {
3363 case gs_join_miter:
3364@@ -4500,8 +4799,8 @@ opvp_setlinejoin(gx_device_vector *vdev, gs_line_join join)
3365 }
3366
3367 /* call SetLineJoin */
3368- if (apiEntry->opvpSetLineJoin) {
3369- r = apiEntry->opvpSetLineJoin(printerContext, linejoin);
3370+ if (opdev->globals.apiEntry->opvpSetLineJoin) {
3371+ r = opdev->globals.apiEntry->opvpSetLineJoin(opdev->globals.printerContext, linejoin);
3372 }
3373 if (r != OPVP_OK) {
3374 ecode = -1;
3375@@ -4516,18 +4815,19 @@ opvp_setlinejoin(gx_device_vector *vdev, gs_line_join join)
3376 static int
3377 opvp_setmiterlimit(gx_device_vector *vdev, double limit)
3378 {
3379- gx_device_opvp *pdev = (gx_device_opvp *)vdev;
3380+ gx_device_opvp *opdev = (gx_device_opvp *)vdev;
3381 opvp_result_t r = -1;
3382 int ecode = 0;
3383 opvp_fix_t l;
3384
3385 /* check page-in */
3386- if (opvp_check_in_page(pdev)) return -1;
3387+ if (opvp_check_in_page(opdev))
3388+ return -1;
3389
3390 /* call SetMiterLimit */
3391 OPVP_F2FIX(limit, l);
3392- if (apiEntry->opvpSetMiterLimit) {
3393- r = apiEntry->opvpSetMiterLimit(printerContext, l);
3394+ if (opdev->globals.apiEntry->opvpSetMiterLimit) {
3395+ r = opdev->globals.apiEntry->opvpSetMiterLimit(opdev->globals.printerContext, l);
3396 }
3397 if (r != OPVP_OK) {
3398 ecode = -1;
3399@@ -4546,7 +4846,7 @@ opvp_setdash(
3400 uint count,
3401 double offset)
3402 {
3403- gx_device_opvp *pdev = (gx_device_opvp *)vdev;
3404+ gx_device_opvp *opdev = (gx_device_opvp *)vdev;
3405 opvp_result_t r = -1;
3406 int ecode = 0;
3407 opvp_fix_t *p = NULL;
3408@@ -4554,7 +4854,8 @@ opvp_setdash(
3409 int i;
3410
3411 /* check page-in */
3412- if (opvp_check_in_page(pdev)) return -1;
3413+ if (opvp_check_in_page(opdev))
3414+ return -1;
3415
3416 /* pattern */
3417 if (count) {
3418@@ -4570,9 +4871,7 @@ opvp_setdash(
3419
3420 /* call SetLineDash */
3421 if (!ecode) {
3422- if (apiEntry->opvpSetLineDash) {
3423- r = apiEntry->opvpSetLineDash(printerContext, count,p);
3424- }
3425+ r = gsopvpSetLineDash((gx_device*) vdev, opdev->globals.printerContext, count,p);
3426 if (r != OPVP_OK) {
3427 ecode = -1;
3428 }
3429@@ -4581,8 +4880,8 @@ opvp_setdash(
3430 /* call SetLineDashOffset */
3431 if (!ecode) {
3432 OPVP_F2FIX(offset, o);
3433- if (apiEntry->opvpSetLineDashOffset) {
3434- r = apiEntry->opvpSetLineDashOffset(printerContext, o);
3435+ if (opdev->globals.apiEntry->opvpSetLineDashOffset) {
3436+ r = opdev->globals.apiEntry->opvpSetLineDashOffset(opdev->globals.printerContext, o);
3437 }
3438 if (r != OPVP_OK) {
3439 ecode = -1;
3440@@ -4591,8 +4890,8 @@ opvp_setdash(
3441
3442 /* call SetLineStyle */
3443 if (!ecode) {
3444- if (apiEntry->opvpSetLineStyle) {
3445- r = apiEntry->opvpSetLineStyle(printerContext,
3446+ if (opdev->globals.apiEntry->opvpSetLineStyle) {
3447+ r = opdev->globals.apiEntry->opvpSetLineStyle(opdev->globals.printerContext,
3448 (count ?
3449 OPVP_LINESTYLE_DASH :
3450 OPVP_LINESTYLE_SOLID));
3451@@ -4613,11 +4912,12 @@ opvp_setdash(
3452 static int
3453 opvp_setflat(gx_device_vector *vdev, double flatness)
3454 {
3455- gx_device_opvp *pdev = (gx_device_opvp *)vdev;
3456+ gx_device_opvp *opdev = (gx_device_opvp *)vdev;
3457 int ecode = 0;
3458
3459 /* check page-in */
3460- if (opvp_check_in_page(pdev)) return -1;
3461+ if (opvp_check_in_page(opdev))
3462+ return -1;
3463
3464 /* what to do ? */
3465
3466@@ -4654,26 +4954,26 @@ opvp_setfillcolor(
3467 const gs_gstate *pgs, /* added for gs 8.15 */
3468 const gx_drawing_color *pdc)
3469 {
3470- gx_device_opvp *pdev = (gx_device_opvp *)vdev;
3471+ gx_device_opvp *opdev = (gx_device_opvp *)vdev;
3472 opvp_result_t r = -1;
3473 int ecode = 0;
3474 gx_color_index color;
3475 static opvp_brush_t brush;
3476
3477 /* check page-in */
3478- if (opvp_check_in_page(pdev)) return -1;
3479+ if (opvp_check_in_page(opdev))
3480+ return -1;
3481
3482 if (!gx_dc_is_pure(pdc)) return_error(gs_error_rangecheck);
3483
3484 /* color */
3485- if (!vectorFillColor) vectorFillColor = &brush;
3486+ if (!opdev->globals.vectorFillColor)
3487+ opdev->globals.vectorFillColor = &brush;
3488 color = gx_dc_pure_color(pdc);
3489- opvp_set_brush_color(pdev, color, vectorFillColor);
3490+ opvp_set_brush_color(opdev, color, opdev->globals.vectorFillColor);
3491
3492 /* call SetFillColor */
3493- if (apiEntry->opvpSetFillColor) {
3494- r = apiEntry->opvpSetFillColor(printerContext, vectorFillColor);
3495- }
3496+ r = gsopvpSetFillColor((gx_device*) vdev, opdev->globals.printerContext, opdev->globals.vectorFillColor);
3497 if (r != OPVP_OK) {
3498 ecode = -1;
3499 }
3500@@ -4690,25 +4990,24 @@ opvp_setstrokecolor(
3501 const gs_gstate *pgs, /* added for gs 8.15 */
3502 const gx_drawing_color *pdc)
3503 {
3504- gx_device_opvp *pdev = (gx_device_opvp *)vdev;
3505+ gx_device_opvp *opdev = (gx_device_opvp *)vdev;
3506 opvp_result_t r = -1;
3507 int ecode = 0;
3508 gx_color_index color;
3509 opvp_brush_t brush;
3510
3511 /* check page-in */
3512- if (opvp_check_in_page(pdev)) return -1;
3513+ if (opvp_check_in_page(opdev))
3514+ return -1;
3515
3516 if (!gx_dc_is_pure(pdc)) return_error(gs_error_rangecheck);
3517
3518 /* color */
3519 color = gx_dc_pure_color(pdc);
3520- opvp_set_brush_color(pdev, color, &brush);
3521+ opvp_set_brush_color(opdev, color, &brush);
3522
3523 /* call SetStrokeColor */
3524- if (apiEntry->opvpSetStrokeColor) {
3525- r = apiEntry->opvpSetStrokeColor(printerContext, &brush);
3526- }
3527+ r = gsopvpSetStrokeColor((gx_device*) vdev, opdev->globals.printerContext, &brush);
3528 if (r != OPVP_OK) {
3529 ecode = -1;
3530 }
3531@@ -4728,7 +5027,7 @@ opvp_vector_dopath(
3532 gx_path_type_t type,
3533 const gs_matrix *pmat)
3534 {
3535- gx_device_opvp *pdev = (gx_device_opvp *)vdev;
3536+ gx_device_opvp *opdev = (gx_device_opvp *)vdev;
3537 opvp_result_t r = -1;
3538 int code = -1;
3539 int ecode = 0;
3540@@ -4755,7 +5054,8 @@ opvp_vector_dopath(
3541 current.x = current.y = 0;
3542 #endif
3543 /* check page-in */
3544- if (opvp_check_in_page(pdev)) return -1;
3545+ if (opvp_check_in_page(opdev))
3546+ return -1;
3547
3548 if (gx_path_is_rectangle(ppath, &rect))
3549 return (*vdev_proc(vdev, dorect))(vdev,
3550@@ -4797,9 +5097,9 @@ opvp_vector_dopath(
3551 switch (pop) {
3552 case gs_pe_moveto:
3553 /* call SetCurrentPoint */
3554- if (apiEntry->opvpSetCurrentPoint) {
3555- r = apiEntry->opvpSetCurrentPoint(
3556- printerContext,
3557+ if (opdev->globals.apiEntry->opvpSetCurrentPoint) {
3558+ r = opdev->globals.apiEntry->opvpSetCurrentPoint(
3559+ opdev->globals.printerContext,
3560 opvp_p[npoints-1].x,
3561 opvp_p[npoints-1].y);
3562 }
3563@@ -4807,9 +5107,9 @@ opvp_vector_dopath(
3564 break;
3565 case gs_pe_lineto:
3566 /* call LinePath */
3567- if (apiEntry->opvpLinePath) {
3568- r = apiEntry->opvpLinePath(
3569- printerContext,
3570+ if (opdev->globals.apiEntry->opvpLinePath) {
3571+ r = opdev->globals.apiEntry->opvpLinePath(
3572+ opdev->globals.printerContext,
3573 OPVP_PATHOPEN,
3574 npoints - 1,
3575 &(opvp_p[1]));
3576@@ -4819,9 +5119,9 @@ opvp_vector_dopath(
3577 case gs_pe_curveto:
3578 /* npoints */
3579 /* call BezierPath */
3580- if (apiEntry->opvpBezierPath) {
3581- r = apiEntry->opvpBezierPath(
3582- printerContext,
3583+ if (opdev->globals.apiEntry->opvpBezierPath) {
3584+ r = opdev->globals.apiEntry->opvpBezierPath(
3585+ opdev->globals.printerContext,
3586 npoints - 1,
3587 &(opvp_p[1])
3588 );
3589@@ -4982,7 +5282,7 @@ opvp_vector_dorect(
3590 fixed y1,
3591 gx_path_type_t type)
3592 {
3593- gx_device_opvp *pdev = (gx_device_opvp *)vdev;
3594+ gx_device_opvp *opdev = (gx_device_opvp *)vdev;
3595 opvp_result_t r = -1;
3596 int code = -1;
3597 int ecode = 0;
3598@@ -4991,7 +5291,8 @@ opvp_vector_dorect(
3599 _fPoint p;
3600
3601 /* check page-in */
3602- if (opvp_check_in_page(pdev)) return -1;
3603+ if (opvp_check_in_page(opdev))
3604+ return -1;
3605
3606 /* begin path */
3607 code = (*vdev_proc(vdev, beginpath))(vdev, type);
3608@@ -5010,8 +5311,9 @@ opvp_vector_dorect(
3609 OPVP_F2FIX(p.y, rectangles[0].p1.y);
3610
3611 /* call RectanglePath */
3612- if (apiEntry->opvpRectanglePath) {
3613- r = apiEntry->opvpRectanglePath(printerContext,
3614+ if (opdev->globals.apiEntry->opvpRectanglePath) {
3615+ r = opdev->globals.apiEntry->opvpRectanglePath(
3616+ opdev->globals.printerContext,
3617 1,
3618 rectangles);
3619 }
3620@@ -5038,22 +5340,23 @@ opvp_vector_dorect(
3621 static int
3622 opvp_beginpath(gx_device_vector *vdev, gx_path_type_t type)
3623 {
3624- gx_device_opvp *pdev = (gx_device_opvp *)vdev;
3625+ gx_device_opvp *opdev = (gx_device_opvp *)vdev;
3626 opvp_result_t r = -1;
3627 int ecode = 0;
3628
3629 /* check page-in */
3630- if (opvp_check_in_page(pdev)) return -1;
3631+ if (opvp_check_in_page(opdev))
3632+ return -1;
3633
3634 /* check clip-path */
3635 if (type & gx_path_type_clip) {
3636- if (apiEntry->opvpResetClipPath)
3637- apiEntry->opvpResetClipPath(printerContext);
3638+ if (opdev->globals.apiEntry->opvpResetClipPath)
3639+ opdev->globals.apiEntry->opvpResetClipPath(opdev->globals.printerContext);
3640 }
3641
3642 /* call NewPath */
3643- if (apiEntry->opvpNewPath) {
3644- r = apiEntry->opvpNewPath(printerContext);
3645+ if (opdev->globals.apiEntry->opvpNewPath) {
3646+ r = opdev->globals.apiEntry->opvpNewPath(opdev->globals.printerContext);
3647 }
3648 if (r != OPVP_OK) {
3649 ecode = -1;
3650@@ -5074,19 +5377,20 @@ opvp_moveto(
3651 double y1,
3652 gx_path_type_t type)
3653 {
3654- gx_device_opvp *pdev = (gx_device_opvp *)vdev;
3655+ gx_device_opvp *opdev = (gx_device_opvp *)vdev;
3656 opvp_result_t r = -1;
3657 int ecode = 0;
3658 opvp_point_t p;
3659
3660 /* check page-in */
3661- if (opvp_check_in_page(pdev)) return -1;
3662+ if (opvp_check_in_page(opdev))
3663+ return -1;
3664
3665 /* call SetCurrentPoint */
3666 OPVP_F2FIX(x1, p.x);
3667 OPVP_F2FIX(y1, p.y);
3668- if (apiEntry->opvpSetCurrentPoint) {
3669- r = apiEntry->opvpSetCurrentPoint(printerContext, p.x, p.y);
3670+ if (opdev->globals.apiEntry->opvpSetCurrentPoint) {
3671+ r = opdev->globals.apiEntry->opvpSetCurrentPoint(opdev->globals.printerContext, p.x, p.y);
3672 }
3673 if (r != OPVP_OK) {
3674 ecode = -1;
3675@@ -5107,21 +5411,23 @@ opvp_lineto(
3676 double y1,
3677 gx_path_type_t type)
3678 {
3679- gx_device_opvp *pdev = (gx_device_opvp *)vdev;
3680+ gx_device_opvp *opdev = (gx_device_opvp *)vdev;
3681 opvp_result_t r = -1;
3682 int ecode = 0;
3683 opvp_point_t points[1];
3684
3685 /* check page-in */
3686- if (opvp_check_in_page(pdev)) return -1;
3687+ if (opvp_check_in_page(opdev))
3688+ return -1;
3689
3690 /* point */
3691 OPVP_F2FIX(x1, points[0].x);
3692 OPVP_F2FIX(y1, points[0].y);
3693
3694 /* call LinePath */
3695- if (apiEntry->opvpLinePath) {
3696- r = apiEntry->opvpLinePath(printerContext, OPVP_PATHOPEN, 1, points);
3697+ if (opdev->globals.apiEntry->opvpLinePath) {
3698+ r = opdev->globals.apiEntry->opvpLinePath(
3699+ opdev->globals.printerContext, OPVP_PATHOPEN, 1, points);
3700 }
3701 if (r != OPVP_OK) {
3702 ecode = -1;
3703@@ -5146,13 +5452,14 @@ opvp_curveto(
3704 double y3,
3705 gx_path_type_t type)
3706 {
3707- gx_device_opvp *pdev = (gx_device_opvp *)vdev;
3708+ gx_device_opvp *opdev = (gx_device_opvp *)vdev;
3709 opvp_result_t r = -1;
3710 int ecode = 0;
3711 opvp_point_t points[4];
3712
3713 /* check page-in */
3714- if (opvp_check_in_page(pdev)) return -1;
3715+ if (opvp_check_in_page(opdev))
3716+ return -1;
3717
3718 /* points */
3719 OPVP_F2FIX(x0, points[0].x);
3720@@ -5165,8 +5472,9 @@ opvp_curveto(
3721 OPVP_F2FIX(y3, points[3].y);
3722
3723 /* call BezierPath */
3724- if (apiEntry->opvpBezierPath) {
3725- r = apiEntry->opvpBezierPath(printerContext,
3726+ if (opdev->globals.apiEntry->opvpBezierPath) {
3727+ r = opdev->globals.apiEntry->opvpBezierPath(
3728+ opdev->globals.printerContext,
3729 3,
3730 &(points[1])
3731 );
3732@@ -5190,21 +5498,23 @@ opvp_closepath(
3733 double y_start,
3734 gx_path_type_t type)
3735 {
3736- gx_device_opvp *pdev = (gx_device_opvp *)vdev;
3737+ gx_device_opvp *opdev = (gx_device_opvp *)vdev;
3738 opvp_result_t r = -1;
3739 int ecode = 0;
3740 opvp_point_t points[1];
3741
3742 /* check page-in */
3743- if (opvp_check_in_page(pdev)) return -1;
3744+ if (opvp_check_in_page(opdev))
3745+ return -1;
3746
3747 /* point */
3748 OPVP_F2FIX(x_start, points[0].x);
3749 OPVP_F2FIX(y_start, points[0].y);
3750
3751 /* call LinePath */
3752- if (apiEntry->opvpLinePath) {
3753- r = apiEntry->opvpLinePath(printerContext, OPVP_PATHCLOSE, 1, points);
3754+ if (opdev->globals.apiEntry->opvpLinePath) {
3755+ r = opdev->globals.apiEntry->opvpLinePath(
3756+ opdev->globals.printerContext, OPVP_PATHCLOSE, 1, points);
3757 }
3758 if (r != OPVP_OK) {
3759 ecode = -1;
3760@@ -5219,16 +5529,17 @@ opvp_closepath(
3761 static int
3762 opvp_endpath(gx_device_vector *vdev, gx_path_type_t type)
3763 {
3764- gx_device_opvp *pdev = (gx_device_opvp *)vdev;
3765+ gx_device_opvp *opdev = (gx_device_opvp *)vdev;
3766 opvp_result_t r = -1;
3767 int ecode = 0;
3768
3769 /* check page-in */
3770- if (opvp_check_in_page(pdev)) return -1;
3771+ if (opvp_check_in_page(opdev))
3772+ return -1;
3773
3774 /* call EndPath */
3775- if (apiEntry->opvpEndPath) {
3776- r = apiEntry->opvpEndPath(printerContext);
3777+ if (opdev->globals.apiEntry->opvpEndPath) {
3778+ r = opdev->globals.apiEntry->opvpEndPath(opdev->globals.printerContext);
3779 }
3780 if (r != OPVP_OK) {
3781 ecode = -1;
3782@@ -5238,9 +5549,9 @@ opvp_endpath(gx_device_vector *vdev, gx_path_type_t type)
3783 /* fill mode */
3784 if (type & gx_path_type_even_odd) {
3785 /* call SetFillMode */
3786- if (apiEntry->opvpSetFillMode) {
3787- r = apiEntry->opvpSetFillMode(
3788- printerContext,
3789+ if (opdev->globals.apiEntry->opvpSetFillMode) {
3790+ r = opdev->globals.apiEntry->opvpSetFillMode(
3791+ opdev->globals.printerContext,
3792 OPVP_FILLMODE_EVENODD
3793 );
3794 }
3795@@ -5249,9 +5560,9 @@ opvp_endpath(gx_device_vector *vdev, gx_path_type_t type)
3796 }
3797 } else {
3798 /* call SetFillMode */
3799- if (apiEntry->opvpSetFillMode) {
3800- r = apiEntry->opvpSetFillMode(
3801- printerContext,
3802+ if (opdev->globals.apiEntry->opvpSetFillMode) {
3803+ r = opdev->globals.apiEntry->opvpSetFillMode(
3804+ opdev->globals.printerContext,
3805 OPVP_FILLMODE_WINDING
3806 );
3807 }
3808@@ -5262,16 +5573,16 @@ opvp_endpath(gx_device_vector *vdev, gx_path_type_t type)
3809
3810 if (type & gx_path_type_stroke) {
3811 /* call StrokeFillPath */
3812- if (apiEntry->opvpStrokeFillPath) {
3813- r = apiEntry->opvpStrokeFillPath(printerContext);
3814+ if (opdev->globals.apiEntry->opvpStrokeFillPath) {
3815+ r = opdev->globals.apiEntry->opvpStrokeFillPath(opdev->globals.printerContext);
3816 }
3817 if (r != OPVP_OK) {
3818 ecode = -1;
3819 }
3820 } else {
3821 /* call FillPath */
3822- if (apiEntry->opvpFillPath) {
3823- r = apiEntry->opvpFillPath(printerContext);
3824+ if (opdev->globals.apiEntry->opvpFillPath) {
3825+ r = opdev->globals.apiEntry->opvpFillPath(opdev->globals.printerContext);
3826 }
3827 if (r != OPVP_OK) {
3828 ecode = -1;
3829@@ -5279,9 +5590,9 @@ opvp_endpath(gx_device_vector *vdev, gx_path_type_t type)
3830 }
3831 } else if (type & gx_path_type_clip) {
3832 /* call SetClipPath */
3833- if (apiEntry->opvpSetClipPath) {
3834- r = apiEntry->opvpSetClipPath(
3835- printerContext,
3836+ if (opdev->globals.apiEntry->opvpSetClipPath) {
3837+ r = opdev->globals.apiEntry->opvpSetClipPath(
3838+ opdev->globals.printerContext,
3839 (type & gx_path_type_even_odd
3840 ? OPVP_CLIPRULE_EVENODD
3841 : OPVP_CLIPRULE_WINDING));
3842@@ -5291,8 +5602,8 @@ opvp_endpath(gx_device_vector *vdev, gx_path_type_t type)
3843 }
3844 } else if (type & gx_path_type_stroke) {
3845 /* call StrokePath */
3846- if (apiEntry->opvpStrokePath) {
3847- r = apiEntry->opvpStrokePath(printerContext);
3848+ if (opdev->globals.apiEntry->opvpStrokePath) {
3849+ r = opdev->globals.apiEntry->opvpStrokePath(opdev->globals.printerContext);
3850 }
3851 if (r != OPVP_OK) {
3852 ecode = -1;
3853diff --git a/contrib/opvp/opvp.h b/contrib/opvp/opvp.h
3854index 426e8cf..db09046 100644
3855--- a/contrib/opvp/opvp.h
3856+++ b/contrib/opvp/opvp.h
3857@@ -160,7 +160,7 @@ typedef struct _opvp_brushdata {
3858 #elif defined(__HP_cc)
3859 opvp_byte_t data[1];
3860 #else
3861- opvp_byte_t data[];
3862+ opvp_byte_t data[1];
3863 #endif
3864
3865 } opvp_brushdata_t;
3866@@ -222,8 +222,8 @@ typedef struct _opvp_api_procs {
3867 opvp_result_t (*opvpEndDoc)(opvp_dc_t);
3868 opvp_result_t (*opvpStartPage)(opvp_dc_t,const opvp_char_t*);
3869 opvp_result_t (*opvpEndPage)(opvp_dc_t);
3870- opvp_result_t (*opvpQueryDeviceCapability)(opvp_dc_t,opvp_flag_t,opvp_int_t*,opvp_byte_t*);
3871- opvp_result_t (*opvpQueryDeviceInfo)(opvp_dc_t,opvp_flag_t,opvp_int_t*,opvp_char_t*);
3872+ opvp_result_t (*opvpQueryDeviceCapability)(opvp_dc_t, opvp_queryinfoflags_t,opvp_int_t*,opvp_byte_t*);
3873+ opvp_result_t (*opvpQueryDeviceInfo)(opvp_dc_t, opvp_queryinfoflags_t,opvp_int_t*,opvp_char_t*);
3874 opvp_result_t (*opvpResetCTM)(opvp_dc_t);
3875 opvp_result_t (*opvpSetCTM)(opvp_dc_t,const opvp_ctm_t*);
3876 opvp_result_t (*opvpGetCTM)(opvp_dc_t,opvp_ctm_t*);
3877@@ -287,8 +287,7 @@ typedef struct _opvp_api_procs {
3878 } opvp_api_procs_t;
3879
3880 /* Function prototype */
3881-opvp_dc_t opvpOpenPrinter(
3882- opvp_int_t outputFD,
3883+extern opvp_dc_t opvpOpenPrinter(opvp_int_t outputFD,
3884 const opvp_char_t *printerModel,
3885 const opvp_int_t apiVersion[2],
3886 opvp_api_procs_t **apiProcs);
3887diff --git a/contrib/opvp/opvp_0_2_0.h b/contrib/opvp/opvp_0_2_0.h
3888index 6030971..8518b7e 100644
3889--- a/contrib/opvp/opvp_0_2_0.h
3890+++ b/contrib/opvp/opvp_0_2_0.h
3891@@ -210,7 +210,7 @@ typedef struct _OPVP_CTM {
3892 typedef struct _OPVP_api_procs {
3893 int (*OpenPrinter)(int,char *,int *,struct _OPVP_api_procs **);
3894 int (*ClosePrinter)(int);
3895- int (*StartJob)(int,char *);
3896+ int (*StartJob)(int, char *);
3897 int (*EndJob)(int);
3898 int (*StartDoc)(int,char *);
3899 int (*EndDoc)(int);
3900@@ -238,7 +238,7 @@ typedef struct _OPVP_api_procs {
3901 int (*GetAlphaConstant)(int,float *);
3902 int (*SetLineWidth)(int,OPVP_Fix);
3903 int (*GetLineWidth)(int,OPVP_Fix *);
3904- int (*SetLineDash)(int,OPVP_Fix *,int);
3905+ int (*SetLineDash)(int, int, OPVP_Fix *);
3906 int (*GetLineDash)(int,OPVP_Fix *,int *);
3907 int (*SetLineDashOffset)(int,OPVP_Fix);
3908 int (*GetLineDashOffset)(int,OPVP_Fix *);
3909diff --git a/contrib/opvp/opvpharness.c b/contrib/opvp/opvpharness.c
3910new file mode 100644
3911index 0000000..95919f4
3912--- /dev/null
3913+++ b/contrib/opvp/opvpharness.c
3914@@ -0,0 +1,947 @@
3915+/* Test harness for checking results after
3916+ removal of globals in opvp device. Note,
3917+ 0.2 API not tested. Assumption is OpenPrinter
3918+ is the first method called and ClosePrinter
3919+ will be the final method called. If not,
3920+ there will be problems. */
3921+
3922+#include "opvp.h"
3923+#include <stdio.h>
3924+#include <stdlib.h>
3925+#include <math.h>
3926+
3927+/* Yes globals, but here we don't care */
3928+FILE *pFile = NULL;
3929+
3930+/* Graphic state members of API that are set and get. */
3931+typedef struct opvp_gstate_s {
3932+ opvp_ctm_t ctm;
3933+ opvp_cspace_t colorspace;
3934+ opvp_fillmode_t fill_mode;
3935+ opvp_float_t alpha;
3936+ opvp_fix_t line_width;
3937+ opvp_int_t line_dash_n;
3938+ opvp_fix_t *line_dash_array;
3939+ opvp_fix_t dash_offset;
3940+ opvp_linestyle_t line_style;
3941+ opvp_linecap_t line_cap;
3942+ opvp_linejoin_t line_join;
3943+ opvp_fix_t miter_limit;
3944+ opvp_paintmode_t paintmode;
3945+} opvp_gstate_t;
3946+
3947+opvp_gstate_t opv_gstate;
3948+
3949+static opvp_result_t
3950+opvpClosePrinter(opvp_dc_t printerContext)
3951+{
3952+ fputs("opvpClosePrinter\n", pFile);
3953+ fprintf(pFile, "\tContext = %d\n", printerContext);
3954+ fclose(pFile);
3955+
3956+ if (opv_gstate.line_dash_array != NULL)
3957+ free(opv_gstate.line_dash_array);
3958+
3959+ return 0;
3960+}
3961+
3962+static opvp_result_t
3963+opvpStartJob(opvp_dc_t printerContext, const opvp_char_t *job_info)
3964+{
3965+ fputs("opvpStartJob\n", pFile);
3966+ fprintf(pFile, "\tContext = %d\n", printerContext);
3967+ fprintf(pFile, "\tjob_info = %s\n", job_info);
3968+ return 0;
3969+}
3970+
3971+static opvp_result_t
3972+opvpEndJob(opvp_dc_t printerContext)
3973+{
3974+ fputs("opvpEndJob\n", pFile);
3975+ fprintf(pFile, "\tContext = %d\n", printerContext);
3976+ return 0;
3977+}
3978+
3979+static opvp_result_t
3980+opvpAbortJob(opvp_dc_t printerContext)
3981+{
3982+ fputs("opvpAbortJob\n", pFile);
3983+ fprintf(pFile, "\tContext = %d\n", printerContext);
3984+ return 0;
3985+}
3986+
3987+static opvp_result_t
3988+opvpStartDoc(opvp_dc_t printerContext, const opvp_char_t *docinfo)
3989+{
3990+ fputs("opvpStartDoc\n", pFile);
3991+ fprintf(pFile, "\tContext = %d\n", printerContext);
3992+ fprintf(pFile, "\tjob_info = %s\n", docinfo);
3993+ return 0;
3994+}
3995+
3996+static opvp_result_t
3997+opvpEndDoc(opvp_dc_t printerContext)
3998+{
3999+ fputs("opvpEndDoc\n", pFile);
4000+ fprintf(pFile, "\tContext = %d\n", printerContext);
4001+ return 0;
4002+}
4003+
4004+static opvp_result_t
4005+opvpStartPage(opvp_dc_t printerContext, const opvp_char_t *pageinfo)
4006+{
4007+ fputs("opvpStartPage\n", pFile);
4008+ fprintf(pFile, "\tContext = %d\n", printerContext);
4009+ fprintf(pFile, "\tjob_info = %s\n", pageinfo);
4010+ return 0;
4011+}
4012+
4013+static opvp_result_t
4014+opvpEndPage(opvp_dc_t printerContext)
4015+{
4016+ fputs("opvpEndPage\n", pFile);
4017+ fprintf(pFile, "\tContext = %d\n", printerContext);
4018+ return 0;
4019+}
4020+
4021+/* Not used */
4022+static opvp_result_t
4023+opvpQueryDeviceCapability(opvp_dc_t printerContext, opvp_flag_t flag, opvp_int_t *a, opvp_byte_t *b)
4024+{
4025+ fputs("opvpQueryDeviceCapability\n", pFile);
4026+ fprintf(pFile, "\tContext = %d\n", printerContext);
4027+ return 0;
4028+}
4029+
4030+/* Not used */
4031+static opvp_result_t
4032+opvpQueryDeviceInfo(opvp_dc_t printerContext, opvp_flag_t flag, opvp_int_t *a, opvp_char_t *b)
4033+{
4034+ fputs("opvpQueryDeviceInfo\n", pFile);
4035+ fprintf(pFile, "\tContext = %d\n", printerContext);
4036+ return 0;
4037+}
4038+
4039+static opvp_result_t
4040+opvpResetCTM(opvp_dc_t printerContext)
4041+{
4042+ fputs("opvpResetCTM\n", pFile);
4043+ fprintf(pFile, "\tContext = %d\n", printerContext);
4044+ opv_gstate.ctm.a = 1.0;
4045+ opv_gstate.ctm.b = 0.0;
4046+ opv_gstate.ctm.c = 0.0;
4047+ opv_gstate.ctm.d = 1.0;
4048+ opv_gstate.ctm.e = 0.0;
4049+ opv_gstate.ctm.f = 0.0;
4050+ return 0;
4051+}
4052+
4053+static opvp_result_t
4054+opvpSetCTM(opvp_dc_t printerContext, const opvp_ctm_t *pctm)
4055+{
4056+ fputs("opvpSetCTM\n", pFile);
4057+ opv_gstate.ctm = *pctm;
4058+ fprintf(pFile, "\tContext = %d\n", printerContext);
4059+ fprintf(pFile, "\tctm.a = %f\n", pctm->a);
4060+ fprintf(pFile, "\tctm.b = %f\n", pctm->b);
4061+ fprintf(pFile, "\tctm.c = %f\n", pctm->c);
4062+ fprintf(pFile, "\tctm.d = %f\n", pctm->d);
4063+ fprintf(pFile, "\tctm.e = %f\n", pctm->e);
4064+ fprintf(pFile, "\tctm.f = %f\n", pctm->f);
4065+ return 0;
4066+}
4067+
4068+static opvp_result_t
4069+opvpGetCTM(opvp_dc_t printerContext, opvp_ctm_t *pctm)
4070+{
4071+ fputs("opvpGetCTM\n", pFile);
4072+ *pctm = opv_gstate.ctm;
4073+ fprintf(pFile, "\tContext = %d\n", printerContext);
4074+ return 0;
4075+}
4076+
4077+static opvp_result_t
4078+opvpInitGS(opvp_dc_t printerContext)
4079+{
4080+ fputs("opvpInitGS\n", pFile);
4081+ fprintf(pFile, "\tContext = %d\n", printerContext);
4082+ return 0;
4083+}
4084+
4085+static opvp_result_t
4086+opvpSaveGS(opvp_dc_t printerContext)
4087+{
4088+ fputs("opvpSaveGS\n", pFile);
4089+ fprintf(pFile, "\tContext = %d\n", printerContext);
4090+ return 0;
4091+}
4092+
4093+static opvp_result_t
4094+opvpRestoreGS(opvp_dc_t printerContext)
4095+{
4096+ fputs("opvpRestoreGS\n", pFile);
4097+ fprintf(pFile, "\tContext = %d\n", printerContext);
4098+ return 0;
4099+}
4100+
4101+static opvp_result_t
4102+opvpQueryColorSpace(opvp_dc_t printerContext, opvp_int_t *n, opvp_cspace_t *colorspace)
4103+{
4104+ fputs("opvpQueryColorSpace\n", pFile);
4105+ fprintf(pFile, "\tContext = %d\n", printerContext);
4106+ *n = 0;
4107+ *colorspace = opv_gstate.colorspace;
4108+ return 0;
4109+}
4110+
4111+static opvp_result_t
4112+opvpSetColorSpace(opvp_dc_t printerContext, opvp_cspace_t colorspace)
4113+{
4114+ fputs("opvpSetColorSpace\n", pFile);
4115+ fprintf(pFile, "\tContext = %d\n", printerContext);
4116+ fprintf(pFile, "\tcolorspace = %d\n", colorspace);
4117+ opv_gstate.colorspace = colorspace;
4118+ return 0;
4119+}
4120+
4121+static opvp_result_t
4122+opvpGetColorSpace(opvp_dc_t printerContext, opvp_cspace_t *colorspace)
4123+{
4124+ fputs("opvpGetColorSpace\n", pFile);
4125+ fprintf(pFile, "\tContext = %d\n", printerContext);
4126+ *colorspace = opv_gstate.colorspace;
4127+ return 0;
4128+}
4129+
4130+static opvp_result_t
4131+opvpSetFillMode(opvp_dc_t printerContext, opvp_fillmode_t fillmode)
4132+{
4133+ fputs("opvpSetFillMode\n", pFile);
4134+ fprintf(pFile, "\tContext = %d\n", printerContext);
4135+ fprintf(pFile, "\tfillmode = %d\n", fillmode);
4136+ opv_gstate.fill_mode = fillmode;
4137+ return 0;
4138+}
4139+
4140+static opvp_result_t
4141+opvpGetFillMode(opvp_dc_t printerContext, opvp_fillmode_t *fillmode)
4142+{
4143+ fputs("opvpGetFillMode\n", pFile);
4144+ fprintf(pFile, "\tContext = %d\n", printerContext);
4145+ *fillmode = opv_gstate.fill_mode;
4146+ return 0;
4147+}
4148+
4149+static opvp_result_t
4150+opvpSetAlphaConstant(opvp_dc_t printerContext, opvp_float_t alpha)
4151+{
4152+ fputs("opvpSetAlphaConstant\n", pFile);
4153+ fprintf(pFile, "\tContext = %d\n", printerContext);
4154+ fprintf(pFile, "\talpha = %f\n", alpha);
4155+ opv_gstate.alpha = alpha;
4156+ return 0;
4157+}
4158+
4159+static opvp_result_t
4160+opvpGetAlphaConstant(opvp_dc_t printerContext, opvp_float_t *alpha)
4161+{
4162+ fputs("opvpGetAlphaConstant\n", pFile);
4163+ fprintf(pFile, "\tContext = %d\n", printerContext);
4164+ *alpha = opv_gstate.alpha;
4165+ return 0;
4166+}
4167+
4168+static opvp_result_t
4169+opvpSetLineWidth(opvp_dc_t printerContext, opvp_fix_t width)
4170+{
4171+ fputs("opvpSetLineWidth\n", pFile);
4172+ fprintf(pFile, "\tContext = %d\n", printerContext);
4173+ fprintf(pFile, "\twidth = %d\n", width);
4174+ opv_gstate.line_width = width;
4175+ return 0;
4176+}
4177+
4178+static opvp_result_t
4179+opvpGetLineWidth(opvp_dc_t printerContext, opvp_fix_t *width)
4180+{
4181+ fputs("opvpGetLineWidth\n", pFile);
4182+ fprintf(pFile, "\tContext = %d\n", printerContext);
4183+ *width = opv_gstate.line_width;
4184+ return 0;
4185+}
4186+
4187+static opvp_result_t
4188+opvpSetLineDash(opvp_dc_t printerContext, opvp_int_t n, const opvp_fix_t *dash)
4189+{
4190+ int k;
4191+
4192+ fputs("opvpSetLineDash\n", pFile);
4193+ fprintf(pFile, "\tContext = %d\n", printerContext);
4194+ fprintf(pFile, "\tn = %d\n", n);
4195+ opv_gstate.line_dash_n = n;
4196+
4197+ if (opv_gstate.line_dash_array != NULL)
4198+ free(opv_gstate.line_dash_array);
4199+
4200+ opv_gstate.line_dash_array = (opvp_fix_t*) malloc(n * sizeof(opvp_fix_t));
4201+ if (opv_gstate.line_dash_array == NULL) {
4202+ fprintf(pFile,"\t Error in dash array allocation. Exiting.");
4203+ fclose(pFile);
4204+ exit(-1);
4205+ }
4206+
4207+ for (k = 0; k < n; k++) {
4208+ opv_gstate.line_dash_array[k] = dash[k];
4209+ fprintf(pFile, "\tdash[%d] = %d\n", k, dash[k]);
4210+ }
4211+ return 0;
4212+}
4213+
4214+static opvp_result_t
4215+opvpGetLineDash(opvp_dc_t printerContext, opvp_int_t *n, opvp_fix_t *dash)
4216+{
4217+ fputs("opvpGetLineDash\n", pFile);
4218+ fprintf(pFile, "\tContext = %d\n", printerContext);
4219+
4220+ *n = opv_gstate.line_dash_n;
4221+ dash = opv_gstate.line_dash_array;
4222+
4223+ return 0;
4224+}
4225+
4226+static opvp_result_t
4227+opvpSetLineDashOffset(opvp_dc_t printerContext, opvp_fix_t offset)
4228+{
4229+ fputs("opvpSetLineDashOffset\n", pFile);
4230+ fprintf(pFile, "\tContext = %d\n", printerContext);
4231+ fprintf(pFile, "\toffset = %d\n", offset);
4232+ opv_gstate.dash_offset = offset;
4233+ return 0;
4234+}
4235+
4236+static opvp_result_t
4237+opvpGetLineDashOffset(opvp_dc_t printerContext, opvp_fix_t *offset)
4238+{
4239+ fputs("opvpGetLineDashOffset\n", pFile);
4240+ fprintf(pFile, "\tContext = %d\n", printerContext);
4241+ *offset = opv_gstate.dash_offset;
4242+ return 0;
4243+}
4244+
4245+static opvp_result_t
4246+opvpSetLineStyle(opvp_dc_t printerContext, opvp_linestyle_t style)
4247+{
4248+ fputs("opvpSetLineStyle\n", pFile);
4249+ fprintf(pFile, "\tContext = %d\n", printerContext);
4250+ fprintf(pFile, "\tstyle = %d\n", style);
4251+ opv_gstate.line_style = style;
4252+ return 0;
4253+}
4254+
4255+static opvp_result_t
4256+opvpGetLineStyle(opvp_dc_t printerContext, opvp_linestyle_t *style)
4257+{
4258+ fputs("opvpGetLineStyle\n", pFile);
4259+ fprintf(pFile, "\tContext = %d\n", printerContext);
4260+ *style = opv_gstate.line_style;
4261+ return 0;
4262+}
4263+
4264+static opvp_result_t
4265+opvpSetLineCap(opvp_dc_t printerContext, opvp_linecap_t cap)
4266+{
4267+ fputs("opvpSetLineCap\n", pFile);
4268+ fprintf(pFile, "\tContext = %d\n", printerContext);
4269+ fprintf(pFile, "\tcap = %d\n", cap);
4270+ opv_gstate.line_cap = cap;
4271+ return 0;
4272+}
4273+
4274+static opvp_result_t
4275+opvpGetLineCap(opvp_dc_t printerContext, opvp_linecap_t *cap)
4276+{
4277+ fputs("opvpGetLineCap\n", pFile);
4278+ fprintf(pFile, "\tContext = %d\n", printerContext);
4279+ *cap = opv_gstate.line_cap;
4280+ return 0;
4281+}
4282+
4283+static opvp_result_t
4284+opvpSetLineJoin(opvp_dc_t printerContext, opvp_linejoin_t join)
4285+{
4286+ fputs("opvpSetLineJoin\n", pFile);
4287+ fprintf(pFile, "\tContext = %d\n", printerContext);
4288+ fprintf(pFile, "\tjoin = %d\n", join);
4289+ opv_gstate.line_join = join;
4290+ return 0;
4291+}
4292+
4293+static opvp_result_t
4294+opvpGetLineJoin(opvp_dc_t printerContext, opvp_linejoin_t *join)
4295+{
4296+ fputs("opvpGetLineJoin\n", pFile);
4297+ fprintf(pFile, "\tContext = %d\n", printerContext);
4298+ *join = opv_gstate.line_join;
4299+ return 0;
4300+}
4301+
4302+static opvp_result_t
4303+opvpSetMiterLimit(opvp_dc_t printerContext, opvp_fix_t miter)
4304+{
4305+ fputs("opvpSetMiterLimit\n", pFile);
4306+ fprintf(pFile, "\tContext = %d\n", printerContext);
4307+ fprintf(pFile, "\tmiter = %d\n", miter);
4308+ opv_gstate.miter_limit = miter;
4309+ return 0;
4310+}
4311+
4312+static opvp_result_t
4313+opvpGetMiterLimit(opvp_dc_t printerContext, opvp_fix_t *miter)
4314+{
4315+ fputs("opvpGetMiterLimit\n", pFile);
4316+ fprintf(pFile, "\tContext = %d\n", printerContext);
4317+ *miter = opv_gstate.miter_limit;
4318+ return 0;
4319+}
4320+
4321+static opvp_result_t
4322+opvpSetPaintMode(opvp_dc_t printerContext, opvp_paintmode_t paintmode)
4323+{
4324+ fputs("opvpSetPaintMode\n", pFile);
4325+ fprintf(pFile, "\tContext = %d\n", printerContext);
4326+ fprintf(pFile, "\tpaintmode = %d\n", paintmode);
4327+ opv_gstate.paintmode = paintmode;
4328+ return 0;
4329+}
4330+
4331+static opvp_result_t
4332+opvpGetPaintMode(opvp_dc_t printerContext, opvp_paintmode_t *paintmode)
4333+{
4334+ fputs("opvpGetPaintMode\n", pFile);
4335+ fprintf(pFile, "\tContext = %d\n", printerContext);
4336+ *paintmode = opv_gstate.paintmode;
4337+ return 0;
4338+}
4339+
4340+static opvp_result_t
4341+opvpSetStrokeColor(opvp_dc_t printerContext, const opvp_brush_t *strokecolor)
4342+{
4343+ int k;
4344+
4345+ fputs("opvpSetStrokeColor\n", pFile);
4346+ fprintf(pFile, "\tContext = %d\n", printerContext);
4347+ if (strokecolor == NULL) {
4348+ fprintf(pFile, "\tstrokecolor is NULL\n");
4349+ } else {
4350+ fprintf(pFile, "\tstrokecolor.colorSpace = %d\n", strokecolor->colorSpace);
4351+
4352+ for (k = 0; k < 4; k++) {
4353+ fprintf(pFile, "\tstrokecolor.color[%d] = %d\n", k, strokecolor->color[k]);
4354+ }
4355+
4356+ fprintf(pFile, "\tstrokecolor.xorg = %d\n", strokecolor->xorg);
4357+ fprintf(pFile, "\tstrokecolor.yorg = %d\n", strokecolor->yorg);
4358+
4359+ if (strokecolor->pbrush == NULL) {
4360+ fprintf(pFile, "\tstrokecolor.pbrush is NULL\n");
4361+ } else {
4362+ fprintf(pFile, "\tstrokecolor.pbrush.type = %d\n", strokecolor->pbrush->type);
4363+ fprintf(pFile, "\tstrokecolor.pbrush.width = %d\n", strokecolor->pbrush->width);
4364+ fprintf(pFile, "\tstrokecolor.pbrush.height = %d\n", strokecolor->pbrush->height);
4365+ fprintf(pFile, "\tstrokecolor.pbrush.pitch = %d\n", strokecolor->pbrush->pitch);
4366+ }
4367+ }
4368+ return 0;
4369+}
4370+
4371+static opvp_result_t
4372+opvpSetFillColor(opvp_dc_t printerContext, const opvp_brush_t *fillcolor)
4373+{
4374+ int k;
4375+
4376+ fputs("opvpSetFillColor\n", pFile);
4377+ fprintf(pFile, "\tContext = %d\n", printerContext);
4378+ if (fillcolor == NULL) {
4379+ fprintf(pFile, "\tfillcolor is NULL\n");
4380+ } else {
4381+ fprintf(pFile, "\tfillcolor.colorSpace = %d\n", fillcolor->colorSpace);
4382+
4383+ for (k = 0; k < 4; k++) {
4384+ fprintf(pFile, "\tfillcolor.color[%d] = %d\n", k, fillcolor->color[k]);
4385+ }
4386+
4387+ fprintf(pFile, "\tfillcolor.xorg = %d\n", fillcolor->xorg);
4388+ fprintf(pFile, "\tfillcolor.yorg = %d\n", fillcolor->yorg);
4389+
4390+ if (fillcolor->pbrush == NULL) {
4391+ fprintf(pFile, "\tfillcolor.pbrush is NULL\n");
4392+ } else {
4393+ fprintf(pFile, "\tfillcolor.pbrush.type = %d\n", fillcolor->pbrush->type);
4394+ fprintf(pFile, "\tfillcolor.pbrush.width = %d\n", fillcolor->pbrush->width);
4395+ fprintf(pFile, "\tfillcolor.pbrush.height = %d\n", fillcolor->pbrush->height);
4396+ fprintf(pFile, "\tfillcolor.pbrush.pitch = %d\n", fillcolor->pbrush->pitch);
4397+ }
4398+ }
4399+ return 0;
4400+}
4401+
4402+static opvp_result_t
4403+opvpSetBgColor(opvp_dc_t printerContext, const opvp_brush_t *bgcolor)
4404+{
4405+ int k;
4406+
4407+ fputs("opvpSetBgColor\n", pFile);
4408+ fprintf(pFile, "\tContext = %d\n", printerContext);
4409+ if (bgcolor == NULL) {
4410+ fprintf(pFile, "\tfillcbgcolorolor is NULL\n");
4411+ } else {
4412+ fprintf(pFile, "\tbgcolor.colorSpace = %d\n", bgcolor->colorSpace);
4413+
4414+ for (k = 0; k < 4; k++) {
4415+ fprintf(pFile, "\tbgcolor.color[%d] = %d\n", k, bgcolor->color[k]);
4416+ }
4417+
4418+ fprintf(pFile, "\tbgcolor.xorg = %d\n", bgcolor->xorg);
4419+ fprintf(pFile, "\tbgcolor.yorg = %d\n", bgcolor->yorg);
4420+
4421+ if (bgcolor->pbrush == NULL) {
4422+ fprintf(pFile, "\tbgcolor.pbrush is NULL\n");
4423+ } else {
4424+ fprintf(pFile, "\tbgcolor.pbrush.type = %d\n", bgcolor->pbrush->type);
4425+ fprintf(pFile, "\tbgcolor.pbrush.width = %d\n", bgcolor->pbrush->width);
4426+ fprintf(pFile, "\tbgcolor.pbrush.height = %d\n", bgcolor->pbrush->height);
4427+ fprintf(pFile, "\tbgcolor.pbrush.pitch = %d\n", bgcolor->pbrush->pitch);
4428+ }
4429+ }
4430+ return 0;
4431+}
4432+
4433+static opvp_result_t
4434+opvpNewPath(opvp_dc_t printerContext)
4435+{
4436+ fputs("opvpNewPath\n", pFile);
4437+ fprintf(pFile, "\tContext = %d\n", printerContext);
4438+ return 0;
4439+}
4440+
4441+static opvp_result_t
4442+opvpEndPath(opvp_dc_t printerContext)
4443+{
4444+ fputs("opvpEndPath\n", pFile);
4445+ fprintf(pFile, "\tContext = %d\n", printerContext);
4446+ return 0;
4447+}
4448+
4449+static opvp_result_t
4450+opvpStrokePath(opvp_dc_t printerContext)
4451+{
4452+ fputs("opvpStrokePath\n", pFile);
4453+ fprintf(pFile, "\tContext = %d\n", printerContext);
4454+ return 0;
4455+}
4456+
4457+static opvp_result_t
4458+opvpFillPath(opvp_dc_t printerContext)
4459+{
4460+ fputs("opvpFillPath\n", pFile);
4461+ fprintf(pFile, "\tContext = %d\n", printerContext);
4462+ return 0;
4463+}
4464+
4465+static opvp_result_t
4466+opvpStrokeFillPath(opvp_dc_t printerContext)
4467+{
4468+ fputs("opvpStrokeFillPath\n", pFile);
4469+ fprintf(pFile, "\tContext = %d\n", printerContext);
4470+ return 0;
4471+}
4472+
4473+static opvp_result_t
4474+opvpSetClipPath(opvp_dc_t printerContext, opvp_cliprule_t cliprule)
4475+{
4476+ fputs("opvpSetClipPath\n", pFile);
4477+ fprintf(pFile, "\tContext = %d\n", printerContext);
4478+ fprintf(pFile, "\tcliprule = %d\n", cliprule);
4479+ return 0;
4480+}
4481+
4482+static opvp_result_t
4483+opvpResetClipPath(opvp_dc_t printerContext)
4484+{
4485+ fputs("opvpResetClipPath\n", pFile);
4486+ fprintf(pFile, "\tContext = %d\n", printerContext);
4487+ return 0;
4488+}
4489+
4490+static opvp_result_t
4491+opvpSetCurrentPoint(opvp_dc_t printerContext, opvp_fix_t pointx, opvp_fix_t pointy)
4492+{
4493+ fputs("opvpSetCurrentPoint\n", pFile);
4494+ fprintf(pFile, "\tContext = %d\n", printerContext);
4495+ fprintf(pFile, "\tpointx = %d\n", pointx);
4496+ fprintf(pFile, "\tpointy = %d\n", pointy);
4497+ return 0;
4498+}
4499+
4500+static opvp_result_t
4501+opvpLinePath(opvp_dc_t printerContext, opvp_pathmode_t pathmode, opvp_int_t npoints, const opvp_point_t *points)
4502+{
4503+ int k;
4504+
4505+ fputs("opvpLinePath\n", pFile);
4506+ fprintf(pFile, "\tContext = %d\n", printerContext);
4507+ fprintf(pFile, "\tpathmode = %d\n", pathmode);
4508+ fprintf(pFile, "\tnpoints = %d\n", npoints);
4509+
4510+ for (k = 0; k < npoints; k++) {
4511+ fprintf(pFile, "\tpoints[%d].x = %d\n", k, points[k].x);
4512+ fprintf(pFile, "\tpoints[%d].y = %d\n", k, points[k].y);
4513+ }
4514+ return 0;
4515+}
4516+
4517+/* Not used */
4518+static opvp_result_t
4519+opvpPolygonPath(opvp_dc_t printerContext, opvp_int_t n, const opvp_int_t *m, const opvp_point_t *p)
4520+{
4521+ fputs("opvpPolygonPath\n", pFile);
4522+ fprintf(pFile, "\tContext = %d\n", printerContext);
4523+ return 0;
4524+}
4525+
4526+static opvp_result_t
4527+opvpRectanglePath(opvp_dc_t printerContext, opvp_int_t n, const opvp_rectangle_t *rects)
4528+{
4529+ int k;
4530+
4531+ fputs("opvpRectanglePath\n", pFile);
4532+ fprintf(pFile, "\tContext = %d\n", printerContext);
4533+ fprintf(pFile, "\tn = %d\n", n);
4534+
4535+ for (k = 0; k < n; k++) {
4536+ fprintf(pFile, "\trects[%d].p0.x = %d\n", k, rects[k].p0.x);
4537+ fprintf(pFile, "\trects[%d].p0.y = %d\n", k, rects[k].p0.y);
4538+ fprintf(pFile, "\trects[%d].p1.x = %d\n", k, rects[k].p1.x);
4539+ fprintf(pFile, "\trects[%d].p1.y = %d\n", k, rects[k].p1.y);
4540+ }
4541+ return 0;
4542+}
4543+
4544+static opvp_result_t
4545+opvpRoundRectanglePath(opvp_dc_t printerContext, opvp_int_t n, const opvp_roundrectangle_t *rects)
4546+{
4547+ int k;
4548+
4549+ fputs("opvpRoundRectanglePath\n", pFile);
4550+ fprintf(pFile, "\tContext = %d\n", printerContext);
4551+ fprintf(pFile, "\tn = %d\n", n);
4552+
4553+ for (k = 0; k < n; k++) {
4554+ fprintf(pFile, "\trects[%d].p0.x = %d\n", k, rects[k].p0.x);
4555+ fprintf(pFile, "\trects[%d].p0.y = %d\n", k, rects[k].p0.y);
4556+ fprintf(pFile, "\trects[%d].p1.x = %d\n", k, rects[k].p1.x);
4557+ fprintf(pFile, "\trects[%d].p1.y = %d\n", k, rects[k].p1.y);
4558+ fprintf(pFile, "\trects[%d].xellipse = %d\n", k, rects[k].xellipse);
4559+ fprintf(pFile, "\trects[%d].yellipse = %d\n", k, rects[k].yellipse);
4560+ }
4561+ return 0;
4562+}
4563+
4564+static opvp_result_t
4565+opvpBezierPath(opvp_dc_t printerContext, opvp_int_t n, const opvp_point_t *points)
4566+{
4567+ int k;
4568+
4569+ fputs("opvpBezierPath\n", pFile);
4570+ fprintf(pFile, "\tContext = %d\n", printerContext);
4571+ fprintf(pFile, "\tn = %d\n", n);
4572+
4573+ for (k = 0; k < n; k++) {
4574+ fprintf(pFile, "\tpoints[%d].x = %d\n", k, points[k].x);
4575+ fprintf(pFile, "\trects[%d].y = %d\n", k, points[k].y);
4576+
4577+ }
4578+ return 0;
4579+}
4580+
4581+/* Not used */
4582+static opvp_result_t
4583+opvpArcPath(opvp_dc_t printerContext, opvp_arcmode_t mode, opvp_arcdir_t dir,
4584+ opvp_fix_t a, opvp_fix_t b, opvp_fix_t c, opvp_fix_t d, opvp_fix_t e, opvp_fix_t f,
4585+ opvp_fix_t g, opvp_fix_t h)
4586+{
4587+ fputs("opvpArcPath\n", pFile);
4588+ fprintf(pFile, "\tContext = %d\n", printerContext);
4589+ return 0;
4590+}
4591+
4592+static opvp_result_t
4593+opvpDrawImage(opvp_dc_t printerContext, opvp_int_t sw, opvp_int_t sh, opvp_int_t raster,
4594+ opvp_imageformat_t format, opvp_int_t dw, opvp_int_t dh, const void *data)
4595+{
4596+ int k;
4597+ unsigned char *data_char = (unsigned char*) data;
4598+
4599+ fputs("opvpDrawImage\n", pFile);
4600+ fprintf(pFile, "\tContext = %d\n", printerContext);
4601+ fprintf(pFile, "\tsw = %d\n", sw);
4602+ fprintf(pFile, "\tsh = %d\n", sh);
4603+ fprintf(pFile, "\traster = %d\n", raster);
4604+ fprintf(pFile, "\tformat = %d\n", format);
4605+ fprintf(pFile, "\tdw = %d\n", dw);
4606+ fprintf(pFile, "\tdh = %d\n", dh);
4607+
4608+ /* No idea how big data is here... Try sw, as byte? */
4609+ for (k = 0; k < sw; k++) {
4610+ fprintf(pFile, "\tdata[%d] = %d\n", k, data_char[k]);
4611+ }
4612+
4613+ return 0;
4614+}
4615+
4616+static opvp_result_t
4617+opvpStartDrawImage(opvp_dc_t printerContext, opvp_int_t sw, opvp_int_t sh, opvp_int_t raster,
4618+ opvp_imageformat_t format, opvp_int_t dw, opvp_int_t dh)
4619+{
4620+ fputs("opvpStartDrawImage\n", pFile);
4621+ fprintf(pFile, "\tContext = %d\n", printerContext);
4622+ fprintf(pFile, "\tsw = %d\n", sw);
4623+ fprintf(pFile, "\tsh = %d\n", sh);
4624+ fprintf(pFile, "\traster = %d\n", raster);
4625+ fprintf(pFile, "\tformat = %d\n", format);
4626+ fprintf(pFile, "\tdw = %d\n", dw);
4627+ fprintf(pFile, "\tdh = %d\n", dh);
4628+ return 0;
4629+}
4630+
4631+static opvp_result_t
4632+opvpTransferDrawImage(opvp_dc_t printerContext, opvp_int_t count, const void *data)
4633+{
4634+ int k;
4635+ unsigned char *data_char = (unsigned char*) data;
4636+
4637+ fputs("opvpTransferDrawImage\n", pFile);
4638+ fprintf(pFile, "\tContext = %d\n", printerContext);
4639+ fprintf(pFile, "\tcount = %d\n", count);
4640+
4641+ for (k = 0; k < count; k++) {
4642+ fprintf(pFile, "\tdata[%d] = %d\n", k, data_char[k]);
4643+ }
4644+ return 0;
4645+}
4646+
4647+static opvp_result_t
4648+opvpEndDrawImage(opvp_dc_t printerContext)
4649+{
4650+ fputs("opvpEndDrawImage\n", pFile);
4651+ fprintf(pFile, "\tContext = %d\n", printerContext);
4652+ return 0;
4653+}
4654+
4655+/* not used */
4656+static opvp_result_t
4657+opvpStartScanline(opvp_dc_t printerContext, opvp_int_t a)
4658+{
4659+ fputs("opvpStartScanline\n", pFile);
4660+ fprintf(pFile, "\tContext = %d\n", printerContext);
4661+ return 0;
4662+}
4663+
4664+/* not used */
4665+static opvp_result_t
4666+opvpScanline(opvp_dc_t printerContext, opvp_int_t a, const opvp_int_t *b)
4667+{
4668+ fputs("opvpScanline\n", pFile);
4669+ fprintf(pFile, "\tContext = %d\n", printerContext);
4670+ return 0;
4671+}
4672+
4673+/* not used */
4674+static opvp_result_t
4675+opvpEndScanline(opvp_dc_t printerContext)
4676+{
4677+ fputs("opvpEndScanline\n", pFile);
4678+ fprintf(pFile, "\tContext = %d\n", printerContext);
4679+ return 0;
4680+}
4681+
4682+static opvp_result_t
4683+opvpStartRaster(opvp_dc_t printerContext, opvp_int_t width)
4684+{
4685+ fputs("opvpStartRaster\n", pFile);
4686+ fprintf(pFile, "\tContext = %d\n", printerContext);
4687+ fprintf(pFile, "\twidth = %d\n", width);
4688+ return 0;
4689+}
4690+
4691+static opvp_result_t
4692+opvpTransferRasterData(opvp_dc_t printerContext, opvp_int_t raster_size, const opvp_byte_t *data)
4693+{
4694+ int k;
4695+
4696+ fputs("opvpTransferRasterData\n", pFile);
4697+ fprintf(pFile, "\tContext = %d\n", printerContext);
4698+ fprintf(pFile, "\traster_size = %d\n", raster_size);
4699+
4700+ for (k = 0; k < raster_size; k++) {
4701+ fprintf(pFile, "\tdata[%d] = %d\n", k, data[k]);
4702+ }
4703+ return 0;
4704+}
4705+
4706+static opvp_result_t
4707+opvpSkipRaster(opvp_dc_t printerContext, opvp_int_t a)
4708+{
4709+ fputs("opvpSkipRaster\n", pFile);
4710+ fprintf(pFile, "\tContext = %d\n", printerContext);
4711+ fprintf(pFile, "\ta = %d\n", a);
4712+ return 0;
4713+}
4714+
4715+static opvp_result_t
4716+opvpEndRaster(opvp_dc_t printerContext)
4717+{
4718+ fputs("opvpEndRaster\n", pFile);
4719+ fprintf(pFile, "\tContext = %d\n", printerContext);
4720+ return 0;
4721+}
4722+
4723+static opvp_result_t
4724+opvpStartStream(opvp_dc_t printerContext)
4725+{
4726+ fputs("opvpStartStream\n", pFile);
4727+ fprintf(pFile, "\tContext = %d\n", printerContext);
4728+ return 0;
4729+}
4730+
4731+/* Not used */
4732+static opvp_result_t
4733+opvpTransferStreamData(opvp_dc_t printerContext, opvp_int_t a, const void *b)
4734+{
4735+ fputs("opvpTransferStreamData\n", pFile);
4736+ fprintf(pFile, "\tContext = %d\n", printerContext);
4737+ return 0;
4738+}
4739+
4740+static opvp_result_t
4741+opvpEndStream(opvp_dc_t printerContext)
4742+{
4743+ fputs("opvpEndStream\n", pFile);
4744+ fprintf(pFile, "\tContext = %d\n", printerContext);
4745+ return 0;
4746+}
4747+
4748+opvp_int_t opvpErrorNo;
4749+
4750+opvp_dc_t
4751+opvpOpenPrinter(opvp_int_t outputFD, const opvp_char_t *printerModel, const opvp_int_t apiVersion[2],
4752+ opvp_api_procs_t **apiProcs)
4753+{
4754+ static opvp_api_procs_t procs;
4755+ opvp_fix_t fixed_value;
4756+
4757+ procs.opvpEndStream = opvpEndStream;
4758+ procs.opvpClosePrinter = opvpClosePrinter;
4759+ procs.opvpStartJob = opvpStartJob;
4760+ procs.opvpEndJob = opvpEndJob;
4761+ procs.opvpAbortJob = opvpAbortJob;
4762+ procs.opvpStartDoc = opvpStartDoc;
4763+ procs.opvpEndDoc = opvpEndDoc;
4764+ procs.opvpStartPage = opvpStartPage;
4765+ procs.opvpEndPage = opvpEndPage;
4766+ procs.opvpQueryDeviceCapability = opvpQueryDeviceCapability;
4767+ procs.opvpQueryDeviceInfo = opvpQueryDeviceInfo;
4768+ procs.opvpResetCTM = opvpResetCTM;
4769+ procs.opvpSetCTM = opvpSetCTM;
4770+ procs.opvpGetCTM = opvpGetCTM;
4771+ procs.opvpInitGS = opvpInitGS;
4772+ procs.opvpSaveGS = opvpSaveGS;
4773+ procs.opvpRestoreGS = opvpRestoreGS;
4774+ procs.opvpQueryColorSpace = opvpQueryColorSpace;
4775+ procs.opvpSetColorSpace = opvpSetColorSpace;
4776+ procs.opvpGetColorSpace = opvpGetColorSpace;
4777+ procs.opvpSetFillMode = opvpSetFillMode;
4778+ procs.opvpGetFillMode = opvpGetFillMode;
4779+ procs.opvpSetAlphaConstant = opvpSetAlphaConstant;
4780+ procs.opvpGetAlphaConstant = opvpGetAlphaConstant;
4781+ procs.opvpSetLineWidth = opvpSetLineWidth;
4782+ procs.opvpGetLineWidth = opvpGetLineWidth;
4783+ procs.opvpSetLineDash = opvpSetLineDash;
4784+ procs.opvpSetLineDash = opvpSetLineDash;
4785+ procs.opvpGetLineDash = opvpGetLineDash;
4786+ procs.opvpSetLineDashOffset = opvpSetLineDashOffset;
4787+ procs.opvpGetLineDashOffset = opvpGetLineDashOffset;
4788+ procs.opvpSetLineStyle = opvpSetLineStyle;
4789+ procs.opvpGetLineStyle = opvpGetLineStyle;
4790+ procs.opvpSetLineCap = opvpSetLineCap;
4791+ procs.opvpGetLineCap = opvpGetLineCap;
4792+ procs.opvpSetLineJoin = opvpSetLineJoin;
4793+ procs.opvpGetLineJoin = opvpGetLineJoin;
4794+ procs.opvpSetMiterLimit = opvpSetMiterLimit;
4795+ procs.opvpGetMiterLimit = opvpGetMiterLimit;
4796+ procs.opvpSetPaintMode = opvpSetPaintMode;
4797+ procs.opvpGetPaintMode = opvpGetPaintMode;
4798+ procs.opvpSetStrokeColor = opvpSetStrokeColor;
4799+ procs.opvpSetFillColor = opvpSetFillColor;
4800+ procs.opvpSetBgColor = opvpSetBgColor;
4801+ procs.opvpNewPath = opvpNewPath;
4802+ procs.opvpEndPath = opvpEndPath;
4803+ procs.opvpStrokePath = opvpStrokePath;
4804+ procs.opvpFillPath = opvpFillPath;
4805+ procs.opvpStrokeFillPath = opvpStrokeFillPath;
4806+ procs.opvpSetClipPath = opvpSetClipPath;
4807+ procs.opvpResetClipPath = opvpResetClipPath;
4808+ procs.opvpSetCurrentPoint = opvpSetCurrentPoint;
4809+ procs.opvpLinePath = opvpLinePath;
4810+ procs.opvpPolygonPath = opvpPolygonPath;
4811+ procs.opvpRectanglePath = opvpRectanglePath;
4812+ procs.opvpRoundRectanglePath = opvpRoundRectanglePath;
4813+ procs.opvpBezierPath = opvpBezierPath;
4814+ procs.opvpArcPath = opvpArcPath;
4815+ procs.opvpDrawImage = opvpDrawImage;
4816+ procs.opvpStartDrawImage = opvpStartDrawImage;
4817+ procs.opvpTransferDrawImage = opvpTransferDrawImage;
4818+ procs.opvpEndDrawImage = opvpEndDrawImage;
4819+ procs.opvpStartScanline = opvpStartScanline;
4820+ procs.opvpScanline = opvpScanline;
4821+ procs.opvpEndScanline = opvpEndScanline;
4822+ procs.opvpStartRaster = opvpStartRaster;
4823+ procs.opvpTransferRasterData = opvpTransferRasterData;
4824+ procs.opvpSkipRaster = opvpSkipRaster;
4825+ procs.opvpEndRaster = opvpEndRaster;
4826+ procs.opvpStartStream = opvpStartStream;
4827+ procs.opvpTransferStreamData = opvpTransferStreamData;
4828+ procs.opvpEndStream = opvpEndStream;
4829+
4830+ *apiProcs = &procs;
4831+
4832+ OPVP_F2FIX(1.0, fixed_value);
4833+
4834+ opv_gstate.ctm.a = 1.0;
4835+ opv_gstate.ctm.b = 0.0;
4836+ opv_gstate.ctm.c = 0.0;
4837+ opv_gstate.ctm.d = 1.0;
4838+ opv_gstate.ctm.e = 0.0;
4839+ opv_gstate.ctm.f = 0.0;
4840+ opv_gstate.colorspace = OPVP_CSPACE_DEVICERGB;
4841+ opv_gstate.fill_mode = OPVP_FILLMODE_EVENODD;
4842+ opv_gstate.alpha = 1.0;
4843+ opv_gstate.line_width = fixed_value;
4844+ opv_gstate.line_dash_n = 0;
4845+ opv_gstate.line_dash_array = NULL;
4846+ opv_gstate.dash_offset = fixed_value;
4847+ opv_gstate.line_style = OPVP_LINESTYLE_SOLID;
4848+ opv_gstate.line_cap = OPVP_LINECAP_BUTT;
4849+ opv_gstate.line_join = OPVP_LINEJOIN_MITER;
4850+ opv_gstate.miter_limit = fixed_value;
4851+ opv_gstate.paintmode = OPVP_PAINTMODE_OPAQUE;
4852+ opv_gstate.colorspace = OPVP_CSPACE_DEVICERGB;
4853+
4854+ pFile = fopen("opvp_command_dump.txt","w");
4855+ if (pFile != NULL)
4856+ {
4857+ fputs("opvpOpenPrinter\n", pFile);
4858+ return 0;
4859+ }
4860+ return -1;
4861+}
4862--
48632.40.0
diff --git a/meta/recipes-extended/ghostscript/ghostscript/CVE-2024-33871-0002.patch b/meta/recipes-extended/ghostscript/ghostscript/CVE-2024-33871-0002.patch
new file mode 100644
index 0000000000..6ac25f0d71
--- /dev/null
+++ b/meta/recipes-extended/ghostscript/ghostscript/CVE-2024-33871-0002.patch
@@ -0,0 +1,43 @@
1From 7145885041bb52cc23964f0aa2aec1b1c82b5908 Mon Sep 17 00:00:00 2001
2From: Zdenek Hutyra <zhutyra@centrum.cz>
3Date: Mon, 22 Apr 2024 13:33:47 +0100
4Subject: [PATCH 7/7] OPVP device - prevent unsafe parameter change with SAFER
5
6Bug #707754 "OPVP device - Arbitrary code execution via custom Driver library"
7
8The "Driver" parameter for the "opvp"/"oprp" device specifies the name
9of a dynamic library and allows any library to be loaded.
10
11The patch does not allow changing this parameter after activating path
12control.
13
14This addresses CVE-2024-33871
15
16CVE: CVE-2024-33871
17
18Upstream-Status: Backport [https://cgit.ghostscript.com/cgi-bin/cgit.cgi/ghostpdl.git/commit/?id=7145885041bb52cc2396]
19
20Signed-off-by: Archana Polampalli <archana.polampalli@windriver.com>
21---
22 contrib/opvp/gdevopvp.c | 6 ++++++
23 1 file changed, 6 insertions(+)
24
25diff --git a/contrib/opvp/gdevopvp.c b/contrib/opvp/gdevopvp.c
26index 64afbfe..f49a380 100644
27--- a/contrib/opvp/gdevopvp.c
28+++ b/contrib/opvp/gdevopvp.c
29@@ -3453,6 +3453,12 @@ _put_params(gx_device *dev, gs_param_list *plist)
30 code = param_read_string(plist, pname, &vdps);
31 switch (code) {
32 case 0:
33+ if (gs_is_path_control_active(dev->memory)
34+ && (!opdev->globals.vectorDriver || strlen(opdev->globals.vectorDriver) != vdps.size
35+ || memcmp(opdev->globals.vectorDriver, vdps.data, vdps.size) != 0)) {
36+ param_signal_error(plist, pname, gs_error_invalidaccess);
37+ return_error(gs_error_invalidaccess);
38+ }
39 buff = realloc(buff, vdps.size + 1);
40 memcpy(buff, vdps.data, vdps.size);
41 buff[vdps.size] = 0;
42--
432.40.0
diff --git a/meta/recipes-extended/ghostscript/ghostscript_9.55.0.bb b/meta/recipes-extended/ghostscript/ghostscript_9.55.0.bb
index 083ee4b337..36c5aa3285 100644
--- a/meta/recipes-extended/ghostscript/ghostscript_9.55.0.bb
+++ b/meta/recipes-extended/ghostscript/ghostscript_9.55.0.bb
@@ -46,6 +46,8 @@ SRC_URI_BASE = "https://github.com/ArtifexSoftware/ghostpdl-downloads/releases/d
46 file://CVE-2024-33870.patch \ 46 file://CVE-2024-33870.patch \
47 file://CVE-2024-33869-0001.patch \ 47 file://CVE-2024-33869-0001.patch \
48 file://CVE-2024-33869-0002.patch \ 48 file://CVE-2024-33869-0002.patch \
49 file://CVE-2024-33871-0001.patch \
50 file://CVE-2024-33871-0002.patch \
49" 51"
50 52
51SRC_URI = "${SRC_URI_BASE} \ 53SRC_URI = "${SRC_URI_BASE} \
generated by cgit v1.2.3-54-g00ecf (git 2.39.0) at 2025-06-14 21:48:22 +0000