void
stp_xml_parse_file_named(const char *name)
{
stp_list_t *dir_list; /* List of directories to scan */
stp_list_t *file_list; /* List of XML files */
stp_list_item_t *item; /* Pointer to current list item */
if (!(dir_list = stp_list_create()))
return;
stp_list_set_freefunc(dir_list, stp_list_node_free_data);
if (getenv("STP_DATA_PATH"))
stp_path_split(dir_list, getenv("STP_DATA_PATH"));
else
stp_path_split(dir_list, PKGXMLDATADIR);
file_list = stp_path_search(dir_list, name);
stp_list_destroy(dir_list);
item = stp_list_get_start(file_list);
while (item)
{
stp_deprintf(STP_DBG_XML,
"stp_xml_parse_file_named: source file: %s\n",
(const char *) stp_list_item_get_data(item));
stp_xml_parse_file((const char *) stp_list_item_get_data(item));
item = stp_list_item_next(item);
}
stp_list_destroy(file_list);
}
static stp_xml_dither_cache_t *
stp_xml_dither_cache_get(int x, int y)
{
stp_list_item_t *ln;
stp_deprintf(STP_DBG_XML,
"stp_xml_dither_cache_get: lookup %dx%d... ", x, y);
if (!dither_matrix_cache)
{
stp_deprintf(STP_DBG_XML, "cache does not exist\n");
return NULL;
}
ln = stp_list_get_start(dither_matrix_cache);
while (ln)
{
if (((stp_xml_dither_cache_t *) stp_list_item_get_data(ln))->x == x &&
((stp_xml_dither_cache_t *) stp_list_item_get_data(ln))->y == y)
{
stp_deprintf(STP_DBG_XML, "found\n");
return ((stp_xml_dither_cache_t *) stp_list_item_get_data(ln));
}
ln = stp_list_item_next(ln);
}
stp_deprintf(STP_DBG_XML, "missing\n");
return NULL;
}
stp_param_string_t *
stp_string_list_find(const stp_string_list_t *list, const char *name)
{
stp_list_item_t *answer =
stp_list_get_item_by_name((const stp_list_t *)list, name);
if (answer)
return (stp_param_string_t *) stp_list_item_get_data(answer);
else
return NULL;
}
stp_param_string_t *
stp_string_list_param(const stp_string_list_t *list, size_t element)
{
stp_list_item_t *answer =
stp_list_get_item_by_index((const stp_list_t *)list, element);
if (answer)
return (stp_param_string_t *) stp_list_item_get_data(answer);
else
return NULL;
}
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
stpi_xml_process_node(stp_mxml_node_t *node, const char *file)
{
stp_list_item_t *item =
stp_list_get_item_by_name(stpi_xml_registry, node->value.element.name);
if (item)
{
stpi_xml_parse_registry *xmlp =
(stpi_xml_parse_registry *) stp_list_item_get_data(item);
(xmlp->parse_func)(node, file);
}
}
/*
* 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_register_xml_parser(const char *name, stp_xml_parse_func parse_func)
{
stpi_xml_parse_registry *xmlp;
stp_list_item_t *item = stp_list_get_item_by_name(stpi_xml_registry, name);
if (item)
xmlp = (stpi_xml_parse_registry *) stp_list_item_get_data(item);
else
{
xmlp = stp_malloc(sizeof(stpi_xml_parse_registry));
xmlp->name = stp_strdup(name);
stp_list_item_create(stpi_xml_registry, NULL, xmlp);
}
xmlp->parse_func = parse_func;
}
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);
}
/*
* Load all available modules. Return nonzero on failure.
*/
int stp_module_load(void)
{
/* initialise libltdl */
#ifdef USE_LTDL
static int ltdl_is_initialised = 0; /* Is libltdl initialised? */
#endif
static int module_list_is_initialised = 0; /* Is the module list initialised? */
#if defined(USE_LTDL) || defined(USE_DLOPEN)
stp_list_t *dir_list; /* List of directories to scan */
stp_list_t *file_list; /* List of modules to open */
stp_list_item_t *file; /* Pointer to current module */
#endif
#ifdef USE_LTDL
if (!ltdl_is_initialised)
{
if (lt_dlinit())
{
stp_erprintf("Error initialising libltdl: %s\n", DLERROR());
return 1;
}
ltdl_is_initialised = 1;
}
/* set default search paths */
lt_dladdsearchdir(PKGMODULEDIR);
#endif
/* initialise module_list */
if (!module_list_is_initialised)
{
if (!(module_list = stp_list_create()))
return 1;
stp_list_set_freefunc(module_list, module_list_freefunc);
module_list_is_initialised = 1;
}
/* search for available modules */
#if defined (USE_LTDL) || defined (USE_DLOPEN)
if (!(dir_list = stp_list_create()))
return 1;
stp_list_set_freefunc(dir_list, stp_list_node_free_data);
if (getenv("STP_MODULE_PATH"))
{
stp_path_split(dir_list, getenv("STP_MODULE_PATH"));
}
else
{
#ifdef USE_LTDL
stp_path_split(dir_list, getenv("LTDL_LIBRARY_PATH"));
stp_path_split(dir_list, lt_dlgetsearchpath());
#else
stp_path_split(dir_list, PKGMODULEDIR);
#endif
}
#ifdef USE_LTDL
file_list = stp_path_search(dir_list, ".la");
#else
file_list = stp_path_search(dir_list, ".so");
#endif
stp_list_destroy(dir_list);
/* load modules */
file = stp_list_get_start(file_list);
while (file)
{
stp_module_open((const char *) stp_list_item_get_data(file));
file = stp_list_item_next(file);
}
stp_list_destroy(file_list);
#else /* use a static module list */
{
int i=0;
while (static_modules[i])
{
stp_module_register(static_modules[i]);
i++;
}
}
#endif
return 0;
}
