static bool
pl_read_device_CRD(gs_cie_render *pcrd, gs_state *pgs)
{
gx_device * pdev = gs_currentdevice(pgs);
gs_c_param_list list;
gs_param_string dstring;
char nbuff[64]; /* ample size */
int code = 0;
/*get the CRDName parameter from the device */
gs_c_param_list_write(&list, gs_state_memory(pgs));
if (param_request((gs_param_list *)&list, "CRDName") < 0)
return false;
if ((code = gs_getdeviceparams(pdev, (gs_param_list *)&list)) >= 0) {
gs_c_param_list_read(&list);
if ( (code = param_read_string( (gs_param_list *)&list,
"CRDName",
&dstring
)) == 0 ) {
if (dstring.size > sizeof(nbuff) - 1)
code = 1;
else {
strncpy(nbuff, (char *)dstring.data, dstring.size);
nbuff[dstring.size] = '\0';
}
}
}
gs_c_param_list_release(&list);
if (code != 0)
return false;
gs_c_param_list_write(&list, gs_state_memory(pgs));
if (param_request((gs_param_list *)&list, nbuff) < 0)
return false;
if ((code = gs_getdeviceparams(pdev, (gs_param_list *)&list)) >= 0) {
gs_param_dict dict;
gs_c_param_list_read(&list);
if ( (code = param_begin_read_dict( (gs_param_list *)&list,
nbuff,
&dict,
false
)) == 0 ) {
code = param_get_cie_render1(pcrd, dict.list, pdev);
param_end_read_dict((gs_param_list *)&list, nbuff, &dict);
if (code > 0)
code = 0;
}
}
gs_c_param_list_release(&list);
return (code == 0);
}
/* Serialize the contents of a gs_param_list (including sub-dicts) */
int /* ret -ve err, else # bytes needed to represent param list, whether */
/* or not it actually fit into buffer. List was successully */
/* serialized only if if this # is <= supplied buf size. */
gs_param_list_serialize(
gs_param_list * list, /* root of list to serialize */
/* list MUST BE IN READ MODE */
byte * buf, /* destination buffer (can be 0) */
int buf_sizeof /* # bytes available in buf (can be 0) */
)
{
int code = 0;
int temp_code;
gs_param_enumerator_t key_enum;
gs_param_key_t key;
WriteBuffer write_buf;
write_buf.buf = buf;
write_buf.buf_end = buf + (buf ? buf_sizeof : 0);
write_buf.total_sizeof = 0;
param_init_enumerator(&key_enum);
/* Each item is serialized as ("word" means compressed word):
* word: key sizeof + 1, or 0 if end of list/dict
* word: data type(gs_param_type_xxx)
* byte[]: key, including trailing \0
* (if simple type)
* byte[]: unpacked representation of data
* (if simple array or string)
* byte[]: unpacked mem image of gs_param_xxx_array structure
* pad: to array alignment
* byte[]: data associated with array contents
* (if string/name array)
* byte[]: unpacked mem image of gs_param_string_array structure
* pad: to void *
* { gs_param_string structure mem image;
* data associated with string;
* } for each string in array
* (if dict/dict_int_keys)
* word: # of entries in dict,
* pad: to void *
* dict entries follow immediately until end-of-dict
*
* NB that this format is designed to allow using an input buffer
* as the direct source of data when expanding a gs_c_param_list
*/
/* Enumerate all the keys; use keys to get their typed values */
while ((code = param_get_next_key(list, &key_enum, &key)) == 0) {
int value_top_sizeof;
int value_base_sizeof;
/* Get next datum & put its type & key to buffer */
gs_param_typed_value value;
char string_key[256];
if (sizeof(string_key) < key.size + 1) {
code = gs_note_error(gs_error_rangecheck);
break;
}
memcpy(string_key, key.data, key.size);
string_key[key.size] = 0;
if ((code = param_read_typed(list, string_key, &value)) != 0) {
code = code > 0 ? gs_note_error(gs_error_unknownerror) : code;
break;
}
wb_put_word((unsigned)key.size + 1, &write_buf);
wb_put_word((unsigned)value.type, &write_buf);
wb_put_bytes((byte *) string_key, key.size + 1, &write_buf);
/* Put value & its size to buffer */
value_top_sizeof = gs_param_type_sizes[value.type];
value_base_sizeof = gs_param_type_base_sizes[value.type];
switch (value.type) {
case gs_param_type_null:
case gs_param_type_bool:
case gs_param_type_int:
case gs_param_type_long:
case gs_param_type_float:
wb_put_bytes((byte *) & value.value, value_top_sizeof, &write_buf);
break;
case gs_param_type_string:
case gs_param_type_name:
case gs_param_type_int_array:
case gs_param_type_float_array:
wb_put_bytes((byte *) & value.value, value_top_sizeof, &write_buf);
wb_put_alignment(value_base_sizeof, &write_buf);
value_base_sizeof *= value.value.s.size;
wb_put_bytes(value.value.s.data, value_base_sizeof, &write_buf);
break;
case gs_param_type_string_array:
case gs_param_type_name_array:
value_base_sizeof *= value.value.sa.size;
wb_put_bytes((const byte *)&value.value, value_top_sizeof, &write_buf);
wb_put_alignment(sizeof(void *), &write_buf);
wb_put_bytes((const byte *)value.value.sa.data, value_base_sizeof,
&write_buf);
{
int str_count;
const gs_param_string *sa;
for (str_count = value.value.sa.size,
sa = value.value.sa.data; str_count-- > 0; ++sa)
wb_put_bytes(sa->data, sa->size, &write_buf);
}
break;
case gs_param_type_dict:
case gs_param_type_dict_int_keys:
wb_put_word(value.value.d.size, &write_buf);
wb_put_alignment(sizeof(void *), &write_buf);
{
int bytes_written =
gs_param_list_serialize(value.value.d.list,
write_buf.buf,
write_buf.buf ? write_buf.buf_end - write_buf.buf : 0);
temp_code = param_end_read_dict(list,
(const char *)key.data,
&value.value.d);
if (bytes_written < 0)
code = bytes_written;
else {
code = temp_code;
if (bytes_written)
wb_put_bytes(write_buf.buf, bytes_written, &write_buf);
}
}
break;
default:
code = gs_note_error(gs_error_unknownerror);
break;
}
if (code < 0)
break;
}
/* Write end marker, which is an (illegal) 0 key length */
if (code >= 0) {
wb_put_word(0, &write_buf);
code = write_buf.total_sizeof;
}
return code;
}
/* 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;
}
