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; }
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 void stp_xml_dither_cache_set(int x, int y, const char *filename) { stp_xml_dither_cache_t *cacheval; assert(x && y && filename); stp_xml_init(); if (dither_matrix_cache == NULL) dither_matrix_cache = stp_list_create(); if (stp_xml_dither_cache_get(x, y)) /* Already cached for this x and y aspect */ return; cacheval = stp_malloc(sizeof(stp_xml_dither_cache_t)); cacheval->x = x; cacheval->y = y; cacheval->filename = stp_strdup(filename); cacheval->dither_array = NULL; stp_list_item_create(dither_matrix_cache, NULL, (void *) cacheval); stp_deprintf(STP_DBG_XML, "stp_xml_dither_cache_set: added %dx%d\n", x, y); stp_xml_exit(); return; }
/* * 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_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; }
/* * Read all available XML files. */ int stp_xml_init_defaults(void) { stp_list_item_t *item; /* Pointer to current list item */ stp_xml_init(); /* Parse each XML file */ item = stp_list_get_start(stpi_xml_preloads); while (item) { stp_deprintf(STP_DBG_XML, "stp_xml_init_defaults: source file: %s\n", (const char *) stp_list_item_get_data(item)); stp_xml_parse_file_named((const char *) stp_list_item_get_data(item)); item = stp_list_item_next(item); } stp_list_destroy(stpi_xml_preloads); stp_xml_exit(); return 0; }
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; }
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; }
stp_curve_t * stp_curve_create_from_xmltree(stp_mxml_node_t *curve) /* The curve node */ { const char *stmp; /* Temporary string */ stp_mxml_node_t *child; /* Child sequence node */ stp_curve_t *ret = NULL; /* Curve to return */ stp_curve_type_t curve_type; /* Type of curve */ stp_curve_wrap_mode_t wrap_mode; /* Curve wrap mode */ double fgamma; /* Gamma value */ stp_sequence_t *seq = NULL; /* Sequence data */ double low, high; /* Sequence bounds */ int piecewise = 0; stp_xml_init(); /* Get curve type */ stmp = stp_mxmlElementGetAttr(curve, "type"); if (stmp) { if (!strcmp(stmp, "linear")) curve_type = STP_CURVE_TYPE_LINEAR; else if (!strcmp(stmp, "spline")) curve_type = STP_CURVE_TYPE_SPLINE; else { stp_deprintf(STP_DBG_CURVE_ERRORS, "stp_curve_create_from_xmltree: %s: \"type\" invalid\n", stmp); goto error; } } else { stp_deprintf(STP_DBG_CURVE_ERRORS, "stp_curve_create_from_xmltree: \"type\" missing\n"); goto error; } /* Get curve wrap mode */ stmp = stp_mxmlElementGetAttr(curve, "wrap"); if (stmp) { if (!strcmp(stmp, "nowrap")) wrap_mode = STP_CURVE_WRAP_NONE; else if (!strcmp(stmp, "wrap")) { wrap_mode = STP_CURVE_WRAP_AROUND; } else { stp_deprintf(STP_DBG_CURVE_ERRORS, "stp_curve_create_from_xmltree: %s: \"wrap\" invalid\n", stmp); goto error; } } else { stp_deprintf(STP_DBG_CURVE_ERRORS, "stp_curve_create_from_xmltree: \"wrap\" missing\n"); goto error; } /* Get curve gamma */ stmp = stp_mxmlElementGetAttr(curve, "gamma"); if (stmp) { fgamma = stp_xmlstrtod(stmp); } else { stp_deprintf(STP_DBG_CURVE_ERRORS, "stp_curve_create_from_xmltree: \"gamma\" missing\n"); goto error; } /* If gamma is set, wrap_mode must be STP_CURVE_WRAP_NONE */ if (fgamma && wrap_mode != STP_CURVE_WRAP_NONE) { stp_deprintf(STP_DBG_CURVE_ERRORS, "stp_curve_create_from_xmltree: " "gamma set and \"wrap\" is not STP_CURVE_WRAP_NONE\n"); goto error; } stmp = stp_mxmlElementGetAttr(curve, "piecewise"); if (stmp && strcmp(stmp, "true") == 0) piecewise = 1; /* Set up the curve */ ret = stp_curve_create(wrap_mode); stp_curve_set_interpolation_type(ret, curve_type); child = stp_mxmlFindElement(curve, curve, "sequence", NULL, NULL, STP_MXML_DESCEND); if (child) seq = stp_sequence_create_from_xmltree(child); if (seq == NULL) { stp_deprintf(STP_DBG_CURVE_ERRORS, "stp_curve_create_from_xmltree: sequence read failed\n"); goto error; } /* Set curve bounds */ stp_sequence_get_bounds(seq, &low, &high); stp_curve_set_bounds(ret, low, high); if (fgamma) stp_curve_set_gamma(ret, fgamma); else /* Not a gamma curve, so set points */ { size_t seq_count; const double* data; stp_sequence_get_data(seq, &seq_count, &data); if (piecewise) { if ((seq_count % 2) != 0) { stp_deprintf(STP_DBG_CURVE_ERRORS, "stp_curve_create_from_xmltree: invalid data count %ld\n", (long)seq_count); goto error; } if (stp_curve_set_data_points(ret, seq_count / 2, (const stp_curve_point_t *) data) == 0) { stp_deprintf(STP_DBG_CURVE_ERRORS, "stp_curve_create_from_xmltree: failed to set curve data points\n"); goto error; } } else { if (stp_curve_set_data(ret, seq_count, data) == 0) { stp_deprintf(STP_DBG_CURVE_ERRORS, "stp_curve_create_from_xmltree: failed to set curve data\n"); goto error; } } } if (seq) { stp_sequence_destroy(seq); seq = NULL; } /* Validate curve */ if (stpi_curve_check_parameters(ret, stp_curve_count_points(ret)) == 0) { stp_deprintf(STP_DBG_CURVE_ERRORS, "stp_curve_create_from_xmltree: parameter check failed\n"); goto error; } stp_xml_exit(); return ret; error: stp_deprintf(STP_DBG_CURVE_ERRORS, "stp_curve_create_from_xmltree: error during curve read\n"); if (ret) stp_curve_destroy(ret); stp_xml_exit(); return NULL; }