static int
perm_put_params(gx_device *pdev, gs_param_list *plist)
{
gx_device_perm_t * const dev = (gx_device_perm_t *)pdev;
gx_device_color_info save_info;
int code;
int new_permute = dev->permute;
int new_mode = dev->mode;
code = param_read_int(plist, "Permute", &new_permute);
if (code < 0)
return code;
code = param_read_int(plist, "Mode", &new_mode);
if (code < 0)
return code;
if (new_mode < 0 || new_mode >= sizeof(perm_cmapping_procs) / sizeof(perm_cmapping_procs[0])) {
dmlprintf(pdev->memory, "rangecheck!\n");
return_error(gs_error_rangecheck);
}
dev->permute = new_permute;
dev->mode = new_mode;
save_info = pdev->color_info;
code = perm_set_color_model(dev, dev->mode, dev->permute);
if (code >= 0)
code = gdev_prn_put_params(pdev, plist);
if (code < 0)
pdev->color_info = save_info;
return code;
}
static int
fpng_put_params(gx_device *dev, gs_param_list *plist)
{
gx_device_fpng *pdev = (gx_device_fpng *)dev;
int code, ecode;
int dsf = pdev->downscale_factor;
const char *param_name;
ecode = 0;
switch (code = param_read_int(plist, (param_name = "DownScaleFactor"), &dsf)) {
case 0:
if (dsf >= 1)
break;
code = gs_error_rangecheck;
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 1:
break;
}
code = gdev_prn_put_params(dev, plist);
if (code < 0)
ecode = code;
pdev->downscale_factor = dsf;
return ecode;
}
static int
pngalpha_put_params(gx_device * pdev, gs_param_list * plist)
{
gx_device_pngalpha *ppdev = (gx_device_pngalpha *)pdev;
int background;
int code;
/* BackgroundColor in format 16#RRGGBB is used for bKGD chunk */
switch(code = param_read_int(plist, "BackgroundColor", &background)) {
case 0:
ppdev->background = background & 0xffffff;
break;
case 1: /* not found */
code = 0;
break;
default:
param_signal_error(plist, "BackgroundColor", code);
break;
}
if (code == 0) {
code = gdev_prn_put_params(pdev, plist);
if ((ppdev->procs.fill_rectangle != pngalpha_fill_rectangle) &&
(ppdev->procs.fill_rectangle != NULL)) {
/* Get current implementation of fill_rectangle and restore ours.
* Implementation is either clist or memory and can change
* during put_params.
*/
ppdev->orig_fill_rectangle = ppdev->procs.fill_rectangle;
ppdev->procs.fill_rectangle = pngalpha_fill_rectangle;
}
}
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;
int depth;
gs_param_string outputFile;
// 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;
}
/* before the device is opened */
int
os2prn_put_params(gx_device * dev, gs_param_list * plist)
{
int ecode = 0, code;
int old_bpp = dev->color_info.depth;
int bpp = old_bpp;
gs_param_string qs;
/* Handle extra parameters */
switch (code = param_read_string(plist, "OS2QUEUE", &qs)) {
case 0:
if (qs.size == strlen(opdev->queue_name) &&
!memcmp(opdev->queue_name, qs.data, qs.size)
) {
qs.data = 0;
break;
}
if (dev->is_open)
ecode = gs_error_rangecheck;
else if (qs.size >= sizeof(opdev->queue_name))
ecode = gs_error_limitcheck;
else
break;
goto qe;
default:
ecode = code;
qe:param_signal_error(plist, "OS2QUEUE", ecode);
case 1:
qs.data = 0;
break;
}
switch (code = param_read_int(plist, "BitsPerPixel", &bpp)) {
case 0:
if (dev->is_open)
ecode = gs_error_rangecheck;
else { /* change dev->color_info is valid before device is opened */
os2prn_set_bpp(dev, bpp);
break;
}
goto bppe;
default:
ecode = code;
bppe:param_signal_error(plist, "BitsPerPixel", ecode);
case 1:
break;
}
if (ecode >= 0)
ecode = gdev_prn_put_params(dev, plist);
if ((ecode >= 0) && (qs.data != 0)) {
memcpy(opdev->queue_name, qs.data, qs.size);
opdev->queue_name[qs.size] = 0;
}
return ecode;
}
/* Put an integer value. */
int
param_put_int(gs_param_list * plist, gs_param_name param_name,
int *pval, int ecode)
{
int code;
switch (code = param_read_int(plist, param_name, pval)) {
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
case 0:
case 1:
break;
}
return ecode;
}
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;
}
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;
}
/* internal variables. */
static int
win_pr2_read_user_settings(gx_device_win_pr2 * wdev, gs_param_list * plist)
{
gs_param_dict dict;
gs_param_string docn = { 0 };
const char* dict_name = "UserSettings";
const char* param_name = "";
int code = 0;
int ecode = 0;
switch (code = param_begin_read_dict(plist, dict_name, &dict, false)) {
default:
param_signal_error(plist, dict_name, code);
return code;
case 1:
break;
case 0:
{
gs_param_int_array ia;
BEGIN_ARRAY_PARAM(param_read_int_array, "DocumentRange", ia, 2, ia)
if ((ia.data[0] < 0) ||
(ia.data[1] < 0) ||
(ia.data[0] > ia.data[1]))
ecode = gs_note_error(gs_error_rangecheck);
wdev->doc_page_begin = ia.data[0];
wdev->doc_page_end = ia.data[1];
END_ARRAY_PARAM(ia, doc_range_error)
BEGIN_ARRAY_PARAM(param_read_int_array, "SelectedRange", ia, 2, ia)
if ((ia.data[0] < 0) ||
(ia.data[1] < 0) ||
(ia.data[0] > ia.data[1]))
ecode = gs_note_error(gs_error_rangecheck);
wdev->user_page_begin = ia.data[0];
wdev->user_page_end = ia.data[1];
END_ARRAY_PARAM(ia, sel_range_error)
param_read_int(dict.list, "Copies", &wdev->user_copies);
param_read_int(dict.list, "Paper", &wdev->user_paper);
param_read_int(dict.list, "Orientation", &wdev->user_orient);
param_read_int(dict.list, "Color", &wdev->user_color);
param_read_int(dict.list, "MaxResolution", &wdev->max_dpi);
switch (code = param_read_string(dict.list, (param_name = "DocumentName"), &docn)) {
case 0:
if (docn.size < sizeof(wdev->doc_name))
break;
code = gs_error_rangecheck;
/* fall through */
default:
ecode = code;
param_signal_error(plist, param_name, ecode);
/* fall through */
case 1:
docn.data = 0;
break;
}
param_end_read_dict(plist, dict_name, &dict);
if (docn.data) {
memcpy(wdev->doc_name, docn.data, docn.size);
wdev->doc_name[docn.size] = 0;
}
wdev->print_copies = 1;
if (wdev->win32_hdevmode) {
LPDEVMODE devmode = (LPDEVMODE) GlobalLock(wdev->win32_hdevmode);
if (devmode) {
devmode->dmCopies = wdev->user_copies;
devmode->dmPaperSize = wdev->user_paper;
devmode->dmOrientation = wdev->user_orient;
devmode->dmColor = wdev->user_color;
GlobalUnlock(wdev->win32_hdevmode);
}
}
}
break;
}
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;
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;
}
