/* Get parameters. */
int
gdev_pdf_get_params(gx_device * dev, gs_param_list * plist)
{
gx_device_pdf *pdev = (gx_device_pdf *) dev;
float cl = (float)pdev->CompatibilityLevel;
int code;
int cdv = CoreDistVersion;
int EmbedFontObjects = 1;
pdev->ParamCompatibilityLevel = cl;
code = gdev_psdf_get_params(dev, plist);
if (code < 0 ||
(code = param_write_int(plist, ".EmbedFontObjects", &EmbedFontObjects)) < 0 ||
(code = param_write_int(plist, "CoreDistVersion", &cdv)) < 0 ||
(code = param_write_float(plist, "CompatibilityLevel", &cl)) < 0 ||
(pdev->is_ps2write && (code = param_write_string(plist, "OPDFReadProcsetPath", &pdev->OPDFReadProcsetPath)) < 0) ||
(!pdev->is_ps2write && (code = param_write_bool(plist, "ForOPDFRead", &pdev->ForOPDFRead)) < 0) ||
/* Indicate that we can process pdfmark and DSC. */
(param_requested(plist, "pdfmark") > 0 &&
(code = param_write_null(plist, "pdfmark")) < 0) ||
(param_requested(plist, "DSC") > 0 &&
(code = param_write_null(plist, "DSC")) < 0) ||
(code = gs_param_write_items(plist, pdev, NULL, pdf_param_items)) < 0
);
return code;
}
static int
tfax_get_params(gx_device * dev, gs_param_list * plist)
{
gx_device_tfax *const tfdev = (gx_device_tfax *)dev;
int code = gdev_fax_get_params(dev, plist);
int ecode = code;
gs_param_string comprstr;
if ((code = param_write_long(plist, "MaxStripSize", &tfdev->MaxStripSize)) < 0)
ecode = code;
if ((code = param_write_int(plist, "FillOrder", &tfdev->FillOrder)) < 0)
ecode = code;
if ((code = param_write_bool(plist, "BigEndian", &tfdev->BigEndian)) < 0)
ecode = code;
#if (TIFFLIB_VERSION >= 20111221)
if ((code = param_write_bool(plist, "UseBigTIFF", &tfdev->UseBigTIFF)) < 0)
ecode = code;
#endif
if ((code = param_write_bool(plist, "TIFFDateTime", &tfdev->write_datetime)) < 0)
ecode = code;
if ((code = tiff_compression_param_string(&comprstr, tfdev->Compression)) < 0 ||
(code = param_write_string(plist, "Compression", &comprstr)) < 0)
ecode = code;
return ecode;
}
static int
tiff_get_some_params(gx_device * dev, gs_param_list * plist, int which)
{
gx_device_tiff *const tfdev = (gx_device_tiff *)dev;
int code = gdev_prn_get_params(dev, plist);
int ecode = code;
gs_param_string comprstr;
if ((code = param_write_bool(plist, "BigEndian", &tfdev->BigEndian)) < 0)
ecode = code;
if ((code = tiff_compression_param_string(&comprstr, tfdev->Compression)) < 0 ||
(code = param_write_string(plist, "Compression", &comprstr)) < 0)
ecode = code;
if (which & 1)
{
if ((code = param_write_long(plist, "DownScaleFactor", &tfdev->DownScaleFactor)) < 0)
ecode = code;
}
if ((code = param_write_long(plist, "MaxStripSize", &tfdev->MaxStripSize)) < 0)
ecode = code;
if ((code = param_write_long(plist, "AdjustWidth", &tfdev->AdjustWidth)) < 0)
ecode = code;
if ((code = param_write_long(plist, "MinFeatureSize", &tfdev->MinFeatureSize)) < 0)
ecode = code;
return ecode;
}
static int
mac_get_params(gx_device *dev, gs_param_list *plist)
{
gx_device_macos *mdev = (gx_device_macos *)dev;
int code;
gs_param_string outputFile;
code = gx_default_get_params(dev, plist);
if (code < 0)
return code;
// UseExternalFonts
code = param_write_bool(plist, "UseExternalFonts", &(mdev->useXFonts));
// color depth
code = param_write_int(plist, "BitsPerPixel", &(mdev->color_info.depth));
// output file name
outputFile.data = (const byte *) mdev->outputFileName;
outputFile.size = strlen(mdev->outputFileName);
outputFile.persistent = false;
code = param_write_string(plist, "OutputFile", &outputFile);
return code;
}
/* Return a string value. */
static int
dsc_put_string(gs_param_list *plist, const char *keyname,
const char *string)
{
gs_param_string str;
param_string_from_transient_string(str, string);
return param_write_string(plist, keyname, &str);
}
/* Write a password to a parameter list. */
int
param_write_password(gs_param_list * plist, const char *kstr,
const password * ppass)
{
gs_param_string ps;
ps.data = (const byte *)ppass->data, ps.size = ppass->size,
ps.persistent = false;
if (ps.size > MAX_PASSWORD)
return_error(e_limitcheck);
return param_write_string(plist, kstr, &ps);
}
/* Get os2pm parameters */
int
os2prn_get_params(gx_device * dev, gs_param_list * plist)
{
int code = gdev_prn_get_params(dev, plist);
gs_param_string qs;
qs.data = opdev->queue_name, qs.size = strlen(qs.data),
qs.persistent = false;
code < 0 ||
(code = param_write_string(plist, "OS2QUEUE", &qs)) < 0;
return code;
}
/* Get parameters. CGM devices add OutputFile to the default set. */
static int
cgm_get_params(gx_device * dev, gs_param_list * plist)
{
gx_device_cgm *cdev = (gx_device_cgm *) dev;
int code = gx_default_get_params(dev, plist);
gs_param_string ofns;
if (code < 0)
return code;
ofns.data = (const byte *)cdev->fname,
ofns.size = strlen(cdev->fname),
ofns.persistent = false;
return param_write_string(plist, "OutputFile", &ofns);
}
static int
txtwrite_get_params(gx_device * dev, gs_param_list * plist)
{
int code;
gs_param_string ofns;
gx_device_txtwrite_t *const tdev = (gx_device_txtwrite_t *) dev;
code = gx_default_get_params(dev, plist);
if (code < 0)
return code;
ofns.data = (const byte *)tdev->fname,
ofns.size = strlen(tdev->fname),
ofns.persistent = false;
code = param_write_string(plist, "OutputFile", &ofns);
return code;
}
static int
tfax_get_params(gx_device * dev, gs_param_list * plist)
{
gx_device_tfax *const tfdev = (gx_device_tfax *)dev;
int code = gdev_fax_get_params(dev, plist);
int ecode = code;
gs_param_string comprstr;
if ((code = param_write_long(plist, "MaxStripSize", &tfdev->MaxStripSize)) < 0)
ecode = code;
if ((code = param_write_int(plist, "FillOrder", &tfdev->FillOrder)) < 0)
ecode = code;
if ((code = param_write_bool(plist, "BigEndian", &tfdev->BigEndian)) < 0)
ecode = code;
if ((code = tiff_compression_param_string(&comprstr, tfdev->Compression)) < 0 ||
(code = param_write_string(plist, "Compression", &comprstr)) < 0)
ecode = code;
return ecode;
}
/* Get standard parameters. */
int
gx_default_get_params(gx_device * dev, gs_param_list * plist)
{
int code;
/* Standard page device parameters: */
bool seprs = false;
gs_param_string dns, pcms, profile_array[NUM_DEVICE_PROFILES];
gsicc_rendering_intents_t profile_intents[NUM_DEVICE_PROFILES];
bool devicegraytok = true; /* Default if device profile stuct not set */
int k;
gs_param_float_array msa, ibba, hwra, ma;
gs_param_string_array scna;
char null_str[1]={'\0'};
gs_param_string temp_str;
#define set_param_array(a, d, s)\
(a.data = d, a.size = s, a.persistent = false);
/* Non-standard parameters: */
int colors = dev->color_info.num_components;
int mns = colors;
int depth = dev->color_info.depth;
int GrayValues = dev->color_info.max_gray + 1;
int HWSize[2];
gs_param_int_array hwsa;
gs_param_float_array hwma, mhwra;
cmm_dev_profile_t *dev_profile;
/* Fill in page device parameters. */
param_string_from_string(dns, dev->dname);
{
const char *cms = get_process_color_model_name(dev);
/* We might have an uninitialized device with */
/* color_info.num_components = 0.... */
if ((cms != NULL) && (*cms != '\0'))
param_string_from_string(pcms, cms);
else
pcms.data = 0;
}
set_param_array(hwra, dev->HWResolution, 2);
set_param_array(msa, dev->MediaSize, 2);
set_param_array(ibba, dev->ImagingBBox, 4);
set_param_array(ma, dev->Margins, 2);
set_param_array(scna, NULL, 0);
/* Fill in non-standard parameters. */
HWSize[0] = dev->width;
HWSize[1] = dev->height;
set_param_array(hwsa, HWSize, 2);
set_param_array(hwma, dev->HWMargins, 4);
set_param_array(mhwra, dev->MarginsHWResolution, 2);
/* Check if the device profile is null. If it is, then we need to
go ahead and get it set up at this time. If the proc is not
set up yet then we are not going to do anything yet */
if (dev->procs.get_profile != NULL) {
code = dev_proc(dev, get_profile)(dev, &dev_profile);
if (dev_profile == NULL) {
code = gsicc_init_device_profile_struct(dev, NULL, 0);
code = dev_proc(dev, get_profile)(dev, &dev_profile);
}
for (k = 0; k < NUM_DEVICE_PROFILES; k++) {
if (dev_profile->device_profile[k] == NULL) {
param_string_from_string(profile_array[k], null_str);
profile_intents[k] = gsPERCEPTUAL;
} else {
param_string_from_string(profile_array[k],
dev_profile->device_profile[k]->name);
profile_intents[k] = dev_profile->intent[k];
}
}
devicegraytok = dev_profile->devicegraytok;
} else {
for (k = 0; k < NUM_DEVICE_PROFILES; k++) {
param_string_from_string(profile_array[k], null_str);
profile_intents[k] = gsPERCEPTUAL;
}
}
/* Transmit the values. */
if (
/* Standard parameters */
(code = param_write_name(plist, "OutputDevice", &dns)) < 0 ||
#ifdef PAGESIZE_IS_MEDIASIZE
(code = param_write_float_array(plist, "PageSize", &msa)) < 0 ||
#endif
(code = (pcms.data == 0 ? 0 :
param_write_name(plist, "ProcessColorModel", &pcms))) < 0 ||
(code = param_write_float_array(plist, "HWResolution", &hwra)) < 0 ||
(code = (dev->ImagingBBox_set ?
param_write_float_array(plist, "ImagingBBox", &ibba) :
param_write_null(plist, "ImagingBBox"))) < 0 ||
(code = param_write_float_array(plist, "Margins", &ma)) < 0 ||
(code = param_write_int(plist, "MaxSeparations", &mns)) < 0 ||
(code = (dev->NumCopies_set < 0 ||
(*dev_proc(dev, get_page_device))(dev) == 0 ? 0:
dev->NumCopies_set ?
param_write_int(plist, "NumCopies", &dev->NumCopies) :
param_write_null(plist, "NumCopies"))) < 0 ||
(code = param_write_name_array(plist, "SeparationColorNames", &scna)) < 0 ||
(code = param_write_bool(plist, "Separations", &seprs)) < 0 ||
(code = param_write_bool(plist, "UseCIEColor", &dev->UseCIEColor)) < 0 ||
/* Non-standard parameters */
/* Note: if change is made in NUM_DEVICE_PROFILES we need to name
that profile here for the device parameter on the command line */
(code = param_write_bool(plist, "DeviceGrayToK", &devicegraytok)) < 0 ||
(code = param_write_string(plist,"OutputICCProfile", &(profile_array[0]))) < 0 ||
(code = param_write_string(plist,"GraphicICCProfile", &(profile_array[1]))) < 0 ||
(code = param_write_string(plist,"ImageICCProfile", &(profile_array[2]))) < 0 ||
(code = param_write_string(plist,"TextICCProfile", &(profile_array[3]))) < 0 ||
(code = param_write_int(plist,"RenderIntent", &(profile_intents[0]))) < 0 ||
(code = param_write_int(plist,"GraphicIntent", &(profile_intents[1]))) < 0 ||
(code = param_write_int(plist,"ImageIntent", &(profile_intents[2]))) < 0 ||
(code = param_write_int(plist,"TextIntent", &(profile_intents[3]))) < 0 ||
(code = param_write_int_array(plist, "HWSize", &hwsa)) < 0 ||
(code = param_write_float_array(plist, ".HWMargins", &hwma)) < 0 ||
(code = param_write_float_array(plist, ".MarginsHWResolution", &mhwra)) < 0 ||
(code = param_write_float_array(plist, ".MediaSize", &msa)) < 0 ||
(code = param_write_string(plist, "Name", &dns)) < 0 ||
(code = param_write_int(plist, "Colors", &colors)) < 0 ||
(code = param_write_int(plist, "BitsPerPixel", &depth)) < 0 ||
(code = param_write_int(plist, "GrayValues", &GrayValues)) < 0 ||
(code = param_write_long(plist, "PageCount", &dev->PageCount)) < 0 ||
(code = param_write_bool(plist, ".IgnoreNumCopies", &dev->IgnoreNumCopies)) < 0 ||
(code = param_write_int(plist, "TextAlphaBits",
&dev->color_info.anti_alias.text_bits)) < 0 ||
(code = param_write_int(plist, "GraphicsAlphaBits",
&dev->color_info.anti_alias.graphics_bits)) < 0 ||
(code = param_write_bool(plist, ".LockSafetyParams", &dev->LockSafetyParams)) < 0 ||
(code = param_write_int(plist, "MaxPatternBitmap", &dev->MaxPatternBitmap)) < 0
)
return code;
/* If LeadingEdge was set explicitly, report it here. */
if (dev->LeadingEdge & LEADINGEDGE_SET_MASK) {
int leadingedge = dev->LeadingEdge & LEADINGEDGE_MASK;
code = param_write_int(plist, "LeadingEdge", &leadingedge);
}
if (code < 0)
return code;
/* Fill in color information. */
if (colors > 1) {
int RGBValues = dev->color_info.max_color + 1;
long ColorValues = (depth >= 32 ? -1 : 1L << depth); /* value can only be 32 bits */
if ((code = param_write_int(plist, "RedValues", &RGBValues)) < 0 ||
(code = param_write_int(plist, "GreenValues", &RGBValues)) < 0 ||
(code = param_write_int(plist, "BlueValues", &RGBValues)) < 0 ||
(code = param_write_long(plist, "ColorValues", &ColorValues)) < 0
)
return code;
}
if (param_requested(plist, "HWColorMap")) {
byte palette[3 << 8];
if (param_HWColorMap(dev, palette)) {
gs_param_string hwcms;
hwcms.data = palette, hwcms.size = colors << depth,
hwcms.persistent = false;
if ((code = param_write_string(plist, "HWColorMap", &hwcms)) < 0)
return code;
}
}
return 0;
}
static int
test10(gs_state * pgs, gs_memory_t * mem)
{
gs_c_param_list list;
gs_param_string nstr, OFstr;
gs_param_float_array PSa;
gs_param_float_array HWRa;
gs_param_int_array HWSa;
int HWSize[2];
float HWResolution[2], PageSize[2];
long MaxBitmap;
int code;
gx_device *dev = gs_currentdevice(pgs);
float xlate_x, xlate_y;
gs_rect cliprect;
gs_c_param_list_write(&list, mem);
code = gs_getdeviceparams(dev, (gs_param_list *) & list);
if (code < 0) {
lprintf1("getdeviceparams failed! code = %d\n", code);
gs_abort(mem);
}
gs_c_param_list_read(&list);
code = param_read_string((gs_param_list *) & list, "Name", &nstr);
if (code < 0) {
lprintf1("reading Name failed! code = %d\n", code);
gs_abort(mem);
}
code = param_read_int_array((gs_param_list *) & list,
"HWSize", &HWSa);
if (code < 0) {
lprintf1("reading HWSize failed! code = %d\n", code);
gs_abort(mem);
}
emprintf3(mem, "HWSize[%d] = [ %d, %d ]\n", HWSa.size,
HWSa.data[0], HWSa.data[1]);
code = param_read_float_array((gs_param_list *) & list,
"HWResolution", &HWRa);
if (code < 0) {
lprintf1("reading Resolution failed! code = %d\n", code);
gs_abort(mem);
}
emprintf3(mem, "HWResolution[%d] = [ %f, %f ]\n", HWRa.size,
HWRa.data[0], HWRa.data[1]);
code = param_read_float_array((gs_param_list *) & list,
"PageSize", &PSa);
if (code < 0) {
lprintf1("reading PageSize failed! code = %d\n", code);
gs_abort(mem);
}
emprintf3(mem, "PageSize[%d] = [ %f, %f ]\n", PSa.size,
PSa.data[0], PSa.data[1]);
code = param_read_long((gs_param_list *) & list,
"MaxBitmap", &MaxBitmap);
if (code < 0) {
lprintf1("reading MaxBitmap failed! code = %d\n", code);
gs_abort(mem);
}
emprintf1(mem, "MaxBitmap = %ld\n", MaxBitmap);
/* Switch to param list functions to "write" */
gs_c_param_list_write(&list, mem);
/* Always set the PageSize. */
PageSize[0] = 72.0 * ypage_wid;
PageSize[1] = 72.0 * xpage_len;
PSa.data = PageSize;
code = param_write_float_array((gs_param_list *) & list,
"PageSize", &PSa);
if (nstr.data[0] != 'v') {
/* Set the OutputFile string file name */
OFstr.persistent = false;
OFstr.data = outfile;
OFstr.size = strlen(outfile);
code = param_write_string((gs_param_list *) & list,
"OutputFile", &OFstr);
if (code < 0) {
lprintf1("setting OutputFile name failed, code=%d\n",
code);
gs_abort(mem);
}
if (nstr.data[0] == 'x') {
HWResolution[0] = HWResolution[1] = 72.0;
} else {
HWResolution[0] = HWResolution[1] = 360.0;
}
HWRa.data = HWResolution;
HWSize[0] = (int)(HWResolution[0] * ypage_wid);
HWSize[1] = (int)(HWResolution[1] * xpage_len);
emprintf3(mem, "\tHWSize = [%d,%d], HWResolution = %f dpi\n",
HWSize[0], HWSize[1], HWResolution[0]);
HWSa.data = HWSize;
code = param_write_float_array((gs_param_list *) & list,
"HWResolution", &HWRa);
code = param_write_int_array((gs_param_list *) & list,
"HWSize", &HWSa);
MaxBitmap = 1000000L;
code = param_write_long((gs_param_list *) & list,
"MaxBitmap", &MaxBitmap);
}
gs_c_param_list_read(&list);
code = gs_putdeviceparams(dev, (gs_param_list *) & list);
emprintf1(mem, "putdeviceparams: code=%d\n", code);
gs_c_param_list_release(&list);
/* note: initgraphics no longer resets the color or color space */
gs_erasepage(pgs);
gs_initgraphics(pgs);
{
gs_color_space *cs = gs_cspace_new_DeviceGray(mem);
gs_setcolorspace(pgs, cs);
gs_setcolorspace(pgs, cs);
gs_decrement(cs, "test10 DeviceGray");
}
gs_clippath(pgs);
gs_pathbbox(pgs, &cliprect);
emprintf4(mem, "\tcliprect = [[%g,%g],[%g,%g]]\n",
cliprect.p.x, cliprect.p.y, cliprect.q.x, cliprect.q.y);
gs_newpath(pgs);
switch (((rotate_value + 270) / 90) & 3) {
default:
case 0: /* 0 = 360 degrees in PS == 90 degrees in printer */
xlate_x = cliprect.p.x;
xlate_y = cliprect.p.y;
break;
case 1: /* 90 degrees in PS = 180 degrees printer */
xlate_x = cliprect.q.x;
xlate_y = cliprect.p.y;
break;
case 2: /* 180 degrees in PS == 270 degrees in printer */
xlate_x = cliprect.q.x;
xlate_y = cliprect.q.y;
break;
case 3: /* 270 degrees in PS == 0 degrees in printer */
xlate_x = cliprect.p.x;
xlate_y = cliprect.q.y;
break;
}
emprintf2(mem, "translate origin to [ %f, %f ]\n", xlate_x, xlate_y);
gs_translate(pgs, xlate_x, xlate_y);
/* further move (before rotate) by user requested amount */
gs_translate(pgs, 72.0 * (float)xmove_origin, 72.0 * (float)ymove_origin);
gs_rotate(pgs, (float)rotate_value + 270.0);
gs_scale(pgs, scale_x * 72.0 / 2032.0,
scale_y * 72.0 / 2032.0);
gs_setlinecap(pgs, gs_cap_butt);
gs_setlinejoin(pgs, gs_join_bevel);
gs_setfilladjust(pgs, 0.0, 0.0);
capture_exec(pgs);
return 0;
}
int
main(int argc, const char *argv[])
{
char achar = '0';
gs_memory_t *mem;
gs_state *pgs;
const gx_device *const *list;
gx_device *dev;
gx_device_bbox *bbdev;
int code;
gp_init();
mem = gs_malloc_init();
gs_lib_init1(mem);
if (argc < 2 || (achar = argv[1][0]) < '1' ||
achar > '0' + countof(tests) - 1
) {
lprintf1("Usage: gslib 1..%c\n", '0' + (char)countof(tests) - 1);
gs_abort(mem);
}
gs_debug['@'] = 1;
gs_debug['?'] = 1;
/*gs_debug['B'] = 1; *//****** PATCH ******/
/*gs_debug['L'] = 1; *//****** PATCH ******/
/*
* gs_iodev_init must be called after the rest of the inits, for
* obscure reasons that really should be documented!
*/
gs_iodev_init(mem);
/****** WRONG ******/
gs_lib_device_list(&list, NULL);
gs_copydevice(&dev, list[0], mem);
check_device_separable(dev);
gx_device_fill_in_procs(dev);
bbdev =
gs_alloc_struct_immovable(mem, gx_device_bbox, &st_device_bbox,
"bbox");
gx_device_bbox_init(bbdev, dev, mem);
code = dev_proc(dev, get_profile)(dev, &bbdev->icc_struct);
rc_increment(bbdev->icc_struct);
/* Print out the device name just to test the gsparam.c API. */
{
gs_c_param_list list;
gs_param_string nstr;
gs_c_param_list_write(&list, mem);
code = gs_getdeviceparams(dev, (gs_param_list *) & list);
if (code < 0) {
lprintf1("getdeviceparams failed! code = %d\n", code);
gs_abort(mem);
}
gs_c_param_list_read(&list);
code = param_read_string((gs_param_list *) & list, "Name", &nstr);
if (code < 0) {
lprintf1("reading Name failed! code = %d\n", code);
gs_abort(mem);
}
dputs("Device name = ");
debug_print_string(nstr.data, nstr.size);
dputs("\n");
gs_c_param_list_release(&list);
}
/*
* If this is a device that takes an OutputFile, set the OutputFile
* to "-" in the copy.
*/
{
gs_c_param_list list;
gs_param_string nstr;
gs_c_param_list_write(&list, mem);
param_string_from_string(nstr, "-");
code = param_write_string((gs_param_list *)&list, "OutputFile", &nstr);
if (code < 0) {
lprintf1("writing OutputFile failed! code = %d\n", code);
gs_abort(mem);
}
gs_c_param_list_read(&list);
code = gs_putdeviceparams(dev, (gs_param_list *)&list);
gs_c_param_list_release(&list);
if (code < 0 && code != gs_error_undefined) {
lprintf1("putdeviceparams failed! code = %d\n", code);
gs_abort(mem);
}
}
dev = (gx_device *) bbdev;
pgs = gs_state_alloc(mem);
gs_setdevice_no_erase(pgs, dev); /* can't erase yet */
{
gs_point dpi;
gs_screen_halftone ht;
gs_dtransform(pgs, 72.0, 72.0, &dpi);
ht.frequency = min(fabs(dpi.x), fabs(dpi.y)) / 16.001;
ht.angle = 0;
ht.spot_function = odsf;
gs_setscreen(pgs, &ht);
}
/* gsave and grestore (among other places) assume that */
/* there are at least 2 gstates on the graphics stack. */
/* Ensure that now. */
gs_gsave(pgs);
gs_erasepage(pgs);
code = (*tests[achar - '1']) (pgs, mem);
gs_output_page(pgs, 1, 1);
{
gs_rect bbox;
gx_device_bbox_bbox(bbdev, &bbox);
dprintf4("Bounding box: [%g %g %g %g]\n",
bbox.p.x, bbox.p.y, bbox.q.x, bbox.q.y);
}
if (code)
dprintf1("**** Test returned code = %d.\n", code);
dputs("Done. Press <enter> to exit.");
fgetc(mem->gs_lib_ctx->fstdin);
gs_lib_finit(0, 0, mem);
return 0;
#undef mem
}
/*
* Implement get_params for a sample device CRD. A useful convention,
* for devices that can provide more than one CRD, is to have a settable
* parameter CRDName, which gives the name of the CRD in use. This sample
* code provides a constant CRDName: making it settable is left as an
* exercise to the reader.
*/
int
sample_device_crd_get_params(gx_device *pdev, gs_param_list *plist,
const char *crd_param_name)
{
int ecode = 0;
if (param_requested(plist, "CRDName") > 0) {
gs_param_string cns;
int code;
cns.data = (const byte *)crd_param_name;
cns.size = strlen(crd_param_name);
cns.persistent = true;
code = param_write_string(plist, "CRDName", &cns);
if (code < 0)
ecode = code;
}
if (param_requested(plist, crd_param_name) > 0) {
gs_cie_render *pcrd;
int code = gs_cie_render1_build(&pcrd, pdev->memory,
"sample_device_crd_get_params");
if (code >= 0) {
gs_cie_transform_proc3 tpqr;
tpqr = bit_TransformPQR;
tpqr.driver_name = pdev->dname;
code = gs_cie_render1_initialize(pdev->memory, pcrd, NULL,
&bit_WhitePoint, NULL /*BlackPoint*/,
NULL /*MatrixPQR*/, &bit_RangePQR, &tpqr,
NULL /*MatrixLMN*/, &bit_EncodeLMN, &bit_RangeLMN,
&bit_MatrixABC, &bit_EncodeABC, NULL /*RangeABC*/,
&bit_RenderTable);
if (code >= 0) {
code = param_write_cie_render1(plist, crd_param_name, pcrd,
pdev->memory);
}
rc_decrement(pcrd, "sample_device_crd_get_params"); /* release */
}
if (code < 0)
ecode = code;
}
if (param_requested(plist, bit_TransformPQR.proc_name) > 0) {
/*
* We definitely do not recommend the following use of a static
* to hold the address: this is a shortcut.
*/
gs_cie_transform_proc my_proc = bit_TransformPQR_proc;
byte *my_addr = gs_alloc_string(pdev->memory, sizeof(my_proc),
"sd_crd_get_params(proc)");
int code;
if (my_addr == 0)
code = gs_note_error(gs_error_VMerror);
else {
gs_param_string as;
memcpy(my_addr, &my_proc, sizeof(my_proc));
as.data = my_addr;
as.size = sizeof(my_proc);
as.persistent = true;
code = param_write_string(plist, bit_TransformPQR.proc_name, &as);
}
if (code < 0)
ecode = code;
}
return ecode;
}
static int
current_param_list(i_ctx_t *i_ctx_p, const param_set * pset,
const ref * psref /*t_string */ )
{
stack_param_list list;
gs_param_list *const plist = (gs_param_list *)&list;
int code = 0;
unsigned int i;
stack_param_list_write(&list, &o_stack, NULL, iimemory);
for (i = 0; i < pset->long_count; i++) {
const char *pname = pset->long_defs[i].pname;
if (pname_matches(pname, psref)) {
long val = (*pset->long_defs[i].current)(i_ctx_p);
code = param_write_long(plist, pname, &val);
if (code < 0)
return code;
}
}
for (i = 0; i < pset->bool_count; i++) {
const char *pname = pset->bool_defs[i].pname;
if (pname_matches(pname, psref)) {
bool val = (*pset->bool_defs[i].current)(i_ctx_p);
code = param_write_bool(plist, pname, &val);
if (code < 0)
return code;
}
}
for (i = 0; i < pset->string_count; i++) {
const char *pname = pset->string_defs[i].pname;
if (pname_matches(pname, psref)) {
gs_param_string val;
(*pset->string_defs[i].current)(i_ctx_p, &val);
code = param_write_string(plist, pname, &val);
if (code < 0)
return code;
}
}
if (psref) {
/*
* Scanner options can be read, but only individually by .getuserparam.
* This avoids putting them into userparams, and being affected by save/restore.
*/
const char *pname;
bool val;
int code;
switch (ztoken_get_scanner_option(psref, i_ctx_p->scanner_options, &pname)) {
case 0:
code = param_write_null(plist, pname);
break;
case 1:
val = true;
code = param_write_bool(plist, pname, &val);
break;
default:
code = 0;
break;
}
if (code < 0)
return code;
}
return code;
}
static int
win_pr2_write_user_settings(gx_device_win_pr2 * wdev, gs_param_list * plist)
{
gs_param_dict dict;
gs_param_int_array range;
gs_param_float_array box;
gs_param_string docn;
gs_param_string papn;
int array[2];
const char* pname = "UserSettings";
int code;
dict.size = 12;
code = param_begin_write_dict(plist, pname, &dict, false);
if (code < 0) return code;
array[0] = wdev->doc_page_begin;
array[1] = wdev->doc_page_end;
range.data = array;
range.size = 2;
range.persistent = false;
code = param_write_int_array(dict.list, "DocumentRange", &range);
if (code < 0) goto error;
array[0] = wdev->user_page_begin;
array[1] = wdev->user_page_end;
range.data = array;
range.size = 2;
range.persistent = false;
code = param_write_int_array(dict.list, "SelectedRange", &range);
if (code < 0) goto error;
box.data = wdev->user_media_size;
box.size = 2;
box.persistent = false;
code = param_write_float_array(dict.list, "MediaSize", &box);
if (code < 0) goto error;
code = param_write_int(dict.list, "Copies", &wdev->user_copies);
if (code < 0) goto error;
code = param_write_int(dict.list, "Paper", &wdev->user_paper);
if (code < 0) goto error;
code = param_write_int(dict.list, "Orientation", &wdev->user_orient);
if (code < 0) goto error;
code = param_write_int(dict.list, "Color", &wdev->user_color);
if (code < 0) goto error;
code = param_write_int(dict.list, "MaxResolution", &wdev->max_dpi);
if (code < 0) goto error;
code = param_write_int(dict.list, "PrintCopies", &wdev->print_copies);
if (code < 0) goto error;
docn.data = (const byte*)wdev->doc_name;
docn.size = strlen(wdev->doc_name);
docn.persistent = false;
code = param_write_string(dict.list, "DocumentName", &docn);
if (code < 0) goto error;
papn.data = (const byte*)wdev->paper_name;
papn.size = strlen(wdev->paper_name);
papn.persistent = false;
code = param_write_string(dict.list, "PaperName", &papn);
if (code < 0) goto error;
code = param_write_bool(dict.list, "UserChangedSettings", &wdev->user_changed_settings);
error:
param_end_write_dict(plist, pname, &dict);
return code;
}
/* Get standard parameters. */
int
gx_default_get_params(gx_device * dev, gs_param_list * plist)
{
int code;
/* Standard page device parameters: */
bool seprs = false;
gs_param_string dns, pcms;
gs_param_float_array msa, ibba, hwra, ma;
gs_param_string_array scna;
#define set_param_array(a, d, s)\
(a.data = d, a.size = s, a.persistent = false);
/* Non-standard parameters: */
int colors = dev->color_info.num_components;
int mns = colors;
int depth = dev->color_info.depth;
int GrayValues = dev->color_info.max_gray + 1;
int HWSize[2];
gs_param_int_array hwsa;
gs_param_float_array hwma, mhwra;
/* Fill in page device parameters. */
param_string_from_string(dns, dev->dname);
{
const char *cms = get_process_color_model_name(dev);
/* We might have an uninitialized device with */
/* color_info.num_components = 0.... */
if ((cms != NULL) && (*cms != '\0'))
param_string_from_string(pcms, cms);
else
pcms.data = 0;
}
set_param_array(hwra, dev->HWResolution, 2);
set_param_array(msa, dev->MediaSize, 2);
set_param_array(ibba, dev->ImagingBBox, 4);
set_param_array(ma, dev->Margins, 2);
set_param_array(scna, NULL, 0);
/* Fill in non-standard parameters. */
HWSize[0] = dev->width;
HWSize[1] = dev->height;
set_param_array(hwsa, HWSize, 2);
set_param_array(hwma, dev->HWMargins, 4);
set_param_array(mhwra, dev->MarginsHWResolution, 2);
/* Transmit the values. */
if (
/* Standard parameters */
(code = param_write_name(plist, "OutputDevice", &dns)) < 0 ||
#ifdef PAGESIZE_IS_MEDIASIZE
(code = param_write_float_array(plist, "PageSize", &msa)) < 0 ||
#endif
(code = (pcms.data == 0 ? 0 :
param_write_name(plist, "ProcessColorModel", &pcms))) < 0 ||
(code = param_write_float_array(plist, "HWResolution", &hwra)) < 0 ||
(code = (dev->ImagingBBox_set ?
param_write_float_array(plist, "ImagingBBox", &ibba) :
param_write_null(plist, "ImagingBBox"))) < 0 ||
(code = param_write_float_array(plist, "Margins", &ma)) < 0 ||
(code = param_write_int(plist, "MaxSeparations", &mns)) < 0 ||
(code = (dev->NumCopies_set < 0 ||
(*dev_proc(dev, get_page_device))(dev) == 0 ? 0:
dev->NumCopies_set ?
param_write_int(plist, "NumCopies", &dev->NumCopies) :
param_write_null(plist, "NumCopies"))) < 0 ||
(code = param_write_name_array(plist, "SeparationColorNames", &scna)) < 0 ||
(code = param_write_bool(plist, "Separations", &seprs)) < 0 ||
(code = param_write_bool(plist, "UseCIEColor", &dev->UseCIEColor)) < 0 ||
/* Non-standard parameters */
(code = param_write_int_array(plist, "HWSize", &hwsa)) < 0 ||
(code = param_write_float_array(plist, ".HWMargins", &hwma)) < 0 ||
(code = param_write_float_array(plist, ".MarginsHWResolution", &mhwra)) < 0 ||
(code = param_write_float_array(plist, ".MediaSize", &msa)) < 0 ||
(code = param_write_string(plist, "Name", &dns)) < 0 ||
(code = param_write_int(plist, "Colors", &colors)) < 0 ||
(code = param_write_int(plist, "BitsPerPixel", &depth)) < 0 ||
(code = param_write_int(plist, "GrayValues", &GrayValues)) < 0 ||
(code = param_write_long(plist, "PageCount", &dev->PageCount)) < 0 ||
(code = param_write_bool(plist, ".IgnoreNumCopies", &dev->IgnoreNumCopies)) < 0 ||
(code = param_write_int(plist, "TextAlphaBits",
&dev->color_info.anti_alias.text_bits)) < 0 ||
(code = param_write_int(plist, "GraphicsAlphaBits",
&dev->color_info.anti_alias.graphics_bits)) < 0 ||
(code = param_write_bool(plist, ".LockSafetyParams", &dev->LockSafetyParams)) < 0
)
return code;
/* If LeadingEdge was set explicitly, report it here. */
if (dev->LeadingEdge & LEADINGEDGE_SET_MASK) {
int leadingedge = dev->LeadingEdge & LEADINGEDGE_MASK;
code = param_write_int(plist, "LeadingEdge", &leadingedge);
}
if (code < 0)
return code;
/* Fill in color information. */
if (colors > 1) {
int RGBValues = dev->color_info.max_color + 1;
long ColorValues = (depth >= 32 ? -1 : 1L << depth); /* value can only be 32 bits */
if ((code = param_write_int(plist, "RedValues", &RGBValues)) < 0 ||
(code = param_write_int(plist, "GreenValues", &RGBValues)) < 0 ||
(code = param_write_int(plist, "BlueValues", &RGBValues)) < 0 ||
(code = param_write_long(plist, "ColorValues", &ColorValues)) < 0
)
return code;
}
if (param_requested(plist, "HWColorMap")) {
byte palette[3 << 8];
if (param_HWColorMap(dev, palette)) {
gs_param_string hwcms;
hwcms.data = palette, hwcms.size = colors << depth,
hwcms.persistent = false;
if ((code = param_write_string(plist, "HWColorMap", &hwcms)) < 0)
return code;
}
}
return 0;
}