/*
* Parse a single XML file.
*/
int
stp_xml_parse_file(const char *file) /* File to parse */
{
stp_mxml_node_t *doc;
stp_mxml_node_t *cur;
FILE *fp;
stp_deprintf(STP_DBG_XML, "stp_xml_parse_file: reading `%s'...\n", file);
fp = fopen(file, "r");
if (!fp)
{
stp_erprintf("stp_xml_parse_file: unable to open %s: %s\n", file,
strerror(errno));
return 1;
}
stp_xml_init();
doc = stp_mxmlLoadFile(NULL, fp, STP_MXML_NO_CALLBACK);
fclose(fp);
cur = doc->child;
while (cur &&
(cur->type != STP_MXML_ELEMENT ||
strcmp(cur->value.element.name, "gimp-print") != 0))
cur = cur->next;
if (cur == NULL || cur->type != STP_MXML_ELEMENT)
{
stp_erprintf("stp_xml_parse_file: %s: parse error\n", file);
stp_mxmlDelete(doc);
return 1;
}
if (strcmp(cur->value.element.name, "gimp-print") != 0)
{
stp_erprintf
("XML file of the wrong type, root node is %s != gimp-print",
cur->value.element.name);
stp_mxmlDelete(doc);
return 1;
}
/* The XML file was read and is the right format */
stpi_xml_process_gimpprint(cur, file);
stp_mxmlDelete(doc);
stp_xml_exit();
return 0;
}
stp_curve_t *
stp_curve_create_from_file(const char* file)
{
stp_curve_t *curve = NULL;
stp_mxml_node_t *doc;
FILE *fp = fopen(file, "r");
if (!fp)
{
stp_deprintf(STP_DBG_CURVE_ERRORS,
"stp_curve_create_from_file: unable to open %s: %s\n",
file, strerror(errno));
return NULL;
}
stp_deprintf(STP_DBG_XML, "stp_curve_create_from_file: reading `%s'...\n",
file);
stp_xml_init();
doc = stp_mxmlLoadFile(NULL, fp, STP_MXML_NO_CALLBACK);
curve = xml_doc_get_curve(doc);
if (doc)
stp_mxmlDelete(doc);
stp_xml_exit();
(void) fclose(fp);
return curve;
}
static stp_array_t *
stpi_dither_array_create_from_file(const char* file)
{
stp_mxml_node_t *doc;
stp_array_t *ret = NULL;
FILE *fp = fopen(file, "r");
if (!fp)
{
stp_erprintf("stp_curve_create_from_file: unable to open %s: %s\n",
file, strerror(errno));
return NULL;
}
stp_xml_init();
stp_deprintf(STP_DBG_XML,
"stpi_dither_array_create_from_file: reading `%s'...\n", file);
doc = stp_mxmlLoadFile(NULL, fp, STP_MXML_NO_CALLBACK);
(void) fclose(fp);
if (doc)
{
ret = xml_doc_get_dither_array(doc);
stp_mxmlDelete(doc);
}
stp_xml_exit();
return ret;
}
static inkgroup_t *
load_inkgroup(const char *name)
{
stp_list_t *dirlist = stpi_data_path();
stp_list_item_t *item;
inkgroup_t *igl = NULL;
item = stp_list_get_start(dirlist);
while (item)
{
const char *dn = (const char *) stp_list_item_get_data(item);
char *ffn = stpi_path_merge(dn, name);
stp_mxml_node_t *inkgroup =
stp_mxmlLoadFromFile(NULL, ffn, STP_MXML_NO_CALLBACK);
stp_free(ffn);
if (inkgroup)
{
int count = 0;
stp_mxml_node_t *node = stp_mxmlFindElement(inkgroup, inkgroup,
"escp2InkGroup", NULL,
NULL, STP_MXML_DESCEND);
if (node)
{
stp_mxml_node_t *child = node->child;
igl = stp_zalloc(sizeof(inkgroup_t));
while (child)
{
if (child->type == STP_MXML_ELEMENT &&
!strcmp(child->value.element.name, "InkList"))
count++;
child = child->next;
}
igl->n_inklists = count;
if (stp_mxmlElementGetAttr(node, "name"))
igl->name = stp_strdup(stp_mxmlElementGetAttr(node, "name"));
else
igl->name = stp_strdup(name);
igl->inklists = stp_zalloc(sizeof(inklist_t) * count);
child = node->child;
count = 0;
while (child)
{
if (child->type == STP_MXML_ELEMENT &&
!strcmp(child->value.element.name, "InkList"))
load_inklist(child, node, &(igl->inklists[count++]));
child = child->next;
}
}
stp_mxmlDelete(inkgroup);
break;
}
item = stp_list_item_next(item);
}
stp_list_destroy(dirlist);
return igl;
}
stp_curve_t *
stp_curve_create_from_string(const char* string)
{
stp_curve_t *curve = NULL;
stp_mxml_node_t *doc;
stp_deprintf(STP_DBG_XML,
"stp_curve_create_from_string: reading '%s'...\n", string);
stp_xml_init();
doc = stp_mxmlLoadString(NULL, string, STP_MXML_NO_CALLBACK);
curve = xml_doc_get_curve(doc);
if (doc)
stp_mxmlDelete(doc);
stp_xml_exit();
return curve;
}
stp_curve_t *
stp_curve_create_from_stream(FILE* fp)
{
stp_curve_t *curve = NULL;
stp_mxml_node_t *doc;
stp_deprintf(STP_DBG_XML, "stp_curve_create_from_fp: reading...\n");
stp_xml_init();
doc = stp_mxmlLoadFile(NULL, fp, STP_MXML_NO_CALLBACK);
curve = xml_doc_get_curve(doc);
if (doc)
stp_mxmlDelete(doc);
stp_xml_exit();
return curve;
}
void
stp_escp2_load_model(const stp_vars_t *v, int model)
{
stp_list_t *dirlist = stpi_data_path();
stp_list_item_t *item;
char buf[1024];
int found = 0;
stp_xml_init();
sprintf(buf, "escp2/model/model_%d.xml", model);
item = stp_list_get_start(dirlist);
while (item)
{
const char *dn = (const char *) stp_list_item_get_data(item);
char *fn = stpi_path_merge(dn, buf);
stp_mxml_node_t *doc = stp_mxmlLoadFromFile(NULL, fn, STP_MXML_NO_CALLBACK);
stp_free(fn);
if (doc)
{
stp_mxml_node_t *node =
stp_mxmlFindElement(doc, doc, "escp2:model", NULL, NULL,
STP_MXML_DESCEND);
if (node)
{
const char *stmp = stp_mxmlElementGetAttr(node, "id");
STPI_ASSERT(stmp && stp_xmlstrtol(stmp) == model, v);
load_model_from_file(v, node, model);
found = 1;
}
stp_mxmlDelete(doc);
if (found)
break;
}
item = stp_list_item_next(item);
}
stp_xml_exit();
stp_list_destroy(dirlist);
STPI_ASSERT(found, v);
}
stp_mxml_node_t *
stp_xmltree_create_from_array(const stp_array_t *array) /* The array */
{
int x_size, y_size;
char *xs, *ys;
stp_mxml_node_t *arraynode = NULL;
stp_mxml_node_t *child = NULL;
stp_xml_init();
/* Get array details */
stp_array_get_size(array, &x_size, &y_size);
/* Construct the allocated strings required */
stp_asprintf(&xs, "%d", x_size);
stp_asprintf(&ys, "%d", y_size);
arraynode = stp_mxmlNewElement(NULL, "array");
stp_mxmlElementSetAttr(arraynode, "x-size", xs);
stp_mxmlElementSetAttr(arraynode, "y-size", ys);
stp_free(xs);
stp_free(ys);
child = stp_xmltree_create_from_sequence(stp_array_get_sequence(array));
if (child)
stp_mxmlAdd(arraynode, STP_MXML_ADD_AFTER, NULL, child);
else
{
stp_mxmlDelete(arraynode);
arraynode = NULL;
}
stp_xml_exit();
return arraynode;
}
int
stp_curve_write(FILE *file, const stp_curve_t *curve) /* The curve */
{
stp_mxml_node_t *xmldoc = NULL;
stp_xml_init();
xmldoc = xmldoc_create_from_curve(curve);
if (xmldoc == NULL)
{
stp_xml_exit();
return 1;
}
stp_mxmlSaveFile(xmldoc, file, curve_whitespace_callback);
if (xmldoc)
stp_mxmlDelete(xmldoc);
stp_xml_exit();
return 0;
}
char *
stp_curve_write_string(const stp_curve_t *curve) /* The curve */
{
stp_mxml_node_t *xmldoc = NULL;
char *retval;
stp_xml_init();
xmldoc = xmldoc_create_from_curve(curve);
if (xmldoc == NULL)
{
stp_xml_exit();
return NULL;
}
retval = stp_mxmlSaveAllocString(xmldoc, curve_whitespace_callback);
if (xmldoc)
stp_mxmlDelete(xmldoc);
stp_xml_exit();
return retval;
}
static stp_mxml_node_t *
xmldoc_create_from_curve(const stp_curve_t *curve)
{
stp_mxml_node_t *xmldoc;
stp_mxml_node_t *rootnode;
stp_mxml_node_t *curvenode;
/* Get curve details */
curvenode = stp_xmltree_create_from_curve(curve);
if (curvenode == NULL)
{
stp_deprintf(STP_DBG_CURVE_ERRORS,
"xmldoc_create_from_curve: error creating curve node\n");
return NULL;
}
/* Create the XML tree */
xmldoc = stp_xmldoc_create_generic();
if (xmldoc == NULL)
{
stp_deprintf(STP_DBG_CURVE_ERRORS,
"xmldoc_create_from_curve: error creating XML document\n");
return NULL;
}
rootnode = xmldoc->child;
if (rootnode == NULL)
{
stp_mxmlDelete(xmldoc);
stp_deprintf(STP_DBG_CURVE_ERRORS,
"xmldoc_create_from_curve: error getting XML document root node\n");
return NULL;
}
stp_mxmlAdd(rootnode, STP_MXML_ADD_AFTER, NULL, curvenode);
return xmldoc;
}
int
main(int argc, char **argv)
{
int status = 0;
argv++;
while (*argv)
{
stp_mxml_node_t *top =
stp_mxmlLoadFromFile(NULL, *argv, STP_MXML_NO_CALLBACK);
if (top)
{
stp_mxml_node_t *n = top;
do
{
const char *attr = stp_mxmlElementGetAttr(n, "translate");
if (attr)
{
const char *str = stp_mxmlElementGetAttr(n, attr);
char *s;
stp_asprintf(&s, "N_(\"%s\");", str);
printf("%-40s /* %s */\n", s, *argv);
stp_free(s);
}
n = stp_mxmlWalkNext(n, top, STP_MXML_DESCEND);
} while (n);
stp_mxmlDelete(top);
}
else
{
fprintf(stderr, "Cannot read %s: %s\n", *argv, strerror(errno));
status = 1;
}
argv++;
}
return status;
}
stp_mxml_node_t *
stp_xmltree_create_from_curve(const stp_curve_t *curve) /* The curve */
{
stp_curve_wrap_mode_t wrapmode;
stp_curve_type_t interptype;
double gammaval, low, high;
stp_sequence_t *seq;
char *cgamma;
stp_mxml_node_t *curvenode = NULL;
stp_mxml_node_t *child = NULL;
stp_xml_init();
/* Get curve details */
wrapmode = stp_curve_get_wrap(curve);
interptype = stp_curve_get_interpolation_type(curve);
gammaval = stp_curve_get_gamma(curve);
if (gammaval && wrapmode != STP_CURVE_WRAP_NONE)
{
stp_deprintf(STP_DBG_CURVE_ERRORS, "stp_xmltree_create_from_curve: "
"curve sets gamma and wrap_mode is not STP_CURVE_WRAP_NONE\n");
goto error;
}
/* Construct the allocated strings required */
stp_asprintf(&cgamma, "%g", gammaval);
curvenode = stp_mxmlNewElement(NULL, "curve");
stp_mxmlElementSetAttr(curvenode, "wrap", stpi_wrap_mode_names[wrapmode]);
stp_mxmlElementSetAttr(curvenode, "type", stpi_curve_type_names[interptype]);
stp_mxmlElementSetAttr(curvenode, "gamma", cgamma);
if (curve->piecewise)
stp_mxmlElementSetAttr(curvenode, "piecewise", "true");
else
stp_mxmlElementSetAttr(curvenode, "piecewise", "false");
stp_free(cgamma);
seq = stp_sequence_create();
stp_curve_get_bounds(curve, &low, &high);
stp_sequence_set_bounds(seq, low, high);
if (gammaval != 0) /* A gamma curve does not require sequence data */
{
stp_sequence_set_size(seq, 0);
}
else
{
const double *data;
size_t count;
data = stpi_curve_get_data_internal(curve, &count);
stp_sequence_set_data(seq, count, data);
}
child = stp_xmltree_create_from_sequence(seq);
if (seq)
{
stp_sequence_destroy(seq);
seq = NULL;
}
if (child == NULL)
{
stp_deprintf(STP_DBG_CURVE_ERRORS,
"stp_xmltree_create_from_curve: sequence node is NULL\n");
goto error;
}
stp_mxmlAdd(curvenode, STP_MXML_ADD_AFTER, NULL, child);
stp_xml_exit();
return curvenode;
error:
stp_deprintf(STP_DBG_CURVE_ERRORS,
"stp_xmltree_create_from_curve: error during xmltree creation\n");
if (curvenode)
stp_mxmlDelete(curvenode);
if (child)
stp_mxmlDelete(child);
stp_xml_exit();
return NULL;
}
