/* We don't attempt to back out if anything fails. */
static int
setparams(i_ctx_t *i_ctx_p, gs_param_list * plist, const param_set * pset)
{
int code;
unsigned int i;
for (i = 0; i < pset->long_count; i++) {
const long_param_def_t *pdef = &pset->long_defs[i];
long val;
if (pdef->set == NULL)
continue;
code = param_read_long(plist, pdef->pname, &val);
switch (code) {
default: /* invalid */
return code;
case 1: /* missing */
break;
case 0:
if (val < pdef->min_value || val > pdef->max_value)
return_error(gs_error_rangecheck);
code = (*pdef->set)(i_ctx_p, val);
if (code < 0)
return code;
}
}
for (i = 0; i < pset->bool_count; i++) {
const bool_param_def_t *pdef = &pset->bool_defs[i];
bool val;
if (pdef->set == NULL)
continue;
code = param_read_bool(plist, pdef->pname, &val);
if (code == 0)
code = (*pdef->set)(i_ctx_p, val);
if (code < 0)
return code;
}
for (i = 0; i < pset->string_count; i++) {
const string_param_def_t *pdef = &pset->string_defs[i];
gs_param_string val;
if (pdef->set == NULL)
continue;
code = param_read_string(plist, pdef->pname, &val);
switch (code) {
default: /* invalid */
return code;
case 1: /* missing */
break;
case 0:
code = (*pdef->set)(i_ctx_p, &val);
if (code < 0)
return code;
}
}
return 0;
}
static int
hpjet_put_params(gx_device *pdev, gs_param_list *plist)
{
gx_device_hpjet *dev = (gx_device_hpjet *)pdev;
int code;
bool ManualFeed;
bool ManualFeed_set = false;
int MediaPosition;
bool MediaPosition_set = false;
bool Tumble;
code = param_read_bool(plist, "ManualFeed", &ManualFeed);
if (code == 0) ManualFeed_set = true;
if (code >= 0) {
code = param_read_int(plist, "MediaPosition", &MediaPosition);
if (code == 0) MediaPosition_set = true;
else if (code < 0) {
if (param_read_null(plist, "MediaPosition") == 0) {
code = 0;
}
}
}
if (code>=0)
{
code=param_read_bool(plist,"Tumble",&Tumble);
if (code != 0) Tumble = false; /* default: no tumble */
}
if (code >= 0)
code = gdev_prn_put_params(pdev, plist);
if (code >= 0) {
dev->Tumble=Tumble;
if (ManualFeed_set) {
dev->ManualFeed = ManualFeed;
dev->ManualFeed_set = true;
}
if (MediaPosition_set) {
dev->MediaPosition = MediaPosition;
dev->MediaPosition_set = true;
}
}
return code;
}
/* from PageBoundingBox. */
static int
bbox_put_params(gx_device * dev, gs_param_list * plist)
{
gx_device_bbox *const bdev = (gx_device_bbox *) dev;
int code;
int ecode = 0;
bool white_is_opaque = bdev->white_is_opaque;
gs_param_name param_name;
gs_param_float_array bba;
code = param_read_float_array(plist, (param_name = "PageBoundingBox"),
&bba);
switch (code) {
case 0:
if (bba.size != 4) {
ecode = gs_note_error(gs_error_rangecheck);
goto e;
}
break;
default:
ecode = code;
e:param_signal_error(plist, param_name, ecode);
case 1:
bba.data = 0;
}
switch (code = param_read_bool(plist, (param_name = "WhiteIsOpaque"), &white_is_opaque)) {
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 0:
case 1:
break;
}
code = gx_forward_put_params(dev, plist);
if (ecode < 0)
code = ecode;
if (code >= 0) {
if( bba.data != 0) {
BBOX_INIT_BOX(bdev);
BBOX_ADD_RECT(bdev, float2fixed(bba.data[0]), float2fixed(bba.data[1]),
float2fixed(bba.data[2]), float2fixed(bba.data[3]));
}
bdev->white_is_opaque = white_is_opaque;
}
bbox_copy_params(bdev, bdev->is_open);
return code;
}
int
gdev_prn_put_params_planar(gx_device * pdev, gs_param_list * plist,
bool *pupb)
{
bool upb = *pupb;
int ecode = 0, code;
if (pdev->color_info.num_components > 1)
ecode = param_read_bool(plist, "UsePlanarBuffer", &upb);
code = gdev_prn_put_params(pdev, plist);
if (ecode >= 0)
ecode = code;
if (ecode >= 0)
*pupb = upb;
return ecode;
}
/* Put a Boolean value. */
int
param_put_bool(gs_param_list * plist, gs_param_name param_name,
bool * pval, int ecode)
{
int code;
switch (code = param_read_bool(plist, param_name, pval)) {
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 0:
case 1:
break;
}
return ecode;
}
/* Put parameters, implementation */
static int
gdev_pdf_put_params_impl(gx_device * dev, const gx_device_pdf * save_dev, gs_param_list * plist)
{
int ecode, code;
gx_device_pdf *pdev = (gx_device_pdf *) dev;
float cl = (float)pdev->CompatibilityLevel;
bool locked = pdev->params.LockDistillerParams;
gs_param_name param_name;
enum psdf_color_conversion_strategy save_ccs = pdev->params.ColorConversionStrategy;
pdev->pdf_memory = gs_memory_stable(pdev->memory);
/*
* If this is a pseudo-parameter (pdfmark or DSC),
* don't bother checking for any real ones.
*/
{
gs_param_string_array ppa;
code = param_read_string_array(plist, (param_name = "pdfmark"), &ppa);
switch (code) {
case 0:
code = pdf_open_document(pdev);
if (code < 0)
return code;
code = pdfmark_process(pdev, &ppa);
if (code >= 0)
return code;
/* falls through for errors */
default:
param_signal_error(plist, param_name, code);
return code;
case 1:
break;
}
code = param_read_string_array(plist, (param_name = "DSC"), &ppa);
switch (code) {
case 0:
code = pdf_open_document(pdev);
if (code < 0)
return code;
code = pdf_dsc_process(pdev, &ppa);
if (code >= 0)
return code;
/* falls through for errors */
default:
param_signal_error(plist, param_name, code);
return code;
case 1:
break;
}
}
/*
* Check for LockDistillerParams before doing anything else.
* If LockDistillerParams is true and is not being set to false,
* ignore all resettings of PDF-specific parameters. Note that
* LockDistillerParams is read again, and reset if necessary, in
* psdf_put_params.
*/
ecode = code = param_read_bool(plist, "LockDistillerParams", &locked);
if (!(locked && pdev->params.LockDistillerParams)) {
/* General parameters. */
{
int efo = 1;
ecode = param_put_int(plist, (param_name = ".EmbedFontObjects"), &efo, ecode);
if (efo != 1)
param_signal_error(plist, param_name, ecode = gs_error_rangecheck);
}
{
int cdv = CoreDistVersion;
ecode = param_put_int(plist, (param_name = "CoreDistVersion"), &cdv, ecode);
if (cdv != CoreDistVersion)
param_signal_error(plist, param_name, ecode = gs_error_rangecheck);
}
switch (code = param_read_float(plist, (param_name = "CompatibilityLevel"), &cl)) {
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 0:
/*
* Must be 1.2, 1.3, 1.4, or 1.5. Per Adobe documentation, substitute
* the nearest achievable value.
*/
if (cl < (float)1.15)
cl = (float)1.1;
else if (cl < (float)1.25)
cl = (float)1.2;
else if (cl < (float)1.35)
cl = (float)1.3;
else if (cl < (float)1.45)
cl = (float)1.4;
else
cl = (float)1.5;
case 1:
break;
}
{ /* HACK : gs_param_list_s::memory is documented in gsparam.h as
"for allocating coerced arrays". Not sure why zputdeviceparams
sets it to the current memory space, while the device
assumes to store them in the device's memory space.
As a hackish workaround we temporary replace it here.
Doing so because we don't want to change the global code now
because we're unable to test it with all devices.
Bug 688531 "Segmentation fault running pdfwrite from 219-01.ps".
This solution to be reconsidered after fixing
the bug 688533 "zputdeviceparams specifies a wrong memory space.".
*/
gs_memory_t *mem = plist->memory;
plist->memory = pdev->pdf_memory;
code = gs_param_read_items(plist, pdev, pdf_param_items);
if (code < 0 ||
(pdev->is_ps2write && (code = param_read_string(plist, "OPDFReadProcsetPath", &pdev->OPDFReadProcsetPath)) < 0) ||
(!pdev->is_ps2write && (code = param_read_bool(plist, "ForOPDFRead", &pdev->ForOPDFRead)) < 0)
);
plist->memory = mem;
}
if (code < 0)
ecode = code;
{
/*
* Setting FirstObjectNumber is only legal if the file
* has just been opened and nothing has been written,
* or if we are setting it to the same value.
*/
long fon = pdev->FirstObjectNumber;
if (fon != save_dev->FirstObjectNumber) {
if (fon <= 0 || fon > 0x7fff0000 ||
(pdev->next_id != 0 &&
pdev->next_id !=
save_dev->FirstObjectNumber + pdf_num_initial_ids)
) {
ecode = gs_error_rangecheck;
param_signal_error(plist, "FirstObjectNumber", ecode);
}
}
}
{
/*
* Set ProcessColorModel now, because gx_default_put_params checks
* it.
*/
static const char *const pcm_names[] = {
"DeviceGray", "DeviceRGB", "DeviceCMYK", "DeviceN", 0
};
int pcm = -1;
ecode = param_put_enum(plist, "ProcessColorModel", &pcm,
pcm_names, ecode);
if (pcm >= 0) {
pdf_set_process_color_model(pdev, pcm);
pdf_set_initial_color(pdev, &pdev->saved_fill_color, &pdev->saved_stroke_color,
&pdev->fill_used_process_color, &pdev->stroke_used_process_color);
}
}
}
if (ecode < 0)
goto fail;
if (pdev->PDFX && pdev->PDFA) {
ecode = gs_note_error(gs_error_rangecheck);
param_signal_error(plist, "PDFA", ecode);
goto fail;
}
if (pdev->PDFX && pdev->ForOPDFRead) {
ecode = gs_note_error(gs_error_rangecheck);
param_signal_error(plist, "PDFX", ecode);
goto fail;
}
if (pdev->PDFA && pdev->ForOPDFRead) {
ecode = gs_note_error(gs_error_rangecheck);
param_signal_error(plist, "PDFA", ecode);
goto fail;
}
if (pdev->PDFA)
pdev->HaveTransparency = false;
/*
* We have to set version to the new value, because the set of
* legal parameter values for psdf_put_params varies according to
* the version.
*/
if (pdev->PDFX)
cl = (float)1.3; /* Instead pdev->CompatibilityLevel = 1.2; - see below. */
if (pdev->PDFA && cl < 1.4)
cl = (float)1.4;
pdev->version = (cl < 1.2 ? psdf_version_level2 : psdf_version_ll3);
if (pdev->ForOPDFRead) {
pdev->ResourcesBeforeUsage = true;
pdev->HaveCFF = false;
pdev->HavePDFWidths = false;
pdev->HaveStrokeColor = false;
cl = (float)1.2; /* Instead pdev->CompatibilityLevel = 1.2; - see below. */
pdev->MaxInlineImageSize = max_long; /* Save printer's RAM from saving temporary image data.
Immediate images doen't need buffering. */
pdev->version = psdf_version_level2;
} else {
pdev->ResourcesBeforeUsage = false;
pdev->HaveCFF = true;
pdev->HavePDFWidths = true;
pdev->HaveStrokeColor = true;
}
pdev->ParamCompatibilityLevel = cl;
ecode = gdev_psdf_put_params(dev, plist);
if (ecode < 0)
goto fail;
if ((pdev->params.ColorConversionStrategy == ccs_CMYK &&
strcmp(pdev->color_info.cm_name, "DeviceCMYK")) ||
(pdev->params.ColorConversionStrategy == ccs_sRGB &&
strcmp(pdev->color_info.cm_name, "DeviceRGB")) ||
(pdev->params.ColorConversionStrategy == ccs_Gray &&
strcmp(pdev->color_info.cm_name, "DeviceGray"))) {
eprintf("ColorConversionStrategy is incompatible to ProcessColorModel.\n");
ecode = gs_note_error(gs_error_rangecheck);
pdev->params.ColorConversionStrategy = save_ccs;
}
if (pdev->params.ColorConversionStrategy == ccs_UseDeviceIndependentColor) {
if (!pdev->UseCIEColor) {
eprintf("Set UseCIEColor for UseDeviceIndependentColor to work properly.\n");
ecode = gs_note_error(gs_error_rangecheck);
pdev->UseCIEColor = true;
}
}
if (pdev->params.ColorConversionStrategy == ccs_UseDeviceIndependentColorForImages) {
if (!pdev->UseCIEColor) {
eprintf("UseDeviceDependentColorForImages is not supported. Use UseDeviceIndependentColor.\n");
pdev->params.ColorConversionStrategy = ccs_UseDeviceIndependentColor;
if (!pdev->UseCIEColor) {
eprintf("Set UseCIEColor for UseDeviceIndependentColor to work properly.\n");
ecode = gs_note_error(gs_error_rangecheck);
pdev->UseCIEColor = true;
}
}
}
if (pdev->params.ColorConversionStrategy == ccs_UseDeviceDependentColor) {
if (!strcmp(pdev->color_info.cm_name, "DeviceCMYK")) {
eprintf("Replacing the deprecated device parameter value UseDeviceDependentColor with CMYK.\n");
pdev->params.ColorConversionStrategy = ccs_CMYK;
} else if (!strcmp(pdev->color_info.cm_name, "DeviceRGB")) {
eprintf("Replacing the deprecated device parameter value UseDeviceDependentColor with sRGB.\n");
pdev->params.ColorConversionStrategy = ccs_sRGB;
} else {
eprintf("Replacing the deprecated device parameter value UseDeviceDependentColor with Gray.\n");
pdev->params.ColorConversionStrategy = ccs_Gray;
}
}
if (cl < 1.5 && pdev->params.ColorImage.Filter != NULL &&
!strcmp(pdev->params.ColorImage.Filter, "JPXEncode")) {
eprintf("JPXEncode requires CompatibilityLevel >= 1.5 .\n");
ecode = gs_note_error(gs_error_rangecheck);
}
if (cl < 1.5 && pdev->params.GrayImage.Filter != NULL &&
!strcmp(pdev->params.GrayImage.Filter, "JPXEncode")) {
eprintf("JPXEncode requires CompatibilityLevel >= 1.5 .\n");
ecode = gs_note_error(gs_error_rangecheck);
}
if (cl < 1.4 && pdev->params.MonoImage.Filter != NULL &&
!strcmp(pdev->params.MonoImage.Filter, "JBIG2Encode")) {
eprintf("JBIG2Encode requires CompatibilityLevel >= 1.4 .\n");
ecode = gs_note_error(gs_error_rangecheck);
}
if (pdev->HaveTrueTypes && pdev->version == psdf_version_level2) {
pdev->version = psdf_version_level2_with_TT ;
}
/*
* Acrobat Reader doesn't handle user-space coordinates larger than
* MAX_USER_COORD. To compensate for this, reduce the resolution so
* that the page size in device space (which we equate to user space) is
* significantly less than MAX_USER_COORD. Note that this still does
* not protect us against input files that use coordinates far outside
* the page boundaries.
*/
#define MAX_EXTENT ((int)(MAX_USER_COORD * 0.9))
/* Changing resolution or page size requires closing the device, */
if (dev->height > MAX_EXTENT || dev->width > MAX_EXTENT) {
double factor =
max(dev->height / (double)MAX_EXTENT,
dev->width / (double)MAX_EXTENT);
gx_device_set_resolution(dev, dev->HWResolution[0] / factor,
dev->HWResolution[1] / factor);
}
#undef MAX_EXTENT
if (pdev->FirstObjectNumber != save_dev->FirstObjectNumber) {
if (pdev->xref.file != 0) {
fseek(pdev->xref.file, 0L, SEEK_SET);
pdf_initialize_ids(pdev);
}
}
/* Handle the float/double mismatch. */
pdev->CompatibilityLevel = (int)(cl * 10 + 0.5) / 10.0;
return 0;
fail:
/* Restore all the parameters to their original state. */
pdev->version = save_dev->version;
pdf_set_process_color_model(pdev, save_dev->pcm_color_info_index);
pdev->saved_fill_color = save_dev->saved_fill_color;
pdev->saved_stroke_color = save_dev->saved_fill_color;
{
const gs_param_item_t *ppi = pdf_param_items;
for (; ppi->key; ++ppi)
memcpy((char *)pdev + ppi->offset,
(char *)save_dev + ppi->offset,
gs_param_type_sizes[ppi->type]);
pdev->ForOPDFRead = save_dev->ForOPDFRead;
pdev->OPDFReadProcsetPath = save_dev->OPDFReadProcsetPath;
}
return ecode;
}
static int
tiff_put_some_params(gx_device * dev, gs_param_list * plist, int which)
{
gx_device_tiff *const tfdev = (gx_device_tiff *)dev;
int ecode = 0;
int code;
const char *param_name;
bool big_endian = tfdev->BigEndian;
uint16 compr = tfdev->Compression;
gs_param_string comprstr;
long downscale = tfdev->DownScaleFactor;
long mss = tfdev->MaxStripSize;
long aw = tfdev->AdjustWidth;
long mfs = tfdev->MinFeatureSize;
/* Read BigEndian option as bool */
switch (code = param_read_bool(plist, (param_name = "BigEndian"), &big_endian)) {
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 0:
case 1:
break;
}
/* Read Compression */
switch (code = param_read_string(plist, (param_name = "Compression"), &comprstr)) {
case 0:
if ((ecode = tiff_compression_id(&compr, &comprstr)) < 0 ||
!tiff_compression_allowed(compr, (which & 1 ? 1 : dev->color_info.depth)))
{
errprintf(tfdev->memory,
(ecode < 0 ? "Unknown compression setting\n" :
"Invalid compression setting for this bitdepth\n"));
param_signal_error(plist, param_name, ecode);
}
break;
case 1:
break;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
}
/* Read Downscale factor */
if (which & 1) {
switch (code = param_read_long(plist,
(param_name = "DownScaleFactor"),
&downscale)) {
case 0:
if (downscale <= 0)
downscale = 1;
break;
case 1:
break;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
}
}
switch (code = param_read_long(plist, (param_name = "MaxStripSize"), &mss)) {
case 0:
/*
* Strip must be large enough to accommodate a raster line.
* If the max strip size is too small, we still write a single
* line per strip rather than giving an error.
*/
if (mss >= 0)
break;
code = gs_error_rangecheck;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 1:
break;
}
switch (code = param_read_long(plist, (param_name = "AdjustWidth"), &aw)) {
case 0:
if (aw >= 0)
break;
code = gs_error_rangecheck;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 1:
break;
}
switch (code = param_read_long(plist, (param_name = "MinFeatureSize"), &mfs)) {
case 0:
if ((mfs >= 0) && (mfs <= 4))
break;
code = gs_error_rangecheck;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 1:
break;
}
if (ecode < 0)
return ecode;
code = gdev_prn_put_params(dev, plist);
if (code < 0)
return code;
tfdev->BigEndian = big_endian;
tfdev->Compression = compr;
tfdev->MaxStripSize = mss;
tfdev->DownScaleFactor = downscale;
tfdev->AdjustWidth = aw;
tfdev->MinFeatureSize = mfs;
return code;
}
static int
mac_put_params(gx_device *dev, gs_param_list *plist)
{
gx_device_macos *mdev = (gx_device_macos *)dev;
int isOpen = mdev->is_open;
int code;
bool useXFonts;
int depth;
gs_param_string outputFile;
// Get the UseExternalFonts Parameter
code = param_read_bool(plist, "UseExternalFonts", &useXFonts);
if (!code)
mdev->useXFonts = useXFonts;
// Get the BitsPerPixel Parameter
code = param_read_int(plist, "BitsPerPixel", &depth);
if (!code) {
code = mac_set_colordepth(dev, depth);
if (code)
param_return_error(plist, "BitsPerPixel", gs_error_rangecheck);
}
// Get OutputFile
code = param_read_string(plist, "OutputFile", &outputFile);
if (code < 0) {
param_signal_error(plist, "OutputFile", code);
return code;
} else if (code == 0) {
if (dev->LockSafetyParams &&
bytes_compare(outputFile.data, outputFile.size,
(const byte *)mdev->outputFileName, strlen(mdev->outputFileName))) {
param_signal_error(plist, "OutputFile", gs_error_invalidaccess);
return gs_error_invalidaccess;
}
if (outputFile.size > (gp_file_name_sizeof - 1)) {
param_signal_error(plist, "OutputFile", gs_error_limitcheck);
return gs_error_limitcheck;
}
/* If filename changed, close file. */
if (outputFile.data != 0 &&
bytes_compare(outputFile.data, outputFile.size,
(const byte *)mdev->outputFileName, strlen(mdev->outputFileName))) {
/* Close the file if it's open. */
if (mdev->outputFile != NULL) {
gx_device_close_output_file(dev, mdev->outputFileName, mdev->outputFile);
memcpy(mdev->outputFileName, outputFile.data, outputFile.size);
mdev->outputFileName[outputFile.size] = 0;
gx_device_open_output_file(dev, mdev->outputFileName, true, true, &(mdev->outputFile));
} else {
memcpy(mdev->outputFileName, outputFile.data, outputFile.size);
mdev->outputFileName[outputFile.size] = 0;
}
}
}
// Get the Default Parameters
mdev->is_open = 0;
code = gx_default_put_params( dev, plist );
mdev->is_open = isOpen;
return code;
}
static int
tfax_put_params(gx_device * dev, gs_param_list * plist)
{
gx_device_tfax *const tfdev = (gx_device_tfax *)dev;
int ecode = 0;
int code;
long mss = tfdev->MaxStripSize;
int fill_order = tfdev->FillOrder;
const char *param_name;
bool big_endian = tfdev->BigEndian;
uint16 compr = tfdev->Compression;
gs_param_string comprstr;
switch (code = param_read_long(plist, (param_name = "MaxStripSize"), &mss)) {
case 0:
/*
* Strip must be large enough to accommodate a raster line.
* If the max strip size is too small, we still write a single
* line per strip rather than giving an error.
*/
if (mss >= 0)
break;
code = gs_error_rangecheck;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 1:
break;
}
/* Following TIFF spec, FillOrder is integer */
switch (code = param_read_int(plist, (param_name = "FillOrder"), &fill_order)) {
case 0:
if (fill_order == 1 || fill_order == 2)
break;
code = gs_error_rangecheck;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 1:
break;
}
/* Read BigEndian option as bool */
switch (code = param_read_bool(plist, (param_name = "BigEndian"), &big_endian)) {
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 0:
case 1:
break;
}
/* Read Compression */
switch (code = param_read_string(plist, (param_name = "Compression"), &comprstr)) {
case 0:
if ((ecode = tiff_compression_id(&compr, &comprstr)) < 0 ||
!tiff_compression_allowed(compr, dev->color_info.depth))
param_signal_error(plist, param_name, ecode);
break;
case 1:
break;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
}
if (ecode < 0)
return ecode;
code = gdev_fax_put_params(dev, plist);
if (code < 0)
return code;
tfdev->MaxStripSize = mss;
tfdev->FillOrder = fill_order;
tfdev->BigEndian = big_endian;
tfdev->Compression = compr;
return code;
}
/* before the device is opened */
int
win_pr2_put_params(gx_device * pdev, gs_param_list * plist)
{
int ecode = 0, code;
int old_bpp = pdev->color_info.depth;
int bpp = old_bpp;
bool tumble = wdev->tumble;
bool nocancel = wdev->nocancel;
int queryuser = 0;
bool old_duplex = wdev->Duplex;
bool old_tumble = wdev->tumble;
int old_orient = wdev->user_orient;
int old_color = wdev->user_color;
int old_paper = wdev->user_paper;
int old_mx_dpi = wdev->max_dpi;
if (wdev->Duplex_set < 0) {
wdev->Duplex_set = 0;
wdev->Duplex = false;
wdev->tumble = false;
}
win_pr2_copy_check(wdev);
code = win_pr2_read_user_settings(wdev, plist);
switch (code = param_read_int(plist, "BitsPerPixel", &bpp)) {
case 0:
if (pdev->is_open) {
if (wdev->selected_bpp == bpp) {
break;
}
ecode = gs_error_rangecheck;
} else { /* change dev->color_info is valid before device is opened */
win_pr2_set_bpp(pdev, bpp);
break;
}
goto bppe;
default:
ecode = code;
bppe:param_signal_error(plist, "BitsPerPixel", ecode);
case 1:
break;
}
switch (code = param_read_bool(plist, "NoCancel", &nocancel)) {
case 0:
if (pdev->is_open) {
if (wdev->nocancel == nocancel) {
break;
}
ecode = gs_error_rangecheck;
} else {
wdev->nocancel = nocancel;
break;
}
goto nocancele;
default:
ecode = code;
nocancele:param_signal_error(plist, "NoCancel", ecode);
case 1:
break;
}
switch (code = param_read_bool(plist, "Tumble", &tumble)) {
case 0:
wdev->tumble = tumble;
break;
default:
ecode = code;
param_signal_error(plist, "Tumble", ecode);
case 1:
break;
}
switch (code = param_read_int(plist, "QueryUser", &queryuser)) {
case 0:
if ((queryuser > 0) &&
(queryuser < 4)) {
win_pr2_print_setup_interaction(wdev, queryuser);
}
break;
default:
ecode = code;
param_signal_error(plist, "QueryUser", ecode);
case 1:
break;
}
if (ecode >= 0)
ecode = gdev_prn_put_params(pdev, plist);
if (wdev->win32_hdevmode && wdev->hdcprn) {
if ( (old_duplex != wdev->Duplex)
|| (old_tumble != wdev->tumble)
|| (old_orient != wdev->user_orient)
|| (old_color != wdev->user_color)
|| (old_paper != wdev->user_paper)
|| (old_mx_dpi != wdev->max_dpi) ) {
LPDEVMODE pdevmode = GlobalLock(wdev->win32_hdevmode);
if (pdevmode) {
win_pr2_update_win(wdev, pdevmode);
ResetDC(wdev->hdcprn, pdevmode);
GlobalUnlock(pdevmode);
}
}
}
return ecode;
}
static int
tfax_put_params(gx_device * dev, gs_param_list * plist)
{
gx_device_tfax *const tfdev = (gx_device_tfax *)dev;
int ecode = 0;
int code;
long mss = tfdev->MaxStripSize;
int fill_order = tfdev->FillOrder;
const char *param_name;
bool big_endian = tfdev->BigEndian;
bool usebigtiff = tfdev->UseBigTIFF;
bool write_datetime = tfdev->write_datetime;
uint16 compr = tfdev->Compression;
gs_param_string comprstr;
switch (code = param_read_long(plist, (param_name = "MaxStripSize"), &mss)) {
case 0:
/*
* Strip must be large enough to accommodate a raster line.
* If the max strip size is too small, we still write a single
* line per strip rather than giving an error.
*/
if (mss >= 0)
break;
code = gs_error_rangecheck;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 1:
break;
}
/* Following TIFF spec, FillOrder is integer */
switch (code = param_read_int(plist, (param_name = "FillOrder"), &fill_order)) {
case 0:
if (fill_order == 1 || fill_order == 2)
break;
code = gs_error_rangecheck;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 1:
break;
}
/* Read BigEndian option as bool */
switch (code = param_read_bool(plist, (param_name = "BigEndian"), &big_endian)) {
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 0:
case 1:
break;
}
/* Read UseBigTIFF option as bool */
switch (code = param_read_bool(plist, (param_name = "UseBigTIFF"), &usebigtiff)) {
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 0:
case 1:
break;
}
#if !(TIFFLIB_VERSION >= 20111221)
if (usebigtiff)
dmlprintf(dev->memory, "Warning: this version of libtiff does not support BigTIFF, ignoring parameter\n");
usebigtiff = false;
#endif
switch (code = param_read_bool(plist, (param_name = "TIFFDateTime"), &write_datetime)) {
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 0:
case 1:
break;
}
/* Read Compression */
switch (code = param_read_string(plist, (param_name = "Compression"), &comprstr)) {
case 0:
if ((ecode = tiff_compression_id(&compr, &comprstr)) < 0 ||
!tiff_compression_allowed(compr, dev->color_info.depth))
param_signal_error(plist, param_name, ecode);
break;
case 1:
break;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
}
if (ecode < 0)
return ecode;
code = gdev_fax_put_params(dev, plist);
if (code < 0)
return code;
tfdev->MaxStripSize = mss;
tfdev->FillOrder = fill_order;
tfdev->BigEndian = big_endian;
tfdev->UseBigTIFF = usebigtiff;
tfdev->Compression = compr;
return code;
}
