static void
load_channel(stp_mxml_node_t *node, stp_mxml_node_t *root, ink_channel_t *icl)
{
const char *name;
stp_mxml_node_t *child = node->child;
int count = 0;
while (child)
{
if (child->type == STP_MXML_ELEMENT &&
!strcmp(child->value.element.name, "subchannel"))
count++;
child = child->next;
}
name = stp_mxmlElementGetAttr(node, "name");
if (name)
icl->name = stp_strdup(name);
icl->n_subchannels = count;
icl->subchannels = stp_zalloc(sizeof(physical_subchannel_t) * count);
count = 0;
child = node->child;
while (child)
{
if (child->type == STP_MXML_ELEMENT)
{
if (!strcmp(child->value.element.name, "subchannel"))
load_subchannel(child, root, &(icl->subchannels[count++]));
else if (!strcmp(child->value.element.name, "HueCurve"))
{
stp_mxml_node_t *cchild = child->child;
stp_curve_t *curve;
const char *cref = stp_mxmlElementGetAttr(child, "ref");
if (cref)
{
cchild = stp_mxmlFindElement(root, root, "curve", "name",
cref, STP_MXML_DESCEND);
STPI_ASSERT(cchild, NULL);
}
else
{
while (cchild && cchild->type != STP_MXML_ELEMENT)
cchild = cchild->next;
STPI_ASSERT(cchild, NULL);
}
curve = stp_curve_create_from_xmltree(cchild);
icl->hue_curve = curve;
}
else if (!strcmp(child->value.element.name, "HueCurveParam"))
{
name = stp_mxmlElementGetAttr(child, "name");
if (name)
icl->hue_curve_name = stp_strdup(name);
}
}
child = child->next;
}
}
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;
}
static void
load_shades(stp_mxml_node_t *node, stp_mxml_node_t *root, inklist_t *ikl)
{
stp_mxml_node_t *child = node->child;
int count = 0;
while (child)
{
if (child->type == STP_MXML_ELEMENT &&
!strcmp(child->value.element.name, "shade"))
count++;
child = child->next;
}
ikl->n_shades = count;
ikl->shades = stp_zalloc(sizeof(shade_t) * count);
count = 0;
child = node->child;
while (child)
{
if (child->type == STP_MXML_ELEMENT &&
!strcmp(child->value.element.name, "shade"))
{
if (stp_mxmlElementGetAttr(child, "count"))
{
unsigned nshades =
stp_xmlstrtoul(stp_mxmlElementGetAttr(child, "count"));
ikl->shades[count].n_shades = nshades;
if (nshades > 0)
{
char *endptr;
stp_mxml_node_t *cchild = child->child;
ikl->shades[count].shades = stp_zalloc(sizeof(double) * nshades);
nshades = 0;
while (cchild && nshades < ikl->shades[count].n_shades)
{
if (cchild->type == STP_MXML_TEXT)
{
double val =
strtod(cchild->value.text.string, &endptr);
if (endptr)
ikl->shades[count].shades[nshades++] = val;
}
cchild = cchild->next;
}
}
}
count++;
}
child = child->next;
}
}
static void
load_inklist(stp_mxml_node_t *node, stp_mxml_node_t *root, inklist_t *ikl)
{
const char *name;
stp_mxml_node_t *child = node->child;
int count = 0;
while (child)
{
if (child->type == STP_MXML_ELEMENT)
{
if (!strcmp(child->value.element.name, "InkName"))
count++;
else if (!strcmp(child->value.element.name, "initSequence") &&
child->child && child->child->type == STP_MXML_TEXT)
ikl->init_sequence = stp_xmlstrtoraw(child->child->value.text.string);
else if (!strcmp(child->value.element.name, "deinitSequence") &&
child->child && child->child->type == STP_MXML_TEXT)
ikl->deinit_sequence = stp_xmlstrtoraw(child->child->value.text.string);
}
child = child->next;
}
name = stp_mxmlElementGetAttr(node, "name");
if (name)
ikl->name = stp_strdup(name);
name = stp_mxmlElementGetAttr(node, "text");
if (name)
ikl->text = stp_strdup(name);
ikl->n_inks = count;
ikl->inknames = stp_zalloc(sizeof(inkname_t) * count);
count = 0;
child = node->child;
while (child)
{
if (child->type == STP_MXML_ELEMENT)
{
if (!strcmp(child->value.element.name, "InkName"))
{
inkname_t *inl = &(ikl->inknames[count++]);
inl->init_sequence = ikl->init_sequence;
inl->deinit_sequence = ikl->deinit_sequence;
load_inkname(child, root, inl, ikl);
}
else if (!strcmp(child->value.element.name, "Shades"))
load_shades(child, root, ikl);
}
child = child->next;
}
}
static int
curve_whitespace_callback(stp_mxml_node_t *node, int where)
{
if (node->type != STP_MXML_ELEMENT)
return 0;
if (strcasecmp(node->value.element.name, "gutenprint") == 0)
{
switch (where)
{
case STP_MXML_WS_AFTER_OPEN:
case STP_MXML_WS_BEFORE_CLOSE:
case STP_MXML_WS_AFTER_CLOSE:
return '\n';
case STP_MXML_WS_BEFORE_OPEN:
default:
return 0;
}
}
else if (strcasecmp(node->value.element.name, "curve") == 0)
{
switch (where)
{
case STP_MXML_WS_AFTER_OPEN:
return '\n';
case STP_MXML_WS_BEFORE_CLOSE:
case STP_MXML_WS_AFTER_CLOSE:
case STP_MXML_WS_BEFORE_OPEN:
default:
return 0;
}
}
else if (strcasecmp(node->value.element.name, "sequence") == 0)
{
const char *count;
switch (where)
{
case STP_MXML_WS_BEFORE_CLOSE:
count = stp_mxmlElementGetAttr(node, "count");
if (strcmp(count, "0") == 0)
return 0;
else
return '\n';
case STP_MXML_WS_AFTER_OPEN:
case STP_MXML_WS_AFTER_CLOSE:
return '\n';
case STP_MXML_WS_BEFORE_OPEN:
default:
return 0;
}
}
else
return 0;
}
/*
* Parse the <dither-matrix> node.
*/
static int
stp_xml_process_dither_matrix(stp_mxml_node_t *dm, /* The dither matrix node */
const char *file) /* Source file */
{
const char *value;
int x = -1;
int y = -1;
value = stp_mxmlElementGetAttr(dm, "x-aspect");
x = stp_xmlstrtol(value);
value = stp_mxmlElementGetAttr(dm, "y-aspect");
y = stp_xmlstrtol(value);
stp_deprintf(STP_DBG_XML,
"stp_xml_process_dither_matrix: x=%d, y=%d\n", x, y);
stp_xml_dither_cache_set(x, y, file);
return 1;
}
static stp_array_t *
stpi_dither_array_create_from_xmltree(stp_mxml_node_t *dm) /* Dither matrix node */
{
const char *stmp;
stp_mxml_node_t *child;
int x_aspect, y_aspect; /* Dither matrix size */
/* Get x-size */
stmp = stp_mxmlElementGetAttr(dm, "x-aspect");
if (stmp)
{
x_aspect = (int) stp_xmlstrtoul(stmp);
}
else
{
stp_erprintf("stpi_dither_array_create_from_xmltree: \"x-aspect\" missing\n");
goto error;
}
/* Get y-size */
stmp = stp_mxmlElementGetAttr(dm, "y-aspect");
if (stmp)
{
y_aspect = (int) stp_xmlstrtoul(stmp);
}
else
{
stp_erprintf("stpi_dither_array_create_from_xmltree: \"y-aspect\" missing\n");
goto error;
}
/* Now read in the array */
child = stp_mxmlFindElement(dm, dm, "array", NULL, NULL, STP_MXML_DESCEND);
if (child)
return stp_array_create_from_xmltree(child);
else
stp_erprintf("stpi_dither_array_create_from_xmltree: cannot find root\n");
error:
return NULL;
}
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;
}
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_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;
}
static void
load_subchannel(stp_mxml_node_t *node, stp_mxml_node_t *root, physical_subchannel_t *icl)
{
const char *name;
stp_mxml_node_t *child = node->child;
name = stp_mxmlElementGetAttr(node, "color");
if (name)
icl->color = stp_xmlstrtol(name);
name = stp_mxmlElementGetAttr(node, "subchannel");
if (name)
icl->subchannel = stp_xmlstrtol(name);
else
icl->subchannel = -1;
name = stp_mxmlElementGetAttr(node, "headOffset");
if (name)
icl->head_offset = stp_xmlstrtol(name);
name = stp_mxmlElementGetAttr(node, "name");
if (name)
icl->name = stp_strdup(name);
name = stp_mxmlElementGetAttr(node, "text");
if (name)
icl->text = stp_strdup(name);
while (child)
{
if (child->type == STP_MXML_ELEMENT)
{
const char *param = child->value.element.name;
name = stp_mxmlElementGetAttr(child, "name");
if (name && !strcmp(param, "ChannelDensityParam"))
icl->channel_density = stp_strdup(name);
else if (name && !strcmp(param, "SubchannelTransitionParam"))
icl->subchannel_transition = stp_strdup(name);
else if (name && !strcmp(param, "SubchannelValueParam"))
icl->subchannel_value = stp_strdup(name);
else if (name && !strcmp(param, "SubchannelScaleParam"))
icl->subchannel_scale = stp_strdup(name);
else if (!strcmp(param, "SplitChannels"))
{
if (stp_mxmlElementGetAttr(child, "count"))
icl->split_channel_count =
stp_xmlstrtoul(stp_mxmlElementGetAttr(child, "count"));
if (icl->split_channel_count > 0)
{
char *endptr;
int count = 0;
stp_mxml_node_t *cchild = child->child;
icl->split_channels =
stp_zalloc(sizeof(short) * icl->split_channel_count);
while (cchild && count < icl->split_channel_count)
{
if (cchild->type == STP_MXML_TEXT)
{
unsigned val =
strtoul(cchild->value.text.string, &endptr, 0);
if (endptr)
icl->split_channels[count++] = val;
}
cchild = cchild->next;
}
}
}
}
child = child->next;
}
}
static void
load_inkname(stp_mxml_node_t *node, stp_mxml_node_t *root, inkname_t *inl,
inklist_t *ikl)
{
const char *name;
stp_mxml_node_t *child = node->child;
int channel_count = 0;
int aux_channel_count = 0;
while (child)
{
if (child->type == STP_MXML_ELEMENT)
{
if (!strcmp(child->value.element.name, "Channels"))
{
stp_mxml_node_t *cchild = child->child;
while (cchild)
{
if (cchild->type == STP_MXML_ELEMENT &&
!strcmp(cchild->value.element.name, "channel"))
{
name = stp_mxmlElementGetAttr(cchild, "index");
if (name)
{
unsigned idx = stp_xmlstrtoul(name);
if (idx + 1 > channel_count)
channel_count = idx + 1;
}
}
cchild = cchild->next;
}
}
else if (!strcmp(child->value.element.name, "AuxChannels"))
{
stp_mxml_node_t *cchild = child->child;
while (cchild)
{
if (cchild->type == STP_MXML_ELEMENT &&
!strcmp(cchild->value.element.name, "channel"))
{
name = stp_mxmlElementGetAttr(cchild, "index");
if (name)
{
unsigned idx = stp_xmlstrtoul(name);
if (idx + 1 > aux_channel_count)
aux_channel_count = idx + 1;
}
}
cchild = cchild->next;
}
}
}
child = child->next;
}
inl->channel_count = channel_count;
if (channel_count > 0)
inl->channels = stp_zalloc(sizeof(ink_channel_t) * channel_count);
inl->aux_channel_count = aux_channel_count;
if (aux_channel_count > 0)
inl->aux_channels = stp_zalloc(sizeof(ink_channel_t) * aux_channel_count);
name = stp_mxmlElementGetAttr(node, "name");
if (name)
inl->name = stp_strdup(name);
name = stp_mxmlElementGetAttr(node, "text");
if (name)
inl->text = stp_strdup(name);
name = stp_mxmlElementGetAttr(node, "InkID");
if (name)
{
if (!strcmp(name, "CMYK"))
inl->inkset = INKSET_CMYK;
else if (!strcmp(name, "CcMmYK"))
inl->inkset = INKSET_CcMmYK;
else if (!strcmp(name, "CcMmYyK"))
inl->inkset = INKSET_CcMmYyK;
else if (!strcmp(name, "CcMmYKk"))
inl->inkset = INKSET_CcMmYKk;
else if (!strcmp(name, "Quadtone"))
inl->inkset = INKSET_QUADTONE;
else if (!strcmp(name, "Hextone"))
inl->inkset = INKSET_HEXTONE;
else if (!strcmp(name, "OTHER"))
inl->inkset = INKSET_OTHER;
else if (!strcmp(name, "Extended"))
inl->inkset = INKSET_EXTENDED;
}
channel_count = 0;
aux_channel_count = 0;
child = node->child;
while (child)
{
if (child->type == STP_MXML_ELEMENT)
{
if (!strcmp(child->value.element.name, "Channels"))
{
stp_mxml_node_t *cchild = child->child;
while (cchild)
{
if (cchild->type == STP_MXML_ELEMENT &&
!strcmp(cchild->value.element.name, "channel"))
{
name = stp_mxmlElementGetAttr(cchild, "index");
if (name)
{
unsigned idx = stp_xmlstrtoul(name);
load_channel(cchild, root, &(inl->channels[idx]));
}
}
cchild = cchild->next;
}
}
else if (!strcmp(child->value.element.name, "AuxChannels"))
{
stp_mxml_node_t *cchild = child->child;
while (cchild)
{
if (cchild->type == STP_MXML_ELEMENT &&
!strcmp(cchild->value.element.name, "channel"))
{
name = stp_mxmlElementGetAttr(cchild, "index");
if (name)
{
unsigned idx = stp_xmlstrtoul(name);
load_channel(cchild, root, &(inl->aux_channels[idx]));
}
}
cchild = cchild->next;
}
}
else if (!strcmp(child->value.element.name, "initSequence") &&
child->child && child->child->type == STP_MXML_TEXT)
ikl->init_sequence = stp_xmlstrtoraw(child->child->value.text.string);
else if (!strcmp(child->value.element.name, "deinitSequence") &&
child->child && child->child->type == STP_MXML_TEXT)
ikl->deinit_sequence = stp_xmlstrtoraw(child->child->value.text.string);
}
child = child->next;
}
}
static void
load_model_from_file(const stp_vars_t *v, stp_mxml_node_t *xmod, int model)
{
stp_mxml_node_t *tmp = xmod->child;
stpi_escp2_printer_t *p = stp_escp2_get_printer(v);
int found_black_head_config = 0;
int found_fast_head_config = 0;
p->max_black_resolution = -1;
p->cd_x_offset = -1;
p->cd_y_offset = -1;
p->duplex_left_margin = SHRT_MIN;
p->duplex_right_margin = SHRT_MIN;
p->duplex_top_margin = SHRT_MIN;
p->duplex_bottom_margin = SHRT_MIN;
while (tmp)
{
if (tmp->type == STP_MXML_ELEMENT)
{
const char *name = tmp->value.element.name;
const char *target = stp_mxmlElementGetAttr(tmp, "src");
if (target)
{
if (!strcmp(name, "media"))
stp_escp2_load_media(v, target);
else if (!strcmp(name, "inputSlots"))
stp_escp2_load_input_slots(v, target);
else if (!strcmp(name, "mediaSizes"))
stp_escp2_load_media_sizes(v, target);
else if (!strcmp(name, "printerWeaves"))
stp_escp2_load_printer_weaves(v, target);
else if (!strcmp(name, "qualityPresets"))
stp_escp2_load_quality_presets(v, target);
else if (!strcmp(name, "resolutions"))
stp_escp2_load_resolutions(v, target);
else if (!strcmp(name, "inkGroup"))
stp_escp2_load_inkgroup(v, target);
}
else if (tmp->child && tmp->child->type == STP_MXML_TEXT)
{
stp_mxml_node_t *child = tmp->child;
const char *val = child->value.text.string;
if (!strcmp(name, "verticalBorderlessSequence"))
{
STPI_ASSERT(!p->vertical_borderless_sequence, NULL);
p->vertical_borderless_sequence = stp_xmlstrtoraw(val);
}
else if (!strcmp(name, "preinitSequence"))
{
STPI_ASSERT(!p->preinit_sequence, NULL);
p->preinit_sequence = stp_xmlstrtoraw(val);
}
else if (!strcmp(name, "preinitRemoteSequence"))
{
STPI_ASSERT(!p->preinit_remote_sequence, NULL);
p->preinit_remote_sequence = stp_xmlstrtoraw(val);
}
else if (!strcmp(name, "postinitRemoteSequence"))
{
STPI_ASSERT(!p->postinit_remote_sequence, NULL);
p->postinit_remote_sequence = stp_xmlstrtoraw(val);
}
else if (!strcmp(name, "commandSet"))
{
if (!strcmp(val, "1998"))
p->flags |= MODEL_COMMAND_1998;
else if (!strcmp(val, "1999"))
p->flags |= MODEL_COMMAND_1999;
else if (!strcmp(val, "2000"))
p->flags |= MODEL_COMMAND_2000;
else if (!strcmp(val, "Pro"))
p->flags |= MODEL_COMMAND_PRO;
}
else if (!strcmp(name, "borderless"))
{
if (!strcmp(val, "No"))
p->flags |= MODEL_ZEROMARGIN_NO;
else if (!strcmp(val, "Yes"))
p->flags |= MODEL_ZEROMARGIN_YES;
else if (!strcmp(val, "Full"))
p->flags |= MODEL_ZEROMARGIN_FULL;
else if (!strcmp(val, "VerticalRestricted"))
p->flags |= MODEL_ZEROMARGIN_RESTR;
else if (!strcmp(val, "HorizontalOnly"))
p->flags |= MODEL_ZEROMARGIN_H_ONLY;
}
else if (!strcmp(name, "preferredEnvelopeOrientation") &&
!strcmp(val, "Landscape"))
p->flags |= MODEL_ENVELOPE_LANDSCAPE_YES;
else if (!strcmp(name, "headConfiguration"))
{
const char *htype = stp_mxmlElementGetAttr(tmp, "type");
unsigned long data[4] = { 0, 0, 0, 0 };
while (child)
{
if (child->type == STP_MXML_ELEMENT && child->child &&
child->child->type == STP_MXML_TEXT)
{
const char *cname = child->value.element.name;
const char *cval = child->child->value.text.string;
if (!strcmp(cname, "Nozzles"))
data[0] = stp_xmlstrtoul(cval);
else if (!strcmp(cname, "MinNozzles"))
data[1] = stp_xmlstrtoul(cval);
else if (!strcmp(cname, "FirstNozzle"))
data[2] = stp_xmlstrtoul(cval);
else if (!strcmp(cname, "NozzleSeparation"))
data[3] = stp_xmlstrtoul(cval);
}
child = child->next;
}
if (!strcmp(htype, "default"))
{
p->nozzles = data[0];
p->min_nozzles = data[1];
p->nozzle_start = data[2];
p->nozzle_separation = data[3];
if (!found_black_head_config)
{
p->black_nozzles = data[0];
p->min_black_nozzles = data[1];
p->black_nozzle_start = data[2];
p->black_nozzle_separation = data[3];
}
if (!found_fast_head_config)
{
p->fast_nozzles = data[0];
p->min_fast_nozzles = data[1];
p->fast_nozzle_start = data[2];
p->fast_nozzle_separation = data[3];
}
}
else if (!strcmp(htype, "black"))
{
p->black_nozzles = data[0];
p->min_black_nozzles = data[1];
p->black_nozzle_start = data[2];
p->black_nozzle_separation = data[3];
found_black_head_config = 1;
}
else if (!strcmp(htype, "fast"))
{
p->fast_nozzles = data[0];
p->min_fast_nozzles = data[1];
p->fast_nozzle_start = data[2];
p->fast_nozzle_separation = data[3];
found_fast_head_config = 1;
}
}
else if (!strcmp(name, "margins"))
{
const char *itype = stp_mxmlElementGetAttr(tmp, "interleave");
const char *mtype = stp_mxmlElementGetAttr(tmp, "media");
const char *dtype = stp_mxmlElementGetAttr(tmp, "duplex");
unsigned long data[4];
int i = 0;
while (child && i < 4)
{
if (child->type == STP_MXML_TEXT)
data[i++] = stp_xmlstrtoul(child->value.text.string);
child = child->next;
}
if (dtype && !strcmp(dtype, "duplex"))
{
p->duplex_left_margin = data[0];
p->duplex_right_margin = data[1];
p->duplex_top_margin = data[2];
p->duplex_bottom_margin = data[3];
}
else if (itype && !strcmp(itype, "soft") &&
mtype && !strcmp(mtype, "sheet"))
{
p->left_margin = data[0];
p->right_margin = data[1];
p->top_margin = data[2];
p->bottom_margin = data[3];
}
else if (itype && !strcmp(itype, "printer") &&
mtype && !strcmp(mtype, "sheet"))
{
p->m_left_margin = data[0];
p->m_right_margin = data[1];
p->m_top_margin = data[2];
p->m_bottom_margin = data[3];
}
else if (itype && !strcmp(itype, "soft") &&
mtype && !strcmp(mtype, "roll"))
{
p->roll_left_margin = data[0];
p->roll_right_margin = data[1];
p->roll_top_margin = data[2];
p->roll_bottom_margin = data[3];
}
else if (itype && !strcmp(itype, "printer") &&
mtype && !strcmp(mtype, "roll"))
{
p->m_roll_left_margin = data[0];
p->m_roll_right_margin = data[1];
p->m_roll_top_margin = data[2];
p->m_roll_bottom_margin = data[3];
}
}
else if (!strcmp(name, "physicalChannels"))
p->physical_channels = stp_xmlstrtoul(val);
else if (!strcmp(name, "baseSeparation"))
p->base_separation = stp_xmlstrtoul(val);
else if (!strcmp(name, "resolutionScale"))
p->resolution_scale = stp_xmlstrtoul(val);
else if (!strcmp(name, "maxBlackResolution"))
p->max_black_resolution = stp_xmlstrtoul(val);
else if (!strcmp(name, "minimumResolution"))
{
p->min_hres = stp_xmlstrtoul(child->value.text.string);
child = child->next;
p->min_vres = stp_xmlstrtoul(child->value.text.string);
}
else if (!strcmp(name, "maximumResolution"))
{
p->max_hres = stp_xmlstrtoul(child->value.text.string);
child = child->next;
p->max_vres = stp_xmlstrtoul(child->value.text.string);
}
else if (!strcmp(name, "extraVerticalFeed"))
p->extra_feed = stp_xmlstrtoul(val);
else if (!strcmp(name, "separationRows"))
p->separation_rows = stp_xmlstrtoul(val);
else if (!strcmp(name, "pseudoSeparationRows"))
p->pseudo_separation_rows = stp_xmlstrtoul(val);
else if (!strcmp(name, "zeroMarginOffset"))
p->zero_margin_offset = stp_xmlstrtoul(val);
else if (!strcmp(name, "microLeftMargin"))
p->micro_left_margin = stp_xmlstrtoul(val);
else if (!strcmp(name, "initialVerticalOffset"))
p->initial_vertical_offset = stp_xmlstrtoul(val);
else if (!strcmp(name, "blackInitialVerticalOffset"))
p->black_initial_vertical_offset = stp_xmlstrtoul(val);
else if (!strcmp(name, "extra720DPISeparation"))
p->extra_720dpi_separation = stp_xmlstrtoul(val);
else if (!strcmp(name, "minHorizontalAlignment"))
p->min_horizontal_position_alignment = stp_xmlstrtoul(val);
else if (!strcmp(name, "baseHorizontalAlignment"))
p->base_horizontal_position_alignment = stp_xmlstrtoul(val);
else if (!strcmp(name, "bidirectionalAutoUpperLimit"))
p->bidirectional_upper_limit = stp_xmlstrtoul(val);
else if (!strcmp(name, "minimumMediaSize"))
{
p->min_paper_width = stp_xmlstrtoul(child->value.text.string);
child = child->next;
p->min_paper_height = stp_xmlstrtoul(child->value.text.string);
}
else if (!strcmp(name, "maximumMediaSize"))
{
p->max_paper_width = stp_xmlstrtoul(child->value.text.string);
child = child->next;
p->max_paper_height = stp_xmlstrtoul(child->value.text.string);
}
else if (!strcmp(name, "maximumImageableArea"))
{
p->max_imageable_width = stp_xmlstrtoul(child->value.text.string);
child = child->next;
p->max_imageable_height = stp_xmlstrtoul(child->value.text.string);
}
else if (!strcmp(name, "CDOffset"))
{
p->cd_x_offset = stp_xmlstrtoul(child->value.text.string);
child = child->next;
p->cd_y_offset = stp_xmlstrtoul(child->value.text.string);
}
else if (!strcmp(name, "CDMediaSize"))
{
p->cd_page_width = stp_xmlstrtoul(child->value.text.string);
child = child->next;
p->cd_page_height = stp_xmlstrtoul(child->value.text.string);
}
else if (!strcmp(name, "extraBottom"))
p->paper_extra_bottom = stp_xmlstrtoul(val);
else if (!strcmp(name, "AlignmentChoices"))
{
p->alignment_passes =
stp_xmlstrtoul(child->value.text.string);
child = child->next;
p->alignment_choices =
stp_xmlstrtoul(child->value.text.string);
child = child->next;
p->alternate_alignment_passes =
stp_xmlstrtoul(child->value.text.string);
child = child->next;
p->alternate_alignment_choices =
stp_xmlstrtoul(child->value.text.string);
}
else if (!strcmp(name, "ChannelNames"))
{
p->channel_names = stp_string_list_create();
while (child)
{
if (child->type == STP_MXML_ELEMENT &&
!strcmp(child->value.element.name, "ChannelName"))
{
const char *cname = stp_mxmlElementGetAttr(child, "name");
stp_string_list_add_string(p->channel_names, cname, cname);
}
child = child->next;
}
}
else if (!strcmp(name, "resolutions"))
stp_escp2_load_resolutions_from_xml(v, tmp);
}
else
{
if (!strcmp(name, "supportsVariableDropsizes"))
p->flags |= MODEL_VARIABLE_YES;
else if (!strcmp(name, "hasFastGraymode"))
p->flags |= MODEL_GRAYMODE_YES;
else if (!strcmp(name, "hasFast360DPI"))
p->flags |= MODEL_FAST_360_YES;
else if (!strcmp(name, "sendZeroAdvance"))
p->flags |= MODEL_SEND_ZERO_ADVANCE_YES;
else if (!strcmp(name, "supportsInkChange"))
p->flags |= MODEL_SUPPORTS_INK_CHANGE_YES;
else if (!strcmp(name, "supportsD4Mode"))
p->flags |= MODEL_PACKET_MODE_YES;
else if (!strcmp(name, "hasInterchangeableInkCartridges"))
p->flags |= MODEL_INTERCHANGEABLE_INK_YES;
else if (!strcmp(name, "resolutions"))
stp_escp2_load_resolutions_from_xml(v, tmp);
}
}
tmp = tmp->next;
}
}
stp_array_t *
stp_array_create_from_xmltree(stp_mxml_node_t *array) /* The array node */
{
const char *stmp; /* Temporary string */
stp_mxml_node_t *child; /* Child sequence node */
int x_size, y_size;
size_t count;
stp_sequence_t *seq = NULL;
stp_array_t *ret = NULL;
stmp = stp_mxmlElementGetAttr(array, "x-size");
if (stmp)
{
x_size = (int) strtoul(stmp, NULL, 0);
}
else
{
stp_erprintf("stp_array_create_from_xmltree: \"x-size\" missing\n");
goto error;
}
/* Get y-size */
stmp = stp_mxmlElementGetAttr(array, "y-size");
if (stmp)
{
y_size = (int) strtoul(stmp, NULL, 0);
}
else
{
stp_erprintf("stp_array_create_from_xmltree: \"y-size\" missing\n");
goto error;
}
/* Get the sequence data */
child = stp_mxmlFindElement(array, array, "sequence", NULL, NULL, STP_MXML_DESCEND);
if (child)
seq = stp_sequence_create_from_xmltree(child);
if (seq == NULL)
goto error;
ret = stp_array_create(x_size, y_size);
if (ret->data)
stp_sequence_destroy(ret->data);
ret->data = seq;
count = stp_sequence_get_size(seq);
if (count != (x_size * y_size))
{
stp_erprintf("stp_array_create_from_xmltree: size mismatch between array and sequence\n");
goto error;
}
return ret;
error:
stp_erprintf("stp_array_create_from_xmltree: error during array read\n");
if (ret)
stp_array_destroy(ret);
return NULL;
}
