static void WarnBadInstruction(gs_font_type42 *pfont, int glyph_index)
{
char buf[gs_font_name_max + 1];
int l;
gs_font_type42 *base_font = pfont;
while ((gs_font_type42 *)base_font->base != base_font)
base_font = (gs_font_type42 *)base_font->base;
if (!base_font->data.warning_bad_instruction) {
l = min(sizeof(buf) - 1, base_font->font_name.size);
memcpy(buf, base_font->font_name.chars, l);
buf[l] = 0;
if (glyph_index >= 0)
emprintf2(pfont->memory,
"Failed to interpret TT instructions for glyph index %d of font %s. "
"Continue ignoring instructions of the font.\n",
glyph_index, buf);
else
emprintf1(pfont->memory,
"Failed to interpret TT instructions in font %s. "
"Continue ignoring instructions of the font.\n",
buf);
base_font->data.warning_bad_instruction = true;
}
}
static void WarnPatented(gs_font_type42 *pfont, ttfFont *ttf, const char *txt)
{
if (!ttf->design_grid) {
char buf[gs_font_name_max + 1];
int l;
gs_font_type42 *base_font = pfont;
while ((gs_font_type42 *)base_font->base != base_font)
base_font = (gs_font_type42 *)base_font->base;
if (!base_font->data.warning_patented) {
l = min(sizeof(buf) - 1, base_font->font_name.size);
memcpy(buf, base_font->font_name.chars, l);
buf[l] = 0;
emprintf2(pfont->memory,
"%s %s requires a patented True Type interpreter.\n",
txt,
buf);
base_font->data.warning_patented = true;
}
}
}
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;
}
/*
* Caller should make sure that this device supports saved_pages:
* dev_proc(dev, dev_spec_op)(dev, gxdso_supports_saved_pages, NULL, 0) == 1
*
* Returns < 0 if error, 1 if erasepage needed, 0 if no action needed.
*/
int
gx_saved_pages_param_process(gx_device_printer *pdev, byte *param, int param_size)
{
byte *param_scan = param;
int param_left = param_size;
byte *token;
int token_size, code, printed_count, collated_copies = 1;
int tmp_num; /* during token scanning loop */
int erasepage_needed = 0;
while (pdev->child)
pdev = (gx_device_printer *)pdev->child;
while ((token = param_parse_token(param_scan, param_left, &token_size)) != NULL) {
switch (param_find_key(token, token_size)) {
case PARAM_BEGIN:
if (pdev->saved_pages_list == NULL) {
if ((pdev->saved_pages_list = gx_saved_pages_list_new(pdev)) == NULL)
return_error(gs_error_VMerror);
/* We need to change to clist mode. Always uses clist when saving pages */
pdev->saved_pages_list->save_banding_type = pdev->space_params.banding_type;
pdev->space_params.banding_type = BandingAlways;
if ((code = gdev_prn_reallocate_memory((gx_device *)pdev, &pdev->space_params, pdev->width, pdev->height)) < 0)
return code;
erasepage_needed |= 1;
}
break;
case PARAM_END:
if (pdev->saved_pages_list != NULL) {
/* restore to what was set before the "begin" */
pdev->space_params.banding_type = pdev->saved_pages_list->save_banding_type;
gx_saved_pages_list_free(pdev->saved_pages_list);
pdev->saved_pages_list = NULL;
/* We may need to change from clist mode since we forced clist when saving pages */
code = gdev_prn_reallocate_memory((gx_device *)pdev, &pdev->space_params, pdev->width, pdev->height);
if (code < 0)
return code;
erasepage_needed |= 1; /* make sure next page is erased */
}
break;
case PARAM_FLUSH:
if (pdev->saved_pages_list != NULL) {
/* Save the collated copy count so the list we return will have it */
collated_copies = pdev->saved_pages_list->collated_copies;
gx_saved_pages_list_free(pdev->saved_pages_list);
}
/* Always return with an empty list, even if we weren't saving previously */
if ((pdev->saved_pages_list = gx_saved_pages_list_new(pdev)) == NULL)
return_error(gs_error_VMerror);
/* restore the original count */
pdev->saved_pages_list->collated_copies = collated_copies;
break;
case PARAM_COPIES: /* copies requires a number next */
/* make sure that we have a list */
if (pdev->saved_pages_list == NULL) {
return_error(gs_error_rangecheck); /* copies not allowed before a 'begin' */
}
/* Move to past 'copies' token */
param_left -= token - param_scan + token_size;
param_scan = token + token_size;
if ((token = param_parse_token(param_scan, param_left, &token_size)) == NULL ||
param_find_key(token, token_size) != PARAM_NUMBER) {
emprintf(pdev->memory, "gx_saved_pages_param_process: copies not followed by number.\n");
return_error(gs_error_typecheck);
}
if (sscanf((const char *)token, "%d", &tmp_num) != 1) {
emprintf1(pdev->memory, "gx_saved_pages_list_print: Number format error '%s'\n", token);
code = gs_error_typecheck;
return code;
}
pdev->saved_pages_list->collated_copies = tmp_num; /* save it for our loop */
break;
case PARAM_PRINT:
/* Move to past 'print' token */
param_left -= token - param_scan + token_size;
param_scan = token + token_size;
code = param_left; /* in case list is NULL, skip rest of string */
if (pdev->saved_pages_list != NULL) {
if ((code = gx_saved_pages_list_print(pdev, pdev->saved_pages_list,
param_scan, param_left, &printed_count)) < 0)
return code;
erasepage_needed |= 1; /* make sure next page is erased */
}
/* adjust for all of the print parameters */
token_size += code;
break;
/* We are expecting an action keyword, so other keywords and tokens */
/* are not valid here (mostly the 'print' parameters). */
default:
{
byte *bad_token = gs_alloc_string(pdev->memory, token_size+1, "saved_pages_param_process");
byte *param_string = gs_alloc_string(pdev->memory, param_size+1, "saved_pages_param_process");
if (bad_token != NULL && param_string != NULL) {
memcpy(bad_token, token, token_size);
bad_token[token_size] = 0; /* terminate string */
memcpy(param_string, param, param_size);
param_string[param_size] = 0; /* terminate string */
emprintf2(pdev->memory, "*** Invalid saved-pages token '%s'\n *** in param string '%s'\n",
bad_token, param_string);
gs_free_string(pdev->memory, bad_token, token_size+1, "saved_pages_param_process");
gs_free_string(pdev->memory, param_string, param_size+1, "saved_pages_param_process");
}
}
}
/* Move to next token */
param_left -= token - param_scan + token_size;
param_scan = token + token_size;
}
return erasepage_needed;
}
