int
pdf__shading_pattern(PDF *p, int shading, const char *optlist)
{
pdc_resopt *results;
pdc_clientdata data;
int gstate = -1;
int retval = -1;
if (p->compatibility == PDC_1_3)
pdc_error(p->pdc, PDF_E_SHADING13, 0, 0, 0, 0);
pdf_check_handle(p, shading, pdc_shadinghandle);
if (optlist && strlen(optlist)) {
pdf_set_clientdata(p, &data);
results = pdc_parse_optionlist(p->pdc,
optlist, pdf_shading_pattern_options, &data, pdc_true);
(void) pdc_get_optvalues("gstate", results, &gstate, NULL);
pdc_cleanup_optionlist(p->pdc, results);
}
if (p->pattern_number == p->pattern_capacity)
pdf_grow_pattern(p);
if (PDF_GET_STATE(p) == pdf_state_page)
pdf_end_contents_section(p);
/* Pattern object */
p->pattern[p->pattern_number].obj_id = pdc_begin_obj(p->out, PDC_NEW_ID);
/* Shadings don't have a painttype, but this signals to the
* code which writes the pattern usage that no color values
* will be required when setting the pattern color space.
*/
p->pattern[p->pattern_number].painttype = 1;
pdc_begin_dict(p->out); /* Pattern dict*/
pdc_puts(p->out, "/PatternType 2\n"); /* shading pattern */
pdc_objref(p->out, "/Shading", p->shadings[shading].obj_id);
p->shadings[shading].used_on_current_page = pdc_true;
if (gstate != -1)
pdc_objref(p->out, "/ExtGState", pdf_get_gstate_id(p, gstate));
pdc_end_dict(p->out); /* Pattern dict*/
pdc_end_obj(p->out); /* Pattern object */
if (PDF_GET_STATE(p) == pdf_state_page)
pdf_begin_contents_section(p);
retval = p->pattern_number;
p->pattern_number++;
return retval;
}
static void
pdf_check_color_values(
PDF *p,
pdf_colorspacetype type,
pdc_scalar c1, pdc_scalar c2, pdc_scalar c3, pdc_scalar c4)
{
switch (type) {
case DeviceGray:
pdc_check_number_limits(p->pdc, "c1", c1, 0.0, EPSILON);
break;
case DeviceRGB:
pdc_check_number_limits(p->pdc, "c1", c1, 0.0, EPSILON);
pdc_check_number_limits(p->pdc, "c2", c2, 0.0, EPSILON);
pdc_check_number_limits(p->pdc, "c3", c3, 0.0, EPSILON);
break;
case DeviceCMYK:
pdc_check_number_limits(p->pdc, "c1", c1, 0.0, EPSILON);
pdc_check_number_limits(p->pdc, "c2", c2, 0.0, EPSILON);
pdc_check_number_limits(p->pdc, "c3", c3, 0.0, EPSILON);
pdc_check_number_limits(p->pdc, "c4", c4, 0.0, EPSILON);
break;
case PatternCS:
pdf_check_handle(p, (int) c1, pdc_patternhandle);
if (c1 == p->pattern_number - 1 && PDF_GET_STATE(p) & pdf_state_pattern)
{
pdc_error(p->pdc, PDF_E_PATTERN_SELF, 0, 0, 0, 0);
}
break;
case Separation:
pdf_check_handle(p, (int) c1, pdc_colorhandle);
pdc_check_number_limits(p->pdc, "c2", c2, 0.0, EPSILON);
break;
case Indexed:
default:
break;
}
} /* pdf_check_color_values */
int
pdf__add_bookmark(PDF *p, const char *text, int len, int parent, int open)
{
static const char *fn = "pdf__add_bookmark";
pdf_outline self;
pdf_dest *dest = (pdf_dest *) p->bookmark_dest;
char *hypertext = NULL;
int acthdl;
int retval = 0;
len = pdc_check_text_length(p->pdc, &text, len, PDF_MAXSTRINGSIZE);
if (!len)
pdc_error(p->pdc, PDC_E_ILLARG_EMPTY, "text", 0, 0, 0);
pdf_init_outline(p, &self);
if (parent != 0)
pdf_check_handle(p, parent, pdc_bookmarkhandle);
self.parent = parent;
self.open = open;
/* creating a Launch action - defined via bookmarkdest */
if (dest->filename)
{
char *actoptlist;
actoptlist = (char *)
pdc_malloc(p->pdc, strlen(dest->filename) + 80, fn);
pdc_sprintf(p->pdc, pdc_false, actoptlist, "filename {%s} ",
dest->filename);
acthdl = pdf__create_action(p, "Launch", actoptlist);
if (acthdl != -1)
{
if (p->pdc->hastobepos) acthdl++;
pdc_sprintf(p->pdc, pdc_false, actoptlist, "activate %d", acthdl);
self.action = pdc_strdup(p->pdc, actoptlist);
}
pdc_free(p->pdc, actoptlist);
}
else
{
self.dest = pdf_init_destination(p);
*self.dest = *dest;
if (dest->name)
self.dest->name = pdc_strdup(p->pdc, dest->name);
}
memcpy(self.textcolor, dest->color, 3 * sizeof(pdc_scalar));
self.fontstyle = dest->fontstyle;
hypertext = pdf_convert_hypertext_depr(p, text, len);
if (hypertext)
retval = pdf_insert_bookmark(p, hypertext, &self, -1);
return retval;
}
void
pdf__set_gstate(PDF *p, int gstate)
{
int bias = p->curr_ppt->eg_bias;
pdf_check_handle(p, gstate, pdc_gstatehandle);
pdc_printf(p->out, "/GS%d gs\n", bias + gstate);
p->extgstates[gstate].used_on_current_page = pdc_true;
}
void
pdf__shfill(PDF *p, int shading)
{
if (p->compatibility == PDC_1_3)
pdc_error(p->pdc, PDF_E_SHADING13, 0, 0, 0, 0);
pdf_check_handle(p, shading, pdc_shadinghandle);
pdf_end_text(p);
pdc_printf(p->out, "/Sh%d sh\n", shading);
p->shadings[shading].used_on_current_page = pdc_true;
}
PDFLIB_API void PDFLIB_CALL
PDF_set_gstate(PDF *p, int gstate)
{
static const char fn[] = "PDF_set_gstate";
if (!pdf_enter_api(p, fn, pdf_state_content, "(p[%p], %d)\n",
(void *) p, gstate))
return;
PDF_INPUT_HANDLE(p, gstate)
pdf_check_handle(p, gstate, pdc_gstatehandle);
pdc_printf(p->out, "/GS%d gs\n", gstate);
p->extgstates[gstate].used_on_current_page = pdc_true;
}
double
pdf__get_value(PDF *p, const char *key, double mod)
{
int i = -1;
int imod = (int) mod;
double result = 0;
const pdc_rectangle *box = NULL;
pdf_ppt *ppt;
i = pdf_get_index(p, key, pdc_false);
if (parms[i].mod_zero && mod != 0)
pdc_error(p->pdc, PDC_E_PAR_ILLVALUE,
pdc_errprintf(p->pdc, "%f", mod), key, 0, 0);
ppt = p->curr_ppt;
switch (i)
{
case PDF_PARAMETER_IMAGEWIDTH:
case PDF_PARAMETER_IMAGEHEIGHT:
case PDF_PARAMETER_RESX:
case PDF_PARAMETER_RESY:
case PDF_PARAMETER_ORIENTATION:
if (p->pdc->hastobepos) imod -= 1;
pdf_check_handle(p, imod, pdc_imagehandle);
break;
case PDF_PARAMETER_FONTMAXCODE:
case PDF_PARAMETER_CAPHEIGHT:
case PDF_PARAMETER_ASCENDER:
case PDF_PARAMETER_DESCENDER:
case PDF_PARAMETER_XHEIGHT:
if (p->pdc->hastobepos) imod -= 1;
pdf_check_handle(p, imod, pdc_fonthandle);
break;
}
switch (i)
{
#if defined(WIN32) && !defined(__BORLANDC__) && !defined(__CYGWIN__) /* CDPDF */
case PDF_PARAMETER_MAXFILEHANDLES:
result = (double) pdc_get_maxfilehandles();
break;
#endif
case PDF_PARAMETER_COMPRESS:
result = (double) pdc_get_compresslevel(p->out);
break;
case PDF_PARAMETER_FLOATDIGITS:
result = (double) p->pdc->floatdigits;
break;
/* TODO (york): take /CropBox into account?
*/
case PDF_PARAMETER_PAGEWIDTH:
box = pdf_get_pagebox(p, pdf_mediabox);
result = box->urx - box->llx;
break;
/* TODO (york): take /CropBox into account?
*/
case PDF_PARAMETER_PAGEHEIGHT:
box = pdf_get_pagebox(p, pdf_mediabox);
result = box->ury - box->lly;
break;
case PDF_PARAMETER_CROPBOX_LLX:
box = pdf_get_pagebox(p, pdf_cropbox);
result = box->llx;
break;
case PDF_PARAMETER_CROPBOX_LLY:
box = pdf_get_pagebox(p, pdf_cropbox);
result = box->lly;
break;
case PDF_PARAMETER_CROPBOX_URX:
box = pdf_get_pagebox(p, pdf_cropbox);
result = box->urx;
break;
case PDF_PARAMETER_CROPBOX_URY:
box = pdf_get_pagebox(p, pdf_cropbox);
result = box->ury;
break;
case PDF_PARAMETER_BLEEDBOX_LLX:
box = pdf_get_pagebox(p, pdf_bleedbox);
result = box->llx;
break;
case PDF_PARAMETER_BLEEDBOX_LLY:
box = pdf_get_pagebox(p, pdf_bleedbox);
result = box->lly;
break;
case PDF_PARAMETER_BLEEDBOX_URX:
box = pdf_get_pagebox(p, pdf_bleedbox);
result = box->urx;
break;
case PDF_PARAMETER_BLEEDBOX_URY:
box = pdf_get_pagebox(p, pdf_bleedbox);
result = box->ury;
break;
case PDF_PARAMETER_TRIMBOX_LLX:
box = pdf_get_pagebox(p, pdf_trimbox);
result = box->llx;
break;
case PDF_PARAMETER_TRIMBOX_LLY:
box = pdf_get_pagebox(p, pdf_trimbox);
result = box->lly;
break;
case PDF_PARAMETER_TRIMBOX_URX:
box = pdf_get_pagebox(p, pdf_trimbox);
result = box->urx;
break;
case PDF_PARAMETER_TRIMBOX_URY:
box = pdf_get_pagebox(p, pdf_trimbox);
result = box->ury;
break;
case PDF_PARAMETER_ARTBOX_LLX:
box = pdf_get_pagebox(p, pdf_artbox);
result = box->llx;
break;
case PDF_PARAMETER_ARTBOX_LLY:
box = pdf_get_pagebox(p, pdf_artbox);
result = box->lly;
break;
case PDF_PARAMETER_ARTBOX_URX:
box = pdf_get_pagebox(p, pdf_artbox);
result = box->urx;
break;
case PDF_PARAMETER_ARTBOX_URY:
box = pdf_get_pagebox(p, pdf_artbox);
result = box->ury;
break;
case PDF_PARAMETER_IMAGEWIDTH:
pdf_get_image_size(p, imod, (double *) &result, NULL);
break;
case PDF_PARAMETER_IMAGEHEIGHT:
pdf_get_image_size(p, imod, NULL, (double *) &result);
break;
case PDF_PARAMETER_RESX:
pdf_get_image_resolution(p, imod, (double *) &result, NULL);
break;
case PDF_PARAMETER_RESY:
pdf_get_image_resolution(p, imod, NULL, (double *) &result);
break;
case PDF_PARAMETER_ORIENTATION:
result = (double) (p->images[imod].orientation);
break;
case PDF_PARAMETER_CURRENTX:
result = (double) (ppt->gstate[ppt->sl].x);
break;
case PDF_PARAMETER_CURRENTY:
result = (double) (ppt->gstate[ppt->sl].y);
break;
case PDF_PARAMETER_CTM_A:
result = (double) (ppt->gstate[ppt->sl].ctm.a);
break;
case PDF_PARAMETER_CTM_B:
result = (double) (ppt->gstate[ppt->sl].ctm.b);
break;
case PDF_PARAMETER_CTM_C:
result = (double) (ppt->gstate[ppt->sl].ctm.c);
break;
case PDF_PARAMETER_CTM_D:
result = (double) (ppt->gstate[ppt->sl].ctm.d);
break;
case PDF_PARAMETER_CTM_E:
result = (double) (ppt->gstate[ppt->sl].ctm.e);
break;
case PDF_PARAMETER_CTM_F:
result = (double) (ppt->gstate[ppt->sl].ctm.f);
break;
case PDF_PARAMETER_TEXTX:
result = pdf_get_tstate(p, to_textx);
break;
case PDF_PARAMETER_TEXTY:
result = pdf_get_tstate(p, to_texty);
break;
case PDF_PARAMETER_UNDERLINEWIDTH:
result = pdf_get_tstate(p, to_underlinewidth);
break;
case PDF_PARAMETER_UNDERLINEPOSITION:
result = pdf_get_tstate(p, to_underlineposition);
break;
case PDF_PARAMETER_WORDSPACING:
result = pdf_get_tstate(p, to_wordspacing);
break;
case PDF_PARAMETER_CHARSPACING:
result = pdf_get_tstate(p, to_charspacing);
break;
case PDF_PARAMETER_HORIZSCALING:
result = 100 * pdf_get_tstate(p, to_horizscaling);
break;
case PDF_PARAMETER_ITALICANGLE:
result = pdf_get_tstate(p, to_italicangle);
break;
case PDF_PARAMETER_TEXTRISE:
result = pdf_get_tstate(p, to_textrise);
break;
case PDF_PARAMETER_LEADING:
result = pdf_get_tstate(p, to_leading);
break;
case PDF_PARAMETER_TEXTRENDERING:
result = pdf_get_tstate(p, to_textrendering);
break;
case PDF_PARAMETER_FONTSIZE:
result = pdf_get_tstate(p, to_fontsize);
break;
case PDF_PARAMETER_FONT:
result = pdf_get_tstate(p, to_font);
if (p->pdc->hastobepos) result += 1;
break;
case PDF_PARAMETER_MONOSPACE:
result = pdf_get_font_float_option(p, fo_monospace);
break;
case PDF_PARAMETER_FONTMAXCODE:
result = (double) (p->fonts[imod].ft.numcodes - 1);
break;
case PDF_PARAMETER_ASCENDER:
result = pdf_font_get_metric_value(p->fonts[imod].ft.m.ascender);
break;
case PDF_PARAMETER_DESCENDER:
result = pdf_font_get_metric_value(p->fonts[imod].ft.m.descender);
break;
case PDF_PARAMETER_CAPHEIGHT:
result = pdf_font_get_metric_value(p->fonts[imod].ft.m.capHeight);
break;
case PDF_PARAMETER_XHEIGHT:
result = pdf_font_get_metric_value(p->fonts[imod].ft.m.xHeight);
break;
default:
pdc_error(p->pdc, PDC_E_PAR_UNSUPPKEY, key, 0, 0, 0);
break;
} /* switch */
return result;
} /* pdf__get_value */
const char *
pdf__get_parameter(PDF *p, const char *key, double mod)
{
int i = -1;
int imod = (int) mod;
const char *result = "";
pdf_ppt *ppt;
i = pdf_get_index(p, key, pdc_false);
if (parms[i].mod_zero && mod != 0)
pdc_error(p->pdc, PDC_E_PAR_ILLPARAM,
pdc_errprintf(p->pdc, "%f", mod), key, 0, 0);
ppt = p->curr_ppt;
switch (i)
{
case PDF_PARAMETER_CAPHEIGHTFAKED:
case PDF_PARAMETER_ASCENDERFAKED:
case PDF_PARAMETER_DESCENDERFAKED:
case PDF_PARAMETER_XHEIGHTFAKED:
if (p->pdc->hastobepos) imod -= 1;
pdf_check_handle(p, imod, pdc_fonthandle);
break;
}
switch (i)
{
case PDF_PARAMETER_BINDING:
result = p->pdc->binding;
break;
case PDF_PARAMETER_OBJORIENT:
result = PDC_BOOLSTR(p->pdc->objorient);
break;
case PDF_PARAMETER_HASTOBEPOS:
result = PDC_BOOLSTR(p->pdc->hastobepos);
break;
case PDF_PARAMETER_PTFRUN:
result = PDC_BOOLSTR(p->pdc->ptfrun);
break;
case PDF_PARAMETER_SMOKERUN:
result = PDC_BOOLSTR(p->pdc->smokerun);
break;
case PDF_PARAMETER_UNICAPLANG:
result = PDC_BOOLSTR(p->pdc->unicaplang);
break;
case PDF_PARAMETER_CONFIGURATION:
result = "lite";
break;
case PDF_PARAMETER_PRODUCT:
result = "PDFlib Lite";
break;
case PDF_PARAMETER_ERRORPOLICY:
result = pdc_get_keyword(p->errorpolicy, pdf_errpol_keylist);
break;
case PDF_PARAMETER_PDIUSEBOX:
result = pdc_get_keyword(p->pdi_usebox, pdf_usebox_keylist);
break;
case PDF_PARAMETER_SEARCHPATH:
case PDF_PARAMETER_FONTAFM:
case PDF_PARAMETER_FONTPFM:
case PDF_PARAMETER_FONTOUTLINE:
case PDF_PARAMETER_HOSTFONT:
case PDF_PARAMETER_ENCODING:
case PDF_PARAMETER_ICCPROFILE:
case PDF_PARAMETER_STANDARDOUTPUTINTENT:
result = pdc_find_resource_nr(p->pdc, key, imod);
break;
case PDF_PARAMETER_FONTNAME:
result = pdf_get_font_char_option(p, fo_fontname);
break;
case PDF_PARAMETER_FONTENCODING:
result = pdf_get_font_char_option(p, fo_encoding);
break;
case PDF_PARAMETER_FONTSTYLE:
result = pdf_get_font_char_option(p, fo_fontstyle);
break;
case PDF_PARAMETER_ASCENDERFAKED:
result = PDC_BOOLSTR(pdf_font_get_is_faked(&p->fonts[imod],
font_ascender));
break;
case PDF_PARAMETER_DESCENDERFAKED:
result = PDC_BOOLSTR(pdf_font_get_is_faked(&p->fonts[imod],
font_descender));
break;
case PDF_PARAMETER_CAPHEIGHTFAKED:
result = PDC_BOOLSTR(pdf_font_get_is_faked(&p->fonts[imod],
font_capheight));
break;
case PDF_PARAMETER_XHEIGHTFAKED:
result = PDC_BOOLSTR(pdf_font_get_is_faked(&p->fonts[imod],
font_xheight));
break;
case PDF_PARAMETER_UNDERLINE:
result = PDC_BOOLSTR((int) pdf_get_tstate(p, to_underline));
break;
case PDF_PARAMETER_OVERLINE:
result = PDC_BOOLSTR((int) pdf_get_tstate(p, to_overline));
break;
case PDF_PARAMETER_STRIKEOUT:
result = PDC_BOOLSTR((int) pdf_get_tstate(p, to_strikeout));
break;
/* deprecated */
case PDF_PARAMETER_INHERITGSTATE:
result = PDC_BOOLSTR(pdc_false);
break;
case PDF_PARAMETER_SCOPE:
result = pdf_current_scope(p);
break;
case PDF_PARAMETER_TEXTFORMAT:
result = pdc_get_keyword(p->textformat, pdf_textformat_keylist);
break;
case PDF_PARAMETER_HYPERTEXTFORMAT:
result = pdc_get_keyword(p->hypertextformat,pdf_textformat_keylist);
break;
case PDF_PARAMETER_HYPERTEXTENCODING:
result = pdf_get_encoding_name(p, p->hypertextencoding, NULL);
break;
case PDF_PARAMETER_RESOURCEFILE:
result = pdc_get_resourcefile(p->pdc);
break;
/* deprecated */
case PDF_PARAMETER_WARNING:
result = PDC_BOOLSTR(0);
break;
case PDF_PARAMETER_OPENWARNING:
result = PDC_BOOLSTR((int) p->debug[(int) 'o']);
break;
case PDF_PARAMETER_FONTWARNING:
result = PDC_BOOLSTR((int) p->debug[(int) 'F']);
break;
case PDF_PARAMETER_ICCWARNING:
result = PDC_BOOLSTR((int) p->debug[(int) 'I']);
break;
case PDF_PARAMETER_IMAGEWARNING:
result = PDC_BOOLSTR((int) p->debug[(int) 'i']);
break;
case PDF_PARAMETER_PDIWARNING:
result = PDC_BOOLSTR((int) p->debug[(int) 'p']);
break;
case PDF_PARAMETER_HONORICCPROFILE:
result = PDC_BOOLSTR((int) p->debug[(int) 'e']);
break;
case PDF_PARAMETER_GLYPHWARNING:
result = PDC_BOOLSTR((int) p->debug[(int) 'g']);
break;
case PDF_PARAMETER_RENDERINGINTENT:
result = pdc_get_keyword(p->rendintent,
pdf_renderingintent_pdfkeylist);
break;
case PDF_PARAMETER_PRESERVEOLDPANTONENAMES:
result = PDC_BOOLSTR(p->preserveoldpantonenames);
break;
case PDF_PARAMETER_SPOTCOLORLOOKUP:
result = PDC_BOOLSTR(p->spotcolorlookup);
break;
case PDF_PARAMETER_PDISTRICT:
result = PDC_BOOLSTR(p->pdi_strict);
break;
case PDF_PARAMETER_TOPDOWN:
result = PDC_BOOLSTR((p->ydirection == -1.0));
break;
case PDF_PARAMETER_USERCOORDINATES:
result = PDC_BOOLSTR(p->usercoordinates);
break;
case PDF_PARAMETER_USEHYPERTEXTENCODING:
result = PDC_BOOLSTR(p->usehyptxtenc);
break;
case PDF_PARAMETER_FILLRULE:
result = pdc_get_keyword(ppt->fillrule, pdf_fillrule_keylist);
break;
case PDF_PARAMETER_COMPATIBILITY:
result = pdc_get_keyword(p->compatibility,
pdf_compatibility_keylist);
break;
case PDF_PARAMETER_STRING:
pdf_check_handle(p, imod, pdc_stringhandle);
result = pdf_get_utilstring(p, imod);
break;
default:
pdc_error(p->pdc, PDC_E_PAR_UNSUPPKEY, key, 0, 0, 0);
break;
} /* switch */
return result ? result : "";
} /* pdf__get_parameter */
PDFLIB_API float PDFLIB_CALL
PDF_get_value(PDF *p, const char *key, float mod)
{
static const char fn[] = "PDF_get_value";
int i = -1;
int imod = (int) mod;
float result = (float) 0;
/* some parameters can be retrieved with p == 0.
*/
if (key != NULL && (i = get_index(key)) != -1)
{
switch (i)
{
case PDF_PARAMETER_MAJOR:
result = PDFLIB_MAJORVERSION;
return result;
case PDF_PARAMETER_MINOR:
result = PDFLIB_MINORVERSION;
return result;
case PDF_PARAMETER_REVISION:
result = PDFLIB_REVISION;
return result;
} /* switch */
}
if (!pdf_enter_api(p, fn, (pdf_state) pdf_state_all,
"(p[%p], \"%s\", %g)", (void *) p, key, mod))
return (float) 0;
if (i == -1)
pdc_error(p->pdc, PDC_E_PAR_UNKNOWNKEY, key, 0, 0, 0);
if ((p->state_stack[p->state_sp] & parms[i].get_scope) == 0)
pdc_error(p->pdc, PDF_E_DOC_SCOPE_GET, key, pdf_current_scope(p), 0, 0);
if (key == NULL || !*key)
pdc_error(p->pdc, PDC_E_ILLARG_EMPTY, "key", 0, 0, 0);
if (parms[i].mod_zero && mod != (float) 0)
pdc_error(p->pdc, PDC_E_PAR_ILLVALUE,
pdc_errprintf(p->pdc, "%f", mod), key, 0, 0);
switch (i)
{
case PDF_PARAMETER_IMAGEWIDTH:
case PDF_PARAMETER_IMAGEHEIGHT:
case PDF_PARAMETER_RESX:
case PDF_PARAMETER_RESY:
PDF_INPUT_HANDLE(p, imod)
pdf_check_handle(p, imod, pdc_imagehandle);
break;
case PDF_PARAMETER_FONTMAXCODE:
case PDF_PARAMETER_CAPHEIGHT:
case PDF_PARAMETER_ASCENDER:
case PDF_PARAMETER_DESCENDER:
PDF_INPUT_HANDLE(p, imod)
pdf_check_handle(p, imod, pdc_fonthandle);
break;
}
switch (i)
{
case PDF_PARAMETER_PAGEWIDTH:
result = p->width;
break;
case PDF_PARAMETER_PAGEHEIGHT:
result = p->height;
break;
case PDF_PARAMETER_IMAGEWIDTH:
result = (float) (p->images[imod].width);
break;
case PDF_PARAMETER_IMAGEHEIGHT:
result = (float) fabs((double) (p->images[imod].height));
break;
case PDF_PARAMETER_RESX:
result = (float) (p->images[imod].dpi_x);
break;
case PDF_PARAMETER_RESY:
result = (float) (p->images[imod].dpi_y);
break;
case PDF_PARAMETER_IMAGE_ICCPROFILE:
break;
case PDF_PARAMETER_ICCCOMPONENTS:
break;
case PDF_PARAMETER_CURRENTX:
result = (float) (p->gstate[p->sl].x);
break;
case PDF_PARAMETER_CURRENTY:
result = (float) (p->gstate[p->sl].y);
break;
case PDF_PARAMETER_TEXTX:
result = (float) (p->tstate[p->sl].m.e);
break;
case PDF_PARAMETER_TEXTY:
result = (float) (p->tstate[p->sl].m.f);
break;
case PDF_PARAMETER_WORDSPACING:
result = (float) (p->tstate[p->sl].w);
break;
case PDF_PARAMETER_CHARSPACING:
result = (float) (p->tstate[p->sl].c);
break;
case PDF_PARAMETER_HORIZSCALING:
result = pdf_get_horiz_scaling(p);
break;
case PDF_PARAMETER_TEXTRISE:
result = (float) (p->tstate[p->sl].rise);
break;
case PDF_PARAMETER_LEADING:
result = (float) (p->tstate[p->sl].l);
break;
case PDF_PARAMETER_TEXTRENDERING:
result = (float) (p->tstate[p->sl].mode);
break;
case PDF_PARAMETER_FONT:
result = (float) (pdf_get_font(p));
if (p->hastobepos) result += 1; \
break;
case PDF_PARAMETER_MONOSPACE:
result = (float) pdf_get_monospace(p);
break;
case PDF_PARAMETER_FONTSIZE:
result = (float) (pdf_get_fontsize(p));
break;
case PDF_PARAMETER_FONTMAXCODE:
result = (float) (p->fonts[imod].numOfCodes - 1);
break;
case PDF_PARAMETER_CAPHEIGHT:
result = (float) (p->fonts[imod].capHeight / (float) 1000);
break;
case PDF_PARAMETER_ASCENDER:
result = (float) (p->fonts[imod].ascender / (float) 1000);
break;
case PDF_PARAMETER_DESCENDER:
result = (float) (p->fonts[imod].descender / (float) 1000);
break;
case PDF_PARAMETER_SUBSETLIMIT:
break;
default:
pdc_error(p->pdc, PDC_E_PAR_UNKNOWNKEY, key, 0, 0, 0);
break;
} /* switch */
pdc_trace(p->pdc, "[%g]\n", result);
return result;
} /* PDF_get_value */
